Python uptime.uptime函数代码示例

def getUt(formatted=True):
    """system uptime"""
    import uptime
    if formatted:
        de = str(datetime.timedelta(seconds=uptime.uptime())).split(":")
        return "System Uptime: %sh, %sm, %ss" % (de[0], de[1], str(round(float(de[2]), 2)))
    else:
        return "System Uptime: %s Seconds." % uptime.uptime()

    def monitor(self):
        MONITOR_PATH = os.path.join(self.LOGS_PATH, "monitor/monitor-log.%s.json" % self.LOG_HOUR)

        data = {}

        data["uptime"] = uptime.uptime()
        data["timestamp"] = datetime.datetime.utcnow().isoformat()
        data["cpu_percent"] = psutil.cpu_percent(0)
        data["free_memory"] = psutil.virtual_memory().available
        data["free_disk"] = psutil.disk_usage(self.DATA_PATH).free

        device = os.path.basename(get_device(self.DATA_PATH))
        if device == 'tmpfs':
            data["iostat"] = None
        else:
            iostat = psutil.disk_io_counters(perdisk=True)[device]
            data["iostat"] = {
                "read_bytes": iostat.read_bytes,
                "write_bytes": iostat.write_bytes,
                "read_count": iostat.read_count,
                "write_count": iostat.write_count
            }

        self.log.debug(data)

        with open(MONITOR_PATH, 'a') as f:
            json.dump(data, f, sort_keys=True)
            f.write('\n')

def system_info():
    viewer_log_file = '/tmp/sync_viewer.log'
    if path.exists(viewer_log_file):
        viewlog = check_output(['tail', '-n', '20', viewer_log_file]).split('\n')
    else:
        viewlog = ["(no viewer log present -- is only the sync server running?)\n"]

    # Get load average from last 15 minutes and round to two digits.
    loadavg = round(getloadavg()[2], 2)

    try:
        run_tvservice = check_output(['tvservice', '-s'])
        display_info = re_split('\||,', run_tvservice.strip('state:'))
    except:
        display_info = False

    # Calculate disk space
    slash = statvfs("/")
    free_space = size(slash.f_bavail * slash.f_frsize)

    # Get uptime
    uptime_in_seconds = uptime()
    system_uptime = timedelta(seconds=uptime_in_seconds)

    return template('system_info', viewlog=viewlog, loadavg=loadavg, free_space=free_space, uptime=system_uptime, display_info=display_info)

def system_info():
    viewer_log_file = "/tmp/screenly_viewer.log"
    if path.exists(viewer_log_file):
        viewlog = check_output(["tail", "-n", "20", viewer_log_file]).split("\n")
    else:
        viewlog = ["(no viewer log present -- is only the screenly server running?)\n"]

    # Get load average from last 15 minutes and round to two digits.
    loadavg = round(getloadavg()[2], 2)

    try:
        run_tvservice = check_output(["tvservice", "-s"])
        display_info = re_split("\||,", run_tvservice.strip("state:"))
    except:
        display_info = False

    # Calculate disk space
    slash = statvfs("/")
    free_space = size(slash.f_bavail * slash.f_frsize)

    # Get uptime
    uptime_in_seconds = uptime()
    system_uptime = timedelta(seconds=uptime_in_seconds)

    return template(
        "system_info",
        viewlog=viewlog,
        loadavg=loadavg,
        free_space=free_space,
        uptime=system_uptime,
        display_info=display_info,
    )

def uptime_data():
    """Returns uptime data.
    """
    return {
        'uptime': mark(uptime.uptime(), 'duration'),
        'boottime': uptime.boottime()
    }

	def GetWinNTUptime(self):
		from uptime import uptime
		seconds  = int(uptime())
		days     = seconds/60/60/24
		seconds -= days*60*60*24
		hours    = seconds/60/60
		seconds -= hours*60*60
		minutes  = seconds/60
		seconds -= minutes*60
		up = {
				"Days": days,
				"Hours": hours,
				"Minutes": minutes
				}
		up_str = u""
		_DAYS = u" days"
		_DAY = u" day"
		_HOURS = u" hours"
		_HOUR = u" hour"
		_MINUTES = u" minutes"
		_MINUTE = u" minute"
		if up["Days"]      > 1:
			up_str += ", " + unicode(up["Days"])    + _DAYS
		elif up["Days"]    > 0:
			up_str += ", " + unicode(up["Days"])    + _DAY
		if up["Hours"]     > 1:
			up_str += ", " + unicode(up["Hours"])   + _HOURS
		elif up["Hours"]   > 0:
			up_str += ", " + unicode(up["Hours"])   + _HOUR
		if up["Minutes"]   > 1:
			up_str += ", " + unicode(up["Minutes"]) + _MINUTES
		elif up["Minutes"] > 0:
			up_str += ", " + unicode(up["Minutes"]) + _MINUTE
		return up_str.lstrip(", ")

