Python syslog.syslog函数代码示例

 def warn_broken_packages(self, pkgs, err):
     pkgs = ', '.join(pkgs)
     syslog.syslog('broken packages after installation: %s' % pkgs)
     self.db.subst('ubiquity/install/broken_install', 'ERROR', err)
     self.db.subst('ubiquity/install/broken_install', 'PACKAGES', pkgs)
     self.db.input('critical', 'ubiquity/install/broken_install')
     self.db.go()

def sendrequest(request):
    try:
        context = zmq.Context.instance()

        client = context.socket(zmq.REQ)
        client.connect("ipc:///var/run/clearwater/alarms")

        poller = zmq.Poller()
        poller.register(client, zmq.POLLIN)

        for reqelem in request[0:-1]:
            client.send(reqelem, zmq.SNDMORE)

        client.send(request[-1])

        socks = dict(poller.poll(2000))

        if client in socks:
            message = client.recv()
        else:
            syslog.syslog(syslog.LOG_ERR, "dropped request: '%s'" % " ".join(request))

        context.destroy(100)

    except Exception as e:
        syslog.syslog(syslog.LOG_ERR, str(e))

 def _reset(self):
     syslog.syslog(syslog.LOG_DEBUG,
                   "Resetting device.")
     self._issue_interface_command(COMMAND_RESET)
     syslog.syslog(syslog.LOG_DEBUG,
                   "Waiting for device to boot up.")
     time.sleep(2)

def timer_save_result():
    global g_save_thread
    global g_rtt_list
    global g_cnt_total
    global g_cnt_get_exception
    global g_cnt_get_error

    g_mutex.acquire()
    if not g_rtt_list:
        syslog.syslog(syslog.LOG_WARNING, 'rtt list is empty')
        if g_cnt_total > 0:
            g_cnt_get_error = g_cnt_total - g_cnt_get_exception
            g_rtt_list.append(65535)
        else:
            g_mutex.release()
            g_save_thread = threading.Timer(g_save_thread_time, timer_save_result)
            g_save_thread.start()
            return

    output_list = [str(item) for item in g_rtt_list]
    syslog.syslog(syslog.LOG_INFO, 'rtt statistic list: %s' % g_list_sep.join(output_list))
    report_data()
    # clear statistic list
    g_rtt_list = list()
    g_cnt_total = 0
    g_cnt_get_exception = 0
    g_cnt_get_error = 0

    g_mutex.release()
    g_save_thread = threading.Timer(g_save_thread_time, timer_save_result)
    g_save_thread.start()

def get_rtt():
    global g_cnt_total
    global g_cnt_get_exception
    global g_cnt_get_error
    global g_report_total
    global g_report_exception
    global g_report_error

    g_cnt_total += 1
    g_report_total += 1

    file_size = 0
    total_size = 0
    try:
        start_time = time.time()
        request = urllib2.Request(url=g_http_res)
        response = urllib2.urlopen(request, timeout=g_overtime)

        if 'content-length' in response.headers:
            file_size = int(response.headers['content-length'])

        while True:
            chunk = response.read(1024)
            if not chunk:
                break
            total_size += len(chunk)
        total_time = time.time() - start_time
    except Exception, e:
        g_cnt_get_exception += 1
        g_report_exception += 1
        syslog.syslog(syslog.LOG_WARNING, 'Warn: http get exception %s' % e)

