content: /*
   * Licensed to the Apache Software Foundation (ASF) under one
   * or more contributor license agreements.  See the NOTICE file
   * distributed with this work for additional information
   * regarding copyright ownership.  The ASF licenses this file
   * to you under the Apache License, Version 2.0 (the
   * "License"); you may not use this file except in compliance
   * with the License.  You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package org.apache.cassandra.io.sstable.format;
  
  import java.io.IOException;
  import java.util.Set;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import org.apache.cassandra.io.sstable.Component;
  import org.apache.cassandra.io.sstable.Descriptor;
  import org.apache.cassandra.io.sstable.format.SSTableFormat.Components;
  import org.apache.cassandra.io.sstable.metadata.ValidationMetadata;
  import org.apache.cassandra.io.util.File;
  import org.apache.cassandra.io.util.FileInputStreamPlus;
  import org.apache.cassandra.io.util.FileOutputStreamPlus;
  import org.apache.cassandra.schema.TableMetadata;
  import org.apache.cassandra.utils.BloomFilterSerializer;
  import org.apache.cassandra.utils.FilterFactory;
  import org.apache.cassandra.utils.IFilter;
  
  public class FilterComponent
  {
      private static final Logger logger = LoggerFactory.getLogger(FilterComponent.class);
  
      final static boolean rebuildFilterOnFPChanceChange = false;
      final static double filterFPChanceTolerance = 0d;
  
      private FilterComponent()
      {
      }
  
      /**
       * Load bloom filter from Filter.db file.
       */
      public static IFilter load(Descriptor descriptor) throws IOException
      {
          File filterFile = descriptor.fileFor(Components.FILTER);
  
          if (!filterFile.exists())
              return null;
  
          if (filterFile.length() == 0)
              return FilterFactory.AlwaysPresent;
  
          try (FileInputStreamPlus stream = descriptor.fileFor(Components.FILTER).newInputStream())
          {
              return BloomFilterSerializer.forVersion(descriptor.version.hasOldBfFormat()).deserialize(stream);
          }
          catch (IOException ex)
          {
              throw new IOException("Failed to load Bloom filter for SSTable: " + descriptor.baseFile(), ex);
          }
      }
  
      public static void save(IFilter filter, Descriptor descriptor, boolean deleteOnFailure) throws IOException
      {
          File filterFile = descriptor.fileFor(Components.FILTER);
          try (FileOutputStreamPlus stream = filterFile.newOutputStream(File.WriteMode.OVERWRITE))
          {
              filter.serialize(stream, descriptor.version.hasOldBfFormat());
              stream.flush();
              stream.sync();
          }
          catch (IOException ex)
          {
              if (deleteOnFailure)
                  descriptor.fileFor(Components.FILTER).deleteIfExists();
              throw new IOException("Failed to save Bloom filter for SSTable: " + descriptor.baseFile(), ex);
          }
      }
  
      /**
       * Optionally loads a Bloom filter.
       * If the filter is not needed (FP chance is neglectable), it returns {@link FilterFactory#AlwaysPresent}.
       * If the filter is expected to be recreated for various reasons the method returns {@code null}.
       * Otherwise, an attempt to load the filter is made and if it succeeds, the loaded filter is returned.
       * If loading fails, the method returns {@code null}.
       *
       * @return {@link FilterFactory#AlwaysPresent}, loaded filter or {@code null} (which means that the filter should be rebuilt)
       */
      public static IFilter maybeLoadBloomFilter(Descriptor descriptor, Set<Component> components, TableMetadata metadata, ValidationMetadata validationMetadata)
      {
          double currentFPChance = validationMetadata != null ? validationMetadata.bloomFilterFPChance : Double.NaN;
          double desiredFPChance = metadata.params.bloomFilterFpChance;
  
          IFilter filter = null;
          if (!shouldUseBloomFilter(desiredFPChance))
          {
              logger.trace("Bloom filter for {} will not be loaded because fpChance={} is negligible", descriptor, desiredFPChance);
              return FilterFactory.AlwaysPresent;
          }
          else if (!components.contains(Components.FILTER) || Double.isNaN(currentFPChance))
          {
              logger.trace("Bloom filter for {} will not be loaded because the filter component is missing or sstable lacks validation metadata", descriptor);
              return null;
          }
          else if (!isFPChanceDiffNegligible(desiredFPChance, currentFPChance) && rebuildFilterOnFPChanceChange)
          {
              if (logger.isTraceEnabled())
                  logger.trace("Bloom filter for {} will not be loaded because fpChance has changed from {} to {} and the filter should be recreated", descriptor, currentFPChance, desiredFPChance);
  
              return null;
          }
  
          try
          {
              filter = load(descriptor);
              if (filter == null || !filter.isInformative())
                  logger.info("Bloom filter for {} is missing or invalid", descriptor);
          }
          catch (IOException ex)
          {
              logger.info("Bloom filter for " + descriptor + " could not be deserialized", ex);
          }
  
          return filter;
      }
  
      static boolean shouldUseBloomFilter(double fpChance)
      {
          return !(Math.abs(1 - fpChance) <= filterFPChanceTolerance);
      }
  
      static boolean isFPChanceDiffNegligible(double fpChance1, double fpChance2)
      {
          return Math.abs(fpChance1 - fpChance2) <= filterFPChanceTolerance;
      }
  }
  