Example #1
0
 def __init__(self, pidfile, confile):
     '''CdmaAlarm class structure method.
     '''
     Daemon.__init__(self, pidfile)
     self.confile = confile
     self.config = ConfigParser.ConfigParser()
     if os.path.exists(self.confile):
         self.config.read(self.confile)
         if not self.config.has_section("omp"):
             print("No such section.")
             sys.exit()
         else:
             self.fwHost = self.config.get("omp", "fw_host")
             self.fwPort = self.config.getint("omp", "fw_port")
             self.fwUser = self.config.get("omp", "fw_user")
             self.fwPasswd = self.config.get("omp", "fw_passwd")
             self.ompUser = self.config.get("omp", "omp_user")
             self.ompPasswd = self.config.get("omp", "omp_passwd")
             self.ompOldPasswd = self.config.get("omp", "omp_passwd_old")
             self.logfile = self.config.get("omp", "omp_alarm_log")
             self.interval = self.config.getint("omp", "omp_alarm_interval")
             
         if not self.config.has_section("mysql"):
             print("No such section.")
             sys.exit()
         else:
             self.myHost = self.config.get("mysql", "mysql_host")
             self.myPort = self.config.getint("mysql", "mysql_port")
             self.myUser = self.config.get("mysql", "mysql_user")
             self.myPasswd = self.config.get("mysql", "mysql_passwd")
             self.myDB = self.config.get("mysql", "mysql_db")
     else:
         print("CDMA configure file is not exist.")
         sys.exit()
Example #2
0
    def __init__(self, useSSL=True):

        Daemon.__init__(self, useSSL)

        self.__MIN_ID = 100000
        self.__MAX_ID = 100000000
        self.__SESSION_TIMEOUT_HOURS = 48

        self.__loggedInUsers = {}
        self.__reverseLoggedInUsers = {}
        self.__userProtocols = {}

        self.__systemProtocol = Protocol(None)
        self.__controlProtocol = Protocol(None)

        try:
            self.__systemProtocol.open(DaemonLocations.systemDaemon[0], DaemonLocations.systemDaemon[1])
        except:
            print "warning, could not connect to system daemon"
        try:
            self.__controlProtocol.open(DaemonLocations.controlDaemon[0], DaemonLocations.controlDaemon[1])
        except:
            print "warning, could not connect to control daemon"
        
        self.registerMethodHandler("login", self.login)
        self.registerMethodHandler("logout", self.logout)
        self.registerMethodHandler("system", self.systemOperation)
        self.registerMethodHandler("control", self.controlOperation)

        self.__consoleOperationReply = None
        self.__controlOperationReply = None        
        self.__systemOperationReply = None
        
        self.__ldapClient = LDAPClient("ldap://henldap:389")
    def __init__(self, pidfile, stdin='/dev/null',
                 stdout='/dev/null', stderr='/dev/null'):
        Daemon.__init__(self, pidfile, stdin, stdout, stderr)
        self.systems = {"otc-gfxtest-bsw-01.local" : { "switch":1, "outlet":1 },
                        "otc-gfxtest-bsw-02.local" : { "switch":1, "outlet":2 },
                        "otc-gfxtest-bsw-03.local" : { "switch":1, "outlet":3 },
                        "otc-gfxtest-bsw-04.local" : { "switch":1, "outlet":4 },
                        "otc-gfxtest-bsw-05.local" : { "switch":1, "outlet":5 },
                        "otc-gfxtest-bsw-06.local" : { "switch":1, "outlet":6 },
                        # "otc-gfxtest-bsw-07.local" : { "switch":1, "outlet":7 },
                        # "otc-gfxtest-sklgt2-01.local" : { "switch":1, "outlet":8},
                        # byt does not boot after power loss
                        # "otc-gfxtest-byt-01.local" : { "switch":2, "outlet":1 },
                        # "otc-gfxtest-byt-02.local" : { "switch":2, "outlet":2 },
                        # "otc-gfxtest-byt-03.local" : { "switch":2, "outlet":3 },
                        # "otc-gfxtest-byt-04.local" : { "switch":2, "outlet":4 },
                        "otc-gfxtest-kbl-01.local" : { "switch":2, "outlet":5 },
                        "otc-gfxtest-kbl-02.local" : { "switch":2, "outlet":4 },
                        "otc-gfxtest-bxt-02.local" : { "switch":2, "outlet":6 },
                        "otc-gfxtest-bxt-01.local" : { "switch":2, "outlet":7 },
                        "otc-gfxtest-sklgt2-02.local" : { "switch":2, "outlet":8}}

        self.switches = { 1 : PowerSwitch(hostname="192.168.1.2",
                                          userid="admin",
                                          password="******"),
                          2:  PowerSwitch(hostname="192.168.1.3",
                                          userid="admin",
                                          password="******") }

        self.hangs = []
Example #4
0
 def __init__(self,pidfile,logfile_path = None,amqp_host = 'localhost',svm_save_filename = None,
              status_filename = None, X_filename = None, y_filename = None):
   if args:
     self.log = Logger(logfile_path,args.verbose)
   else:
     self.log = Logger(logfile_path)
   
   #For progress messages
   self.files_processed = 0
   
   #Make sure pickle supports compress
   pickle.HIGHEST_PROTOCOL
   
   self.svc = svm.SVC(kernel="linear")
   self.X_filename = os.path.abspath(X_filename) if X_filename else None
   self.y_filename = os.path.abspath(y_filename) if y_filename else None
   self.__X = None
   self.__y = None
   self.amqp_host = amqp_host
   self.amqp_queue = 'classifyd'
   self.svm_filename = os.path.abspath(svm_save_filename) if svm_save_filename else None
   
   self.status_filename = status_filename
   if self.status_filename and os.path.exists(self.status_filename):
     #if the file exists, try to load it from there
     f = open(self.status_filename,'rb')
     self.status = pickle.load(f)
     f.close()
   else:
     #if not, then assume we are starting over
     self.status = Status()
   #call the parent's __init__ to initialize the daemon variables
   Daemon.__init__(self,pidfile)
