def getStat(self):
     return {'memTotal': psutil.TOTAL_PHYMEM,
             'memFree': psutil.avail_phymem(),
             'swapTotal': psutil.total_virtmem(),
             'swapFree': psutil.avail_virtmem(),
             'buffers': psutil.phymem_buffers(),
             'cached': psutil.cached_phymem()}
Example #2
0
    def mem(self, widget, data=None) :
	print ' \n DETAILS OF PHYSICAL AND VIRTUAL MEMORY\n '
	print 'Total physical memory (in bytes) - '
	print psutil.TOTAL_PHYMEM
	print 'Available physical memory (in bytes) - '
	print psutil.avail_phymem()
	print 'Used physical memory (in bytes) - '
	print psutil.used_phymem()
	print 'Total virtual memory (in bytes) - '
	print psutil.total_virtmem()
	print 'Available virtual memory (in bytes) - '
	print psutil.avail_virtmem()
	print 'Used virtual memory (in bytes) - '
	print psutil.used_virtmem()
	print 'Total cached memory (in bytes) - '
	print psutil.cached_phymem()
Example #3
0
def main(expr):
    vars = {'free': psutil.avail_virtmem(),
            'available': psutil.avail_virtmem(),
            'pfree': psutil.avail_phymem(),
            'buffers': psutil.phymem_buffers(),
            'total': psutil.total_virtmem(),
            'cached': psutil.cached_phymem(),
    }
    return eval(expr, {}, vars)
Example #4
0
    def generate(self, **kwargs):
        result = {'mem_phys_total': psutil.TOTAL_PHYMEM,
                  'mem_phys_avail': psutil.avail_phymem(),
                  'mem_phys_used': psutil.used_phymem(),
                  'mem_virt_total': psutil.total_virtmem(),
                  'mem_virt_avail': psutil.used_virtmem(),
                  'cpu_cores': self._get_total_core(),
                }

        return result
Example #5
0
 def get_system_status(self):
    
     system_info = []
     
     get_sys_cpu_info = str(psutil.cpu_percent(interval=int(psutil.NUM_CPUS))) + "%"
     get_sys_mem_info = "total phymem: " + str(int(psutil.TOTAL_PHYMEM ) /1000 /1000) + " MB"
     get_sys_virtmem_info = "total virtmem: " + str(int(psutil.total_virtmem()) /1000 /1000) + " MB"
     system_info.append([get_sys_cpu_info,get_sys_mem_info,get_sys_virtmem_info])
             
     return system_info
 def generate(self, **kwargs):
     result = {
         'mem_phys_total': psutil.TOTAL_PHYMEM,
         'mem_phys_avail': psutil.avail_phymem(),
         'mem_phys_used': psutil.used_phymem(),
         'mem_virt_total': psutil.total_virtmem(),
         'mem_virt_avail': psutil.avail_virtmem(),
         'mem_virt_used': psutil.used_virtmem(),
         'cpu_cores': self._get_total_cores(),
     }
     return result
Example #7
0
 def getMemStatus(self):
     memstatus = {}
     memstatus['total_phymem'] = str(int(psutil.TOTAL_PHYMEM ) /1024 /1024) + " MB"
     memstatus['total_virtmem'] = str(int(psutil.total_virtmem()) /1024 /1024) + " MB"
     memstatus['phymem_usage_percent'] = psutil.phymem_usage().percent
     memstatus['phymem_usage_used'] = str(int(psutil.phymem_usage().used) /1024 /1024) + "MB"
     memstatus['phtmem_usage_free'] = str(int(psutil.phymem_usage().free) /1024 /1024) + "MB"
     memstatus['virtmem_usage_percent'] = psutil.virtmem_usage().percent
     memstatus['virtmem_usage_used'] = str(int(psutil.virtmem_usage().used) /1024 /1024) + "MB"
     memstatus['virtmem_usage_free'] = str(int(psutil.virtmem_usage().free) /1024 /1024) + "MB"
     return memstatus
