def printminmaxavg(entries, details=False):
""" Print start, current, minimum, maximum, and average usage
"""
# list comprehension:
values = [int(e[1]) for e in entries]
min_used = min(values)
max_used = max(values)
max_used_entry = entries[values.index(max_used)]
min_used_entry = entries[values.index(min_used)]
avg_used = mean(values)
if details:
print(' started:', scale('M', entries[0][1]), 'on',
entries[0][0].date())
print(' currently:', scale('M', entries[-1][1]), 'on',
entries[-1][0].date())
print(' min used:', scale('M', min_used), 'on',
min_used_entry[0].date())
print(' max used:', scale('M', max_used), 'on',
max_used_entry[0].date())
print(' avg used:', scale('M', avg_used))
else:
print(' started:', humanize(entries[0][1]), 'on',
entries[0][0].date())
print(' currently:', humanize(entries[-1][1]), 'on',
entries[-1][0].date())
print(' min used:', humanize(min_used), 'on',
min_used_entry[0].date())
print(' max used:', humanize(max_used), 'on',
max_used_entry[0].date())
print(' avg used:', humanize(avg_used))
async def chat(id: str, page: Optional[int] = 0):
if not user.is_connected():
await user.connect()
if not await user.is_user_authorized():
return templates.get_template("auth/not_authorized.html").render()
try:
try:
id = int(id)
except:
pass
chat = await user.get_entity(id)
await user.conversation(chat).mark_read()
messages = await user.get_messages(id, limit=10, add_offset=10 * page)
msgs = []
for m in messages:
m: types.Message
r = await m.get_reply_message()
reply = None
if r:
name = r.sender.title if hasattr(
r.sender, 'title') else r.sender.first_name
if r.file:
rfile = models.MessageMedia(
type=r.file.mime_type,
typ=r.file.mime_type.split("/")[0],
size=utils.humanize(r.file.size),
filename=r.file.name)
else:
rfile = None
reply = models.ReplyMessage(
name=name,
id=r.id,
file=rfile,
text=utils.replacing_text(r.text) if r.text else None)
if m.file:
file = models.MessageMedia(type=m.file.mime_type,
typ=m.file.mime_type.split("/")[0],
size=utils.humanize(m.file.size),
filename=m.file.name)
else:
file = None
msgs.append(
models.Message(
id=m.id,
sender=m.sender,
text=utils.replacing_text(m.text) if m.text else None,
file=file,
reply=reply,
mentioned=m.mentioned,
date=m.date.strftime("%Y-%m-%d %H:%M:%S"),
out=m.out))
return templates.get_template("chat.jinja2").render(messages=msgs,
chat=chat,
page=page)
except Exception as ex:
return templates.get_template('error.jinja2').render(
error='<br>'.join(ex.args))
def chk4variant(size, variance, entries, name=''):
""" Print any usage entry that goes outside of
the given day-to-day variance.
"""
lastUsed = 0
last_e1 = '0'
lastdate = date(2019, 1, 2)
lclSize = size
for e in entries:
thisdate = e[0].date()
thistime = e[0].time()
if thisdate == lastdate:
continue
lastdate = thisdate
# do something with the data we have
#print(' ', thisdate, e[1], 'used out of', lclSize)
thisUsed = e[1]
if thisUsed != lastUsed:
delta = thisUsed - lastUsed
pct = (delta / lclSize) * 100
h_e1 = humanize(e[1])
h_l1 = humanize(last_e1)
h_sz = humanize(size)
p_e1 = f'{pctize(e[1], lclSize):.1f}'
p_l1 = f'{pctize(last_e1, lclSize):.1f}'
if pct > variance: # current hard-coded variance
event_list.append(
f'{str(thisdate)} {str.ljust(name, 12)}: {h_e1} ({p_e1}%) used out of {h_sz}, up from {h_l1} ({p_l1}%)'
)
elif pct < -variance:
event_list.append(
f'{str(thisdate)} {str.ljust(name, 12)}: {h_e1} ({p_e1}%) used out of {h_sz}, dn from {h_l1} ({p_l1}%)'
)
lastUsed = thisUsed
last_e1 = e[1]
def get_output_stats(self, data=None):
""" returns final stats, as dict of strings """
if not data:
data = self.analyze()
requests = data['requests_count']
time_delta = data['last_datetime'] - data['first_datetime']
req_per_sec = str(round(requests / time_delta.seconds, 3))
twohoundreds_avg_size = humanize(data['2XX_total_size'] //
data['2XX_count'])
response_status = dict_to_str(data['response_status_count'])
return {
'requests': str(requests),
'status_count': response_status,
'request_per_second': req_per_sec,
'2XX_avg_size': twohoundreds_avg_size,
}
def __unicode__(self):
return humanize(self.type_name)
def __unicode__(self):
return humanize(self.field_name)
async def cache():
try:
size = utils.humanize(utils.get_size('cache'))
except:
size = "0.0B"
return templates.get_template("cache.jinja2").render(size=size)
def __unicode__(self):
return humanize(self.type_name)
def __unicode__(self):
return humanize(self.field_name)
def analyze(sysname, sysdata, switches):
""" Look for entries to print
sysname is the name of the system we're investigating
sysdata is a dictionary, uses sysname as the key
switches is a tuple of Booleans:
switches[0] = show_events
switches[1] = show_disk
switches[2] = show_details
switches[3] = show_filesystem
switches[4] = show_mem
switches[5] = show_ping
"""
global event_list # final output list
event_list = [] # start fresh
variance = 19.9 # default variance
nextdate = date(2019, 1, 2)
lastdate = date(2019, 1, 2)
thisdate = date(2019, 1, 3)
show_events, show_disk, show_details, show_filesystem, show_mem, show_ping = switches
if sysname == '':
return False
if sysname not in sysdata.keys():
print('analyze(): system', sysname, 'not in sysdata dictionary.')
return
datedEntries = sysdata[sysname]
if len(datedEntries) == 0:
print('analyze(): no entries for', sysname)
return
print(
'# ----------------------------------------------------------------------------'
)
print('Analyzing system', sysname + ':')
print()
# we have three keys: name, uptime, load:
for sysptr in datedEntries:
''' datedEntries is a list of system objects
sysptr is the dictionary for the given system name
'''
# --- uptime entries:
entries = sysptr.get_entries('uptime')
# entries is the list of of uptime entries
for e in entries:
# each 'e' is a list: [datetime, [list_of_words]]
thisdate = e[0].date()
thistime = e[0].time()
if thisdate == lastdate:
continue # skip duplicate date entries
lastdate = thisdate
if thisdate != nextdate:
if nextdate != date(2019, 1, 2):
event_list.append(
f'{str(thisdate)} unexpected datestamp, expected: {str(nextdate)}'
)
nextdate = thisdate + ONEDAY
uptime = e[1]
if 'days,' not in uptime and 'day,' not in uptime:
# means that we rebooted less than a day ago,
# so see if we can figure out when we did reboot:
reboottime = uptime[0].rstrip(',')
if 'min,' not in uptime:
lclhours, lclminutes = reboottime.split(':')
else:
lclhours = '0'
lclminutes = uptime[0]
ago = timedelta(hours=int(lclhours), minutes=int(lclminutes))
rebootdate = e[0] - ago
event_list.append(
str(rebootdate.date()) + ' Rebooted : ' +
str(rebootdate.time()))
# --- load entries:
entries = sysptr.get_entries('load')
sp = sysptr.get_component('load')
# get_component() returns a dictionary (key 'entries') with a list of entries
analyze_load(5.0, sp['entries'])
# --- Memory entries:
entries = sysptr.get_entries('Mem')
sp = sysptr.get_component('Mem')
# get_component returns a dictionary (key 'entries', 'size'):
# entries is a list, each value is a list [datetime, size_in_bytes]
chk4variant(sp['size'], SWAPVARIANCE, entries, 'Mem')
if show_mem:
print('Memory (' + humanize(sp['size']) + '):')
printminmaxavg(entries, show_details)
print()
# --- Swap entries:
entries = sysptr.get_entries('Swap')
sp = sysptr.get_component('Swap')
# get_component returns a dictionary (key 'entries', 'size'):
# entries is a list, each value is a list [datetime, size_in_bytes]
chk4variant(sp['size'], SWAPVARIANCE, entries, 'Swap')
if show_mem:
print('Swap (' + humanize(sp['size']) + '):')
printminmaxavg(entries, show_details)
print()
# --- Ping entries:
if show_ping:
entries = sysptr.get_entries('Ping')
if not entries:
print('no ping entries')
else:
# get_entries() returned a list of [datetime, 'OK'] or error messages
print('Ping entries:')
ping_ok = True # preset
for e in entries:
thisdate = e[0].date()
thistime = e[0].time()
if thisdate == lastdate:
continue
lastdate = thisdate
# do something with the data we have
if e[1] != 'OK': # flag it
print(f' {str(thisdate)} - {e[1]}')
event_list.append(str(thisdate) + ' ' + e[1])
ping_ok = False
if ping_ok == True:
print(' Ping tests all OK')
print()
# --- Services entries:
entries = sysptr.get_entries('Services')
if entries != None:
# get_entries() returned a list of [datetime, 'OK'] or error messages
for e in entries:
thisdate = e[0].date()
thistime = e[0].time()
if thisdate == lastdate:
continue
lastdate = thisdate
# do something with the data we have
if e[1][0] != 'OK':
tmpstr = str(thisdate) + ' ' + e[1][0] + '\n'
if type(e[1]) == type([]):
y = e[1]
for x in y[1:]:
tmpstr += ' ' + x + '\n'
event_list.append(tmpstr)
# --- Disk entries:
if show_disk:
if len(show_filesystem):
disklist = show_filesystem
else:
disklist = sysptr.get_dskkeys()
for disk in disklist:
lcldisksize = sysptr.get_dsksize(disk)
''' entries is a list of a datetime and a size '''
entries = sysptr.get_entries(disk)
if entries != None:
# - scan for changes >20% of current usage
chk4variant(size=lcldisksize,
variance=DISKVARIANCE,
entries=entries,
name=disk)
# - show min, max, average daily usage
if show_details:
print("'{}' ({}):".format(disk,
scale('M', lcldisksize)))
else:
print("'{}' ({}):".format(disk, humanize(lcldisksize)))
printminmaxavg(entries, show_details)
print()
# --- Other entries:
entries = sysptr.get_entries('<entry>')
if entries != None:
print('<entry> entries:')
for e in entries:
thisdate = e[0].date()
thistime = e[0].time()
if thisdate == lastdate:
continue
lastdate = thisdate
# do something with the data we have
print()
if show_events:
event_list.sort()
print('Events:')
print()
print(f'{event_list[0][:10]} Logging starts')
for x in event_list:
print(x)
print()
return True # all OK
