Disable passive service check submission (globally)
        Format of the line that triggers function call::

        STOP_ACCEPTING_PASSIVE_SVC_CHECKS

        :return: None
967805
def stop_accepting_passive_svc_checks(self):
        
        if self.my_conf.accept_passive_service_checks:
            self.my_conf.modified_attributes |= DICT_MODATTR["MODATTR_PASSIVE_CHECKS_ENABLED"].value
            self.my_conf.accept_passive_service_checks = False
            self.my_conf.explode_global_conf()
            self.daemon.update_program_status()
1101121
def stop(self, silent=False):
        
        self.send_stop_signal(silent)
        self._lock.wait()
908765
def Stop():
    

    if global_options.loglevel >= 1 and global_benchmark:
        t = time.time() - global_starting_time
        global_options.stdlog.write(
            "######### Time spent in benchmarked functions #########\n")
        global_options.stdlog.write("# function\tseconds\tpercent\n")
        for key, value in global_benchmark.items():
            global_options.stdlog.write(
                "# %s\t%6i\t%5.2f%%\n" % (key, value,
                                          (100.0 * float(value) / t)))
        global_options.stdlog.write(
            "#######################################################\n")

    if global_options.loglevel >= 1:
        global_options.stdlog.write(getFooter() + "\n")

    # close files
    if global_options.stdout != sys.stdout:
        global_options.stdout.close()
    # do not close log, otherwise error occurs in atext.py
    # if global_options.stdlog != sys.stdout:
    #   global_options.stdlog.close()

    if global_options.stderr != sys.stderr:
        global_options.stderr.close()

    if global_options.timeit_file:

        outfile = open(global_options.timeit_file, "a")

        if global_options.timeit_header:
            outfile.write("\t".join(
                ("name", "wall", "user", "sys", "cuser", "csys",
                 "host", "system", "release", "machine",
                 "start", "end", "path", "cmd")) + "\n")

        csystem, host, release, version, machine = map(str, os.uname())
        uusr, usys, c_usr, c_sys = map(lambda x: "%5.2f" % x, os.times()[:4])
        t_end = time.time()
        c_wall = "%5.2f" % (t_end - global_starting_time)

        if sys.argv[0] == "run.py":
            cmd = global_args[0]
            if len(global_args) > 1:
                cmd += " '" + "' '".join(global_args[1:]) + "'"
        else:
            cmd = sys.argv[0]

        result = "\t".join((global_options.timeit_name,
                            c_wall, uusr, usys, c_usr, c_sys,
                            host, csystem, release, machine,
                            time.asctime(time.localtime(global_starting_time)),
                            time.asctime(time.localtime(t_end)),
                            os.path.abspath(os.getcwd()),
                            cmd)) + "\n"

        outfile.write(result)
        outfile.close()
620063
def stop(self):
        '''
        
        '''
        self.redirect_display(False)
        EasyProcess.stop(self)
        if self.use_xauth:
            self._clear_xauth()
        return self
214683
def stop(name):
    '''
    
    '''
    __salt__['file.touch']('{0}/down'.format(_service_path(name)))
    cmd = 'svc -d {0}'.format(_service_path(name))
    return not __salt__['cmd.retcode'](cmd, python_shell=False)
1021870
def stop
      Guard::Compat::UI.info "Guard::RemoteSync stopped."
      Guard::Compat::UI.notify("Guard::RemoteSync stopped.",notifier_options)
    end
1097312
def disable_active_checks(self, checks):
        
        self.active_checks_enabled = False
        for chk_id in self.checks_in_progress:
            chk = checks[chk_id]
            chk.status = ACT_STATUS_WAIT_CONSUME
            chk.exit_status = self.state_id
            chk.output = self.output
            chk.check_time = time.time()
            chk.execution_time = 0
            chk.perf_data = self.perf_data
197138
def halt_running():
    ''''''
    vultr = Vultr(API_KEY)

    try:
            serverList = vultr.server.list()
            #logging.info('Listing servers:\n%s', dumps(
            #serverList, indent=2
        #))
    except VultrError as ex:
        logging.error('VultrError: %s', ex)

    for serverID in serverList:
        if serverList[serverID]['power_status'] == 'running':
            logging.info(serverList[serverID]['label'] + " will be gracefully shutdown.")
            vultr.server.halt(serverID)
836273
def suppress_keyboard_interrupt_message():
    
    old_excepthook = sys.excepthook

    def new_hook(type, value, traceback):
        if type != KeyboardInterrupt:
            old_excepthook(type, value, traceback)
        else:
            sys.exit(130)

    sys.excepthook = new_hook
1335549
def request_stop(self, message='', exit_code=0):
        
        # Log an error message if exit code is not 0
        # Force output to stderr
        if exit_code:
            if message:
                logger.error(message)
                try:
                    sys.stderr.write(message)
                except Exception:  # pylint: disable=broad-except
                    pass
            logger.error("Sorry, I bail out, exit code: %d", exit_code)
            try:
                sys.stderr.write("Sorry, I bail out, exit code: %d" % exit_code)
            except Exception:  # pylint: disable=broad-except
                pass
        else:
            if message:
                logger.info(message)

        self.unlink()
        self.do_stop()

        logger.info("Stopped %s.", self.name)
        sys.exit(exit_code)
1149151
def _ignore_request(self, path):
        """"""
        return any([
            re.match(pattern, path) for pattern in QC_SETTINGS['IGNORE_REQUEST_PATTERNS']
        ])
527338
def silence_errors(f):
    
    @wraps(f)
    def wrapper(*args, **kwds):
        status = np.seterr(all='ignore')
        result = f(*args, **kwds)
        np.seterr(**status)
        return result
    return wrapper
130178
def stop_request(self, stop_now=False):
        
        logger.debug("Sending stop request to %s, stop now: %s", self.name, stop_now)

        res = self.con.get('stop_request', {'stop_now': '1' if stop_now else '0'})
        return res
676185
def start_executing_svc_checks(self):
        
        # todo: #783 create a dedicated brok for global parameters
        if not self.my_conf.execute_service_checks:
            self.my_conf.modified_attributes |= DICT_MODATTR["MODATTR_ACTIVE_CHECKS_ENABLED"].value
            self.my_conf.execute_service_checks = True
            self.my_conf.explode_global_conf()
            self.daemon.update_program_status()
1365353
def stop(self):
        
        if ( self.dev == None ): return ''
        buf = [REPORT_ID, ord('p'), 0, 0, 0, 0, 0, 0, 0]
        return self.write(buf);
1150979
def stop(self, check=True):
        
        if (check and self.countiter > 0 and self.opts['termination_callback'] and
                self.opts['termination_callback'] != str(self.opts['termination_callback'])):
            self.callbackstop = self.opts['termination_callback'](self)

        return self._stopdict(self, check)
477260
def disable_host_freshness_checks(self):
        
        if self.my_conf.check_host_freshness:
            self.my_conf.modified_attributes |= \
                DICT_MODATTR["MODATTR_FRESHNESS_CHECKS_ENABLED"].value
            self.my_conf.check_host_freshness = False
            self.my_conf.explode_global_conf()
            self.daemon.update_program_status()