Reset a Redis Cluster node.
324463
def cluster_reset(self, *, hard=False):
        """"""
        reset = hard and b'HARD' or b'SOFT'
        fut = self.execute(b'CLUSTER', b'RESET', reset)
        return wait_ok(fut)
674040
async def reset_all(self, full=True):
        
        conn = await self.redis()

        if full:
            await conn.flushdb()
        else:
            keys = await conn.keys(self.generate_key('*'))
            await conn.delete(*keys)
160852
def reset(self):
        
        super(MorseComplex, self).reset()

        self.base_partitions = {}
        self.merge_sequence = {}

        self.persistences = []
        self.max_indices = []

        # State properties
        self.persistence = 0.
1315764
def _reset(self):
        """"""
        self._in_declare = False
        self._is_create = False
        self._begin_depth = 0

        self.consume_ws = False
        self.tokens = []
        self.level = 0
94150
def reset(self):
        """"""
        self.domain = \
            dns.name.Name(dns.name.from_text(socket.gethostname())[1:])
        if len(self.domain) == 0:
            self.domain = dns.name.root
        self.nameservers = []
        self.localhosts = set([
          'localhost',
          'loopback',
          '127.0.0.1',
          '0.0.0.0',
          '::1',
          'ip6-localhost',
          'ip6-loopback',
        ])
        # connected and active network interfaces
        self.interfaces = set()
        self.search = set()
        self.search_patterns = ['www.%s.com', 'www.%s.org', 'www.%s.net', ]
        self.port = 53
        self.timeout = 2.0
        self.lifetime = 30.0
        self.keyring = None
        self.keyname = None
        self.keyalgorithm = dns.tsig.default_algorithm
        self.edns = -1
        self.ednsflags = 0
        self.payload = 0
        self.cache = None
1184562
def _reset(self):
        """"""
        self.nr_of_executed_insns = 0
        self.begin = None
        self.end = None
        self.coverage = {}
863694
async def reset(self, force = True, connmark = None):
        '''
        
        '''
        if connmark is None:
            connmark = self.connmark
        self.scheduler.emergesend(ConnectionControlEvent(self, ConnectionControlEvent.RESET, force, connmark))
173194
def _reset(self):
        

        self._name = None
        self._start_time = None
        self._owner = os.getuid()
        self._paths['task_dir'] = None
        self._paths['task_config'] = None
        self._loaded = False
1201588
def reset_cmd_timeout(self):
        """"""
        if self._cmd_timeout:
            self._cmd_timeout.cancel()
        self._cmd_timeout = self.loop.call_later(self.client.timeout,
                                                 self.transport.close)
234569
def reset(self):
        """"""
        if self._topology_type == TOPOLOGY_TYPE.ReplicaSetWithPrimary:
            topology_type = TOPOLOGY_TYPE.ReplicaSetNoPrimary
        else:
            topology_type = self._topology_type

        # The default ServerDescription's type is Unknown.
        sds = dict((address, ServerDescription(address))
                   for address in self._server_descriptions)

        return TopologyDescription(
            topology_type,
            sds,
            self._replica_set_name,
            self._max_set_version,
            self._max_election_id,
            self._topology_settings)
188507
private final void cleanupAfterExceptionDuringNodeDirCheck() {
        if (nodeDirectory != null) {
            // attempt to remove the node directory
            try {
                if (session.exists(nodeDirectory, this)) {
                    session.rmdir(nodeDirectory);
                }
                nodeDirectory = null;
            } catch (final ClusterInfoException cie2) {}
        }
    }
1347950
def _reset_state(self):
        """"""
        self._uuid = None
        self._columns = None
        self._rownumber = 0
        # Internal helper state
        self._state = self._STATE_NONE
        self._data = None
        self._columns = None
1126053
void reset(
    Object        key)
  {
    _nodeKey[0] = key;
    _nodeKey[midPoint()] = key;
    _population = 1;
    _rightChild = null;
    _leftChild = null;
    _balance = 0;
  }
1024374
def reload(self):
        """"""
        status = self.get_status()
        if status != 'running':
            raise ClusterError('cannot reload: cluster is not running')

        process = subprocess.run(
            [self._pg_ctl, 'reload', '-D', self._data_dir],
            stdout=subprocess.PIPE, stderr=subprocess.PIPE)

        stderr = process.stderr

        if process.returncode != 0:
            raise ClusterError(
                'pg_ctl stop exited with status {:d}: {}'.format(
                    process.returncode, stderr.decode()))
634302
def reset(project, user):
        """"""
        d = Project.path(project, user) + "output"
        if os.path.isdir(d):
            shutil.rmtree(d)
            os.makedirs(d)
        else:
            raise flask.abort(404)
        if os.path.exists(Project.path(project, user) + ".done"):
            os.unlink(Project.path(project, user) + ".done")
        if os.path.exists(Project.path(project, user) + ".status"):
            os.unlink(Project.path(project, user) + ".status")
317377
async def cluster_reset_all_nodes(self, soft=True):
        
        option = 'SOFT' if soft else 'HARD'
        res = list()
        for node in await self.cluster_nodes():
            res.append(
                await self.execute_command(
                    'CLUSTER RESET', option, node_id=node['id']
                ))
        return res
584926
def reset():
    
    if hasattr(ray.worker.global_worker, "signal_counters"):
        ray.worker.global_worker.signal_counters = defaultdict(lambda: b"0")