Example #5
0
    def __init__(self, configFilePath='/usr/local/hen/etc/configs/config'):
        Daemon.__init__(self)

        self.__version = "Console Daemon v0.2 (dumb)"
        self.__terminalServerConnections = {}
        self.__terminalServerSockets = []
        self.__configFilePath = configFilePath
        self.__configFile = ConfigParser.ConfigParser()
        self.__configFile.read(configFilePath)
        self.__henPhysicalTopology = self.__configFile.get('MAIN','PHYSICAL_TOPOLOGY')
        self.__henLogPath = self.__configFile.get('MAIN', 'LOG_PATH')
        self.__parser = HenParser(self.__henPhysicalTopology, \
                                  None, \
                                  None, \
                                  self.__henLogPath, \
                                  None,
                                  None,
                                  None, \
                                  None)

        self.__controlProtocol = None

        # Create instances for all terminal servers in the testbed
        self.__terminalServerNodes = {}
        for terminalServerNode in self.__parser.getNodes("serial", "all").values():
            self.__terminalServerNodes[terminalServerNode.getNodeID()] = terminalServerNode.getInstance()
        self.__computerNodes = self.__parser.getNodes("computer", "all")
                                
        self.__registerMethods()
Example #6
0
 def __init__(self, config_file):
     """CdmaSms class structure method.
     """
     config = configparser.ConfigParser()
     if os.path.exists(config_file):
         config.read(config_file)
         if not config.has_section("sms"):
             print("No 'sms' section.")
             sys.exit()
         else:
             self.sms_host = config.get("sms", "sms_host")
             self.sms_port = config.getint("sms", "sms_port")
             self.sms_user = config.get("sms", "sms_user")
             self.sms_passwd = config.get("sms", "sms_passwd")
             self.sms_send_uri = config.get("sms", "sms_send_uri")
             self.logfile = config.get("sms", "sms_log")
             self.sms_pid = config.get("sms", "sms_pid")
             self.interval = config.getint("sms", "sms_interval")
                     
         if not config.has_section("mysql"):
             print("No 'mysql' section.")
             sys.exit()
         else:
             self.mysql_host = config.get("mysql", "mysql_host")
             self.mysql_port = config.getint("mysql", "mysql_port")
             self.mysql_user = config.get("mysql", "mysql_user")
             self.mysql_passwd = config.get("mysql", "mysql_passwd")
             self.mysql_db = config.get("mysql", "mysql_db")
     else:
         print("CDMA configure file is not exist.")
         sys.exit()
     Daemon.__init__(self, self.sms_pid)
Example #7
0
 def __init__(self, pidfile, cfgfile):
     Daemon.__init__(self, pidfile)
     self.jobs = {}
     self.immediately = False
     self.scheduler = Scheduler(daemonic=False)
     self.logger = logging.getLogger(self.__class__.__name__)
     if os.path.exists(cfgfile):
         with open(cfgfile, 'rt') as f:
             config = yaml.load(f.read())
         for k1 in config.keys():
             if k1 == 'version':
                 pass
             if k1 == 'immediately':
                 self.immediately = config[k1]
             elif k1 == 'taobao':
                 self.jobs[k1] = config[k1]
                 self.jobs[k1]['id'] = None
                 if 'chktime' in self.jobs[k1].keys():
                     self.jobs[k1]['btime'] = time.strptime(self.jobs[k1]['chktime'].split('-')[0], '%H:%M')
                     self.jobs[k1]['etime'] = time.strptime(self.jobs[k1]['chktime'].split('-')[1], '%H:%M')
                     if self.jobs[k1]['btime'] >= self.jobs[k1]['etime']:
                         raise ValueError('"chktime" is illegal')
                 else:
                     raise ValueError('There is no "chktime" be found in configure.')
             else:
                 pass
     else:
         self.logger.error('{0} not found'.format(cfgfile))
Example #8
0
    def __init__(self, pid_file, sent=None):
        Daemon.__init__(self, pid_file)
        c = config.Config()
        self.config = c.cfg
#        self.log = logging.getLogger('trends')
        self.stats_freq = 3600
        self.sid = SentimentIntensityAnalyzer()
Example #9
0
 def __init__(self):
     Daemon.__init__(self)
     self.__hen_manager = HenManager()
     self.__hen_manager.initLogging()
     self.__hardware_processor = LSHardwareProcessor(self.__hen_manager, \
                                                 self.__parseMacTableURL())
     self.__registerMethods()
Example #10
0
 def __init__(self, debug):
     self.__debug = debug
     Daemon.__init__(self)
     self.__registerMethods()
     self.device_list = []
     self.__detector_daemon = DetectorDaemon(self.device_list, self.__debug)
     self.__detector_daemon.start()