Example #8
0
 def collect(self):
     return dict(
         cpu_times=psutil.cpu_times()._asdict(),
         mem=dict(
             total_phymem=psutil.TOTAL_PHYMEM,
             avail_phymem=psutil.avail_phymem(),
             avail_virtmem=psutil.avail_virtmem(),
             cached_phymem=psutil.cached_phymem(),
             phymem_buffers=psutil.phymem_buffers(),
             total_virtmem=psutil.total_virtmem(),
             used_phymem=psutil.used_phymem(),
             used_virtmem=psutil.used_virtmem(),
         ),
         processes=list(self._processes()),
         net=dict(ifaces=self._net_dev(), proto=self._net_proto()),
         io=self._io_stats(),
         fs=dict(self._fs_usage()),
         fh=self._file_handles(),
     )
Example #9
0
    def refresh(self):
        logging.debug("Host.refresh(): Refreshing all host entries")
        self.refreshVirtServiceSpecs()
        self.__machine_type=platform.machine()
        self.__network_name=platform.node()
        self.__processor=platform.processor()
        self.__python_version=platform.python_version()
        self.__linuxKernel_version=platform.release()
        #self.__name=platform.system()
        dist_info=platform.linux_distribution(distname='', version='', id='', supported_dists=('SuSE', 'debian', 'redhat'), full_distribution_name=1)
        self.__distroName=dist_info[0]
        self.__distroVersion=dist_info[1]
        self.__distroCode=dist_info[2]
        self.__vm_manager_pid=os.getpid()
        self.__freePhyMem=psutil.avail_phymem()/1048576
        self.__freeVirtMem=psutil.avail_virtmem()/1048576
        self.__totalVirtMem=psutil.total_virtmem()/1048576
        self.__usedPhyMem=psutil.used_phymem()/1048576
        self.__manager_process=psutil.Process(self.__vm_manager_pid)
        self.__virt_process=psutil.Process(int(self.__virtProcessPid))
        self.__processUptime=datetime.datetime.fromtimestamp(self.__manager_process.create_time).strftime("%Y-%m-%d %H:%M")
        #self.__processOwner=self.__manager_process.username
        #self.__numOfProcessThreads=self.__manager_process.get_num_threads()
        #self.__numOfVirtProcessThreads=self.__virt_process.get_num_threads()
    
        #for thread in self.__virt_process.get_threads():
        #    self.__virtProcessThreadIDs.append(thread[0])
            
        #for thread in self.__manager_process.get_threads():
        #    self.__processThreadIDs.append(thread[0])

        self.__virtProcessCpuUsage=self.__virt_process.get_cpu_percent()
        self.__proccessCpuUsage=self.__manager_process.get_cpu_percent()
        mem=self.__virt_process.get_memory_info()
        self.__virtProcessMemUsage=mem[1]/1048576
        mem=self.__manager_process.get_memory_info()
        self.__processMemUsage=mem[1]/1048576
        #self.__processOpenedFilesSpecs=self.__manager_process.get_open_files()
        #self.__virtProcessOpenedFilesSpecs=self.__virt_process.get_open_files()
        #self.__processConnectionsSpecs=self.__manager_process.get_connections()
        #self.__virtProcessConnectionsSpecs=self.__virt_process.get_connections()
        self.__cpuUsage=psutil.cpu_percent()
    def test_total_virtmem(self):
        # This test is not particularly accurate and may fail if the OS is
        # consuming memory for other applications.
        # We just want to test that the difference between psutil result
        # and sysctl's is not too high.
        p = subprocess.Popen("sysctl vm.vmtotal", shell=1, stdout=subprocess.PIPE)
        result = p.communicate()[0].strip()
        if sys.version_info >= (3,):
            result = str(result, sys.stdout.encoding)
        sysctl_total_virtmem, _ = parse_sysctl_vmtotal(result)
        psutil_total_virtmem = psutil.total_virtmem()
        difference = abs(sysctl_total_virtmem - psutil_total_virtmem)

        # On my system I get a difference of 4657152 bytes, probably because
        # the system is consuming memory for this same test.
        # Assuming psutil is right, let's use a tollerance of 10 MB and consider
        # the test as failed if we go over it.
        if difference > (10 * 2**20):
            self.fail("sysctl=%s; psutil=%s; difference=%s;" %(
                       sysctl_total_virtmem, psutil_total_virtmem, difference))
