#!/bin/bash

# Copyright 2016 The Kubernetes Authors.
#
# Licensed 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.

set -e
global CASSANDRA_CONF_DIR := '/etc/cassandra'
global CASSANDRA_CFG := "$CASSANDRA_CONF_DIR/cassandra.yaml"

# we are doing StatefulSet or just setting our seeds
if test -z $CASSANDRA_SEEDS {
  global HOSTNAME := $[hostname -f]
  global CASSANDRA_SEEDS := $[hostname -f]
}

# The following vars relate to there counter parts in $CASSANDRA_CFG
# for instance rpc_address
global CASSANDRA_RPC_ADDRESS := $(CASSANDRA_RPC_ADDRESS:-0.0.0.0)
global CASSANDRA_NUM_TOKENS := $(CASSANDRA_NUM_TOKENS:-32)
global CASSANDRA_CLUSTER_NAME := $(CASSANDRA_CLUSTER_NAME:='Test Cluster')
global CASSANDRA_LISTEN_ADDRESS := $(POD_IP:-$HOSTNAME)
global CASSANDRA_BROADCAST_ADDRESS := $(POD_IP:-$HOSTNAME)
global CASSANDRA_BROADCAST_RPC_ADDRESS := $(POD_IP:-$HOSTNAME)
global CASSANDRA_DISK_OPTIMIZATION_STRATEGY := $(CASSANDRA_DISK_OPTIMIZATION_STRATEGY:-ssd)
global CASSANDRA_MIGRATION_WAIT := $(CASSANDRA_MIGRATION_WAIT:-1)
global CASSANDRA_ENDPOINT_SNITCH := $(CASSANDRA_ENDPOINT_SNITCH:-SimpleSnitch)
global CASSANDRA_DC := $(CASSANDRA_DC)
global CASSANDRA_RACK := $(CASSANDRA_RACK)
global CASSANDRA_RING_DELAY := $(CASSANDRA_RING_DELAY:-30000)
global CASSANDRA_AUTO_BOOTSTRAP := $(CASSANDRA_AUTO_BOOTSTRAP:-true)
global CASSANDRA_SEEDS := $(CASSANDRA_SEEDS:false)
global CASSANDRA_SEED_PROVIDER := $(CASSANDRA_SEED_PROVIDER:-org.apache.cassandra.locator.SimpleSeedProvider)
global CASSANDRA_AUTO_BOOTSTRAP := $(CASSANDRA_AUTO_BOOTSTRAP:false)

# Turn off JMX auth
global CASSANDRA_OPEN_JMX := $(CASSANDRA_OPEN_JMX:-false)
# send GC to STDOUT
global CASSANDRA_GC_STDOUT := $(CASSANDRA_GC_STDOUT:-false)