Example #11
0
  def stop(self, *args, **kwargs):
    GPIO.setmode(GPIO.BCM)
    GPIO.setwarnings(False)

    GPIO.setup(self.rpin,GPIO.OUT)
    GPIO.setup(self.gpin,GPIO.OUT)
    GPIO.setup(self.bpin,GPIO.OUT)
    self.rled = GPIO.PWM(self.rpin,self.freq)
    self.gled = GPIO.PWM(self.gpin,self.freq)
    self.bled = GPIO.PWM(self.bpin,self.freq)

    self.rled.ChangeDutyCycle(0)
    self.gled.ChangeDutyCycle(0)
    self.bled.ChangeDutyCycle(50)
    time.sleep(1)
    self.rled.stop()
    self.gled.stop()
    self.bled.stop()
    GPIO.cleanup()

    if os.path.exists(self.cf):
      os.remove(self.cf)

    if os.path.exists(self.bf):
      os.remove(self.bf)

    Daemon.stop(self, *args, **kwargs)
Example #12
0
 def __init__(
     self,
     configLoc,
     pidfile="/tmp/httpJsonStats.pid",
     stdin="/dev/null",
     stdout="/tmp/httpJson.log",
     stderr="/tmp/httpJson.log",
 ):
     self.configLoc = configLoc
     self._jsonStr = ""
     self._CARBON_SERVER = "server.domain.com"
     self._CARBON_PORT = 2003
     self._delay = 20
     self._stdin = stdin
     self._stdout = stdout
     self._stderr = stderr
     self._pidfile = pidfile
     self._evaluateConfig()
     if self._jsonStr["global"]["GRAPHITE_SERVER"]:
         self._CARBON_SERVER = self._jsonStr["global"]["GRAPHITE_SERVER"]
     if self._jsonStr["global"]["GRAPHITE_PORT"]:
         self._CARBON_PORT = self._jsonStr["global"]["GRAPHITE_PORT"]
     if self._jsonStr["global"]["INTERVAL"]:
         self._delay = self._jsonStr["global"]["INTERVAL"]
     if self._jsonStr["global"]["LOG_FILE"]:
         self._stdout = self._jsonStr["global"]["LOG_FILE"]
     if self._jsonStr["global"]["ERR_LOG_FILE"]:
         self._stderr = self._jsonStr["global"]["ERR_LOG_FILE"]
     if self._jsonStr["global"]["PID_FILE"]:
         self._pidfile = self._jsonStr["global"]["PID_FILE"]
     del self._jsonStr["global"]
     Daemon.__init__(self, self._pidfile, self._stdin, self._stdout, self._stderr)
Example #13
0
 def __init__(self, pidfile, confile):
     '''ZhwhPanCity class structure method.
     '''
     Daemon.__init__(self, pidfile)
     self.confile = confile
     self.config = ConfigParser.ConfigParser()
     if os.path.exists(self.confile):
         self.config.read(self.confile)
         if not self.config.has_section("pancity"):
             print("No such section.")
             sys.exit()
         else:
             self.mail_smtp_host = self.config.get("pancity", "mail_smtp_host")
             self.mail_smtp_port = self.config.getint("pancity", "mail_smtp_port")
             self.mail_from = self.config.get("pancity", "mail_from")
             self.mail_password = self.config.get("pancity", "mail_password")
             self.mail_to = self.config.get("pancity", "mail_to")
             self.xls_path = self.config.get("pancity", "pancity_xls_path")
             self.interval = self.config.getint("pancity", "pancity_interval")
             self.logfile = self.config.get("pancity", "pancity_log")
             
         if not self.config.has_section("mysql"):
             print("No such section.")
             sys.exit()
         else:
             self.myHost = self.config.get("mysql", "mysql_host")
             self.myPort = self.config.getint("mysql", "mysql_port")
             self.myUser = self.config.get("mysql", "mysql_user")
             self.myPasswd = self.config.get("mysql", "mysql_passwd")
             self.myDB = self.config.get("mysql", "mysql_db")
     else:
         print("ZHWH configure file is not exist.")
         sys.exit()
Example #14
0
    def __init__(self, pidfile, argv):
        Daemon.__init__(self, pidfile)

        reload(sys)
        sys.setdefaultencoding('utf-8')
        # acquire cookie
        cookie_jar = cookielib.CookieJar()
        opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cookie_jar))
        urllib2.install_opener(opener)

        self.parser = optparse.OptionParser(self.MSG_USAGE)
        self.parser.add_option('-d', '--dbd', action='store_true', dest='dbd', help="DBD",default=False)
        self.parser.add_option('-u', '--undbd', action='store_true', dest='undbd', help="Un-DBD",default=False)
        self.parser.add_option('-i', '--input', action='store_true', dest='input', help="Input name & password",default=False)
        self.parser.add_option('-t', '--time', action='store_true', dest='time', help="Auto time card",default=False)
        self.parser.add_option('-g', '--debug', action='store_true', dest='debug', help="for debug",default=False)
        self.parser.add_option('--sync', action='store_true', dest='sync', help="Sync data with server",default=False)
        self.parser.add_option('--local', action='store_true', dest='local', help="Not sync with server",default=False)
        self.parser.add_option('--nodaemon', action='store_true', dest='nodaemon', help="Start with no-daemon",default=False)
        self.options, self.args = self.parser.parse_args(argv)

        hdlr = logging.FileHandler(self.log_file)
        formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
        hdlr.setFormatter(formatter)
        self.logger.addHandler(hdlr)
        self.logger.setLevel(logging.INFO)
Example #15
0
 def __init__(self,pidfile=None):
     pidfile = pidfile or PidFile(PID_NAME, PID_DIR).get_path()
     Daemon.__init__(self,pidfile)
     self.basic_plugin=['ServerPlugin']
     config=agentConfig.get_config()
     self.sender = Sender(port=config['recv_port'])
     self.check_frequency=config['check_freq']
