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()
    }

	def parse_output(self, data, ethmac):
		self.spec["ethernet_MAC"]  = ethmac
		self.spec["current_MAC"]   = cp.utils.get_MAC()
		self.spec["source_address"]= cp.utils.get_SA()
		# shakey
		self.spec["local_address"] = [(s.connect(('8.8.8.8', 80)), s.getsockname()[0], s.close()) for s in [socket.socket(socket.AF_INET, socket.SOCK_DGRAM)]][0][1]

		fields = data.split()
		#self.spec["uptime"] = fields[2][:-1]
		#self.spec["uptime"] = re.search("up .*?,",data).group(0)[3:-1]
		self.spec["uptime"] = float(uptime.uptime() / (60*60))
		self.spec["load1"]  = float(fields[-3][:-1])
		self.spec["load5"]  = float(fields[-2][:-1])
		self.spec["load15"] = float(fields[-1])

		return self.spec

def system_uptime():
    """ Return uptime of the system
        linux only

        :rtype: datetime.timedelta
    """
    try:
        import uptime
        uptime_seconds = uptime.uptime()
    except ImportError:
        if sys.platform.startswith('linux') and os.path.exists('/proc/uptime'):
            with open('/proc/uptime', 'r') as f:
                uptime_seconds = float(f.readline().split()[0])
        else:
            raise ValueError('Using uptime in non-linux environments needs uptime module to be installed')
    return datetime.timedelta(seconds=uptime_seconds)

    def take_sample(self):

        # memory
        mem = psutil.virtual_memory()
        mem_used = mem.total - mem.available
        mem_used_ratio = float(mem_used)/float(mem.total)
        if mem_used_ratio > 0.9 or mem.available <= 0.5E9:
            severity = 'high'
        elif mem_used_ratio > 0.8 or mem.available <= 1E9:
            severity = 'medium'
        else:
            severity = 'low'
        self.metrics['Memory'] = {'value': '{:.1%}'.format(mem_used_ratio), 'severity':severity, 'used': str(mem.used),
                                  'total': str(mem.total)}

        self.metrics['User'] = {'value': win32api.GetUserName()}
        self.metrics['Up time'] = {'value': str(datetime.timedelta(seconds=uptime.uptime()))}
        self.metrics['CPU count'] = {'value': str(multiprocessing.cpu_count())}
        self.metrics['Last seen'] = {'value': str(time.time())}  # client display calculates time delta from this

def status():
    boards, totalsize = {}, 0

    for board in config['boards']:
        # Index size on disk
        size = 0
        for f in glob.glob(os.path.join(config['index'], '%s_*' % board)):
            st = os.stat(f)
            size += st.st_size

        # Other information
        try:
            ix = whoosh.index.open_dir(config['index'], board, readonly=True)
            num = ix.doc_count()
            updated = ix.last_modified()
            ix.close()
        except whoosh.index.EmptyIndexError:
            num = 0
            updated = None

        totalsize += size
        boards[board] = {'size': size, 'num': num, 'updated': updated}

    # Misc. information
    try:
        statvfs = os.statvfs(config['index'])
        freesize = statvfs.f_bavail * statvfs.f_bsize
    except AttributeError:
        freesize = None
    uname = platform.uname()
    os_details = {
        'Linux': ('%s %s' % platform.linux_distribution()[:2]).capitalize(),
        'FreeBSD': uname[2],
        'Darwin': platform.mac_ver()[0],
        'Windows': '%s %s' % platform.win32_ver()[0::2],
    }.get(platform.system(), 'Unknown version')

    return templates.get_template('status.mako').render(
        uname=uname, os_details=os_details, uptime=uptime.uptime(),
        totalsize=totalsize, freesize=freesize,
        boards=boards
    )

def up():
    t = uptime.uptime()
    days = 0
    hours = 0
    min = 0
    out = ""
    while t > 86400:
        t -= 86400
        days += 1
    while t > 3600:
        t -= 3600
        hours += 1
    while t > 60:
        t -= 60
        min += 1
    if days > 0:
        out += str(days) + "d "
    out += str(hours) + "h "
    out += str(min) + "m"
    return out