Example #11
0
 def __call__(self):
     status = []
     status.append(('num cpus', psutil.NUM_CPUS))
     status.append(('cpu used', '%.2f%%' % psutil.cpu_percent()))
     total_phy = psutil.TOTAL_PHYMEM
     used_phy = psutil.used_phymem()
     status.append(('total phy mem', ConvertBytes(total_phy)))
     status.append(('used phy mem', ConvertBytes(used_phy)))
     status.append(('free phy mem', ConvertBytes(total_phy - used_phy)))
     try:
         status.append(('buffers', ConvertBytes(psutil.phymem_buffers())))
         status.append(('cached', ConvertBytes(psutil.cached_phymem())))
     except:
         pass
     total_virt = psutil.total_virtmem()
     used_virt = psutil.used_virtmem()
     status.append(('total virt mem', ConvertBytes(total_virt)))
     status.append(('used virt mem', ConvertBytes(used_virt)))
     status.append(('free virt mem', ConvertBytes(total_virt - used_virt)))
     return status
Example #12
0
 def collect(self):
     return dict(
         cpu_times=psutil.cpu_times()._asdict(),
         mem=dict(
             total_phymem=psutil.TOTAL_PHYMEM,
             avail_phymem=psutil.avail_phymem(),
             avail_virtmem=psutil.avail_virtmem(),
             cached_phymem=psutil.cached_phymem(),
             phymem_buffers=psutil.phymem_buffers(),
             total_virtmem=psutil.total_virtmem(),
             used_phymem=psutil.used_phymem(),
             used_virtmem=psutil.used_virtmem(),
         ),
         processes=list(self._processes()),
         net=dict(
             ifaces=self._net_dev(),
             proto=self._net_proto()
         ),
         io=self._io_stats(),
         fs=dict(self._fs_usage()),
         fh=self._file_handles(),
     )
Example #13
0
 def done(self):
     server = {}
     server['load_average']  = os.getloadavg()
     server['total_phymem']  = psutil.TOTAL_PHYMEM
     server['total_virtmem'] = psutil.total_virtmem()
     server['used_phymem']   = psutil.used_phymem()
     server['used_virtmem']  = psutil.used_virtmem()
     server['cpu_percent']   = psutil.cpu_percent()
     server['cpu_count']     = psutil.NUM_CPUS
     
     f_processes = []
     processes = psutil.get_process_list()
     processes.sort(key=lambda x: x.get_cpu_times())
     processes.reverse()
     for p in processes[:10]:
         f_processes.append((p.name, p.get_cpu_times(), p.get_memory_percent(),time.ctime(p.create_time),))
     
     server['processes'] = f_processes
     return server
     
     
     
Example #14
0
# -*- coding: utf-8 -*-
"""
Created on Tue Sep  3 09:21:57 2013

@author: ozdemircili
"""

import psutil
psutil.phymem_usage()
psutil.virtmem_usage()
psutil.cached_phymem()
psutil.phymem_buffers()
psutil.avail_phymem()
psutil.used_phymem()
psutil.total_virtmem()
psutil.avail_virtmem()
psutil.used_virtmem()

psutil.cpu_percent()

#CPU

from __future__ import print_function

with open('/proc/cpuinfo') as f:
    for line in f:

        #Formatting the output!!
        if line.strip():
            if line.rstrip('\n').startswith('model name'):
                model_name = line.rstrip('\n').split(':')[1]
Example #15
0
 def test_total_virtmem(self):
     x = psutil.total_virtmem()
     self.assertTrue(isinstance(x, (int, long)))
     self.assertTrue(x >= 0)
 def test_total_virtmem(self):
     x = psutil.total_virtmem()
     self.assertTrue(isinstance(x, (int, long)))
     self.assertTrue(x >= 0)
Example #17
0
# -*- coding: utf-8 -*-
"""
Created on Tue Sep  3 09:21:57 2013

@author: ozdemircili
"""


import psutil
psutil.phymem_usage()
psutil.virtmem_usage()
psutil.cached_phymem()
psutil.phymem_buffers()
psutil.avail_phymem()
psutil.used_phymem()
psutil.total_virtmem()
psutil.avail_virtmem()
psutil.used_virtmem()

psutil.cpu_percent()

#CPU

from __future__ import print_function

with open('/proc/cpuinfo') as f:
    for line in f:
       
        #Formatting the output!!
        if line.strip():
            if line.rstrip('\n').startswith('model name'):
Example #18
0
 def getMemPerc(cls):
     return "%03d" % int(100.0 * (1.0 - float(psutil.avail_virtmem()) / float(psutil.total_virtmem()))) + \
         "m% "