Example #16
0
 def __init__(self):
     Daemon.__init__(self)
     # Initalise variables
     self.__henManager = HenManager()
     self.__nodes = None
     self.__vlans = {} # 
     self.__vlan_info = {} # switch_name -> [vlan_name,vlan_name,...]
     self.__switch_instances = {}
     self.__test_mode = False
     self.__minimum_id = 200
     self.__maximum_id = 2000
     self.__vlanOwnerFilename = "/usr/local/hen/etc/switchd/vlan_owner.dat"
     
     self.__int_to_vlan = {} # (computer_str,interface_str) -> vlan_name
     
     self.__switchdb = SwitchDB()
     log.debug("Switchdb "+str(self.__switchdb))
     # Register hen rpc methods and handlers
     log.debug("Registering methods")
     self.__registerMethods()
     # Load vlan info
     log.debug("Loading vlan info")
     self.__initaliseVlanInfo()
     # Setup mac polling
     log.debug("Loading henmanager")
     self.__switchdb.setHenManager(self.__henManager)
     log.debug("Loading links Db")
     self.__switchdb.loadLinksDb()
     log.debug("Initiating Nodes")
     self.initiateNodes()
     
     # vlan owners
     self.__vlan_owner_name = {}
     self.__vlan_name_owner = {}
     self.loadVlanOwnerFile()
Example #17
0
 def __init__(self):
     cur_path = os.path.dirname(os.path.abspath(__file__))
     self.app = webapp.create_app()
     self.app.debug = True
     self.port = get_config().getint("setup", "listen_port")
     self.pidfile = os.path.join(cur_path, "..", get_config().get("setup", "pidpath"))
     Daemon.__init__(self, self.pidfile)
Example #18
0
 def __init__(self, config_file):
     """CdmaAlarm class structure method.
     """
     self.config_file = config_file
     self.config = ConfigParser()
     if os.path.exists(self.config_file):
         self.config.read(self.config_file)
         if not self.config.has_section("omp"):
             print("No such section.")
             sys.exit()
         else:
             self.omp_host = self.config.get("omp", "omp_host")
             self.omp_port = self.config.getint("omp", "omp_port")
             self.omp_user = self.config.get("omp", "omp_user")
             self.omp_passwd = self.config.get("omp", "omp_passwd")
             self.omp_old_passwd = self.config.get("omp", "omp_passwd_old")
             self.logfile = self.config.get("omp", "omp_alarm_log")
             self.omp_alarm_pid = self.config.get("omp", "omp_alarm_pid")
             self.interval = self.config.getint("omp", "omp_alarm_interval")
             
         if not self.config.has_section("mysql"):
             print("No such section.")
             sys.exit()
         else:
             self.mysql_host = self.config.get("mysql", "mysql_host")
             self.mysql_port = self.config.getint("mysql", "mysql_port")
             self.mysql_user = self.config.get("mysql", "mysql_user")
             self.mysql_passwd = self.config.get("mysql", "mysql_passwd")
             self.mysql_db = self.config.get("mysql", "mysql_db")
     else:
         print('CDMA configure file is not exist.')
         sys.exit()
     Daemon.__init__(self, self.omp_alarm_pid)
Example #19
0
 def __init__(self, pidfile, confile):
     '''CdmaSms class structure method.
     '''
     Daemon.__init__(self, pidfile)
     
     config = ConfigParser.ConfigParser()
     if os.path.exists(confile):
         config.read(confile)
         if not config.has_section("sms"):
             print("No 'sms' section.")
             sys.exit()
         else:
             self.smsHost = config.get("sms", "sms_host")
             self.smsPort = config.getint("sms", "sms_port")
             self.smsUser = config.get("sms", "sms_user")
             self.smsPasswd = config.get("sms", "sms_passwd")
             self.smsSendUri = config.get("sms", "sms_send_uri")
             self.logfile = config.get("sms", "sms_log")
             self.interval = config.getint("sms", "sms_interval")
                     
         if not config.has_section("mysql"):
             print("No 'mysql' section.")
             sys.exit()
         else:
             self.myHost = config.get("mysql", "mysql_host")
             self.myPort = config.getint("mysql", "mysql_port")
             self.myUser = config.get("mysql", "mysql_user")
             self.myPasswd = config.get("mysql", "mysql_passwd")
             self.myDB = config.get("mysql", "mysql_db")
     else:
         print("CDMA configure file is not exist.")
         sys.exit()
Example #20
0
 def __init__(self, *args, **kwargs):
     self.sb = None
     self.params = None
     self.nodes = None
     self.processes = {}
     self.running = True
     Daemon.__init__(self, *args, **kwargs)