def find_grub_target():
    # This needs to be somewhat duplicated from grub-installer here because we
    # need to be able to show the user what device GRUB will be installed to
    # well before grub-installer is run.
    try:
        boot = ""
        root = ""
        regain_privileges()
        p = PartedServer()
        for disk in p.disks():
            p.select_disk(disk)
            for part in p.partitions():
                part = part[1]
                if p.has_part_entry(part, "mountpoint"):
                    mp = p.readline_part_entry(part, "mountpoint")
                    if mp == "/boot":
                        boot = disk.replace("=", "/")
                    elif mp == "/":
                        root = disk.replace("=", "/")
        drop_privileges()
        if boot:
            return boot
        elif root:
            return root
        return "(hd0)"
    except Exception, e:
        drop_privileges()
        import syslog

        syslog.syslog("Exception in find_grub_target: " + str(e))
        return "(hd0)"

 def initSignalHandlers(self):
     sigs = [ signal.SIGINT, signal.SIGTERM, signal.SIGUSR1, signal.SIGUSR2 ]
     for s in sigs:
         syslog.syslog( syslog.LOG_DEBUG, "DEBUG  Registering handler for "+
                        self.sigmap[s])
         sig = Signal.create(s,self)
         sig.signal.connect(self.handleSignal)

 def mkdir(self, path=None):
     try:
         os.makedirs(path)
         syslog.syslog(syslog.LOG_NOTICE, 'created local directory: %s' % path)
     except OSError as e:
         if e.errno != errno.EEXIST or not os.path.exists(path):
             raise

    def process_jobs(self):
        d = self.do_get(self.engine.address,
                        self.engine.port,
                        "/jobs",
                        self.engine.secret,
                        3)

        if d == None or d.get('status') == None or d.get('status') == "error":
            syslog.syslog(syslog.LOG_ERR,
                          "engine %s offline, disabling" % self.engine.name)
            self.enqueue({
                "item":   "engine",
                "action": "disable",
                "data":   self.engine
            })
            return False
        if not d.get('data'): return True

        self.enqueue({
            "item":   "job",
            "action": "handle",
            "active": 1,
            "engine": self.engine,
            "data":   d.get('data')
        })

        return True

    def stop(self):
        """Stop the daemon."""

        # Get the pid from the pidfile
        try:
            with open(self.pidfile, "r") as pidf:
                pid = int(pidf.read().strip())
        except IOError:
            pid = None

        if not pid:
            message = "pidfile {0} does not exist. " + "Daemon not running?\n"
            sys.stderr.write(message.format(self.pidfile))
            return  # not an error in a restart

        # Try killing the daemon process
        try:
            while True:
                os.kill(pid, signal.SIGTERM)
                time.sleep(0.1)
        except OSError as err:
            e = str(err.args)
            if e.find("No such process") > 0:
                if os.path.exists(self.pidfile):
                    os.remove(self.pidfile)
            else:
                print(str(err.args))
                sys.exit(1)
        syslog.syslog(syslog.LOG_INFO, "{}: stopped".format(os.path.basename(sys.argv[0])))

