anchor.diff:  # See http://wiki.apache.org/cassandra/HintedHandoff
   hinted_handoff_enabled: true
   # this defines the maximum amount of time a dead host will have hints
  -# generated.  After it has been dead this long, hints will be dropped.
  -max_hint_window_in_ms: 3600000 # one hour
  -# Sleep this long after delivering each hint
  -hinted_handoff_throttle_delay_in_ms: 1
  -
  -# authentication backend, implementing IAuthenticator; used to identify users
  -authenticator: org.apache.cassandra.auth.AllowAllAuthenticator
  -
  -# authorization backend, implementing IAuthority; used to limit access/provide permissions
  -authority: org.apache.cassandra.auth.AllowAllAuthority
  +# generated.  After it has been dead this long, new hints for it will not be
  +# created until it has been seen alive and gone down again.
  +max_hint_window_in_ms: 10800000 # 3 hours
  +# Maximum throttle in KBs per second, per delivery thread.  This will be
  +# reduced proportionally to the number of nodes in the cluster.  (If there
  +# are two nodes in the cluster, each delivery thread will use the maximum
  +# rate; if there are three, each will throttle to half of the maximum,
  +# since we expect two nodes to be delivering hints simultaneously.)
  +hinted_handoff_throttle_in_kb: 1024
  +# Number of threads with which to deliver hints;
  +# Consider increasing this number when you have multi-dc deployments, since
  +# cross-dc handoff tends to be slower
  +max_hints_delivery_threads: 2
  +
  +# The following setting populates the page cache on memtable flush and compaction
  +# WARNING: Enable this setting only when the whole node's data fits in memory.
  +# Defaults to: false
  +# populate_io_cache_on_flush: false
  +
  +# Authentication backend, implementing IAuthenticator; used to identify users
  +# Out of the box, Cassandra provides org.apache.cassandra.auth.{AllowAllAuthenticator,
  +# PasswordAuthenticator}.
  +#
  +# - AllowAllAuthenticator performs no checks - set it to disable authentication.
  +# - PasswordAuthenticator relies on username/password pairs to authenticate
  +#   users. It keeps usernames and hashed passwords in system_auth.credentials table.
  +#   Please increase system_auth keyspace replication factor if you use this authenticator.
  +authenticator: AllowAllAuthenticator
  +
  +# Authorization backend, implementing IAuthorizer; used to limit access/provide permissions
  +# Out of the box, Cassandra provides org.apache.cassandra.auth.{AllowAllAuthorizer,
  +# CassandraAuthorizer}.
  +#
  +# - AllowAllAuthorizer allows any action to any user - set it to disable authorization.
  +# - CassandraAuthorizer stores permissions in system_auth.permissions table. Please
  +#   increase system_auth keyspace replication factor if you use this authorizer.
  +authorizer: AllowAllAuthorizer
  +
  +# Validity period for permissions cache (fetching permissions can be an
  +# expensive operation depending on the authorizer, CassandraAuthorizer is
  +# one example). Defaults to 2000, set to 0 to disable.
  +# Will be disabled automatically for AllowAllAuthorizer.
  +permissions_validity_in_ms: 2000
   
   # The partitioner is responsible for distributing rows (by key) across
   # nodes in the cluster.  Any IPartitioner may be used, including your
   # own as long as it is on the classpath.  Out of the box, Cassandra
  -# provides org.apache.cassandra.dht.RandomPartitioner
  -# org.apache.cassandra.dht.ByteOrderedPartitioner,
  -# org.apache.cassandra.dht.OrderPreservingPartitioner (deprecated),
  -# and org.apache.cassandra.dht.CollatingOrderPreservingPartitioner
  -# (deprecated).
  +# provides org.apache.cassandra.dht.{Murmur3Partitioner, RandomPartitioner
  +# ByteOrderedPartitioner, OrderPreservingPartitioner (deprecated)}.
   # 
   # - RandomPartitioner distributes rows across the cluster evenly by md5.
  -#   When in doubt, this is the best option.
  +#   This is the default prior to 1.2 and is retained for compatibility.
  +# - Murmur3Partitioner is similar to RandomPartioner but uses Murmur3_128
  +#   Hash Function instead of md5.  When in doubt, this is the best option.
   # - ByteOrderedPartitioner orders rows lexically by key bytes.  BOP allows
   #   scanning rows in key order, but the ordering can generate hot spots
   #   for sequential insertion workloads.
   # - OrderPreservingPartitioner is an obsolete form of BOP, that stores
   # - keys in a less-efficient format and only works with keys that are
   #   UTF8-encoded Strings.
  -# - CollatingOPP colates according to EN,US rules rather than lexical byte
  +# - CollatingOPP collates according to EN,US rules rather than lexical byte
   #   ordering.  Use this as an example if you need custom collation.
   #
   # See http://wiki.apache.org/cassandra/Operations for more on
   # partitioners and token selection.
  -partitioner: org.apache.cassandra.dht.RandomPartitioner
  -
  -# directories where Cassandra should store data on disk.
  +partitioner: org.apache.cassandra.dht.Murmur3Partitioner
  +
  +# Directories where Cassandra should store data on disk.  Cassandra
  +# will spread data evenly across them, subject to the granularity of
  +# the configured compaction strategy.
   data_file_directories:
  -    - /var/vcap/store/cassandra/data
  +    - /var/lib/cassandra/data
   
   # commit log
  -commitlog_directory: /var/vcap/sys/log/cassandra/commitlog
  +commitlog_directory: /var/lib/cassandra/commitlog
  +
  +# policy for data disk failures:
  +# stop: shut down gossip and Thrift, leaving the node effectively dead, but
  +#       can still be inspected via JMX.
  +# best_effort: stop using the failed disk and respond to requests based on
  +#              remaining available sstables.  This means you WILL see obsolete
  +#              data at CL.ONE!
  +# ignore: ignore fatal errors and let requests fail, as in pre-1.2 Cassandra
  +disk_failure_policy: stop
  +
  +# Maximum size of the key cache in memory.
  +#
  +# Each key cache hit saves 1 seek and each row cache hit saves 2 seeks at the
  +# minimum, sometimes more. The key cache is fairly tiny for the amount of
  +# time it saves, so it's worthwhile to use it at large numbers.
  +# The row cache saves even more time, but must contain the entire row,
  +# so it is extremely space-intensive. It's best to only use the
  +# row cache if you have hot rows or static rows.
  +#
  +# NOTE: if you reduce the size, you may not get you hottest keys loaded on startup.
  +#
  +# Default value is empty to make it "auto" (min(5% of Heap (in MB), 100MB)). Set to 0 to disable key cache.
  +key_cache_size_in_mb:
  +
  +# Duration in seconds after which Cassandra should
  +# save the key cache. Caches are saved to saved_caches_directory as
  +# specified in this configuration file.
  +#
  +# Saved caches greatly improve cold-start speeds, and is relatively cheap in
  +# terms of I/O for the key cache. Row cache saving is much more expensive and
  +# has limited use.
  +#
  +# Default is 14400 or 4 hours.
  +key_cache_save_period: 14400
  +
  +# Number of keys from the key cache to save
  +# Disabled by default, meaning all keys are going to be saved
  +# key_cache_keys_to_save: 100
  +
  +# Maximum size of the row cache in memory.
  +# NOTE: if you reduce the size, you may not get you hottest keys loaded on startup.
  +#
  +# Default value is 0, to disable row caching.
  +row_cache_size_in_mb: 0
  +
  +# Duration in seconds after which Cassandra should
  +# safe the row cache. Caches are saved to saved_caches_directory as specified
  +# in this configuration file.
  +#
  +# Saved caches greatly improve cold-start speeds, and is relatively cheap in
  +# terms of I/O for the key cache. Row cache saving is much more expensive and
  +# has limited use.
  +#
  +# Default is 0 to disable saving the row cache.
  +row_cache_save_period: 0
  +
  +# Number of keys from the row cache to save
  +# Disabled by default, meaning all keys are going to be saved
  +# row_cache_keys_to_save: 100
  +
  +# The provider for the row cache to use.
  +#
  +# Supported values are: ConcurrentLinkedHashCacheProvider, SerializingCacheProvider
  +#
  +# SerializingCacheProvider serialises the contents of the row and stores
  +# it in native memory, i.e., off the JVM Heap. Serialized rows take
  +# significantly less memory than "live" rows in the JVM, so you can cache
  +# more rows in a given memory footprint.  And storing the cache off-heap
  +# means you can use smaller heap sizes, reducing the impact of GC pauses.
  +# Note however that when a row is requested from the row cache, it must be
  +# deserialized into the heap for use.
  +#
  +# It is also valid to specify the fully-qualified class name to a class
  +# that implements org.apache.cassandra.cache.IRowCacheProvider.
  +#
  +# Defaults to SerializingCacheProvider
  +row_cache_provider: SerializingCacheProvider
   
   # saved caches
  -saved_caches_directory: /var/vcap/store/cassandra/saved_caches
  +saved_caches_directory: /var/lib/cassandra/saved_caches
   
   # commitlog_sync may be either "periodic" or "batch." 
   # When in batch mode, Cassandra won't ack writes until the commit log
  
positive.code: #    deployment conventions (as it did Facebook's), this is best used
  #    as an example of writing a custom Snitch class.
  #  - Ec2Snitch:
  #    Appropriate for EC2 deployments in a single Region.  Loads Region
  #    and Availability Zone information from the EC2 API. The Region is
  #    treated as the Datacenter, and the Availability Zone as the rack.
  #    Only private IPs are used, so this will not work across multiple
  #    Regions.
  #  - Ec2MultiRegionSnitch:
  
negative.code: # the maximum number of secondary indexes created on a single CF.
  memtable_flush_queue_size: 4
  
  # Whether to, when doing sequential writing, fsync() at intervals in
  # order to force the operating system to flush the dirty
  # buffers. Enable this to avoid sudden dirty buffer flushing from
  # impacting read latencies. Almost always a good idea on SSDs; not
  # necessarily on platters.
  trickle_fsync: false
  trickle_fsync_interval_in_kb: 10240
  
  # TCP port, for commands and data
  storage_port: 7000
  