Example #21
0
class TorrentClient(object):
    def __init__(self, hostname=None, port=9090):
        self.daemon = None
        if not hostname:
            self.daemon = Daemon(["transmission-daemon", "-f", "-p", str(port)])
            self.daemon.start()
            hostname = "localhost"
        self._connection = TransmissionConnection(hostname, port)
        self._session = self._connection.execute(Command("session-get"))
        
    def __del__(self):
        if self.daemon:
            self.daemon.stop()
            
    def add_torrent(self, auto=None, metadata=None, filename=None, file=None, url=None):
        if auto:
            if isinstance(auto, str):
                if "://" in auto:
                    data = urllib2.urlopen(auto).read()
                else:
                    data = open(auto, "r").read()
            elif hasattr(auto, "read"):
                data = auto.read()
            elif hasattr(auto, "content"):
                data = auto.content
            else:
                raise AttributeError()
        else:
            if metadata:
                data = metadata
            elif filename:
                data = open(filename, "r").read()
            elif url:
                data = urllib2.urlopen(url).read()
            elif file:
                data = file.read()

        data = base64.encodestring(data)
        
        command = Command("torrent-add")
        command["metainfo"] = data
        command["paused"] = True
            
        torrent = self._connection.execute(command)
        return self.get_torrent(torrent["torrent-added"]["id"])
            
    def get_torrent(self, id):
        command = TorrentGetCommand(Torrent.static_fields, id)
        torrent = self._connection.execute(command)
        return Torrent(self, torrent)

    def _get_torrents(self):
        command = TorrentGetListCommand(Torrent.static_fields)
        list = self._connection.execute(command)
        torrent_list = map(lambda t: Torrent(self, t), list)
        return torrent_list
    
    download_dir = session_property("download-dir")
    torrents = property(_get_torrents)
Example #22
0
 def __init__(self, config=CONFIG_FILE):
     """\brief Registers remote methods and starts update thread (timer)
     """
     Daemon.__init__(self)
     self.__config_path = config
     self.__parseConfig(self.__config_path)
     self.__registerMethods()
     self.__checker_lock = threading.Lock()
	def __init__(self):
		self.readConfig(CONFIG_FILE)
		Daemon.__init__(self,self.PIDFILE)
		self.alerts = {}
		self.dict_modified = 0 
		self.delay_window = 0
		self.last_notification = 0 
		self.host_name = ''
Example #24
0
 def __init__(self, config=None, section=None):
     """
     override parent __init__, then run it at end
     """
     self.conf = config
     self.sect = section
     prefix = self.conf.get(self.sect, 'log')+'/'+self.sect
     Daemon.__init__(self, prefix+'.pid', stdout=prefix+'.log', stderr=prefix+'.log')
Example #25
0
 def __init__( self, timeinterval = 30, logfile = "machine_%s.log" % MachineTools.getMachineName(), loglevel = logging.INFO ):
     curfile = os.path.basename( sys._getframe().f_code.co_filename )
     curfile, ext = os.path.splitext( curfile )
     pidfile = os.path.abspath( curfile + "_" + MachineTools.getMachineName() + ".pid" )
     Daemon.__init__( self, os.path.abspath( pidfile ) )
     self.timeInterval = timeinterval
     self.targetFile = logfile
     self.logLevel = loglevel
Example #26
0
 def __init__(self, pid_file):
     """
     Constructor
     """
     logging.basicConfig(filename='log_tweets.txt',level=logging.DEBUG)
     Daemon.__init__(self, pid_file)
     self.db = None
     print "constructor"
Example #27
0
    def __init__(self,Config):
        self.Config = Config
        pidfile = Config.pid_filename
        stdin   = '/dev/null'
        stdout  = '/dev/null'
        stderr  = '/dev/null'
        if Config.log_filename != "":
            stderr = Config.log_filename  
	Daemon.__init__(self, pidfile, stdin, stdout, stderr)
Example #28
0
 def __init__(self):
     Daemon.__init__(self)
     self.__henManager = HenManager()
     # Allow specialized instance dictionary to be created in hm
     # self.__henManager.createNodeInstances()
     self.__registerMethods()
     self.__computerID = self.__getComputerID()
     self.__computerInfo = self.__henManager.getNodes("computer")[self.__computerID]
     self.__ifaceIDtoNameMappings = self.__getIfaceMappings()
Example #29
0
 def __init__( self, confFile, pidFile, logFile, handlefulllog, beforedays = 0 ):
     Daemon.__init__( self, pidFile )
     self.confFile = confFile
     self.pidFile = pidFile
     self.logFile = logFile
     self.beforeDays = beforedays
     self.handleFullLog = handlefulllog
     # save datas defined in config file
     self.datas = []
Example #30
0
  def __init__ (self, name):
    Daemon.__init__(self, name, "-1")

    # check that independent beams is off
    if self.cfg["INDEPENDENT_BEAMS"] == "1":
      raise Exception ("ServerDaemons incompatible with INDEPENDENT_BEAMS")  
    self.req_host = self.cfg["SERVER_HOST"]
    self.log_dir  = self.cfg["SERVER_LOG_DIR"]
    self.control_dir = self.cfg["SERVER_CONTROL_DIR"]
Example #31
0
def stop_exec(nicename, pidfile):
    Daemon.kill(pidfile)
    flog.debug("process " + nicename + " terminated.")
Example #32
0
 def __init__(self,pf):
     Daemon.__init__(self, pf)