def lo():
    """ The program turns on LED
    """

    # Set up logging
    syslog.syslog('Lo Starting')
    logging.basicConfig(filename='ha-conn.log',level=logging.DEBUG)
    logging.info('Lo starting')

    # set up the MQTT environment
    client = mqtt.Client()
    client.on_connect = on_connect
    client.on_message = on_message

    client.connect("127.0.0.1", 1883, 60)

    topic = "homeassistant/2/101/1/P"
    msgDict = {}
    msgDict['action'] = "P"
    msgDict['result'] = 0
    msgDict['req_ID'] = 4
    msgDict['deviceID'] = 101
    msgDict['instance'] = 1
    msgDict['float1'] = 300 

    msg = json.dumps(msgDict) 
    print(topic + " " + msg)

    logging.info(topic + " " + msg)
    publish.single(topic, msg, hostname="127.0.0.1")

    def setupStation(self, config_dict):
        """Set up the weather station hardware."""
        # Get the hardware type from the configuration dictionary. This will be
        # a string such as "VantagePro"
        stationType = config_dict['Station']['station_type']
    
        # Find the driver name for this type of hardware
        driver = config_dict[stationType]['driver']
        
        syslog.syslog(syslog.LOG_INFO, "engine: Loading station type %s (%s)" % (stationType, driver))

        # Import the driver:
        __import__(driver)
    
        # Open up the weather station, wrapping it in a try block in case
        # of failure.
        try:
            # This is a bit of Python wizardry. First, find the driver module
            # in sys.modules.
            driver_module = sys.modules[driver]
            # Find the function 'loader' within the module:
            loader_function = getattr(driver_module, 'loader')
            # Call it with the configuration dictionary as the only argument:
            self.console = loader_function(config_dict, self)
        except Exception, ex:
            # Signal that we have an initialization error:
            raise InitializationError(ex)

    def __init__(self, engine, config_dict):
        super(StdQC, self).__init__(engine, config_dict)

        # If the 'StdQC' or 'MinMax' sections do not exist in the configuration
        # dictionary, then an exception will get thrown and nothing will be
        # done.
        try:
            mm_dict = config_dict['StdQC']['MinMax']
        except KeyError:
            syslog.syslog(syslog.LOG_NOTICE, "engine: No QC information in config file.")
            return

        self.min_max_dict = {}

        target_unit_name = config_dict['StdConvert']['target_unit']
        target_unit = weewx.units.unit_constants[target_unit_name.upper()]
        converter = weewx.units.StdUnitConverters[target_unit]

        for obs_type in mm_dict.scalars:
            minval = float(mm_dict[obs_type][0])
            maxval = float(mm_dict[obs_type][1])
            if len(mm_dict[obs_type]) == 3:
                group = weewx.units._getUnitGroup(obs_type)
                vt = (minval, mm_dict[obs_type][2], group)
                minval = converter.convert(vt)[0]
                vt = (maxval, mm_dict[obs_type][2], group)
                maxval = converter.convert(vt)[0]
            self.min_max_dict[obs_type] = (minval, maxval)
        
        self.bind(weewx.NEW_LOOP_PACKET, self.new_loop_packet)
        self.bind(weewx.NEW_ARCHIVE_RECORD, self.new_archive_record)

def logprint(message,verbose=1,error_tuple=None):
    
  """
  |Print the message passed  and if the system is in debug mode or if the error is important send a mail
  |Remember, to clear syslog you could use :  > /var/log/syslog
  |To read system log in openwrt type:logread 

  """
# used like this:
#   except Exception as e:
#    message="""error in dataExchanged["cmd"]=="updateObjFromNode" """
#    logprint(message,verbose=10,error_tuple=(e,sys.exc_info()))

  message=str(message)

  if error_tuple!=None: 
    e=error_tuple[0]
    exc_type, exc_obj, exc_tb=error_tuple[1]
    fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
    #to print the message in the system log (to read system log in openwrt type:logread )
    message=message+", e:"+str(e.args)+str(exc_type)+str(fname)+" at line:"+str(exc_tb.tb_lineno)

  debug=1
  debug_level=0
  
  if verbose>debug_level or verbose>8:
    syslog.syslog(message) 
    print(message)

 def log(self, msg, level='info'):
     """
     log this information to syslog or user provided logfile.
     """
     if not self.config['log_file']:
         # If level was given as a str then convert to actual level
         level = LOG_LEVELS.get(level, level)
         syslog(level, u'{}'.format(msg))
     else:
         # Binary mode so fs encoding setting is not an issue
         with open(self.config['log_file'], 'ab') as f:
             log_time = time.strftime("%Y-%m-%d %H:%M:%S")
             # nice formating of data structures using pretty print
             if isinstance(msg, (dict, list, set, tuple)):
                 msg = pformat(msg)
                 # if multiline then start the data output on a fresh line
                 # to aid readability.
                 if '\n' in msg:
                     msg = u'\n' + msg
             out = u'{} {} {}\n'.format(log_time, level.upper(), msg)
             try:
                 # Encode unicode strings to bytes
                 f.write(out.encode('utf-8'))
             except (AttributeError, UnicodeDecodeError):
                 # Write any byte strings straight to log
                 f.write(out)