Sends a reset signal to the network.
353339
def sendReset(self, sequenceId=0):
    
    for col in xrange(self.numColumns):
      self.sensorInputs[col].addResetToQueue(sequenceId)
    self.network.run(1)
91897
public function reset()
    {
        $this->values[self::PROTOCOL_VERSION] = null;
        $this->values[self::SOURCE_ID] = null;
        $this->values[self::DESTINATION_ID] = null;
        $this->values[self::NNAMESPACE] = null;
        $this->values[self::PAYLOAD_TYPE] = null;
        $this->values[self::PAYLOAD_UTF8] = null;
        $this->values[self::PAYLOAD_BINARY] = null;
    }
425201
def send_respawn(self):
        
        nick = self.player.nick
        self.send_struct('<B%iH' % len(nick), 0, *map(ord, nick))
953016
def reset(self):
        ""
        log.info("resetting client")
        rpc_client = self._rpc_client
        self._addrs.append(self._peer.addr)
        self.__init__(self._addrs)
        self._rpc_client = rpc_client
        self._dispatcher.rpc_client = rpc_client
        rpc_client._client = weakref.ref(self)
1214072
public void reset() {
        if (nonNull(client)) {
            synchronized (mutex) {
                if (nonNull(client)) { // double-guard
                    client.shutdown();
                    client = null;
                }
            }
        }
    }
504752
def reset_everything(self, payload):
        """"""
        kill_signal = signals['9']
        self.process_handler.kill_all(kill_signal, True)
        self.process_handler.wait_for_finish()
        self.reset = True

        answer = {'message': 'Resetting current queue', 'status': 'success'}
        return answer
877757
def clear_to_reset(self, config_vars):
        """"""

        super(RemoteBridgeState, self).clear_to_reset(config_vars)
        self.status = BRIDGE_STATUS.IDLE
        self.error = 0
989744
def send(self, msg):
        """"""
        self._router.broker.defer(self._send, msg)
1303340
protected void reset()
    {
        this.active = false;
        synchronized (this.cachedChannelsNonTransactional)
        {
            for (ChannelProxy channel : this.cachedChannelsNonTransactional)
            {
                try
                {
                    channel.getTargetChannel().close();
                }
                catch (Throwable ex)
                {
                    this.logger.trace("Could not close cached Rabbit Channel", ex);
                }
            }
            this.cachedChannelsNonTransactional.clear();
        }
        synchronized (this.cachedChannelsTransactional)
        {
            for (ChannelProxy channel : this.cachedChannelsTransactional)
            {
                try
                {
                    channel.getTargetChannel().close();
                }
                catch (Throwable ex)
                {
                    this.logger.trace("Could not close cached Rabbit Channel", ex);
                }
            }
            this.cachedChannelsTransactional.clear();
        }
        this.active = true;
    }
822884
def trapped_signals(cls, new_signal_handler):
    """"""
    try:
      previous_signal_handler = cls.reset_signal_handler(new_signal_handler)
      yield
    finally:
      cls.reset_signal_handler(previous_signal_handler)
1283904
public function resetConfiguration(){
        $rest = $this->getService( self::API_WIFI_CONFIG_RESET);
        $rest->POST();

        return $rest->getSuccess();
    }
806712
def send(self, fail_silently=False):
        """"""
        if not self.recipients():
            # Don't bother creating the network connection if
            # there's nobody to send to.
            return 0
        return self.get_connection(fail_silently).send_messages([self])
611083
def __send_break(self):
        
        if self.port:
            self.logger.debug("sendBreak to device to reboot", extra={'type': '<->'})
            result = self.port.safe_sendBreak()
            time.sleep(1)
            if result:
                self.logger.debug("reset completed", extra={'type': '<->'})
            else:
                self.logger.warning("reset failed", extra={'type': '<->'})
            return result
        return None
1323087
def _reset_on_error(self, server, func, *args, **kwargs):
        
        try:
            return func(*args, **kwargs)
        except NetworkTimeout:
            # The socket has been closed. Don't reset the server.
            raise
        except ConnectionFailure:
            self.__reset_server(server.description.address)
            raise
86303
public void reset() {
        state = BreakerState.CLOSED;
        isHardTrip = false;
        byPass = false;
        isAttemptLive = false;

        notifyBreakerStateChange(getStatus());
    }
678310
private void signalConnected() {
        if (alternate != null) {
            LOGGER.info("Connected to Node {} ({})",
                system(hostname.nameAndAddress()), system(alternate.nameAndAddress()));
        } else {
            LOGGER.info("Connected to Node {}", system(hostname.nameAndAddress()));
        }
        if (eventBus != null && eventBus.hasSubscribers()) {
            eventBus.publish(new NodeConnectedEvent(hostname));
        }
    }
1006527
def send_signal(signal, request, user, **kwargs):
    '''
    '''
    params = {
        'user_ip': request.remote_addr
    }
    params.update(kwargs)
    if user.is_authenticated:
        params['uid'] = user.id
    signal.send(request.url, **params)