Example #33
0
    def test_recover_trades(self, mock_broker):
        """
        Test: Daemon.recover_trades()
        Scenarios:
            - No trades in broker or db
                Assertions:
                    - Strategies recover no trades
            - Trade in broker and db
                Assertions:
                    - Trade gets distributed to correct strategy
            - Trade is in broker, not db
                Assert:
                    - Trade deleted from db
                    - Trade gets distributed to correct strategy
            - Trade in db, broker unsure
                Assert:
                    - Trade deleted from db
                    - Trade's strategy does NOT adopt it
            - Trade in db has wonky data (non-existant strategy name, etc.)
            - (All):
                Assert: trades are distributed to strategies.
        """
        """
        Scenario: No trades in broker or db
        """
        mock_broker.get_trades = MagicMock(return_value=Trades())
        DB.execute.return_value = []

        Daemon.recover_trades()
        # Check that no trades were adopted
        for s in Daemon.strategies:
            self.assertEqual(len(s.open_trade_ids), 0)
        """
        Scenario: Open trade in broker and db
        """
        def db_execute(query):
            if query == 'SELECT trade_id FROM open_trades_live':
                return [('id666', )]
            elif query == 'SELECT strategy, broker FROM open_trades_live WHERE trade_id="id666"':
                return [('Fifty', 'oanda')]
            elif query == 'SELECT oanda_name FROM instruments WHERE id=4':
                return [('USD_JPY', )]
            elif query == 'DELETE FROM open_trades_live WHERE trade_id="id666"':
                return
            else:
                print('unexpected query: {}'.format(query))
                raise Exception

        DB.execute = db_execute
        trades = Trades()
        trades.append(
            Trade(units=1,
                  broker_name='oanda',
                  instrument=Instrument(4),
                  stop_loss=90,
                  strategy=self._strat,
                  take_profit=100,
                  trade_id='id666'))
        mock_broker.get_open_trades = MagicMock(return_value=trades)
        mock_broker.is_trade_closed = MagicMock(return_value=(False, None))
        Daemon.recover_trades()
        # check Fifty adopted one trade
        for s in Daemon.strategies:
            if s.get_name() == 'Fifty':
                self.assertEqual(len(s.open_trade_ids), 1)
            else:
                self.assertEqual(len(s.open_trade_ids), 0)
        # check trade is the trade we think it is
        self.assertEqual(Fifty.open_trade_ids[0], 'id666')
        '''
        self.assertEqual(Fifty._open_trades[0].get_broker_name(), 'oanda')
        self.assertEqual(Fifty._open_trades[0].get_instrument().get_name(), 'USD_JPY')
        self.assertEqual(Fifty._open_trades[0].get_instrument().get_id(), 4)
        self.assertEqual(Fifty._open_trades[0].get_stop_loss(), 90)
        self.assertEqual(Fifty._open_trades[0].get_take_profit(), 100)
        self.assertEqual(Fifty._open_trades[0].get_trade_id(), 'id666')
        '''
        # Cleanup
        self._strat.cleanup()
        """
        Scenario: Trade is in broker, not db
        """

        # Trade may have been opened manually.
        # Nothing should happen for these trades.
        def db_execute(query):
            if query == 'SELECT trade_id FROM open_trades_live':
                return []
            elif query == 'SELECT strategy, broker FROM open_trades_live WHERE trade_id="id666"':
                return []
            elif query == 'SELECT oanda_name FROM instruments WHERE id=4':
                return [('USD_JPY', )]
            else:
                raise Exception

        DB.execute = MagicMock(side_effect=db_execute)
        trades = Trades()
        trades.append(
            Trade(units=1,
                  broker_name='oanda',
                  instrument=Instrument(4),
                  stop_loss=90,
                  strategy=self._strat,
                  take_profit=100,
                  trade_id='id666'))
        mock_broker.get_open_trades = MagicMock(return_value=trades)

        Daemon.recover_trades()
        # db should stay the same (no inserts or deletions)
        # Broker trades should stay the same...
        calls = [
            call('SELECT trade_id FROM open_trades_live'),
            call(
                'SELECT strategy, broker FROM open_trades_live WHERE trade_id="id666"'
            )
        ]
        DB.execute.assert_has_calls(calls)
        # Check no trades adopted
        for s in Daemon.strategies:
            self.assertEqual(len(s.open_trade_ids), 0)
        """
        Scenario: Trade in db, broker unsure
        """

        def db_execute(query):
            if query == 'SELECT trade_id FROM open_trades_live':
                return [('id666', )]
            elif query == 'SELECT strategy, broker FROM open_trades_live WHERE trade_id="id666"':
                return [('Fifty', 'oanda')]
            elif query == 'SELECT oanda_name FROM instruments WHERE id=4':
                return [('USD_JPY', )]
            elif query == 'DELETE FROM open_trades_live WHERE trade_id="id666"':
                return
            else:
                raise Exception

        DB.execute = MagicMock(side_effect=db_execute)
        mock_broker.get_open_trades = MagicMock(return_value=Trades())

        Daemon.recover_trades()
        # Check trade deleted from db
        calls = [
            call('SELECT trade_id FROM open_trades_live'),
            call('DELETE FROM open_trades_live WHERE trade_id="id666"')
        ]
        DB.execute.assert_has_calls(calls)
        # Check no trades adopted
        for s in Daemon.strategies:
            self.assertEqual(len(s.open_trade_ids), 0)
        """ 
        module cleanup
        """
        Daemon.shutdown()
Example #34
0
 def __init__(self, title, config):
     self._config = config
     self._title = title
     pid_file = '/tmp/daemon-email-listener_' + title + '.pid'
     Daemon.__init__(self, pid_file)
Example #35
0
 def __init__(self, pidfile):
     Daemon.__init__(self,
                     pidfile,
                     stdout='/tmp/watch_stdout.log',
                     stderr='/tmp/watch_stderr.log')
Example #36
0
 def __init__(self, *args, **kwargs):
     Daemon.__init__(self, *args, **kwargs)
Example #37
0
import threading

import ATRHandler
import utils
from atr_cmd import AtrCmd
from daemon import Daemon

if __name__ == '__main__':
    utils.get_client_id()  # creates necessary config before launch
    server = Daemon(('127.0.0.1', 1234), ATRHandler.ATRHandler)
    threading.Thread(target=server.serve_forever).start()
    AtrCmd().cmdloop_with_keyboard_interrupt()
