Python Common.kill方法代码示例

# 需要导入模块: from pyasm.common import Common [as 别名]
# 或者: from pyasm.common.Common import kill [as 别名]
    def _check(self):

        # This will kill the TACTIC process 
        # This is very harsh and should be used sparingly if at all
        use_restart = Config.get_value("services", "use_periodic_restart")
        if use_restart in [True, 'true']:
            if self.num_checks and self.num_checks % self.kill_interval == 0:
                # read pid file
                log_dir = "%s/log" % Environment.get_tmp_dir()
                file = open("%s/pid.%s" % (log_dir,self.port), "r")
                pid = file.read()
                file.close()
                Common.kill(pid)

                #self.run()
                self.num_checks += 1
                return


        self.num_checks += 1

        start = time.clock()
        try:
            response = self.check()
        except IOError, e:

            pid = self._get_pid() 
            if pid:
                Common.kill(pid)

# 需要导入模块: from pyasm.common import Common [as 别名]
# 或者: from pyasm.common.Common import kill [as 别名]
    def final_kill(self):
        '''Kill the startup, startup_queue, watch_folder processes. This is used primarily in Windows Service.
           Linux service should have actively killed the processes already'''
        log_dir = "%s/log" % Environment.get_tmp_dir()
        files = os.listdir(log_dir)
        ports = []
        watch_folders = []
        queues = []

        for filename in files:
            base, ext = os.path.splitext(filename)
            if base == 'pid':
                ports.append(ext[1:])
            elif base == 'watch_folder':
                watch_folders.append(ext[1:])
            elif base == 'startup_queue':
                queues.append(ext[1:])

    
        for port in ports:
            try:
                file_name = "%s/pid.%s" % (log_dir,port)
                file = open(file_name, "r")
                pid = file.readline().strip()
                file.close()
                Common.kill(pid)
            except IOError, e:
                continue

# 需要导入模块: from pyasm.common import Common [as 别名]
# 或者: from pyasm.common.Common import kill [as 别名]
 def execute(my):
     import cherrypy
     print
     print "Stopping TACTIC ..."
     print 
     print " ... stopping Schduler"
     scheduler = Scheduler.get()
     scheduler.stop()
     print " ... stopping Cherrypy"
     cherrypy.engine.stop()
     cherrypy.engine.exit()
     print " ... closing DB connections"
     DbContainer.close_all_global_connections()
     print " ... kill current process"
     Common.kill()
     print "Done."

# 需要导入模块: from pyasm.common import Common [as 别名]
# 或者: from pyasm.common.Common import kill [as 别名]
            def execute(self):
                # wait until KillThread is premitted
                while GlobalContainer.get("KillThreadCmd:allow") == "false":
                    print "Kill locked ... waiting 5 seconds"
                    time.sleep(5)
                    continue

                import cherrypy
                print
                print "Stopping TACTIC ..."
                print 
                print " ... stopping Schduler"
                scheduler = Scheduler.get()
                scheduler.stop()
                print " ... stopping Cherrypy"
                cherrypy.engine.stop()
                cherrypy.engine.exit()
                print " ... closing DB connections"
                DbContainer.close_all_global_connections()
                print " ... kill current process"
                Common.kill()
                print "Done."

# 需要导入模块: from pyasm.common import Common [as 别名]
# 或者: from pyasm.common.Common import kill [as 别名]
    def _check(my):

        # This will kill the TACTIC process 
        # This is very harsh and should be used sparingly if at all
        use_restart = Config.get_value("services", "use_periodic_restart")
        if use_restart in [True, 'true']:
            if my.num_checks and my.num_checks % my.kill_interval == 0:
                # read pid file
                log_dir = "%s/log" % Environment.get_tmp_dir()
                file = open("%s/pid.%s" % (log_dir,my.port), "r")
                pid = file.read()
                file.close()
                print "Killing process: ", pid
                Common.kill(pid)

                #my.run()
                my.num_checks += 1
                return



        my.num_checks += 1

        start = time.clock()
        try:
            response = my.check()
        except IOError, e:
            print "Tactic IOError: ", str(e)

            # Kill if unresponsive ... (only on linux)
            log_dir = "%s/log" % Environment.get_tmp_dir()
            file = open("%s/pid.%s" % (log_dir,my.port), "r")
            pid = file.read()
            file.close()
            print "Killing process: ", pid
            Common.kill(pid) 

# 需要导入模块: from pyasm.common import Common [as 别名]
# 或者: from pyasm.common.Common import kill [as 别名]
        self.num_checks += 1

        start = time.clock()
        try:
            response = self.check()
        except IOError, e:

            pid = self._get_pid() 
            if pid:
                Common.kill(pid)
        else:
            if response and response != "OK":
                #self.end = True
                pid = self._get_pid() 
                if pid:
                    Common.kill(pid)
                return

        '''
        # check the time it took to respond
        end = time.clock()
        interval = end - start

        # if greater than 5 second, kill the process and restart
        if interval > 5:
            # read pid file
            log_dir = "%s/log" % Environment.get_tmp_dir()
            file = open("%s/pid.%s" % (log_dir,self.port), "r")
            pid = file.read()
            file.close()

# 需要导入模块: from pyasm.common import Common [as 别名]
# 或者: from pyasm.common.Common import kill [as 别名]
    def _run(self):

        task = self.kwargs.get("task")
        paths = task.get_paths()
        count = 0
        restart = False

        while True:
            
            if not paths:
                time.sleep(1)
                continue
            
            path = paths.pop(0)
            checkin_path = "%s.checkin" % path
            lock_path = "%s.lock" % path
            error_path = "%s.error" % path

            if not os.path.exists(path):
                continue
            if not os.path.exists(checkin_path):
                #print "Action Thread SKIP: no checkin path [%s]" % checkin_path
                continue
            else:
                # Exit if another process is also checking this file in.                
                f = open(checkin_path, "r")
                pid = f.readline()
                f.close()
                if pid != str(os.getpid()):
                    continue

            try:

                kwargs = {
                    "project_code": task.project_code,
                    "search_type": task.search_type,
                    "base_dir": task.base_dir,
                    "process": task.process,
                    "script_path": task.script_path,
                    "path": path
                }

                handler = task.get("handler")
                if handler:
                    cmd = Common.create_from_class_path(handler, [], kwargs)
                else:
                    # create a "custom" command that will act on the file
                    cmd = CheckinCmd(**kwargs)

                #print "Process [%s] checking in [%s]" % (os.getpid(), path)
                cmd.execute()

                # TEST
                #time.sleep(1)
                #if os.path.exists(path):
                #    os.unlink(path)

                count += 1
                if count == 20:
                    restart = True
                    task.set_clean(True)
                    break


            except Exception as e:
                print "Error: ", e
                f = open(error_path,"w")
                f.write(str(e))
                f.close()
                #raise

            finally:

                task.set_clean(True)
                if os.path.exists(checkin_path):
                    os.unlink(checkin_path)
                if os.path.exists(lock_path):
                    os.unlink(lock_path)
                task.set_clean(False)
                
                if restart:
                    task.set_clean(True)



        # restart every 20 check-ins
        if restart:
            for path in paths:
                checkin_path = "%s.checkin" % path
                lock_path = "%s.lock" % path
                if os.path.exists(checkin_path):
                    os.unlink(checkin_path)
                if os.path.exists(lock_path):
                    os.unlink(lock_path)
            # this exaggerates the effect of not pausing check thread for cleaning
            #time.sleep(10)
            Common.kill()