Resets the server.

        :raises: IloError, on an error from iLO.
961260
def reset_server(self):
        
        sushy_system = self._get_sushy_system(PROLIANT_SYSTEM_ID)
        try:
            sushy_system.reset_system(sushy.RESET_FORCE_RESTART)
        except sushy.exceptions.SushyError as e:
            msg = (self._('The Redfish controller failed to reset server. '
                          'Error %(error)s') %
                   {'error': str(e)})
            LOG.debug(msg)
            raise exception.IloError(msg)
498038
def reset(self):
        
        self._count = 0
        self._sum = float(0)
        self._min = float('inf')
        self._max = float(0)
554708
def reset
      self.user_agent         = DEFAULT_USER_AGENT
      self.server_url         = DEFAULT_SERVER_URL
      self.chef_version       = DEFAULT_CHEF_VERSION
      self.client_name        = DEFAULT_CLIENT_NAME
      self.client_key         = DEFAULT_CLIENT_KEY
      self.connection_options = DEFAULT_CONNECTION_OPTIONS
      self.middleware         = DEFAULT_MIDDLEWARE
      self
    end
85108
def _reset(self):
        '''
        
        '''
        self.__cmd = ['zypper', '--non-interactive']
        self.__exit_code = 0
        self.__call_result = dict()
        self.__error_msg = ''
        self.__env = salt.utils.environment.get_module_environment(globals())

        # Call config
        self.__xml = False
        self.__no_lock = False
        self.__no_raise = False
        self.__refresh = False
        self.__ignore_repo_failure = False
        self.__systemd_scope = False
        self.__root = None

        # Call status
        self.__called = False
1249026
def reset():
        """"""
        Logger.journal = []
        Logger.fatal_warnings = False
        Logger._ignored_codes = set()
        Logger._ignored_domains = set()
        Logger._verbosity = 2
        Logger._last_checkpoint = 0
50648
def reset(self):
        

        self.request_head = None
        #self.request_log = None
        self.request_body = None
        self.request_method = None
        self.request_counter = None
        self.exception = None
        if self.transport:
            self.transport.reset()
196965
def _reset_server(self, address):
        
        server = self._servers.get(address)

        # "server" is None if another thread removed it from the topology.
        if server:
            server.reset()

            # Mark this server Unknown.
            self._description = self._description.reset_server(address)
            self._update_servers()
1192505
public void reset() throws IOException {
        synchronized (lock) {
            ensureOpen();
            if (markedChar < 0)
                throw new IOException((markedChar == INVALIDATED)
                                      ? "Mark invalid"
                                      : "Stream not marked");
            nextChar = markedChar;
            skipLF = markedSkipLF;
        }
    }
148098
def reset_server_and_request_check(self, address):
        """"""
        with self._lock:
            self._reset_server(address)
            self._request_check(address)
29459
def _reset_errors(self, msg=None):
        
        if msg is not None and msg in self._errors:
            del self._errors[msg]
        else:
            self._errors = {}
321725
def reset( self ):
        
        if not self.plugin():
            return False
        
        self.plugin().reset()
        self.refreshUi()
        
        return True
193102
public function reset() {
        $this->processstarted = false;
        $this->linenb = 0;
        $this->cir->init();
        $this->errors = array();
    }
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
603732
def reset(self):
        
        self._count = 0
        self._exception_count = 0
        self._stat_start_time = None
        self._time_sum = float(0)
        self._time_min = float('inf')
        self._time_max = float(0)

        self._server_time_sum = float(0)
        self._server_time_min = float('inf')
        self._server_time_max = float(0)
        self._server_time_stored = False

        self._request_len_sum = float(0)
        self._request_len_min = float('inf')
        self._request_len_max = float(0)

        self._reply_len_sum = float(0)
        self._reply_len_min = float('inf')
        self._reply_len_max = float(0)
35164
def _reset_on_error(self, server_address, session):
        
        try:
            try:
                yield
            except PyMongoError as exc:
                if session and exc.has_error_label(
                        "TransientTransactionError"):
                    session._unpin_mongos()
                raise
        except NetworkTimeout:
            # The socket has been closed. Don't reset the server.
            # Server Discovery And Monitoring Spec: "When an application
            # operation fails because of any network error besides a socket
            # timeout...."
            raise
        except NotMasterError:
            # "When the client sees a "not master" error it MUST replace the
            # server's description with type Unknown. It MUST request an
            # immediate check of the server."
            self._reset_server_and_request_check(server_address)
            raise
        except ConnectionFailure:
            # "Client MUST replace the server's description with type Unknown
            # ... MUST NOT request an immediate check of the server."
            self.__reset_server(server_address)
            raise
        except OperationFailure as exc:
            if exc.code in helpers._RETRYABLE_ERROR_CODES:
                # Do not request an immediate check since the server is likely
                # shutting down.
                self.__reset_server(server_address)
            raise
980172
def reset!
      self.api_username = DEFAULT_API_USERNAME
      self.api_key      = DEFAULT_API_KEY
      self.adapter      = DEFAULT_ADAPTER
      self.endpoint     = DEFAULT_ENDPOINT
      self.user_agent   = DEFAULT_USER_AGENT
      self.raise_errors = DEFAULT_RAISE_ERRORS
      self
    end
993869
def reset(self):
        
        self._variables_shim = {}
        self._executable = None
        self._bitstrings = None

        self.status = 'connected'