echo Starting Cassandra on $(CASSANDRA_LISTEN_ADDRESS)
echo CASSANDRA_CONF_DIR $(CASSANDRA_CONF_DIR)
echo CASSANDRA_CFG $(CASSANDRA_CFG)
echo CASSANDRA_AUTO_BOOTSTRAP $(CASSANDRA_AUTO_BOOTSTRAP)
echo CASSANDRA_BROADCAST_ADDRESS $(CASSANDRA_BROADCAST_ADDRESS)
echo CASSANDRA_BROADCAST_RPC_ADDRESS $(CASSANDRA_BROADCAST_RPC_ADDRESS)
echo CASSANDRA_CLUSTER_NAME $(CASSANDRA_CLUSTER_NAME)
echo CASSANDRA_COMPACTION_THROUGHPUT_MB_PER_SEC $(CASSANDRA_COMPACTION_THROUGHPUT_MB_PER_SEC)
echo CASSANDRA_CONCURRENT_COMPACTORS $(CASSANDRA_CONCURRENT_COMPACTORS)
echo CASSANDRA_CONCURRENT_READS $(CASSANDRA_CONCURRENT_READS)
echo CASSANDRA_CONCURRENT_WRITES $(CASSANDRA_CONCURRENT_WRITES)
echo CASSANDRA_COUNTER_CACHE_SIZE_IN_MB $(CASSANDRA_COUNTER_CACHE_SIZE_IN_MB)
echo CASSANDRA_DC $(CASSANDRA_DC)
echo CASSANDRA_DISK_OPTIMIZATION_STRATEGY $(CASSANDRA_DISK_OPTIMIZATION_STRATEGY)
echo CASSANDRA_ENDPOINT_SNITCH $(CASSANDRA_ENDPOINT_SNITCH)
echo CASSANDRA_GC_WARN_THRESHOLD_IN_MS $(CASSANDRA_GC_WARN_THRESHOLD_IN_MS)
echo CASSANDRA_INTERNODE_COMPRESSION $(CASSANDRA_INTERNODE_COMPRESSION)
echo CASSANDRA_KEY_CACHE_SIZE_IN_MB $(CASSANDRA_KEY_CACHE_SIZE_IN_MB)
echo CASSANDRA_LISTEN_ADDRESS $(CASSANDRA_LISTEN_ADDRESS)
echo CASSANDRA_LISTEN_INTERFACE $(CASSANDRA_LISTEN_INTERFACE)
echo CASSANDRA_MEMTABLE_ALLOCATION_TYPE $(CASSANDRA_MEMTABLE_ALLOCATION_TYPE)
echo CASSANDRA_MEMTABLE_CLEANUP_THRESHOLD $(CASSANDRA_MEMTABLE_CLEANUP_THRESHOLD)
echo CASSANDRA_MEMTABLE_FLUSH_WRITERS $(CASSANDRA_MEMTABLE_FLUSH_WRITERS)
echo CASSANDRA_MIGRATION_WAIT $(CASSANDRA_MIGRATION_WAIT)
echo CASSANDRA_NUM_TOKENS $(CASSANDRA_NUM_TOKENS)
echo CASSANDRA_RACK $(CASSANDRA_RACK)
echo CASSANDRA_RING_DELAY $(CASSANDRA_RING_DELAY)
echo CASSANDRA_RPC_ADDRESS $(CASSANDRA_RPC_ADDRESS)
echo CASSANDRA_RPC_INTERFACE $(CASSANDRA_RPC_INTERFACE)
echo CASSANDRA_SEEDS $(CASSANDRA_SEEDS)
echo CASSANDRA_SEED_PROVIDER $(CASSANDRA_SEED_PROVIDER)


# if DC and RACK are set, use GossipingPropertyFileSnitch
if [[ $CASSANDRA_DC && $CASSANDRA_RACK ]] {
  echo "dc=$CASSANDRA_DC" > $CASSANDRA_CONF_DIR/cassandra-rackdc.properties
  echo "rack=$CASSANDRA_RACK" >> $CASSANDRA_CONF_DIR/cassandra-rackdc.properties
  global CASSANDRA_ENDPOINT_SNITCH := '"GossipingPropertyFileSnitch'"
}

if test -n $CASSANDRA_MAX_HEAP {
  sed -ri "s/^(#)?-Xmx[0-9]+.*/-Xmx$CASSANDRA_MAX_HEAP/" "$CASSANDRA_CONF_DIR/jvm.options"
  sed -ri "s/^(#)?-Xms[0-9]+.*/-Xms$CASSANDRA_MAX_HEAP/" "$CASSANDRA_CONF_DIR/jvm.options"
}

if test -n $CASSANDRA_REPLACE_NODE {
   echo "-Dcassandra.replace_address=$CASSANDRA_REPLACE_NODE/" >> "$CASSANDRA_CONF_DIR/jvm.options"
}

for rackdc in [dc rack] {
  global var := ""CASSANDRA_$(rackdc^^)""
  global val := $(!var)
  if test $val {
	sed -ri 's/^('"$rackdc"'=).*/\1 '"$val"'/' "$CASSANDRA_CONF_DIR/cassandra-rackdc.properties"
  }
}

# TODO what else needs to be modified
for yaml in [\
  broadcast_address \
  broadcast_rpc_address \
  cluster_name \
  disk_optimization_strategy \
  endpoint_snitch \
  listen_address \
  num_tokens \
  rpc_address \
  start_rpc \
  key_cache_size_in_mb \
  concurrent_reads \
  concurrent_writes \
  memtable_cleanup_threshold \
  memtable_allocation_type \
  memtable_flush_writers \
  concurrent_compactors \
  compaction_throughput_mb_per_sec \
  counter_cache_size_in_mb \
  internode_compression \
  endpoint_snitch \
  gc_warn_threshold_in_ms \
  listen_interface \
  rpc_interface] \
   {
  global var := ""CASSANDRA_$(yaml^^)""
  global val := $(!var)
  if test $val {
    sed -ri 's/^(# )?('"$yaml"':).*/\2 '"$val"'/' $CASSANDRA_CFG
  }
}

echo "auto_bootstrap: $(CASSANDRA_AUTO_BOOTSTRAP)" >> $CASSANDRA_CFG

