def init_logging(filename): if filename == '-': logs.init_stderr_logging() else: if conf.has_option('main', 'logfile'): filename = conf.get('main', 'logfile') logs.init_generic_logging(logfile=filename, stderr=False)
def main(args): """Main controller""" init_generic_logging( logfile=LOG_FILE, stderr=False, read_config=True, ) if args.listblocktypes: print_detention_profiles() return LOGGER.info('Starting automatic detentions based on %s', args.profile.name) addresses = get_addresses_to_detain(args) detentions = [] # List of successfully blocked ip-addresses for address, comment in addresses: try: detentions.append(detain(address, args.profile, comment)) except GeneralException as error: LOGGER.error(error) continue if args.profile.mailfile and detentions: report_detentions(args.profile, detentions)
def main(): """Main program""" init_generic_logging( logfile=LOGFILE, stderr=True, formatter=logging.Formatter(LOGFORMAT), read_config=False, stderr_level=logging.ERROR if sys.stderr.isatty() else logging.CRITICAL, ) stderr = logging.getLogger('') django.setup() opts = parse_args() if opts.verify: LOGGER.info("-v option used, setting log level to DEBUG") stderr.setLevel(logging.DEBUG) LOGGER.setLevel(logging.DEBUG) sysnames = [] if opts.hostname: sysnames.append(opts.hostname.strip()) if opts.hostsfile: sysnames.extend(read_hostsfile(opts.hostsfile)) LOGGER.debug('Start checking PSUs and FANs') check_psus_and_fans(get_psus_and_fans(sysnames), dryrun=opts.dryrun)
def main(): """Main controller""" init_generic_logging( logfile=nav.buildconf.localstatedir + "/log/arnold/autoenable.log", stderr=False, read_config=True, ) LOGGER.info("Starting autoenable") candidates = Identity.objects.filter( autoenable__lte=datetime.now(), status__in=['disabled', 'quarantined']) if len(candidates) <= 0: LOGGER.info("No ports ready for opening.") sys.exit(0) # For each port that is blocked, try to enable the port. for candidate in candidates: try: open_port(candidate, getpass.getuser(), eventcomment="Opened automatically by autoenable") interface = candidate.interface netbox = interface.netbox LOGGER.info("Opening %s %s:%s for %s", netbox.sysname, interface.module, interface.baseport, candidate.mac) except GeneralException as why: LOGGER.error(why) continue
def main(options): """Main controller""" init_generic_logging( logfile=nav.buildconf.localstatedir + "/log/arnold/start_arnold.log", stderr=False, read_config=True, ) if options.listblocktypes: print_detention_profiles() return profile = verify_options(options) if not profile: return LOGGER.info('Starting automatic detentions based on %s' % profile.name) addresses = get_addresses_to_detain(options) detentions = [] # List of successfully blocked ip-addresses for address, comment in addresses: try: detentions.append(detain(address, profile, comment)) except GeneralException, error: LOGGER.error(error) continue
def main(): """Main thresholdmon program""" parser = make_option_parser() (_options, _args) = parser.parse_args() init_generic_logging( logfile=LOGFILE_PATH, stderr=False, stdout=True, read_config=True, ) django.setup() scan()
def main(): """Main program""" init_generic_logging( logfile=LOGFILE, stderr=True, formatter=logging.Formatter(LOGFORMAT), read_config=False, stderr_level=logging.ERROR if sys.stderr.isatty() else logging.CRITICAL, ) stderr = logging.getLogger('') django.setup() parser = OptionParser() parser.add_option( "-d", "--dry-run", action="store_true", dest="dryrun", help="Dry run. No changes will be made and no events posted") parser.add_option( "-f", "--file", dest="hostsfile", help="A file with hostnames to check. Must be one FQDN per line") parser.add_option("-n", "--netbox", dest="hostname", help="Check only this hostname. Must be a FQDN") parser.add_option("-v", "--verify", action="store_true", dest="verify", help="Print (lots of) debug-information to stderr") opts, _args = parser.parse_args() if opts.verify: LOGGER.info("-v option used, setting log level to DEBUG") stderr.setLevel(logging.DEBUG) LOGGER.setLevel(logging.DEBUG) sysnames = [] if opts.hostname: sysnames.append(opts.hostname.strip()) if opts.hostsfile: sysnames.extend(read_hostsfile(opts.hostsfile)) LOGGER.debug('Start checking PSUs and FANs') check_psus_and_fans(get_psus_and_fans(sysnames), dryrun=opts.dryrun)
def __init__(self, **kwargs): signal.signal(signal.SIGHUP, self.signalhandler) signal.signal(signal.SIGTERM, self.signalhandler) self.conf = config.serviceconf() init_generic_logging(stderr=True, read_config=True) self._deamon = kwargs.get("fork", 1) self._isrunning = 1 self._checkers = [] self._looptime = int(self.conf.get("checkinterval", 60)) LOGGER.debug("Setting checkinterval=%i", self._looptime) self.db = db.db() LOGGER.debug("Reading database config") LOGGER.debug("Setting up runqueue") self._runqueue = RunQueue.RunQueue(controller=self) self.dirty = 1
def main(): """Good old main...""" before = time.time() fmt = logging.Formatter(LOG_FORMAT) init_generic_logging( logfile=LOG_FILE, stderr=False, formatter=fmt, read_config=True ) _logger = logging.getLogger('') _logger.debug('-' * 60) # Visual separation line try: check_devices_on_maintenance() except Exception: _logger.exception("An unhandled exception occurred:") _logger.debug('Finished in %.3fs' % (time.time() - before)) _logger.debug('-' * 60) # Visual separation line
def __init__(self, **kwargs): signal.signal(signal.SIGHUP, self.signalhandler) signal.signal(signal.SIGTERM, self.signalhandler) self.config = config.pingconf() init_generic_logging(stderr=True, read_config=True) self._isrunning = 1 self._looptime = int(self.config.get("checkinterval", 60)) LOGGER.info("Setting checkinterval=%i", self._looptime) self.db = db.db() sock = kwargs.get("socket", None) self.pinger = megaping.MegaPing(sock) self._nrping = int(self.config.get("nrping", 3)) # To keep status... self.netboxmap = {} # hash netboxid -> netbox self.down = [] # list of netboxids down self.replies = {} # hash netboxid -> circbuf self.ipToNetboxid = {}
def __init__(self, foreground=False): if not foreground: signal.signal(signal.SIGHUP, self.signalhandler) signal.signal(signal.SIGTERM, self.signalhandler) signal.signal(signal.SIGINT, self.signalhandler) self.conf = config.serviceconf() init_generic_logging(stderr=True, read_config=True) self._isrunning = 1 self._checkers = [] self._looptime = int(self.conf.get("checkinterval", 60)) _logger.debug("Setting checkinterval=%i", self._looptime) self.db = db.db() _logger.debug("Reading database config") _logger.debug("Setting up runqueue") self._runqueue = RunQueue.RunQueue(controller=self) self.dirty = 1
def main(): """Main controller""" init_generic_logging(logfile=join(localstatedir, 'log', LOGFILE), stderr=False) config = NetbiosTrackerConfig() start = time.time() _logger.info('=== Starting netbiostracker ===') addresses = tracker.get_addresses_to_scan(config.get_exceptions()) scanresult = tracker.scan(addresses) parsed_results = tracker.parse(scanresult, config.get_encoding()) tracker.update_database(parsed_results) _logger.info('Scanned %d addresses, got %d results in %.2f seconds', len(addresses), len(parsed_results), time.time() - start) _logger.info('Netbiostracker done')
def main(): """Main program""" init_generic_logging( logfile=LOGFILE, stderr=True, read_config=True, ) opts = parse_args() sysnames = [] if opts.hostname: sysnames.append(opts.hostname.strip()) if opts.hostsfile: sysnames.extend(read_hostsfile(opts.hostsfile)) LOGGER.debug('Start checking PSUs and FANs') check_psus_and_fans(get_psus_and_fans(sysnames), dryrun=opts.dryrun)
def __init__(self, socket=None, foreground=False): if not foreground: signal.signal(signal.SIGHUP, self.signalhandler) signal.signal(signal.SIGTERM, self.signalhandler) signal.signal(signal.SIGINT, self.signalhandler) self.config = config.pingconf() init_generic_logging(stderr=True, read_config=True) self._isrunning = 1 self._looptime = int(self.config.get("checkinterval", 60)) _logger.info("Setting checkinterval=%i", self._looptime) self.db = db.db() self.pinger = megaping.MegaPing(socket) self._nrping = int(self.config.get("nrping", 3)) # To keep status... self.netboxmap = {} # hash netboxid -> netbox self.down = [] # list of netboxids down self.replies = {} # hash netboxid -> circbuf self.ip_to_netboxid = {}
def main(): """Good old main...""" before = time.clock() log_file = os.path.join(nav.buildconf.localstatedir, 'log', 'maintengine.log') fmt = logging.Formatter(LOG_FORMAT) init_generic_logging( logfile=log_file, stderr=False, formatter=fmt, read_config=True, ) logger = logging.getLogger('') logger.debug('------------------------------------------------------------') try: check_devices_on_maintenance() except Exception: logger.exception("An unhandled exception occurred:") logger.debug('Finished in %.3fs' % (time.clock() - before)) logger.debug('------------------------------------------------------------')
def main(): """Main controller""" init_generic_logging( logfile=nav.buildconf.localstatedir + "/log/arnold/t1000.log", stderr=False, read_config=True, ) LOGGER.info("Starting t1000") django.setup() # Fetch all mac-addresses that we have detained, check if they are # active somewhere else. As NAV collects arp and cam data periodically, # we need to give one hour slack to ensure data is correct. identities = Identity.objects.filter( last_changed__lte=datetime.now() - timedelta(hours=1), status__in=['disabled', 'quarantined']) if len(identities) <= 0: LOGGER.info("No detained ports in database where lastchanged > 1 " "hour.") sys.exit(0) for identity in identities: LOGGER.info("%s is %s, checking for activity", identity.mac, identity.status) try: candidate = find_computer_info(identity.mac) except NoDatabaseInformationError as error: LOGGER.info(error) continue # If this mac-address is active behind another port, block it. if candidate.endtime > datetime.now(): if candidate.interface == identity.interface: LOGGER.info('Active on detained interface, will not pursue') else: pursue(identity, candidate) else: LOGGER.info("%s is not active.", candidate.mac)
def main(): """Program entry point""" parser = make_option_parser() options = parser.parse_args() init_generic_logging( logfile=LOG_FILE, stderr=options.stderr, stdout=True, read_config=True, ) if options.l2 or options.vlan: # protect against multiple invocations of long-running jobs verify_singleton() if options.l2: do_layer2_detection() if options.vlan: if options.include_vlans: vlans = [int(v) for v in options.include_vlans] else: vlans = [] do_vlan_detection(vlans) delete_unused_prefixes() delete_unused_vlans()
def main(days=None): """Controller""" exit_if_already_running() init_generic_logging(logfile=LOGFILE, stderr=False) run(days)
def main(args): """Send all reports""" init_generic_logging(logfile=LOGFILE, stderr=False) send_reports(args.period)