Example #38
0
 def __init__(self, pidfile):
     Daemon.__init__(self, pidfile, stdout=logfile, stderr=logfile)
 def __init__(self,pidfile):
     Daemon.__init__(self,pidfile, '/dev/null', '/dev/null', '/dev/null')
Example #40
0
 def stop(self):
     tornado.ioloop.IOLoop.instance().stop()
     self.relay.stop_and_clean()
     Daemon.stop(self)
Example #41
0
 def stop(self, *args, **kwargs):
     logging.info("XiaomiBTDaemon stopped!!!")
     Daemon.stop(self, *args, **kwargs)
Example #42
0
                self.stopold()
                self._couples = newcouples
                i = 1
            else:
                i = i + 1
            time.sleep(self._option['sleep'])
        self.stopold()


if __name__ == '__main__':
    if len(sys.argv) != 2:
        print "Usage : python couplemanager.py [start|stop|restart|run]"
        sys.exit(2)

    mode = sys.argv[1]
    runner = CoupleManager('../conf/cpmng.conf')
    adaemon = Daemon('cpmng', runner)
    if 'start' == mode:
        adaemon.start()
    elif 'stop' == mode:
        adaemon.stop()
    elif 'restart' == mode:
        adaemon.restart()
    elif 'run' == mode:
        adaemon.run()
    else:
        print "Unknown command"
        sys.exit(2)
    sys.exit(0)
Example #43
0
 def __init__(self, pid_file, server, reporter, autorestart):
     Daemon.__init__(self, pid_file, autorestart=autorestart)
     self.server = server
     self.reporter = reporter
Example #44
0
 def __init__(self, args):
     self.args = args
     Daemon.__init__(self,
                     self.args.pidfile,
                     stderr=self.args.error_log,
                     stdout=self.args.access_log)
Example #45
0
 def __init__(self, pid_file):
     Daemon.__init__(self, pid_file)
     self.search_key = "sport"
Example #46
0
 def stop(self):
     # TODO: Stop the fswatcher and the web server
     self.exit()
     Daemon.stop(self)
Example #47
0
    import sys, os
    # mine
    from daemon import Daemon
    from configuration import Setup
    from rss_seeker import RSS_Daemon
except ImportError, e:
    print "ERROR!!! Missing module : ", format(e.message[16:])
    sys.exit(1)

if __name__ == "__main__":

    if len(sys.argv) == 2:
        if 'start' == sys.argv[1]:
            conf = Setup()
            daemon = RSS_Daemon(conf)
            daemon.start()
        elif 'stop' == sys.argv[1]:
            daemon = Daemon('daemon-rss.pid')
            daemon.stop()
        elif 'restart' == sys.argv[1]:
            conf = Setup()
            daemon = RSS_Daemon(conf)
            daemon.restart()
        else:
            print "Unknown command"
            sys.exit(2)
        sys.exit(0)
    else:
        print "usage: %s start|stop|restart" % sys.argv[0]
        sys.exit(2)
Example #48
0
	def __init__(self, tvmaxepy):
		self.schedule = os.getenv("HOME") + '/.tvmaxe/schedule'
		self.tvmaxepy = tvmaxepy
		self.donejobs = []
		Daemon.__init__(self, "/tmp/tvmaxed.pid")
Example #49
0
 def __init__(self, pidfile):
     Daemon.__init__(self, pidfile)
     self.run_forever = True
Example #50
0
    def run(self):

        self.dashboard_ip = None

        if settings.DASHBOARD_IP_ENV is not None:
            self.dashboard_ip = os.environ.get(settings.DASHBOARD_IP_ENV)

        daemon = Daemon(settings.DASHBOARD_TOKEN, settings.OUTPUT_DIR,
                        settings.SCRIPTS_DIR, settings.SPEED, settings.MODELS)

        jobs = []
        max_jobs = settings.NUM_THREADS

        processes = []
        decoded_processes = {}

        while True:

            # If there is no process or we have less processes
            if len(processes) == 0 or \
                    len(processes) < len(self.alive_jobs(jobs)):

                new_processes = \
                    daemon.get_processes_to_decode(
                        self.get_url(settings.DECODE_URLS['PROCESS_LIST']))

                # Try to avoid race conditions
                processes = \
                    processes + \
                    [p for p in new_processes
                        if p["id"] not in decoded_processes]

                if len(processes) == 0:

                    daemon.delete_file_list(
                        self.get_url(settings.DECODE_URLS['FILES_TO_DELETE']),
                        settings.DECODE_URLS['UPDATE'])

                    time.sleep(5)
                    continue

            # We have nothing to do, kill zombies
            if len(self.alive_jobs(jobs)) == 0:
                while multiprocessing.active_children():
                    time.sleep(1)

            if len(self.alive_jobs(jobs)) < max_jobs:
                process = processes[0]
                decoded_processes[process["id"]] = True
                processes = processes[1:]

                p = multiprocessing.Process(
                    target=daemon.decode_process,
                    args=(process,
                          self.get_url(settings.DECODE_URLS['DOWNLOAD']),
                          self.get_url(settings.DECODE_URLS['UPDATE_PROCESS']),
                          self.get_url(settings.DECODE_URLS['UPLOAD']),
                          self.get_url(settings.DECODE_URLS['GET_FILE'])))

                p.daemon = True
                jobs.append(p)
                p.start()
            else:
                # We are full, kill zombies (join terminated processes)
                while multiprocessing.active_children():
                    time.sleep(1)

            daemon.delete_file_list(
                self.get_url(settings.DECODE_URLS['FILES_TO_DELETE']),
                settings.DECODE_URLS['UPDATE'])
