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.db.commitlog;
  
  
  import java.io.IOException;
  import java.util.List;
  import java.util.Map;
  
  public interface CommitLogMBean
  {
      /**
       *  Command to execute to archive a commitlog segment.  Blank to disabled.
       */
      public String getArchiveCommand();
  
      /**
       * Command to execute to make an archived commitlog live again
       */
      public String getRestoreCommand();
  
      /**
       * Directory to scan the recovery files in
       */
      public String getRestoreDirectories();
  
      /**
       * Restore mutations created up to and including this timestamp in GMT
       * There are only three different formats to express three time precisions:
       * Seconds, Milliseconds, and Microseconds.
       * Seconds format: yyyy:MM:dd HH:mm:ss (2012:04:31 20:43:12)
       * Milliseconds format: yyyy:MM:dd HH:mm:ss.SSS (2012:04:31 20:43:12.633)
       * Microseconds format: yyyy:MM:dd HH:mm:ss.SSSSSS (2012:04:31 20:43:12.633222)
       *
       * Recovery will continue through the segment when the first client-supplied
       * timestamp greater than this time is encountered, but only mutations less than
       * or equal to this timestamp will be applied.
       */
      public long getRestorePointInTime();
  
      /**
       * get precision of the timestamp used in the restore (MILLISECONDS, MICROSECONDS, ...)
       * to determine if passed the restore point in time.
       */
      public String getRestorePrecision();
  
      /**
       * Recover a single file.
       */
      public void recover(String path) throws IOException;
  
      /**
       * @return file names (not full paths) of active commit log segments (segments containing unflushed data)
       */
      public List<String> getActiveSegmentNames();
  
      /**
       * @return Files which are pending for archival attempt.  Does NOT include failed archive attempts.
       */
      public List<String> getArchivingSegmentNames();
  
      /**
       * @return The size of the mutations in all active commit log segments (uncompressed).
       */
      public long getActiveContentSize();
  
      /**
       * @return The space taken on disk by the commit log (compressed).
       */
      public long getActiveOnDiskSize();
  
      /**
       * @return A map between active log segments and the compression ratio achieved for each.
       */
      public Map<String, Double> getActiveSegmentCompressionRatios();
  
      public boolean getCDCBlockWrites();
  
      public void setCDCBlockWrites(boolean val);
  
      /** Returns true if internodes streaming of CDC data should go through write path */
      boolean isCDCOnRepairEnabled();
  
      /** Set whether enable write path for CDC data during internodes streaming, e.g. repair */
      void setCDCOnRepairEnabled(boolean value);
  }
  