# set the seed to itself.  This is only for the first pod, otherwise
# it will be able to get seeds from the seed provider
if [[ $CASSANDRA_SEEDS == 'false' ]] {
  sed -ri 's/- seeds:.*/- seeds: "'"$POD_IP"'"/' $CASSANDRA_CFG
} else { # if we have seeds set them.  Probably StatefulSet
  sed -ri 's/- seeds:.*/- seeds: "'"$CASSANDRA_SEEDS"'"/' $CASSANDRA_CFG
}

sed -ri 's/- class_name: SEED_PROVIDER/- class_name: '"$CASSANDRA_SEED_PROVIDER"'/' $CASSANDRA_CFG

# send gc to stdout
if [[ $CASSANDRA_GC_STDOUT == 'true' ]] {
  sed -ri 's/ -Xloggc:\/var\/log\/cassandra\/gc\.log//' $CASSANDRA_CONF_DIR/cassandra-env.sh
}

# enable RMI and JMX to work on one port
echo "JVM_OPTS=\"\$JVM_OPTS -Djava.rmi.server.hostname=$POD_IP\"" >> $CASSANDRA_CONF_DIR/cassandra-env.sh

# getting WARNING messages with Migration Service
echo "-Dcassandra.migration_task_wait_in_seconds=$(CASSANDRA_MIGRATION_WAIT)" >> $CASSANDRA_CONF_DIR/jvm.options
echo "-Dcassandra.ring_delay_ms=$(CASSANDRA_RING_DELAY)" >> $CASSANDRA_CONF_DIR/jvm.options

if [[ $CASSANDRA_OPEN_JMX == 'true' ]] {
  export LOCAL_JMX=no
  sed -ri 's/ -Dcom\.sun\.management\.jmxremote\.authenticate=true/ -Dcom\.sun\.management\.jmxremote\.authenticate=false/' $CASSANDRA_CONF_DIR/cassandra-env.sh
  sed -ri 's/ -Dcom\.sun\.management\.jmxremote\.password\.file=\/etc\/cassandra\/jmxremote\.password//' $CASSANDRA_CONF_DIR/cassandra-env.sh
}

chmod 700 $(CASSANDRA_DATA)
chown -c -R cassandra $(CASSANDRA_DATA) $(CASSANDRA_CONF_DIR)

export CLASSPATH=/kubernetes-cassandra.jar

