docs: def stop(self, wait=True, wait_other_notice=False, signal_event=signal.SIGTERM, **kwargs):
          """
          Stop the node.
            - wait: if True (the default), wait for the Cassandra process to be
              really dead. Otherwise return after having sent the kill signal.
            - wait_other_notice: return only when the other live nodes of the
              cluster have marked this node has dead.
            - signal_event: Signal event to send to Cassandra; default is to
              let Cassandra clean up and shut down properly (SIGTERM [15])
            - Optional:
               + gently: Let Cassandra clean up and shut down properly; unless
                         false perform a 'kill -9' which shuts down faster.
          """
          if self.is_running():
              if wait_other_notice:
                  marks = [(node, node.mark_log()) for node in list(self.cluster.nodes.values()) if node.is_live() and node is not self]
  
              if common.is_win():
                  # Just taskkill the instance, don't bother trying to shut it down gracefully.
                  # Node recovery should prevent data loss from hard shutdown.
                  # We have recurring issues with nodes not stopping / releasing files in the CI
                  # environment so it makes more sense just to murder it hard since there's
                  # really little downside.
  
                  # We want the node to flush its data before shutdown as some tests rely on small writes being present.
                  # The default Periodic sync at 10 ms may not have flushed data yet, causing tests to fail.
                  # This is not a hard requirement, however, so we swallow any exceptions this may throw and kill anyway.
                  if signal_event is signal.SIGTERM:
                      try:
                          self.flush()
                      except:
                          common.warning("Failed to flush node: {0} on shutdown.".format(self.name))
                          pass
  
                  os.system("taskkill /F /PID " + str(self.pid))
                  if self._find_pid_on_windows():
                      common.warning("Failed to terminate node: {0} with pid: {1}".format(self.name, self.pid))
              else:
                  # Determine if the signal event should be updated to keep API compatibility
                  if 'gently' in kwargs and kwargs['gently'] is False:
                      signal_event = signal.SIGKILL
  
                  os.kill(self.pid, signal_event)
  
              if wait_other_notice:
                  for node, mark in marks:
                      node.watch_log_for_death(self, from_mark=mark)
              else:
                  time.sleep(.1)
  
              still_running = self.is_running()
              if still_running and wait:
                  wait_time_sec = 1
                  for i in xrange(0, 7):
                      # we'll double the wait time each try and cassandra should
                      # not take more than 1 minute to shutdown
                      time.sleep(wait_time_sec)
                      if not self.is_running():
                          return True
                      wait_time_sec = wait_time_sec * 2
                  raise NodeError("Problem stopping node %s" % self.name)
              else:
                  return True
          else:
              return False