Example #51
0
	def __init__(self,path,pid):
		self.path = path
		self.q = Queue()
		Daemon.__init__(self,pid)
Example #52
0
 def __init__(self):
     self.name = 'yisa1'
     Daemon.__init__(self, pidfile='/var/run/%s.pid' % (self.name.lower()), stderr='/tmp/yisa_error.log')
     procname.setprocname(self.name)
Example #53
0
 def start(self):
     Daemon.start(self)
Example #54
0
            'exclude': exc_dirs,
            'qtt': qtt,
            'mqi': mqi,
            'triggermod': triggers
        }

    return watch_sections, module_sections


mod_instances = {}  # instances of module object per section

daemon = Daemon(
    user="******",
    group="root",
    stdin="/dev/null",
    stdout="/var/log/insync/insync.log",
    stderr="/var/log/insync/insync.err",
    pidfile="/var/log/insync/insync.pid",
    conf="./insync.conf",
    workers=str(max_workers_default),
)

if __name__ == "__main__":
    signal.signal(signal.SIGABRT, clean_exit)
    signal.signal(signal.SIGTERM, clean_exit)
    signal.signal(signal.SIGQUIT, clean_exit)
    signal.signal(signal.SIGINT, clean_exit)

    watch_sections, module_sections = read_config(daemon.options.conf)
    if daemon.service():
        if not watch_sections:
            sys.exit()
Example #55
0
 def __init__ (self, name, id):
   Daemon.__init__(self, name, id)
   (self.req_host, self.beam_id) = self.getConfig(id)
   self.subband_id = 1
Example #56
0
 def __init__(self, pidfile, options, args):
     self.options = options
     self.args = args
     Daemon.__init__(self, pidfile)
Example #57
0
class Loader(object):

    do_restart = False

    def __init__(self):

        # Get options via arg
        from couchpotato.runner import getOptions
        self.options = getOptions(base_path, sys.argv[1:])

        # Load settings
        settings = Env.get('settings')
        settings.setFile(self.options.config_file)

        # Create data dir if needed
        if self.options.data_dir:
            self.data_dir = self.options.data_dir
        else:
            self.data_dir = os.path.expanduser(Env.setting('data_dir'))

        if self.data_dir == '':
            self.data_dir = getDataDir()

        if not os.path.isdir(self.data_dir):
            os.makedirs(self.data_dir)

        # Create logging dir
        self.log_dir = os.path.join(self.data_dir, 'logs')
        if not os.path.isdir(self.log_dir):
            os.mkdir(self.log_dir)

        # Logging
        from couchpotato.core.logger import CPLog
        self.log = CPLog(__name__)

        formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s',
                                      '%H:%M:%S')
        hdlr = handlers.RotatingFileHandler(
            os.path.join(self.log_dir, 'error.log'), 'a', 500000, 10)
        hdlr.setLevel(logging.CRITICAL)
        hdlr.setFormatter(formatter)
        self.log.logger.addHandler(hdlr)

    def addSignals(self):

        signal.signal(signal.SIGINT, self.onExit)
        signal.signal(signal.SIGTERM, lambda signum, stack_frame: sys.exit(1))

        from couchpotato.core.event import addEvent
        addEvent('app.after_shutdown', self.afterShutdown)

    def afterShutdown(self, restart):
        self.do_restart = restart

    def onExit(self, signal, frame):
        from couchpotato.core.event import fireEvent
        fireEvent('app.crappy_shutdown', single=True)

    def run(self):

        self.addSignals()

        from couchpotato.runner import runCouchPotato
        runCouchPotato(self.options,
                       base_path,
                       sys.argv[1:],
                       data_dir=self.data_dir,
                       log_dir=self.log_dir,
                       Env=Env)

        if self.do_restart:
            self.restart()

    def restart(self):
        try:
            # remove old pidfile first
            try:
                if self.runAsDaemon():
                    try:
                        self.daemon.stop()
                    except:
                        pass
            except:
                self.log.critical(traceback.format_exc())

            # Release log files and shutdown logger
            logging.shutdown()
            time.sleep(3)

            args = [sys.executable] + [
                os.path.join(base_path, os.path.basename(__file__))
            ] + sys.argv[1:]
            subprocess.Popen(args)
        except:
            self.log.critical(traceback.format_exc())

    def daemonize(self):

        if self.runAsDaemon():
            try:
                from daemon import Daemon
                self.daemon = Daemon(self.options.pid_file)
                self.daemon.daemonize()
            except SystemExit:
                raise
            except:
                self.log.critical(traceback.format_exc())

    def runAsDaemon(self):
        return self.options.daemon and self.options.pid_file
Example #58
0
 def __init__(self, pidfile, autorestart, start_event=True):
     Daemon.__init__(self, pidfile, autorestart=autorestart)
     self.run_forever = True
     self.collector = None
     self.start_event = start_event
Example #59
0
 def __init__(self, pidf):
     Daemon.__init__(self, pidf)
     self.metric = Metric_Fling()
     config = self.read_config()
     self.sleeptime = config["nodeup"]["sleeptime"]
Example #60
0
 def __init__(self):
     Daemon.__init__(self, 'ubrs.pid')
     self.ip = config.HTTP_IP
     self.port = config.HTTP_PORT
     self.relay = Relay(os.path.join(os.getcwd(), config.UBR_PATH))
     self.app = UBRSApplication(self.relay)