def os_status():
    # Unlike most stats, we don't need up-to-the-second reports on these.
    # We're going to sample the data approximately once every eighty cycles.
    if random.random() > 0.0125:
        return

    with statsd.pipeline() as pipe:
        # Restart required?
        if os.path.isfile('/var/run/reboot-required'):
            pipe.gauge('os.restart_required', 1)
        else:
            pipe.gauge('os.restart_required', 0)

        # Updates availale?
        apt_update_check = '/usr/lib/update-notifier/apt-check'
        if os.path.isfile(apt_update_check):
            process = subprocess.Popen(apt_update_check, stderr=subprocess.PIPE)
            _, response = process.communicate()
            regular, security = response.split(';')
            pipe.gauge('os.updates.regular', regular)
            pipe.gauge('os.updates.security', security)

        # Uptime
        pipe.gauge('os.uptime', uptime.uptime())

        # Host clock offset
        try:
            response = ntplib.NTPClient().request('pool.ntp.org')
        except ntplib.NTPException:
            pass
        else:
            pipe.gauge('os.ntp.offset', response.offset)

def uptime_string(startup_time_in_seconds, last_error_time):
    # Machine info
    uname = platform.uname()
    uptime_seconds = uptime.uptime()
    # Delta uptime in human readable format
    uptime_string = str(timedelta(seconds=uptime_seconds))
    # Time now
    now = time.time()
    delta = now - startup_time_in_seconds
    bot_uptime = str(timedelta(seconds=int(delta)))
    # Get memory usage with ps
    memory = memory_usage_ps()
    # Make messsge
    string = ""
    string += "\U0001F4BB Running on " + uname[0] + " " + uname[2] + " " + uname[4] + "\n"
    string += "\U0000231B Machine Uptime: " + uptime_string + "\n"
    string += "\U0001F916 Bot uptime: " + bot_uptime + "\n"
    string += "\U0001F4CA Bot memory usage: " + memory + "MB"

    if last_error_time is not None:
        delta = now - last_error_time
        last_error = str(timedelta(seconds=int(delta)))
        string += "\n\U0001F480 " + last_error + " without casualties"

    return string

    def _boot_time_windows():
        try:
            from time import time
            import uptime

            return int(time() - uptime.uptime())
        except:
            return

 def get_up_stats(self):
   try:
     from uptime import uptime
     m, s = divmod(uptime(), 60)
     h, m = divmod(m, 60)
     return "%d:%02d:%02d" % (h, m, s)
   except Exception as e:
     logger.error('Server error : ' + str(e))

    def __init__(self):
        """Create a new record, gathering information relevant to the machine on which
        this code is running.

        """
        self.time = datetime.datetime.utcnow()
        self.hostname = socket.gethostname()
        self.load_average = os.getloadavg()[1]
        self.uptime = uptime.uptime() / 86400.

def get_platform_info():
  stats = OrderedDict([
    ('Hostname',     platform.node()),
    ('Distribution', " ".join(platform.dist())),
    ('Kernel',       platform.uname()[2]),
    ('Uptime',       str(timedelta(seconds=uptime()))),
    ('Load avg',     ", ".join([str(k) for k in os.getloadavg()]))
    ])
  return stats

  def get_uptime(self, socket = False):
    data = {'uptime' : uptime.uptime(),
            'timestamp' : int(time.time()),
            'day' : self.weather.is_day(),
            'load' : os.getloadavg()}

    if socket:
      self.__send_message({'type':'uptime','data':data})
    else:
      return data

def jsondata():
    uptime_var = int(uptime())
    temp = read_temp()
    tempString = str(temp)
    if temp >= 60.0:
        saying = "Oh Shit, That Beer Is Hot!"
    else:
        saying = "Yeah That Beer Is Cold!"
    timeString = datetime.datetime.now().strftime("%Y-%m-%d %H:%M")
    cpu_percent = psutil.cpu_percent()
    virtmem_percent = psutil.virtual_memory()[2]
    return jsonify(uptime=uptime_var, temp=tempString, time=timeString, cpu=cpu_percent, ram=virtmem_percent, saying=saying)

def host_stats():
    return {
        'uptime': int(uptime()),
        'linux': ''.join(platform.linux_distribution()),
        'kernel': platform.uname()[2],
        'cpu': {
            'cpu_count': cpu_count(),
            'model_name': cpu_model_name()
        },
        'memory': memory_stats(),
        'network': network_stats(),
        'disk': disk_stats(),
        'docker': docker_stats()
    }