def get_env_info():
'''Gets general information about the computer.'''
infodict = OrderedDict()
infodict["Name"] = platform.node()
infodict["System"] = platform.system()
infodict["System alias"] = " ".join(platform.system_alias(
platform.system(), platform.release(), platform.version()))
infodict["Platform"] = platform.platform()
if infodict["System"] == "Linux": # System-specific information
infodict["Distribution"] = " ".join(platform.dist())
elif infodict["System"] == "Windows":
infodict["OS"] = " ".join(platform.win32_ver())
elif infodict["System"] == "MacOS":
verinfo = platform.mac_ver()[1]
macver = " ".join(platform.mac_ver())
macver[1] = verinfo
infodict["OS"] = " ".join(macver)
infodict["Boot time"] = datetime.datetime.fromtimestamp(
psutil.get_boot_time()).strftime("%c")
infodict["Uptime"] = str(datetime.datetime.fromtimestamp(
time.time() - psutil.get_boot_time()).strftime("%d:%H:%M:%S:%f"))
for user in psutil.get_users():
infodict["User '" + user.name + "' terminal"] = user.terminal
infodict["User '" + user.name + "' host"] = user.host
infodict["User '" + user.name + "' started"] = str(
datetime.datetime.fromtimestamp(user.started).strftime("%c"))
return infodict
def boot_time(time_format=None):
'''
Return the boot time in number of seconds since the epoch began.
CLI Example:
time_format
Optionally specify a `strftime`_ format string. Use
``time_format='%c'`` to get a nicely-formatted locale specific date and
time (i.e. ``Fri May 2 19:08:32 2014``).
.. _strftime: https://docs.python.org/2/library/datetime.html#strftime-strptime-behavior
.. versionadded:: 2014.1.4
.. code-block:: bash
salt '*' ps.boot_time
'''
try:
b_time = int(psutil.boot_time())
except AttributeError:
# get_boot_time() has been removed in newer psutil versions, and has
# been replaced by boot_time() which provides the same information.
b_time = int(psutil.get_boot_time())
if time_format:
# Load epoch timestamp as a datetime.datetime object
b_time = datetime.datetime.fromtimestamp(b_time)
try:
return b_time.strftime(time_format)
except TypeError as exc:
raise SaltInvocationError('Invalid format string: {0}'.format(exc))
return b_time
def stats():
# OS identification
yield 'osname', osname()
# Uptime
yield 'uptime', time.time() - psutil.get_boot_time()
# CPU temperature
try:
temps = []
for line in check_output('sensors').split('\n'):
m = re.match(r'^Core \d+:\s*\+(\d+\.\d+)', line)
if m:
temps.append(float(m.group(1)))
assert len(temps) == psutil.NUM_CPUS
yield 'temps', temps
except:
pass
# CPU usage
yield 'cpu_usage', round(psutil.cpu_percent(), 2)
# Memory usage
mem = psutil.phymem_usage()
yield 'memory', (mem.used, mem.total)
# Disk usage
disk = psutil.disk_usage('/')
yield 'disk', (disk.used, disk.total)
def stats():
# OS identification
yield 'osname', osname()
# Uptime
yield 'uptime', time.time() - psutil.get_boot_time()
# CPU temperature
try:
temps = []
for line in check_output('sensors').split('\n'):
m = re.match(r'^Core \d+:\s*\+(\d+\.\d+)', line)
if m:
temps.append(float(m.group(1)))
assert len(temps) == psutil.NUM_CPUS
yield 'temps', temps
except:
pass
# CPU usage
yield 'cpu_usage', round(psutil.cpu_percent(), 2)
# Memory usage
mem = psutil.phymem_usage()
yield 'memory', (mem.used, mem.total)
# Disk usage
disk = psutil.disk_usage('/')
yield 'disk', (disk.used, disk.total)
def _basic_monitoring(self):
status = {}
memory = psutil.virtual_memory()
total_memory_mb = int(memory.total) / 1024
free_memory_mb = int(memory.free) / 1024
used_memory_mb = total_memory_mb - free_memory_mb
memory_utilization = round(
float(used_memory_mb) / float(total_memory_mb) * 100, 2)
disk = psutil.disk_usage("/")
status["agent_id"] = self.agent_context.agent_id
status["timestamp"] = int(time.time())
status["total_disk_GB"] = disk[0]
status["disk_utilization"] = disk[3]
if int(psutil.__version__.split(".")[0]) > 2:
status["cpu_cores"] = int(psutil.cpu_count())
status["boot_time"] = int(psutil.boot_time())
else:
status["cpu_cores"] = int(psutil.NUM_CPUS)
status["boot_time"] = int(psutil.get_boot_time())
status["cpu_utilization"] = psutil.cpu_percent(interval=1)
status["total_memory_MB"] = total_memory_mb
status["memory_utilization"] = memory_utilization
logger.debug("Basic monitoring: %s" % (json.dumps(status)))
return status
def index():
load_avg = os.getloadavg()
uptime = datetime.now() - datetime.fromtimestamp(psutil.get_boot_time())
disks = get_disks()
users = get_users()
netifs = get_network_interfaces()
netifs.sort(key=lambda x: x.get("bytes_sent"), reverse=True)
data = {
"os": platform.platform().decode("utf-8"),
"hostname": socket.gethostname().decode("utf-8"),
"uptime": str(uptime).split(".")[0],
"load_avg": load_avg,
"cpus": psutil.NUM_CPUS,
"vmem": psutil.virtual_memory(),
"swap": psutil.swap_memory(),
"disks": disks,
"cpu_percent": psutil.cpu_times_percent(0),
"users": users,
"net_interfaces": netifs,
"page": "overview",
"is_xhr": request.is_xhr
}
return render_template("index.html", **data)
def boot_time(time_format=None):
'''
Return the boot time in number of seconds since the epoch began.
CLI Example:
time_format
Optionally specify a `strftime`_ format string. Use
``time_format='%c'`` to get a nicely-formatted locale specific date and
time (i.e. ``Fri May 2 19:08:32 2014``).
.. _strftime: https://docs.python.org/2/library/datetime.html#strftime-strptime-behavior
.. versionadded:: 2014.1.4
.. code-block:: bash
salt '*' ps.boot_time
'''
try:
b_time = int(psutil.boot_time())
except AttributeError:
# get_boot_time() has been removed in newer psutil versions, and has
# been replaced by boot_time() which provides the same information.
b_time = int(psutil.get_boot_time())
if time_format:
# Load epoch timestamp as a datetime.datetime object
b_time = datetime.datetime.fromtimestamp(b_time)
try:
return b_time.strftime(time_format)
except TypeError as exc:
raise SaltInvocationError('Invalid format string: {0}'.format(exc))
return b_time
def index():
load_avg = os.getloadavg()
uptime = datetime.now() - datetime.fromtimestamp(psutil.get_boot_time())
disks = get_disks()
users = get_users()
netifs = get_network_interfaces()
netifs.sort(key=lambda x: x.get("bytes_sent"), reverse=True)
data = {
"os": platform.platform().decode("utf-8"),
"hostname": socket.gethostname().decode("utf-8"),
"uptime": str(uptime).split(".")[0],
"load_avg": load_avg,
"cpus": psutil.NUM_CPUS,
"vmem": psutil.virtual_memory(),
"swap": psutil.swap_memory(),
"disks": disks,
"cpu_percent": psutil.cpu_times_percent(0),
"users": users,
"net_interfaces": netifs,
"page": "overview",
"is_xhr": request.is_xhr
}
return render_template("index.html", **data)
def boot_time():
"""
Get system boot time
:return:
"""
b_time = psutil.get_boot_time()
return datetime.datetime.fromtimestamp(b_time).strftime(
"%Y-%m-%d %H:%M:%S")
def boot():
try:
boot_time = psutil.boot_time()
except AttributeError:
boot_time = psutil.get_boot_time()
# Compatible < 2.0.0
has_boot = time.time() - boot_time
hour = int(has_boot / 3600)
return str(hour) + ':' + str(int((has_boot - hour * 3600) / 60))
def index():
uptime = datetime.now() - datetime.fromtimestamp(psutil.get_boot_time())
return render_template('system/system.html',
uptime = str(uptime).split('.')[0],
load = os.getloadavg(),
net = psutil.net_io_counters(),
memory = psutil.virtual_memory(),
swap = psutil.swap_memory(),
)
def boot():
try:
boot_time = psutil.boot_time()
except AttributeError:
boot_time = psutil.get_boot_time()
# Compatible < 2.0.0
has_boot = time.time() - boot_time
hour = int(has_boot / 3600)
return str(hour) + ':' + str(int((has_boot - hour * 3600) / 60))
def index():
uptime = datetime.now() - datetime.fromtimestamp(psutil.get_boot_time())
return render_template(
'system/system.html',
uptime=str(uptime).split('.')[0],
load=os.getloadavg(),
net=psutil.net_io_counters(),
memory=psutil.virtual_memory(),
swap=psutil.swap_memory(),
)
def uptime(self):
try:
d = {}
boot = datetime.now() - datetime.fromtimestamp(psutil.get_boot_time())
boot = str(boot)
uptime = boot[:-7]
d['uptime'] = uptime
return json.dumps(d)
except Exception as e:
self.logger.error("Could not get uptime %s" % e)
def boot_time():
'''
Return the boot time in number of seconds since the epoch began.
CLI Example:
.. code-block:: bash
salt '*' ps.boot_time
'''
return psutil.get_boot_time()
def boot_time():
'''
Return the boot time in number of seconds since the epoch began.
CLI Example:
.. code-block:: bash
salt '*' ps.boot_time
'''
return psutil.get_boot_time()
def uptime(self):
try:
if psutil.version_info >= (2, 0, 0):
b = psutil.boot_time()
else:
b = psutil.get_boot_time()
d = {}
boot = datetime.now() - datetime.fromtimestamp(b)
boot = str(boot)
uptime = boot[:-7]
d['uptime'] = uptime
return json.dumps(d)
except Exception as e:
self.logger.error("Could not get uptime %s" % e)
def uptime(self):
try:
if psutil.version_info >= (2, 0, 0):
b = psutil.boot_time()
else:
b = psutil.get_boot_time()
d = {}
boot = datetime.now() - datetime.fromtimestamp(b)
boot = str(boot)
uptime = boot[:-7]
d['uptime'] = uptime
return json.dumps(d)
except Exception as e:
self.logger.error("Could not get uptime %s" % e)
def sysinfo(self, facts):
now = datetime.datetime.now()
try:
btime = datetime.datetime.fromtimestamp(psutil.get_boot_time())
except AttributeError:
# old psutil version
btime = datetime.datetime.fromtimestamp(psutil.BOOT_TIME)
#facts["hostname"] = socket.getfqdn()
facts["hostname"] = socket.gethostname()
facts["os"] = platform.platform()
facts["kernel"] = platform.release()
facts["cpus"] = psutil.NUM_CPUS
facts["uptime"] = str(now - btime).split(".")[0]
def fetch():
#
ldict = {"step": MODULEFILE + "/" + inspect.stack()[0][3],
"hostname": platform.node().split(".")[0]}
l = logging.LoggerAdapter(fetch_lg(), ldict)
#
l.info("Gathering host info...")
host_props = {}
host_props["machine"] = platform.machine()
host_props["arch"] = platform.machine()
host_props["release"] = platform.release()
host_props["system"] = platform.system()
host_props["hostname"] = platform.node()
host_props["name"] = host_props["hostname"]
host_props["domainname"] = ".".join(socket.gethostname().split('.')[1:])
host_props["fqdn"] = socket.gethostname()
host_props["memory"] = psutil.virtual_memory().total
host_props["memory_used"] = psutil.virtual_memory().percent
host_props["cpu"] = psutil.NUM_CPUS
dt = datetime.datetime.fromtimestamp
host_props["boottime"] = dt(psutil.get_boot_time())
host_props["cpu_used"] = psutil.cpu_percent(interval=1, percpu=False)
host_props["hardwareisa"] = platform.processor()
host_props["hardwaremodel"] = platform.processor()
host_props["user"] = os.environ['USER']
ostype = os.uname()[0]
if ostype == "Linux":
host_props["kernel_release"] = platform.uname()[2]
host_props["kernel_version"] = platform.uname()[2].split('-')[0]
try:
host_props_extra = fetch_linux()
except Exception as _:
if sillyfacter.config.STRICT:
raise
if sillyfacter.config.DEBUG:
l.exception("")
l.error("unable to fetch linux specific info '{}'".format(_))
host_props_extra = {}
host_props = dict(host_props.items() + host_props_extra.items())
for i in host_props:
l.debug("{:<15}: {}".format(i, host_props[i]))
return host_props
def get_uptime_minutes(self):
"""Get the system uptime in seconds"""
boot_time = None
try:
boot_time = psutil.boot_time()
except Exception:
pass
if boot_time is None:
try:
boot_time = psutil.get_boot_time()
except Exception:
pass
if boot_time is None:
try:
boot_time = psutil.BOOT_TIME
except Exception:
pass
uptime = None
if boot_time is not None and boot_time > 0:
uptime = int((time.time() - boot_time) / 60)
if uptime is not None and uptime < 0:
uptime = 0
return uptime
def index(self):
bandwidth = getBandwidth()
transmission, couchpotato, sickbeard, headphones = get_program_status()
tmpl = env.get_template('index.html')
return tmpl.render(
# sys info
cpu = psutil.cpu_percent(),
ram = psutil.virtual_memory().percent,
bootTime = psutil.get_boot_time(),
usedDisk = convertBytes(psutil.disk_usage('/').used),
totalDisk = psutil.disk_usage('/').total >> 30,
monthlyBW = {{MONTHLY_BANDWIDTH}},
currTime = str(datetime.datetime.now()),
# Charts
hourly_tx = bandwidth['hourly_tx'],
hourly_rx = bandwidth['hourly_rx'],
daily_tx = bandwidth['daily_tx'],
daily_rx = bandwidth['daily_rx'],
monthly_tx = bandwidth['monthly_tx'],
monthly_rx = bandwidth['monthly_rx'],
totalAll = bandwidth['totalAll'],
totalMonth = bandwidth['totalMonth'],
# Maintenance
transmissionIsOn = transmission,
couchpotatoIsOn = couchpotato,
sickbeardIsOn = sickbeard,
headphonesIsOn = headphones,
# Streaming Media
tv = get_directory_structure('/home/tv'),
music = get_directory_structure('/home/music'),
other = get_directory_structure('/home/other'),
movies = get_directory_structure('/home/movies')
)
## -- psutil from Giampaolo Rodola' -- ##
##########################################################
import psutil
__version__ = "ver. 1.0 - beta"
__date__ = 2013, 7, 28
print("-- for help type -- info --")
new = input(" what do you wanna know about the system?: ")
##############################################################################
## memory ##
memo = psutil.virtual_memory()
swap = psutil.swap_memory()
## systm ##
user = psutil.get_users()
boot = psutil.get_boot_time()
syst = psutil.get_pid_list()
sysl = psutil.get_process_list()
## cpu ##
cpus = psutil.NUM_CPUS
cpuc = psutil.cpu_percent(interval=1, percpu=True)
cpuv = psutil.cpu_times(percpu=True)
## network ##
netw = psutil.network_io_counters()
nets = psutil.network_io_counters(pernic=True)
## disk ##
dska = psutil.disk_partitions(all=False)
dskb = psutil.disk_io_counters(perdisk=False)
dskm = psutil.disk_io_counters(perdisk=True)
dskc = psutil.disk_usage("C:")
dskd = psutil.disk_usage("D:")
def runtime_info():
info = dict()
info['uptime'] = psutil.get_boot_time()
return info
def output_sys_y(sysy): return psutil.get_boot_time()
__date__ = 2013, 8, 3
#####################################################
## cpu ##
cpus = psutil.NUM_CPUS
cpul = psutil.cpu_percent(interval=1, percpu=True)
cpuv = psutil.cpu_times(percpu=True)
## memory ##
mema = psutil.virtual_memory()
memw = psutil.swap_memory()
## disk ##
dskc = psutil.disk_usage("/root/")
dskd = psutil.disk_usage("/")
## systm ##
sysz = psutil.get_users()
sysy = psutil.get_boot_time()
sysr = psutil.get_pid_list()
sysh = psutil.get_process_list()
## network ##
netn = psutil.network_io_counters()
netm = psutil.network_io_counters(pernic=True)
#####################################################
def print_options():
print("Options:")
print(" CPU info's")
print(" 'l' cpu load in %")
print(" 's' cpu's in systm")
print(" 'v' cpu load")
print(" RAM info's")
print(" 'a' ram info")
print(" 'w' swap info")
def uptime():
uptime = datetime.now() - datetime.fromtimestamp(psutil.get_boot_time())
return str(uptime)
def boot():
has_boot = time.time() - psutil.get_boot_time()
hour = int(has_boot / 3600)
return str(hour) + ':' + str(int((has_boot - hour * 3600) / 60))
def status_uptime(self):
return time.time() - psutil.get_boot_time()
def upTime(): try: return time.time()-psutil.boot_time() except: return time.time()-psutil.get_boot_time()
def getUptime():
bootTime = int(ps.get_boot_time())
return int(getTimestamp() - bootTime)
def status_uptime(self):
return time.time() - psutil.get_boot_time()
if diff_out_p < 0:
diff_out_p = 0
old_net_data[nic] = data
sock.send(msgpack.packb({
"service": "machine",
"msg_type": "value",
"resource_type": "network",
"unit": nic,
"values": {
"bps_in": diff_in_b / interval,
"bps_out": diff_out_b / interval,
"pps_in": diff_in_p / interval,
"pps_out": diff_out_p / interval
}
}))
sock.send(msgpack.packb({
"service": "machine",
"msg_type": "value",
"resource_type": "uptime",
"unit": "",
"values": {
"uptime": time.time() - psutil.get_boot_time()
}
}))
time.sleep(interval)
def fetch2json(f, fetchable):
ldict = {"step": MODULEFILE + "/" + inspect.stack()[0][3],
"hostname": platform.node().split(".")[0]}
l = logging.LoggerAdapter(fetch_lg(), ldict)
#
myfslookup, mynslookup = lookup(f)
fetched = {}
fetched["_scan_id"] = platform.node()
fetched["_scan_time"] = datetime.datetime.now()
fetched["has"] = {}
fetched["had"] = {}
dt = datetime.datetime.fromtimestamp
boottime = dt(psutil.get_boot_time())
# host main
if "os" in f:
for item, val in f["os"].iteritems():
fetched[item] = val
# special
if "custom" in f:
pass
# host networks
if "network" in f:
fetched["has"]["network"] = []
for item in f["network"]:
newitem = {}
newitem["ifname"] = item["ifname"]
newitem["ip"] = item["ip"]
#if newitem["ip"] in f["nslookup"]:
# newitem["hostname"] = f["nslookup"][newitem["ip"]]
fetched["has"]["network"].append(newitem)
# host procs
if "process" in f:
fetched["has"]["process"] = []
for pid in f["process"]:
_process_type = set()
newitem = {}
newitem["pid"] = pid
newitem["commandline"] = f["process"][pid]["cmdline"]
newitem["exe"] = f["process"][pid]["exe"]
if "exe_fs" in f["process"][pid]:
newitem["exe_fs"] = f["process"][pid]["exe_fs"]
newitem["user"] = f["process"][pid]["user"]
newitem["createtime"] = f["process"][pid]["create_time"]
if boottime + datetime.timedelta(seconds=600) \
> newitem["createtime"]:
_process_type.add("startup-prog")
else:
_process_type.add("user-prog")
#
# proc network conn
if "connection" in f["process"][pid]:
newitem["connection"] = []
newconns = f["process"][pid]["connection"]
for conn in newconns:
conn_src = conn[0]
conn_src_ip = ":".join(conn_src.split(':')[:-1])
conn_src_port = ":".join(conn_src.split(':')[-1:])
conn_src_host = conn_src_ip
conn_dst = conn[1]
if conn_dst is not None:
conn_dst_ip = ":".join(conn_dst.split(':')[:-1])
conn_dst_port = ":".join(conn_dst.split(':')[-1:])
conn_dst_host = conn_dst_ip
_process_type_network = "network-client"
else:
conn_dst_port = "*"
conn_dst_ip = "0.0.0.0"
conn_dst_host = "*"
_process_type_network = "network-daemon"
conn_pair = {"source": conn_src_host + ":" + conn_src_port,
"destination": conn_dst_host +
":" + conn_dst_port}
newitem["connection"].append(conn_pair)
_process_type.add(_process_type_network)
if len(newitem["connection"]) == 0:
del newitem["connection"]
#
# proc open mounts
if "open" in f["process"][pid]:
newitem["open"] = []
newitem["fs"] = []
open_fs = set()
mountpairs = f["process"][pid]["open"]
for mountpair in mountpairs:
if "path" in mountpair and "fs" in mountpair:
fs = mountpair["fs"]
open_fs.add(fs)
_, fstype = myfslookup(dev=fs)
if fstype is not None and len(fstype) > 0:
_process_type.add("{}-client".format(fstype))
fl = mountpair["path"]
newitem["open"].append({"file": fl,
"filesystem": fs})
open_fs_list = list(open_fs)
if len(open_fs_list) > 0:
newitem["open_filesystem"] = open_fs_list
newitem["type"] = list(_process_type)
fetched["has"]["process"].append(newitem)
if "user" in f:
users = f["user"]
if "current" in users:
fetched["has"]["user"] = users["current"]
if "last" in users:
fetched["had"]["user"] = users["last"]
#
if "custom" in f:
fetched_custom = {}
for modulename, val in f["custom"].iteritems():
try:
fetched_custom = None
m = fetchable["custom"][modulename]
if hasattr(m, "output_for_json"):
fetched_custom = getattr(m, "output_for_json")(val)
elif hasattr(m, "output"):
fetched_custom = getattr(m, "output")(val)
else:
l.error("Could not find outout handler in module " +
"'{}'".format(m))
except:
l.error("custom module {} not loaded".format(modulename))
else:
if fetched_custom is not None:
fetched = dict(fetched, **fetched_custom)
return fetched
def get_boot_time():
return psutil.get_boot_time()
def boot_time():
# psutil-2.x.x is not backward compatible to psutil-1.x.x
try:
return psutil.boot_time()
except AttributeError:
return psutil.get_boot_time()
def boot():
has_boot = time.time() - psutil.get_boot_time()
hour = int(has_boot / 3600)
return str(hour) + ':' + str(int((has_boot - hour * 3600) / 60))
def boot_time(): # psutil-2.x.x is not backward compatible to psutil-1.x.x try: return psutil.boot_time() except AttributeError: return psutil.get_boot_time()
def load_data(self):
"""
Check System health status along with internet connectivity status and POST health check data after every seconds.
"""
flag = 0
device_id = self.get_device_id()
while True:
try:
firmware_usage = self.get_utilization("tracker*.zip")
except:
print "firmware is not running"
else:
print "Firmware usage:"+str(firmware_usage)
app_usage = self.get_utilization("gateway_monitor*.zip")
print "Monitoring app usage:"+json.dumps(app_usage)
if self.internet_on():
if self.token is None:
self.token = self.get_api_token()
if flag >= 1:
flag = 0
to_timestamp = datetime.utcnow()
log = {
"device_id":device_id,
"from_timestamp":from_timestamp.strftime("%Y-%m-%d %I:%M:%S %p"),
"to_timestamp":to_timestamp.strftime("%Y-%m-%d %I:%M:%S %p"),
"status" : "Connection Lost",
}
log = json.dumps(log,indent=4)
# print log
try:
requests.post(''.join([self.url,"/lrs/api/v1.0/gateway/internet/log"]),data=log,headers={'Content-Type':'application/json'}, auth=(self.token,''),verify=False,timeout=10)
except:
pass
cpu_utilization = psutil.cpu_percent()
boot_time = datetime.utcfromtimestamp(psutil.get_boot_time())
uptime = datetime.now() - boot_time
uptime = int(uptime.total_seconds())
memstats = psutil.virtual_memory()
mem_utilization = ((memstats.total-memstats.free)/memstats.total)*100
temperature = self.get_cpu_temperature()
firmware_status = self.firmware_status()
status = {
"timestamp":datetime.utcnow().strftime("%Y-%m-%d %I:%M:%S %p"),
"cpu_utilization":cpu_utilization,
"boot_time":boot_time.strftime("%Y-%m-%d %I:%M:%S %p"),
"uptime":uptime,
"mem_utilization":round(mem_utilization,2),
"temperature":temperature,
"device_id" : device_id,
"firmware_status":firmware_status
}
data = json.dumps(status,indent=4)
# print data
try:
resp = requests.post(''.join([self.url,"/lrs/api/v1.0/statastic"]),data=data,headers={'Content-Type':'application/json'}, auth=(self.token,''),verify=False,timeout=10)
except requests.exceptions.Timeout:
pass
except requests.exceptions.TooManyRedirects:
sys.exit(1)
except requests.exceptions.RequestException as e:
print e
sys.exit(1)
elif flag == 0:
flag = 1
from_timestamp = datetime.utcnow()
else:
flag += 1
tm.sleep(10)