Example #19
0
def check_mem():
	server = 'localhost'
	port = 2003
	##	hostname needed for the graphite tree
	hostname = socket.gethostname()
	##	build the tree up a bit
	tree = hostname+".memory."
	##	build a dictionary of the values we want to graph
	try:
		mem_dict = {"total_physical_memory": psutil.phymem_usage().total, 'free_physical_memory':psutil.phymem_usage().free, "used_physical_memory": psutil.phymem_usage().used, "total_virtual_memory":psutil.total_virtmem(), "free_virtual_memory": psutil.avail_virtmem(), "used_virtual_memory": psutil.used_virtmem()}
		##	Iterate the dictionary and write out the value to graphite for each key
		for key in mem_dict:
			w2g(server, port, tree+key, mem_dict[key])
	except Exception as e: ##	clean up errors a bit
		print e
		exit(1)
Example #20
0
    def _store_resources(self, store=True):
        """Looks at the resources usage and store the data locally.

        store (bool): if False, run the method but do not store the
                      resulting values - useful for initializing the
                      previous values

        """
        logger.debug("ResourceService._store_resources")
        # We use the precise time to compute the delta
        now = time.time()
        delta = now - self._last_saved_time
        self._last_saved_time = now
        now = int(now)

        data = {}

        # CPU
        cpu_times = self._get_cpu_times()
        data["cpu"] = dict((x, int(round((cpu_times[x] -
                                          self._prev_cpu_times[x])
                                   / delta * 100.0)))
                            for x in cpu_times)
        data["cpu"]["num_cpu"] = psutil.NUM_CPUS
        self._prev_cpu_times = cpu_times

        # Memory. We differentiate from old and deprecated (< 0.3.0)
        # methods to the new ones. Remove the differentiation when we
        # drop the support for Ubuntu 11.10 (which ships 0.2.1).
        ram_cached = psutil.cached_phymem()
        ram_buffers = psutil.phymem_buffers()
        if psutil_version < (0, 3, 0):
            data["memory"] = {
                "ram_total": psutil.TOTAL_PHYMEM / B_TO_MB,
                "ram_available": psutil.avail_phymem() / B_TO_MB,
                "ram_cached": ram_cached / B_TO_MB,
                "ram_buffers": ram_buffers / B_TO_MB,
                "ram_used": (psutil.used_phymem() - ram_cached - ram_buffers)
                                  / B_TO_MB,
                "swap_total": psutil.total_virtmem() / B_TO_MB,
                "swap_available": psutil.avail_virtmem() / B_TO_MB,
                "swap_used": psutil.used_virtmem() / B_TO_MB,
                }
        else:
            phymem = psutil.phymem_usage()
            virtmem = psutil.virtmem_usage()
            data["memory"] = {
                "ram_total": phymem.total / B_TO_MB,
                "ram_available": phymem.free / B_TO_MB,
                "ram_cached": ram_cached / B_TO_MB,
                "ram_buffers": ram_buffers / B_TO_MB,
                "ram_used": (phymem.used - ram_cached - ram_buffers) / B_TO_MB,
                "swap_total": virtmem.total / B_TO_MB,
                "swap_available": virtmem.free / B_TO_MB,
                "swap_used": virtmem.used / B_TO_MB,
                }

        data["services"] = {}
        # Details of our services
        for service in self._local_services:
            dic = {"autorestart": self._will_restart[service],
                   "running": True}
            proc = self._procs[service]
            # If we don't have a previously found process for the
            # service, we find it
            if proc is None:
                proc = self._find_proc(service)
            # If we still do not find it, there is no process
            if proc is None:
                dic["running"] = False
            # We have a process, but maybe it has been shut down
            elif not proc.is_running():
                # If so, let us find the new one
                proc = self._find_proc(service)
                # If there is no new one, continue
                if proc is None:
                    dic["running"] = False
            # If the process is not running, we have nothing to do.
            if not dic["running"]:
                data["services"][str(service)] = dic
                continue

            try:
                dic["since"] = self._last_saved_time - proc.create_time
                dic["resident"], dic["virtual"] = \
                    (x / 1048576  for x in proc.get_memory_info())
                cpu_times = proc.get_cpu_times()
                dic["user"] = int(
                    round((cpu_times[0] -
                           self._services_prev_cpu_times[service][0])
                          / delta * 100))
                dic["sys"] = int(
                    round((cpu_times[1] -
                           self._services_prev_cpu_times[service][1])
                          / delta * 100))
                self._services_prev_cpu_times[service] = cpu_times
                try:
                    dic["threads"] = proc.get_num_threads()
                except AttributeError:
                    dic["threads"] = 0  # 0 = Not implemented

                self._procs[service] = proc
            except psutil.error.NoSuchProcess:
                # Shut down while we operated?
                dic = {"autorestart": self._will_restart[service],
                       "running": False}
            data["services"][str(service)] = dic

        if store:
            if len(self._local_store) >= 5000:  # almost 7 hours
                self._local_store = self._local_store[1:]
            self._local_store.append((now, data))

        return True