su cassandra -c "$CASSANDRA_HOME/bin/cassandra -f"
(CommandList
  children: [
    (C {(set)} {(-e)})
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:CASSANDRA_CONF_DIR)
          op: Equal
          rhs: {(/etc/cassandra)}
          spids: [48]
        )
      ]
      spids: [48]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:CASSANDRA_CFG)
          op: Equal
          rhs: {($ VSub_Name "$CASSANDRA_CONF_DIR") (/cassandra.yaml)}
          spids: [51]
        )
      ]
      spids: [51]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$CASSANDRA_SEEDS"))} {(Lit_Other "]")})
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:HOSTNAME)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: (CommandList children:[(C {(hostname)} {(-f)})])
                        left_token: <Left_CommandSub "$(">
                        spids: [76 80]
                      )
                    }
                  spids: [75]
                )
              ]
              spids: [75]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:CASSANDRA_SEEDS)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: (CommandList children:[(C {(hostname)} {(-f)})])
                        left_token: <Left_CommandSub "$(">
                        spids: [84 88]
                      )
                    }
                  spids: [83]
                )
              ]
              spids: [83]
            )
          ]
          spids: [-1 72]
        )
      ]
      spids: [-1 90]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:CASSANDRA_RPC_ADDRESS)
          op: Equal
          rhs: 
            {
              (DQ 
                (BracedVarSub
                  token: <VSub_Name CASSANDRA_RPC_ADDRESS>
                  suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{(0.0.0.0)})
                  spids: [101 105]
                )
              )
            }
          spids: [99]
        )
      ]
      spids: [99]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:CASSANDRA_NUM_TOKENS)
          op: Equal
          rhs: 
            {
              (DQ 
                (BracedVarSub
                  token: <VSub_Name CASSANDRA_NUM_TOKENS>
                  suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{(32)})
                  spids: [110 114]
                )
              )
            }
          spids: [108]
        )
      ]
      spids: [108]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:CASSANDRA_CLUSTER_NAME)
          op: Equal
          rhs: 
            {
              (DQ 
                (BracedVarSub
                  token: <VSub_Name CASSANDRA_CLUSTER_NAME>
                  suffix_op: (StringUnary op_id:VTest_ColonEquals arg_word:{("'Test Cluster'")})
                  spids: [119 123]
                )
              )
            }
          spids: [117]
        )
      ]
      spids: [117]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:CASSANDRA_LISTEN_ADDRESS)
          op: Equal
          rhs: 
            {
              (BracedVarSub
                token: <VSub_Name POD_IP>
                suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{($ VSub_Name "$HOSTNAME")})
                spids: [127 131]
              )
            }
          spids: [126]
        )
      ]
      spids: [126]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:CASSANDRA_BROADCAST_ADDRESS)
          op: Equal
          rhs: 
            {
              (BracedVarSub
                token: <VSub_Name POD_IP>
                suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{($ VSub_Name "$HOSTNAME")})
                spids: [134 138]
              )
            }
          spids: [133]
        )
      ]
      spids: [133]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:CASSANDRA_BROADCAST_RPC_ADDRESS)
          op: Equal
          rhs: 
            {
              (BracedVarSub
                token: <VSub_Name POD_IP>
                suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{($ VSub_Name "$HOSTNAME")})
                spids: [141 145]
              )
            }
          spids: [140]
        )
      ]
      spids: [140]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:CASSANDRA_DISK_OPTIMIZATION_STRATEGY)
          op: Equal
          rhs: 
            {
              (DQ 
                (BracedVarSub
                  token: <VSub_Name CASSANDRA_DISK_OPTIMIZATION_STRATEGY>
                  suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{(ssd)})
                  spids: [149 153]
                )
              )
            }
          spids: [147]
        )
      ]
      spids: [147]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:CASSANDRA_MIGRATION_WAIT)
          op: Equal
          rhs: 
            {
              (DQ 
                (BracedVarSub
                  token: <VSub_Name CASSANDRA_MIGRATION_WAIT>
                  suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{(1)})
                  spids: [158 162]
                )
              )
            }
          spids: [156]
        )
      ]
      spids: [156]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:CASSANDRA_ENDPOINT_SNITCH)
          op: Equal
          rhs: 
            {
              (DQ 
                (BracedVarSub
                  token: <VSub_Name CASSANDRA_ENDPOINT_SNITCH>
                  suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{(SimpleSnitch)})
                  spids: [167 171]
                )
              )
            }
          spids: [165]
        )
      ]
      spids: [165]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:CASSANDRA_DC)
          op: Equal
          rhs: {(DQ (${ VSub_Name CASSANDRA_DC))}
          spids: [174]
        )
      ]
      spids: [174]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:CASSANDRA_RACK)
          op: Equal
          rhs: {(DQ (${ VSub_Name CASSANDRA_RACK))}
          spids: [181]
        )
      ]
      spids: [181]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:CASSANDRA_RING_DELAY)
          op: Equal
          rhs: 
            {
              (DQ 
                (BracedVarSub
                  token: <VSub_Name CASSANDRA_RING_DELAY>
                  suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{(30000)})
                  spids: [190 194]
                )
              )
            }
          spids: [188]
        )
      ]
      spids: [188]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:CASSANDRA_AUTO_BOOTSTRAP)
          op: Equal
          rhs: 
            {
              (DQ 
                (BracedVarSub
                  token: <VSub_Name CASSANDRA_AUTO_BOOTSTRAP>
                  suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{(true)})
                  spids: [199 203]
                )
              )
            }
          spids: [197]
        )
      ]
      spids: [197]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:CASSANDRA_SEEDS)
          op: Equal
          rhs: 
            {
              (DQ 
                (BracedVarSub
                  token: <VSub_Name CASSANDRA_SEEDS>
                  suffix_op: (Slice begin:(ArithVarRef name:false))
                  spids: [208 212]
                )
              )
            }
          spids: [206]
        )
      ]
      spids: [206]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:CASSANDRA_SEED_PROVIDER)
          op: Equal
          rhs: 
            {
              (DQ 
                (BracedVarSub
                  token: <VSub_Name CASSANDRA_SEED_PROVIDER>
                  suffix_op: 
                    (StringUnary
                      op_id: VTest_ColonHyphen
                      arg_word: {(org.apache.cassandra.locator.SimpleSeedProvider)}
                    )
                  spids: [217 221]
                )
              )
            }
          spids: [215]
        )
      ]
      spids: [215]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:CASSANDRA_AUTO_BOOTSTRAP)
          op: Equal
          rhs: 
            {
              (DQ 
                (BracedVarSub
                  token: <VSub_Name CASSANDRA_AUTO_BOOTSTRAP>
                  suffix_op: (Slice begin:(ArithVarRef name:false))
                  spids: [226 230]
                )
              )
            }
          spids: [224]
        )
      ]
      spids: [224]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:CASSANDRA_OPEN_JMX)
          op: Equal
          rhs: 
            {
              (DQ 
                (BracedVarSub
                  token: <VSub_Name CASSANDRA_OPEN_JMX>
                  suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{(false)})
                  spids: [239 243]
                )
              )
            }
          spids: [237]
        )
      ]
      spids: [237]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:CASSANDRA_GC_STDOUT)
          op: Equal
          rhs: 
            {
              (DQ 
                (BracedVarSub
                  token: <VSub_Name CASSANDRA_GC_STDOUT>
                  suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{(false)})
                  spids: [251 255]
                )
              )
            }
          spids: [249]
        )
      ]
      spids: [249]
    )
    (C {(echo)} {(Starting)} {(Cassandra)} {(on)} {(${ VSub_Name CASSANDRA_LISTEN_ADDRESS)})
    (C {(echo)} {(CASSANDRA_CONF_DIR)} {(${ VSub_Name CASSANDRA_CONF_DIR)})
    (C {(echo)} {(CASSANDRA_CFG)} {(${ VSub_Name CASSANDRA_CFG)})
    (C {(echo)} {(CASSANDRA_AUTO_BOOTSTRAP)} {(${ VSub_Name CASSANDRA_AUTO_BOOTSTRAP)})
    (C {(echo)} {(CASSANDRA_BROADCAST_ADDRESS)} {(${ VSub_Name CASSANDRA_BROADCAST_ADDRESS)})
    (C {(echo)} {(CASSANDRA_BROADCAST_RPC_ADDRESS)} {(${ VSub_Name CASSANDRA_BROADCAST_RPC_ADDRESS)})
    (C {(echo)} {(CASSANDRA_CLUSTER_NAME)} {(${ VSub_Name CASSANDRA_CLUSTER_NAME)})
    (C {(echo)} {(CASSANDRA_COMPACTION_THROUGHPUT_MB_PER_SEC)} 
      {(${ VSub_Name CASSANDRA_COMPACTION_THROUGHPUT_MB_PER_SEC)}
    )
    (C {(echo)} {(CASSANDRA_CONCURRENT_COMPACTORS)} {(${ VSub_Name CASSANDRA_CONCURRENT_COMPACTORS)})
    (C {(echo)} {(CASSANDRA_CONCURRENT_READS)} {(${ VSub_Name CASSANDRA_CONCURRENT_READS)})
    (C {(echo)} {(CASSANDRA_CONCURRENT_WRITES)} {(${ VSub_Name CASSANDRA_CONCURRENT_WRITES)})
    (C {(echo)} {(CASSANDRA_COUNTER_CACHE_SIZE_IN_MB)} 
      {(${ VSub_Name CASSANDRA_COUNTER_CACHE_SIZE_IN_MB)}
    )
    (C {(echo)} {(CASSANDRA_DC)} {(${ VSub_Name CASSANDRA_DC)})
    (C {(echo)} {(CASSANDRA_DISK_OPTIMIZATION_STRATEGY)} 
      {(${ VSub_Name CASSANDRA_DISK_OPTIMIZATION_STRATEGY)}
    )
    (C {(echo)} {(CASSANDRA_ENDPOINT_SNITCH)} {(${ VSub_Name CASSANDRA_ENDPOINT_SNITCH)})
    (C {(echo)} {(CASSANDRA_GC_WARN_THRESHOLD_IN_MS)} {(${ VSub_Name CASSANDRA_GC_WARN_THRESHOLD_IN_MS)})
    (C {(echo)} {(CASSANDRA_INTERNODE_COMPRESSION)} {(${ VSub_Name CASSANDRA_INTERNODE_COMPRESSION)})
    (C {(echo)} {(CASSANDRA_KEY_CACHE_SIZE_IN_MB)} {(${ VSub_Name CASSANDRA_KEY_CACHE_SIZE_IN_MB)})
    (C {(echo)} {(CASSANDRA_LISTEN_ADDRESS)} {(${ VSub_Name CASSANDRA_LISTEN_ADDRESS)})
    (C {(echo)} {(CASSANDRA_LISTEN_INTERFACE)} {(${ VSub_Name CASSANDRA_LISTEN_INTERFACE)})
    (C {(echo)} {(CASSANDRA_MEMTABLE_ALLOCATION_TYPE)} 
      {(${ VSub_Name CASSANDRA_MEMTABLE_ALLOCATION_TYPE)}
    )
    (C {(echo)} {(CASSANDRA_MEMTABLE_CLEANUP_THRESHOLD)} 
      {(${ VSub_Name CASSANDRA_MEMTABLE_CLEANUP_THRESHOLD)}
    )
    (C {(echo)} {(CASSANDRA_MEMTABLE_FLUSH_WRITERS)} {(${ VSub_Name CASSANDRA_MEMTABLE_FLUSH_WRITERS)})
    (C {(echo)} {(CASSANDRA_MIGRATION_WAIT)} {(${ VSub_Name CASSANDRA_MIGRATION_WAIT)})
    (C {(echo)} {(CASSANDRA_NUM_TOKENS)} {(${ VSub_Name CASSANDRA_NUM_TOKENS)})
    (C {(echo)} {(CASSANDRA_RACK)} {(${ VSub_Name CASSANDRA_RACK)})
    (C {(echo)} {(CASSANDRA_RING_DELAY)} {(${ VSub_Name CASSANDRA_RING_DELAY)})
    (C {(echo)} {(CASSANDRA_RPC_ADDRESS)} {(${ VSub_Name CASSANDRA_RPC_ADDRESS)})
    (C {(echo)} {(CASSANDRA_RPC_INTERFACE)} {(${ VSub_Name CASSANDRA_RPC_INTERFACE)})
    (C {(echo)} {(CASSANDRA_SEEDS)} {(${ VSub_Name CASSANDRA_SEEDS)})
    (C {(echo)} {(CASSANDRA_SEED_PROVIDER)} {(${ VSub_Name CASSANDRA_SEED_PROVIDER)})
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (DBracket
                  expr: 
                    (LogicalAnd
                      left: (WordTest w:{($ VSub_Name "$CASSANDRA_DC")})
                      right: (WordTest w:{($ VSub_Name "$CASSANDRA_RACK")})
                    )
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (SimpleCommand
              words: [{(echo)} {(DQ ("dc=") ($ VSub_Name "$CASSANDRA_DC"))}]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {($ VSub_Name "$CASSANDRA_CONF_DIR") (/cassandra-rackdc.properties)}
                  spids: [539]
                )
              ]
            )
            (SimpleCommand
              words: [{(echo)} {(DQ ("rack=") ($ VSub_Name "$CASSANDRA_RACK"))}]
              redirects: [
                (Redir
                  op_id: Redir_DGreat
                  fd: -1
                  arg_word: {($ VSub_Name "$CASSANDRA_CONF_DIR") (/cassandra-rackdc.properties)}
                  spids: [552]
                )
              ]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:CASSANDRA_ENDPOINT_SNITCH)
                  op: Equal
                  rhs: {(DQ (GossipingPropertyFileSnitch))}
                  spids: [558]
                )
              ]
              spids: [558]
            )
          ]
          spids: [-1 529]
        )
      ]
      spids: [-1 563]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (C {(Lit_Other "[")} {(-n)} {(DQ ($ VSub_Name "$CASSANDRA_MAX_HEAP"))} {(Lit_Other "]")})
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (C {(sed)} {(-ri)} 
              {(DQ ("s/^(#)?-Xmx[0-9]+.*/-Xmx") ($ VSub_Name "$CASSANDRA_MAX_HEAP") (/))} {(DQ ($ VSub_Name "$CASSANDRA_CONF_DIR") (/jvm.options))}
            )
            (C {(sed)} {(-ri)} 
              {(DQ ("s/^(#)?-Xms[0-9]+.*/-Xms") ($ VSub_Name "$CASSANDRA_MAX_HEAP") (/))} {(DQ ($ VSub_Name "$CASSANDRA_CONF_DIR") (/jvm.options))}
            )
          ]
          spids: [-1 579]
        )
      ]
      spids: [-1 613]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (C {(Lit_Other "[")} {(-n)} {(DQ ($ VSub_Name "$CASSANDRA_REPLACE_NODE"))} 
                  {(Lit_Other "]")}
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (SimpleCommand
              words: [
                {(echo)}
                {(DQ ("-Dcassandra.replace_address=") ($ VSub_Name "$CASSANDRA_REPLACE_NODE") (/))}
              ]
              redirects: [
                (Redir
                  op_id: Redir_DGreat
                  fd: -1
                  arg_word: {(DQ ($ VSub_Name "$CASSANDRA_CONF_DIR") (/jvm.options))}
                  spids: [640]
                )
              ]
            )
          ]
          spids: [-1 629]
        )
      ]
      spids: [-1 647]
    )
    (ForEach
      iter_name: rackdc
      iter_words: [{(dc)} {(rack)}]
      do_arg_iter: False
      body: 
        (DoGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:var)
                  op: Equal
                  rhs: 
                    {
                      (DQ (CASSANDRA_) 
                        (BracedVarSub
                          token: <VSub_Name rackdc>
                          suffix_op: (StringUnary op_id:VOp1_DCaret arg_word:{(SQ )})
                          spids: [667 670]
                        )
                      )
                    }
                  spids: [664]
                )
              ]
              spids: [664]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:val)
                  op: Equal
                  rhs: {(DQ (BracedVarSub token:<VSub_Name var> prefix_op:VSub_Bang spids:[676679]))}
                  spids: [674]
                )
              ]
              spids: [674]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: (C {(Lit_Other "[")} {(DQ ($ VSub_Name "$val"))} {(Lit_Other "]")})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(sed)} {(-ri)} 
                      {(SQ <"s/^(">) (DQ ($ VSub_Name "$rackdc")) (SQ <"=).*/\\1 ">) 
                        (DQ ($ VSub_Name "$val")) (SQ </>)
                      } {(DQ ($ VSub_Name "$CASSANDRA_CONF_DIR") (/cassandra-rackdc.properties))}
                    )
                  ]
                  spids: [-1 694]
                )
              ]
              spids: [-1 723]
            )
          ]
          spids: [661 725]
        )
      spids: [655 659]
    )
    (ForEach
      iter_name: yaml
      iter_words: [
        {(broadcast_address)}
        {(broadcast_rpc_address)}
        {(cluster_name)}
        {(disk_optimization_strategy)}
        {(endpoint_snitch)}
        {(listen_address)}
        {(num_tokens)}
        {(rpc_address)}
        {(start_rpc)}
        {(key_cache_size_in_mb)}
        {(concurrent_reads)}
        {(concurrent_writes)}
        {(memtable_cleanup_threshold)}
        {(memtable_allocation_type)}
        {(memtable_flush_writers)}
        {(concurrent_compactors)}
        {(compaction_throughput_mb_per_sec)}
        {(counter_cache_size_in_mb)}
        {(internode_compression)}
        {(endpoint_snitch)}
        {(gc_warn_threshold_in_ms)}
        {(listen_interface)}
        {(rpc_interface)}
      ]
      do_arg_iter: False
      body: 
        (DoGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:var)
                  op: Equal
                  rhs: 
                    {
                      (DQ (CASSANDRA_) 
                        (BracedVarSub
                          token: <VSub_Name yaml>
                          suffix_op: (StringUnary op_id:VOp1_DCaret arg_word:{(SQ )})
                          spids: [839 842]
                        )
                      )
                    }
                  spids: [836]
                )
              ]
              spids: [836]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:val)
                  op: Equal
                  rhs: {(DQ (BracedVarSub token:<VSub_Name var> prefix_op:VSub_Bang spids:[848851]))}
                  spids: [846]
                )
              ]
              spids: [846]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: (C {(Lit_Other "[")} {(DQ ($ VSub_Name "$val"))} {(Lit_Other "]")})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(sed)} {(-ri)} 
                      {(SQ <"s/^(# )?(">) (DQ ($ VSub_Name "$yaml")) (SQ <":).*/\\2 ">) 
                        (DQ ($ VSub_Name "$val")) (SQ </>)
                      } {(DQ ($ VSub_Name "$CASSANDRA_CFG"))}
                    )
                  ]
                  spids: [-1 866]
                )
              ]
              spids: [-1 894]
            )
          ]
          spids: [833 896]
        )
      spids: [736 831]
    )
    (SimpleCommand
      words: [{(echo)} {(DQ ("auto_bootstrap: ") (${ VSub_Name CASSANDRA_AUTO_BOOTSTRAP))}]
      redirects: [
        (Redir
          op_id: Redir_DGreat
          fd: -1
          arg_word: {($ VSub_Name "$CASSANDRA_CFG")}
          spids: [908]
        )
      ]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (DBracket
                  expr: 
                    (BoolBinary
                      op_id: BoolBinary_GlobDEqual
                      left: {($ VSub_Name "$CASSANDRA_SEEDS")}
                      right: {(SQ <false>)}
                    )
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (C {(sed)} {(-ri)} 
              {(SQ <"s/- seeds:.*/- seeds: \"">) (DQ ($ VSub_Name "$POD_IP")) (SQ <"\"/">)} {($ VSub_Name "$CASSANDRA_CFG")}
            )
          ]
          spids: [-1 934]
        )
      ]
      else_action: [
        (C {(sed)} {(-ri)} 
          {(SQ <"s/- seeds:.*/- seeds: \"">) (DQ ($ VSub_Name "$CASSANDRA_SEEDS")) (SQ <"\"/">)} {($ VSub_Name "$CASSANDRA_CFG")}
        )
      ]
      spids: [953 975]
    )
    (C {(sed)} {(-ri)} 
      {(SQ <"s/- class_name: SEED_PROVIDER/- class_name: ">) 
        (DQ ($ VSub_Name "$CASSANDRA_SEED_PROVIDER")) (SQ </>)
      } {($ VSub_Name "$CASSANDRA_CFG")}
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (DBracket
                  expr: 
                    (BoolBinary
                      op_id: BoolBinary_GlobDEqual
                      left: {($ VSub_Name "$CASSANDRA_GC_STDOUT")}
                      right: {(SQ <true>)}
                    )
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (C {(sed)} {(-ri)} {(SQ <"s/ -Xloggc:\\/var\\/log\\/cassandra\\/gc\\.log//">)} 
              {($ VSub_Name "$CASSANDRA_CONF_DIR") (/cassandra-env.sh)}
            )
          ]
          spids: [-1 1013]
        )
      ]
      spids: [-1 1027]
    )
    (SimpleCommand
      words: [
        {(echo)}
        {
          (DQ ("JVM_OPTS=") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
            (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("JVM_OPTS -Djava.rmi.server.hostname=") ($ VSub_Name "$POD_IP") 
            (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
          )
        }
      ]
      redirects: [
        (Redir
          op_id: Redir_DGreat
          fd: -1
          arg_word: {($ VSub_Name "$CASSANDRA_CONF_DIR") (/cassandra-env.sh)}
          spids: [1044]
        )
      ]
    )
    (SimpleCommand
      words: [
        {(echo)}
        {
          (DQ ("-Dcassandra.migration_task_wait_in_seconds=") (${ VSub_Name CASSANDRA_MIGRATION_WAIT))
        }
      ]
      redirects: [
        (Redir
          op_id: Redir_DGreat
          fd: -1
          arg_word: {($ VSub_Name "$CASSANDRA_CONF_DIR") (/jvm.options)}
          spids: [1062]
        )
      ]
    )
    (SimpleCommand
      words: [{(echo)} {(DQ ("-Dcassandra.ring_delay_ms=") (${ VSub_Name CASSANDRA_RING_DELAY))}]
      redirects: [
        (Redir
          op_id: Redir_DGreat
          fd: -1
          arg_word: {($ VSub_Name "$CASSANDRA_CONF_DIR") (/jvm.options)}
          spids: [1076]
        )
      ]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (DBracket
                  expr: 
                    (BoolBinary
                      op_id: BoolBinary_GlobDEqual
                      left: {($ VSub_Name "$CASSANDRA_OPEN_JMX")}
                      right: {(SQ <true>)}
                    )
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (C {(export)} {(Lit_VarLike "LOCAL_JMX=") (no)})
            (C {(sed)} {(-ri)} 
              {
                (SQ 
                  <
"s/ -Dcom\\.sun\\.management\\.jmxremote\\.authenticate=true/ -Dcom\\.sun\\.management\\.jmxremote\\.authenticate=false/"
                  >
                )
              } {($ VSub_Name "$CASSANDRA_CONF_DIR") (/cassandra-env.sh)}
            )
            (C {(sed)} {(-ri)} 
              {
                (SQ 
                  <
"s/ -Dcom\\.sun\\.management\\.jmxremote\\.password\\.file=\\/etc\\/cassandra\\/jmxremote\\.password//"
                  >
                )
              } {($ VSub_Name "$CASSANDRA_CONF_DIR") (/cassandra-env.sh)}
            )
          ]
          spids: [-1 1097]
        )
      ]
      spids: [-1 1129]
    )
    (C {(chmod)} {(700)} {(DQ (${ VSub_Name CASSANDRA_DATA))})
    (C {(chown)} {(-c)} {(-R)} {(cassandra)} {(DQ (${ VSub_Name CASSANDRA_DATA))} 
      {(DQ (${ VSub_Name CASSANDRA_CONF_DIR))}
    )
    (C {(export)} {(Lit_VarLike "CLASSPATH=") (/kubernetes-cassandra.jar)})
    (C {(su)} {(cassandra)} {(-c)} {(DQ ($ VSub_Name "$CASSANDRA_HOME") ("/bin/cassandra -f"))})
  ]
)