Example #21
0
    def _store_resources(self, store=True):
        """Looks at the resources usage and store the data locally.

        store (bool): if False, run the method but do not store the
                      resulting values - useful for initializing the
                      previous values

        """
        logger.debug("ResourceService._store_resources")
        # We use the precise time to compute the delta
        now = time.time()
        delta = now - self._last_saved_time
        self._last_saved_time = now
        now = int(now)

        data = {}

        # CPU
        cpu_times = self._get_cpu_times()
        data["cpu"] = dict((x, int(round((cpu_times[x] -
                                          self._prev_cpu_times[x])
                                   / delta * 100.0)))
                            for x in cpu_times)
        data["cpu"]["num_cpu"] = psutil.NUM_CPUS
        self._prev_cpu_times = cpu_times

        # Memory. We differentiate from old and deprecated (< 0.3.0)
        # methods to the new ones. Remove the differentiation when we
        # drop the support for Ubuntu 11.10 (which ships 0.2.1).
        ram_cached = psutil.cached_phymem()
        ram_buffers = psutil.phymem_buffers()
        if psutil_version < (0, 3, 0):
            data["memory"] = {
                "ram_total": psutil.TOTAL_PHYMEM / B_TO_MB,
                "ram_available": psutil.avail_phymem() / B_TO_MB,
                "ram_cached": ram_cached / B_TO_MB,
                "ram_buffers": ram_buffers / B_TO_MB,
                "ram_used": (psutil.used_phymem() - ram_cached - ram_buffers)
                                  / B_TO_MB,
                "swap_total": psutil.total_virtmem() / B_TO_MB,
                "swap_available": psutil.avail_virtmem() / B_TO_MB,
                "swap_used": psutil.used_virtmem() / B_TO_MB,
                }
        else:
            phymem = psutil.phymem_usage()
            virtmem = psutil.virtmem_usage()
            data["memory"] = {
                "ram_total": phymem.total / B_TO_MB,
                "ram_available": phymem.free / B_TO_MB,
                "ram_cached": ram_cached / B_TO_MB,
                "ram_buffers": ram_buffers / B_TO_MB,
                "ram_used": (phymem.used - ram_cached - ram_buffers) / B_TO_MB,
                "swap_total": virtmem.total / B_TO_MB,
                "swap_available": virtmem.free / B_TO_MB,
                "swap_used": virtmem.used / B_TO_MB,
                }

        data["services"] = {}
        # Details of our services
        for service in self._local_services:
            dic = {"autorestart": self._will_restart[service],
                   "running": True}
            proc = self._procs[service]
            # If we don't have a previously found process for the
            # service, we find it
            if proc is None:
                proc = self._find_proc(service)
            # If we still do not find it, there is no process
            if proc is None:
                dic["running"] = False
            # We have a process, but maybe it has been shut down
            elif not proc.is_running():
                # If so, let us find the new one
                proc = self._find_proc(service)
                # If there is no new one, continue
                if proc is None:
                    dic["running"] = False
            # If the process is not running, we have nothing to do.
            if not dic["running"]:
                data["services"][str(service)] = dic
                continue

            try:
                dic["since"] = self._last_saved_time - proc.create_time
                dic["resident"], dic["virtual"] = \
                    (x / 1048576  for x in proc.get_memory_info())
                cpu_times = proc.get_cpu_times()
                dic["user"] = int(
                    round((cpu_times[0] -
                           self._services_prev_cpu_times[service][0])
                          / delta * 100))
                dic["sys"] = int(
                    round((cpu_times[1] -
                           self._services_prev_cpu_times[service][1])
                          / delta * 100))
                self._services_prev_cpu_times[service] = cpu_times
                try:
                    dic["threads"] = proc.get_num_threads()
                except AttributeError:
                    dic["threads"] = 0  # 0 = Not implemented

                self._procs[service] = proc
            except psutil.error.NoSuchProcess:
                # Shut down while we operated?
                dic = {"autorestart": self._will_restart[service],
                       "running": False}
            data["services"][str(service)] = dic

        if store:
            if len(self._local_store) >= 5000:  # almost 7 hours
                self._local_store = self._local_store[1:]
            self._local_store.append((now, data))

        return True
Example #22
0
    def run(self):
        speed_avg = psutil.network_io_counters(pernic=True)
        seguir = True
        while seguir:
            #calculate time generate stats
            start = time.time()
            #calculate stats
            # speed network #
            network_actual = pick_speed_in_secs(2)
            network_avg = pick_speed_avg(speed_avg);
            speed_avg = network_avg[2];
            # pack all #
            try:
                temperature = int(int(os.popen("cat /sys/class/thermal/thermal_zone0/temp").read())/1000)
            except:
                temperature = 40
            data = {
                "network_down": network_actual[1],#
                "network_up": network_actual[0],#
                "network_avg_down": network_avg[1],#
                "network_avg_up": network_avg[0],#
                "cache": psutil.cached_phymem(),#
                "buffer": psutil.phymem_buffers(),#
                "used": psutil.used_phymem(),#
                "swap_total": psutil.total_virtmem(),#
                "swap_used": psutil.used_virtmem(),#
                "hdd_use_": psutil.disk_usage('/')[3],
                "hdd_use_home": psutil.disk_usage('/home')[3],
                "cpu_use": psutil.cpu_percent(interval=1),#
                "cpu_mhz": int(os.popen("cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq").read()[:-3]),
                "temp": temperature
            }
            data_string = json.dumps(data)
            #print 'ENCODED:', data_string
            temp = time.localtime(start)
            datatime = str(temp[2])+"/"+str(temp[1])+"/"+str(temp[0])+" "+str(temp[3])+"/"+str(temp[4])+"/"+str(temp[5])
                
            if (os.path.exists(url_file_location) != True):
                data = {
                    "ava": psutil.avail_phymem(),#
                    "swap_ava": psutil.avail_virtmem(),#
                }
                data_string_2 = json.dumps(data)
                tmp = True
            else:
                tmp = False

            f=open(str(url_file_location),"a")
            if (tmp == True):
                f.write('"data":'+data_string_2)
            f.write(', '+'"'+datatime+'":'+data_string)

            f.close()
            
            del data
            del data_string
            del temp
            del datatime
            del network_actual
            del temperature

            time.sleep(generate_time - int(time.time() - start))
Example #23
0
def swapinfo():
	return (psutil.total_virtmem(),psutil.used_virtmem(),) # Return total and used swap
Example #24
0
            #os._exit(0)
            sent = True
    
    
class ThreadedTCPServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):
    pass

global auth
auth = hashlib.sha512(hashlib.sha512(bot.config["user"]).hexdigest()+hashlib.sha512(bot.config["pass"]).hexdigest()).hexdigest()
randport = random.randint(10000,12000)
upnpdata = {}
upnpdata = auth+",,,"+str(randport)+",,,"+bot.config["host_config_name"]
upnp_response = client(bot.config["web_server_ip"],55555, upnpdata)
if upnp_response=="clean":
    server_thread = threading.Thread(target=ThreadedTCPServer((bot.config["ip"], randport),ThreadedTCPRequestHandler).serve_forever)
    server_thread.daemon = True
    server_thread.start()
    global sysinfo
    sysinfo = {}
    sysinfo["ram"] = str(psutil.TOTAL_PHYMEM/1024/1024)
    sysinfo["swap"] = str(psutil.total_virtmem()/1024/1024)
    sysinfo["pyver"] = ('%s %s' %
                    (platform.python_implementation(),platform.python_version()))

    while True:

        time.sleep(2)
if upnp_response=="error":
    print("bad auth to web server. shutting down.")

#server_thread = threading.Thread(target=ThreadedTCPServer((bot.config["ip"], int(bot.config["port"])),ThreadedTCPRequestHandler).serve_forever)