def main():
argvLength = len(sys.argv)
if argvLength < 3:
print '''
[ERROR] WorkInfoMigration argv required at least 3
++ Usage
++++ scheduler : module section cfgfile
'''
return
module = os.path.basename(sys.argv[0])
section = sys.argv[1]
cfgfile = sys.argv[2]
cfg = ConfigParser.ConfigParser()
cfg.read(cfgfile)
logPath = cfg.get("GENERAL", "LOG_PATH")
logFile = os.path.join(logPath, "%s_%s.log" % (module, section))
logCfgPath = cfg.get("GENERAL", "LOG_CONF")
logCfg = ConfigParser.ConfigParser()
logCfg.read(logCfgPath)
Log.Init(
Log.CRotatingLog(logFile, logCfg.get("LOG", "MAX_SIZE"),
logCfg.get("LOG", "MAX_CNT")))
global workInfoMigration
workInfoMigration = WorkInfoMigration(cfg)
workInfoMigration.run()
__LOG__.Trace('main is terminated')
def main():
module = os.path.basename(sys.argv[0])
if len(sys.argv) > 2:
section = sys.argv[1] # LOG_LOADER
cfgfile = sys.argv[2] # /home/tacs/TACS-EF/LOG-ETL/conf/LOG-ETL.conf
cfg = ConfigParser.ConfigParser()
cfg.read(cfgfile)
logPath = cfg.get("GENERAL", "LOG_PATH")
logFile = os.path.join(logPath, "%s_%s.log" % (module, section))
logCfgPath = cfg.get("GENERAL", "LOG_CONF")
logCfg = ConfigParser.ConfigParser()
logCfg.read(logCfgPath)
Log.Init(
Log.CRotatingLog(logFile, logCfg.get("LOG", "MAX_SIZE"),
logCfg.get("LOG", "MAX_CNT")))
logLoader = LogLoader(cfg, section)
logLoader.run()
else:
__LOG__.Trace('Argument Length !!!')
def main():
reload(sys)
sys.setdefaultencoding('UTF-8')
module = os.path.basename(sys.argv[0])
section = sys.argv[1]
cfgfile = sys.argv[2]
cfg = ConfigParser.ConfigParser()
cfg.read(cfgfile)
logPath = cfg.get("GENERAL", "LOG_PATH")
logFile = os.path.join(logPath, "%s_%s.log" % (module, section))
logCfgPath = cfg.get("GENERAL", "LOG_CONF")
logCfg = ConfigParser.ConfigParser()
logCfg.read(logCfgPath)
Log.Init(
Log.CRotatingLog(logFile, logCfg.get("LOG", "MAX_SIZE"),
logCfg.get("LOG", "MAX_CNT")))
workInfoDistributer = WorkInfoDistributer(cfg)
workInfoDistributer.run()
__LOG__.Trace('main is terminated.')
def main():
if len(sys.argv) < 3:
sys.stderr.write("Usage: %s SECTION CONFIG\n" % (sys.argv[0]))
sys.stderr.flush()
sys.exit()
sSect = sys.argv[1]
sConf = sys.argv[2]
Conf = ConfigParser.SafeConfigParser()
Conf.read(sConf)
sLogd = os.path.expanduser(Conf.get('COMMON', 'LOG'))
sLogm = os.path.splitext(os.path.basename(
sys.argv[0]))[0] + "." + sSect + ".log"
sLogs = os.path.join(sLogd, sLogm)
if not '-d' in sys.argv:
Log.Init(Log.CRotatingLog(sLogs, 30000000, 10))
else:
Log.Init()
__LOG__.Trace("process strt: ( pid:%d ) >>>" % (os.getpid()))
try:
oWork = Worker(sSect, sConf)
oWork.work()
except Exception, ex:
__LOG__.Exception()
def main():
print '111'
module = os.path.basename(sys.argv[0])
section = sys.argv[1] # MQConnect
cfgfile = sys.argv[2]
cfg = ConfigParser.ConfigParser()
cfg.read(cfgfile)
logPath = cfg.get("GENERAL", "LOG_PATH")
logFile = os.path.join(logPath, "%s_%s.log" % (module, section))
logCfgPath = cfg.get("GENERAL", "LOG_CONF")
logCfg = ConfigParser.ConfigParser()
logCfg.read(logCfgPath)
Log.Init(
Log.CRotatingLog(logFile, logCfg.get("LOG", "MAX_SIZE"),
logCfg.get("LOG", "MAX_CNT")))
mc = MQConnect(cfg, section)
print '222'
mc.run()
__LOG__.Trace("end main!")
def initLog(dbConf, logName):
# LOG 관련 DEFAULT VALUE
logDir = "."
logLine = 1000000
logDevide = 5
DB_CONF = {}
DB_CONF = loadConfig(dbConf)
try:
logDir = DB_CONF["GENERAL"]["LOG_DIR"]
if not os.path.exists(logDir):
__LOG__.Trace(
"LOG_DIR(%s) doesn't exist. Current directory will be used.\n"
% logDir)
logDir = "."
except:
pass
try:
logLine = int(DB_CONF["GENERAL"]["LOG_LINE"])
except:
pass
try:
logDevide = int(DB_CONF["GENERAL"]["LOG_DEVIDE"])
except:
pass
Log.Init(
Log.CRotatingLog(
"%s/%s.%s.log" % (logDir, os.path.basename(sys.argv[0]), logName),
logLine, logDevide))
def main() :
# load config
conf = ConfigParser.ConfigParser()
conf.read("Config/dataserver.cnf")
cachePath = conf.get("dataserver", "cache_path")
if (not os.path.exists(cachePath)) :
try : os.makedirs(cachePath)
except : __LOG__.Exception(); return
dumpPath = conf.get("dataserver", "dump_path")
if (not os.path.exists(dumpPath)) :
try : os.makedirs(dumpPath)
except : __LOG__.Exception(); return
from Modules.Process import writePid
pid_file = os.path.join(conf.get("dataserver", "root_path"), \
os.path.basename(sys.argv[0])[:-3])
if (writePid(pid_file) == False) :
print "dataserver is already running."
return
if (conf.has_option("dataserver", "log_path")) :
log_file = os.path.join(conf.get("dataserver", "log_path"), \
os.path.basename(sys.argv[0])[:-3] + ".log")
else :
log_file = os.path.join(conf.get("dataserver", "root_path"), \
"log", os.path.basename(sys.argv[0])[:-3] + ".log")
Log.Init(Log.CRotatingLog(log_file, 1000000, 10))
__LOG__.Trace("--------------------------------------")
__LOG__.Trace(" DATA SERVER START..")
__LOG__.Trace("--------------------------------------")
client_port = conf.getint("dataserver", "client_port")
master_port = conf.getint("dataserver", "master_port")
__LOG__.Trace("Service port %d." % client_port)
__LOG__.Trace("Master port %d." % master_port)
thread_list = []
thread_list.append(Handle.startC(client_port, conf))
thread_list.append(Handle.startM(master_port, conf))
thread_list.append(CacheCleaner.start(conf))
thread_list.append(CacheDump.start(conf))
for thread in thread_list :
thread.setDaemon(True)
thread.start()
try :
for thread in thread_list :
thread.join()
except :
__LOG__.Exception()
def Main(args):
if (len(args) < 6):
Usage()
sys.exit()
try:
opts, args = getopt.getopt(args[1:], "", ["force", "pipe", "udp"])
except getopt.GetoptError:
Usage()
sys.exit()
path = "/tmp/mobigen/%s" % args[0]
for o, v in opts:
if o in ("--force"):
try:
os.unlink(path)
except:
pass
break
bPIPE = False
for o, v in opts:
if o in ("--pipe"):
try:
os.mkfifo(path)
except:
pass
gate = open(path, "r")
bPIPE = True
break
if o in ("--udp"):
gate = socket(AF_UNIX, SOCK_DGRAM)
gate.bind(path)
break
if (len(args) == 4):
Log.Init(Log.CRotatingLog(args[1], args[2], args[3]))
try:
while True:
if bPIPE:
log = gate.readline()
if (len(log) == 0):
time.sleep(1)
continue
__LOG__.Write(log[:-1])
else:
log, addr = gate.recvfrom(1000000)
__LOG__.Write(log[:-1])
except:
__LOG__.Exception()
def Main(argv):
logFile = "%s/MSD.log" % (Default.M6_LOG_DIR)
# FIXME : ADD MSD log option to Default
#Log.Init( Log.CRotatingLog (logFile, Default.MSD_LOG_MAX_LINE, Default.MSD_LOG_MAX_FILE))
Log.Init(
Log.CRotatingLog(logFile, Default.BIM_LOG_MAX_LINE,
Default.BIM_LOG_MAX_FILE))
server = TCPThreadServer.Server(9999, MSD.MSD, None)
#__LOG__.Trace("Start BSD (port=%s)" % Default.PORT["BMD"])
__LOG__.Trace("Start MSD (port=9999)")
server.start()
def Main(argv):
if len(argv) < 3:
print "Usage: %s ip port node_id " % sys.argv[0]
print " %s 10.0.0.1 1234 1 " % sys.argv[0]
print
sys.exit()
logFile = "SM_%s_%s_%s.log" % (argv[0], argv[1], argv[2])
Log.Init(Log.CRotatingLog(logFile, 10000000, 2))
#Log.Init( )
#Log.Init(Log.CUDPLog2( 9999 ))
s = SM(argv[0], argv[1], argv[2])
s.start()
def Main() :
global SHUTDOWN
try : opts, args = getopt.getopt(sys.argv[1:], 'dl', ["last", "debug"])
except : Usage()
if len(args) !=7 : Usage()
try : os.makedirs(args[6])
except : pass
options = {}
for o, v in opts:
if o in ('-l', '--last') : options['LastRecordFlag'] = True
if o in ('-d', '--debug') : options['Debug'] = None
if(not options.has_key("Debug")) :
logPath = args[6]
logPath = logPath.replace('/', '_')
logPath = "../LOG/CSV-RECV%s.log" % logPath
Log.Init(Log.CRotatingLog(logPath, 1000000, 10))
obj = Recv(args[0], args[1], args[2], args[3], args[4], args[5], args[6], **options)
__LOG__.Trace("Recv start")
obj.setDaemon(1)
obj.start()
time.sleep(10) # obj 정상수행이전에 While로 들어가는 시간차 설정
while True :
if SHUTDOWN : break
if obj.IsAlive() == False:
__LOG__.Trace("Recv dead detected, so join")
obj.Release()
try :
obj = Recv(args[0], args[1], args[2], args[3], args[4], args[5], args[6], **options)
obj.start()
__LOG__.Trace("*** Recv restart")
except :
__LOG__.Exception()
time.sleep(2)
obj.Release()
__LOG__.Trace("--- Recv shutdown")
def main():
module = os.path.basename(sys.argv[0])
section = sys.argv[1] # TACS_MQ_LOADER
cfgFile = sys.argv[2]
cfg = ConfigParser.ConfigParser()
cfg.read(cfgFile)
logPath = cfg.get("GENERAL", "LOG_PATH")
logFile = os.path.join(logPath, "%s_%s.log" % (module, section))
logCfgPath = cfg.get("GENERAL", "LOG_CONF")
logCfg = ConfigParser.ConfigParser()
logCfg.read(logCfgPath)
Log.Init(Log.CRotatingLog(logFile, logCfg.get("LOG", "MAX_SIZE"), logCfg.get("LOG", "MAX_CNT") ))
ml = MQLoader(section, cfg)
ml.run()
def main():
argvLength = len(sys.argv)
if argvLength < 3:
print '''
[ERROR] WorkInfoCollector argv required at least 3
++ Usage
++++ scheduler : module section cfgfile
++++ migration : module section cfgfile searchStartDate(yyyyMMddHHmm) searchEndDate(yyyyMMddHHmm)
'''
return
module = os.path.basename(sys.argv[0])
section = sys.argv[1]
cfgfile = sys.argv[2]
searchStartDate = None
searchEndDate = None
migration = False
if argvLength == 5:
migration = True
searchStartDate = sys.argv[3]
searchEndDate = sys.argv[4]
cfg = ConfigParser.ConfigParser()
cfg.read(cfgfile)
logPath = cfg.get("GENERAL", "LOG_PATH")
logFile = os.path.join(logPath, "%s_%s.log" % (module, section))
logCfgPath = cfg.get("GENERAL", "LOG_CONF")
logCfg = ConfigParser.ConfigParser()
logCfg.read(logCfgPath)
Log.Init(
Log.CRotatingLog(logFile, logCfg.get("LOG", "MAX_SIZE"),
logCfg.get("LOG", "MAX_CNT")))
global workInfoCollector
workInfoCollector = WorkInfoCollector(cfg)
workInfoCollector.run(searchStartDate, searchEndDate, migration)
__LOG__.Trace('main is terminated')
def main():
module = os.path.basename(sys.argv[0])
section = sys.argv[1] # TACS_FILE_MONITOR
cfgfile = sys.argv[2] # /home/tacs/user/KimJW/ETL/conf/FileMonitor.conf
cfg = ConfigParser.ConfigParser()
cfg.read(cfgfile)
if '-d' not in sys.argv:
log_path = cfg.get("GENERAL", "LOG_PATH")
log_file = os.path.join(log_path, "%s_%s.log" % (module, section))
Log.Init(Log.CRotatingLog(log_file, 1000000, 9))
else:
LOG.Init()
fm = FileMonitor(cfg, section)
fm.run(section)
__LOG__.Trace("end main!")
def SetLog(self):
#default Log
self.logFilePath = 'Log'
self.logFileSize = 1000000
self.logFileCount = 10
if self.PARSER.get('Log', 'LogFilePath') != '':
self.logFilePath = self.PARSER.get('Log', 'LogFilePath')
self.logFileSize = self.PARSER.get('Log', 'LogFileSize')
self.logFileCount = self.PARSER.get('Log', 'LogFileCount')
if not os.path.exists(self.logFilePath):
os.makedirs(self.logFilePath)
LOG_NAME = '%s/%s_%s.log' % (
self.logFilePath, os.path.basename(sys.argv[0])[:-3], self.SECTION)
Log.Init(
Log.CRotatingLog(os.path.expanduser(LOG_NAME),
int(self.logFileSize), int(self.logFileCount)))
def main():
if len(sys.argv) < 3:
sys.stderr.write('Usage : %s conf_file section' % PROC_NAME)
sys.stderr.flush()
return
conf_file = sys.argv[1]
section = sys.argv[2]
conf = ConfigParser.ConfigParser()
conf.read(conf_file)
log_path = conf.get('GENERAL', 'LOG_PATH')
if not os.path.exists(log_path):
try:
os.makedirs(log_path)
except:
pass
type = 'handler'
if conf.has_option(section, 'handler_type'):
type = conf.get(section, 'handler_type')
log_name = '%s_%s_%s.log' % (PROC_NAME, type, section)
log_file = os.path.join(log_path, log_name)
mlib_path = None
if conf.has_option('GENERAL', 'MLIB_PATH'):
mlib_path = conf.get('GENERAL', 'MLIB_PATH')
if mlib_path:
sys.path.insert(0, mlib_path)
try:
import Mobigen.Common.Log as Log
except:
raise Exception('Can not import Mobigen.Common.Log')
log = Log.Init(Log.CRotatingLog(log_file, 10240000, 9))
Worker(log=__LOG__, conf=conf, section=section).start()
def set_logger(self):
self.logFilePath = 'Log'
self.logFileSize = 1000000
self.logFileCount = 10
if (self.cfg != None):
if self.cfg.has_option('Log', 'LogFilePath'):
self.logFilePath = self.cfg.get('Log', 'LogFilePath')
if self.cfg.has_option('Log', 'LogFileSize'):
self.logFileSize = self.cfg.getint('Log', 'LogFileSize')
if self.cfg.has_option('Log', 'LogFileCount'):
self.logFileCount = self.cfg.getint('Log', 'LogFileCount')
if not os.path.exists(self.logFilePath):
os.makedirs(self.logFilePath)
LOG_NAME = '%s/%s.log' % (self.logFilePath,
os.path.basename(self.module)[:-3])
Log.Init(
Log.CRotatingLog(os.path.expanduser(LOG_NAME),
self.logFileSize, self.logFileCount))
def main():
module = os.path.basename(sys.argv[0])
section = 'IRIS_MIGRATION'
cfgfile = '/home/tacs/user/KimJW/Migration/migration.conf'
cfg = ConfigParser.ConfigParser()
cfg.read(cfgfile)
log_file = '%s_%s.log' % (module, section)
Log.Init(Log.CRotatingLog(log_file, 1000000, 9))
im = IrisMirgration(cfg, section)
loadTable = None
if len(sys.argv) > 1:
loadTable = sys.argv[1]
im.loadData(loadTable)
else:
im.run()
__LOG__.Trace('end main!')
def set_logger(self):
self.logFilePath = 'Log'
self.logFileSize = 1000000
self.logFileCount = 10
if (self.conf_parser != None):
if self.conf_parser.get('Log', 'LogFilePath') != '':
self.logFilePath = self.conf_parser.get('Log', 'LogFilePath')
self.logFileSize = self.conf_parser.get('Log', 'LogFileSize')
self.logFileCount = self.conf_parser.get('Log', 'LogFileCount')
if not os.path.exists(self.logFilePath):
print self.logFilePath
os.makedirs(self.logFilePath)
LOG_NAME = '%s/%s_%s.log' % (self.logFilePath,
os.path.basename(self.module)[:-3],
self.section)
Log.Init(Log.CRotatingLog(os.path.expanduser(LOG_NAME),
int(self.logFileSize),
int(self.logFileCount)))
def main():
global roleManager
module = os.path.basename(sys.argv[0])
section = sys.argv[1] # ROLE_MANAGER
cfgfile = sys.argv[2] # /home/tacs/TACS-EF/ETL/conf/RoleManager.conf
try :
cfg = ConfigParser.ConfigParser()
cfg.read(cfgfile)
if '-d' not in sys.argv :
log_path = cfg.get('GENERAL', 'LOG_PATH')
log_file = os.path.join(log_path, '%s_%s.log' % (module, section))
Log.Init(Log.CRotatingLog(log_file, 10000000, 9))
else:
LOG.Init()
roleManager = RoleManager(cfg, section)
roleManager.run(section)
except :
__LOG__.Exception()
__LOG__.Trace('end main!')
def main():
module = os.path.basename(sys.argv[0])
cfgfile = sys.argv[1]
cfg = ConfigParser.ConfigParser()
cfg.read(cfgfile)
logPath = cfg.get("GENERAL", "LOG_PATH")
logFile = os.path.join(logPath, "%s.log" % module)
logCfgPath = cfg.get("GENERAL", "LOG_CONF")
logCfg = ConfigParser.ConfigParser()
logCfg.read(logCfgPath)
Log.Init(
Log.CRotatingLog(logFile, logCfg.get("LOG", "MAX_SIZE"),
logCfg.get("LOG", "MAX_CNT")))
workInfoFailOver = WorkInfoFailOver(cfg)
workInfoFailOver.run()
__LOG__.Trace('main is terminated')
def main():
cfg = ConfigParser.ConfigParser()
cfg.read(sys.argv[2])
log_dir = cfg.get("GENERAL", "LOG_DIR")
log_name= os.path.join(log_dir, str(os.path.basename(sys.argv[0]))) + \
"_" + \
sys.argv[1] + ".log"
Log.Init(Log.CRotatingLog(log_name, 1000000, 9))
__LOG__.Trace(
"=============================================================")
__LOG__.Trace(" Module start")
__LOG__.Trace(
"=============================================================")
time_list = config(cfg)
scheduler(time_list)
while True:
try:
time.sleep(1)
except:
__LOG__.Exception()
break
def main():
module = os.path.basename(sys.argv[0])
section = sys.argv[1] # TACS_FILE_MONITOR
cfgfile = sys.argv[2] # /home/tacs/user/KimJW/ETL/conf/FileMonitor.conf
cfg = ConfigParser.ConfigParser()
cfg.read(cfgfile)
logPath = cfg.get("GENERAL", "LOG_PATH")
logFile = os.path.join(logPath, "%s_%s.log" % (module, section))
logCfgPath = cfg.get("GENERAL", "LOG_CONF")
logCfg = ConfigParser.ConfigParser()
logCfg.read(logCfgPath)
Log.Init(
Log.CRotatingLog(logFile, logCfg.get("LOG", "MAX_SIZE"),
logCfg.get("LOG", "MAX_CNT")))
fm = QMigration(cfg, section)
fm.run(section)
__LOG__.Trace("end main!")
def main():
global roleManager
module = os.path.basename(sys.argv[0])
section = sys.argv[1] # ROLE_MANAGER
cfgfile = sys.argv[2] # /home/tacs/TACS-EF/ETL/conf/RoleManager.conf
cfg = ConfigParser.ConfigParser()
cfg.read(cfgfile)
logPath = cfg.get("GENERAL", "LOG_PATH")
logFile = os.path.join(logPath, "%s_%s.log" % (module, section))
logCfgPath = cfg.get("GENERAL", "LOG_CONF")
logCfg = ConfigParser.ConfigParser()
logCfg.read(logCfgPath)
Log.Init(Log.CRotatingLog(logFile, logCfg.get("LOG", "MAX_SIZE"), logCfg.get("LOG", "MAX_CNT") ))
roleManager = RoleManager(cfg, section)
roleManager.run(section)
__LOG__.Trace('end main!')
import os.path
import base64
import time
import sys
import signal
try:
from Mobigen.Common import Log
from Mobigen.Common.Log import __LOG__
Log.Init()
except:
pass
class LoginFailException(Exception) : pass
class ConnectionFailException(Exception) : pass
class LoadTypeException(Exception) : pass
class Cursor(object):
def __init__(self, sock, Debug=False, LogModule='STDOUT'):
object.__init__(self)
self.firstExecute = False
self.sock = sock
self.isDebug = Debug
if Debug:
signal.signal(signal.SIGINT, self._signal_handler)
self.buffer = []
self.LogModule = LogModule;
self.record_sep = ' ' #^^ : record sep
self.field_sep = ' ' #^_ : unit sep
#!/bin/env python
# -*- coding: cp949 -*-
import Mobigen.Common.Log as Log; Log.Init()
BINMAP = {}
BINMAP['0']="0000"; BINMAP['1']="0001"; BINMAP['2']="0010"; BINMAP['3']="0011";
BINMAP['4']="0100"; BINMAP['5']="0101"; BINMAP['6']="0110"; BINMAP['7']="0111";
BINMAP['8']="1000"; BINMAP['9']="1001"; BINMAP['A']="1010"; BINMAP['B']="1011";
BINMAP['C']="1100"; BINMAP['D']="1101"; BINMAP['E']="1110"; BINMAP['F']="1111";
def ToBinString(data) :
data = data.upper()
binList = []
for ch in data : binList.append(BINMAP[ch])
return "".join(binList)
def parseCellIdentifier(rawdata) :
if(not rawdata) : return [-1, -1, -1]
bin = ToBinString(rawdata)
sector = int(bin[0:3], 2)
rnc = int(bin[3:8], 2)
nodeb = int(bin[8:16], 2)
if (rnc == 14) :
sector = 0
nodeb = int ("%s%s" % (bin[8:16] , bin[0:3]) , 2)
return [sector, rnc, nodeb]
# SendMessage Timeout
#-------------------------------------------------------
try:
if opts.has_key('-t'):
g_SEND_TIMEOUT = int(opts['-t'].strip())
except:
pass # default timeout
#-------------------------------------------------------
# if SendMessage Timeout Failed, retry Falg : 07.09.28
#-------------------------------------------------------
try:
if opts.has_key('-r'):
g_RETRY_SENDFLAG = True
except:
pass # default timeout
#-------------------------------------------------------
# HeartBeat, Key
#-------------------------------------------------------
g_INIT_KEY = '0,*,*' # heartbeat,key1,key2
g_INIT_KEY = args[2]
LOG_FILE = '%s.log' % sys.argv[0]
Log.Init(Log.CRotatingLog(LOG_FILE, 10000000, 3, 'a', debugLevel))
__LOG__.Trace(
"START :LEVEL [%s:%d], KEY:[%s]+++++++++++++++++++++++++++++++++++++++++++++++++"
% (strLevel, debugLevel, g_INIT_KEY), (logging.CRITICAL))
main()
def main() :
global g_sequence, g_sequence_timeout, g_wait_time, g_isFile
if len(sys.argv) < 3 :
usage()
sys.exit()
try:
opts, args = getopt.getopt(sys.argv[1:], "hsw:ct:fn:", ["help", "waittime"])
except :
# print help information and exit:
usage()
sys.exit(2)
iniFile = False
g_wait_time = 0
logSize = 10000000
logFileNum = 3
for o, a in opts:
if o in ("-h", "--help"):
usage()
sys.exit()
if o in ("-s"):
g_sequence = True
if o in ("-w", "--waittime"):
g_sequence_timeout = int(a)
if o in ("-c"):
iniFile = True
if o in ("-t"):
g_wait_time = int(a)
if o in ("-f"):
g_isFile = True
if o in ("-n"):
try:
(logFileNum, logSize) = map(int, a.split(","))
except:
logSize = 10000000
logFileNum = 3
if iniFile == False and len(args) < 2:
usage()
sys.exit()
log_port = None
if iniFile :
iniFileName = args.pop()
(args, log_port) = readIniFile(iniFileName, args)
else :
log_port = args.pop()
if not log_port:
__LOG__.Trace( "log_port error" )
usage()
sys.exit()
if g_isFile:
# -f 옵션인 경우 파일에 저장함.
Log.Init( Log.CRotatingLog( log_port, logSize, logFileNum ) )
__LOG__.Trace( "log_port: [%s]" % log_port)
countProcess = SFLauncher(args, log_port)
countProcess.setDaemon(True)
countProcess.start()
global SHUTDOWN
while 1 :
try:
if SHUTDOWN : break
#else : time.sleep(1)
else : select.select([],[],[], 1)
except:
if SHUTDOWN : break
pass
__LOG__.Trace('MAIN : kill()')
countProcess.kill()
countProcess.join()
__LOG__.Trace('MAIN : closed')
#########################################################
#import psyco
#psyco.profile()
### import python foundation class ###
import os, signal, sys, time, re
import thread
import logging
from logging.handlers import RotatingFileHandler
from socket import *
import ConfigParser
import shlex
import Mobigen.Common.Log as Log
Log.Init()
PS_EXECMD = {}
PS_GROUP = {}
GROUP_PS = {}
PS_PROCNAME = {}
PS_PID = {}
PS_TYPE = {}
PS_DESC = {}
PS_ORDER = {}
PS_TIME = {}
PS_MODE = {}
PS_TERM = {}
PS_FORCE_KILL = {}
OLD_PID = {}
#!/usr/bin/python
#---------------------------------------------------------------------
# version | date : writer : description
#---------+-----------------------------------------------------------
# V2.0 | 070424 : cdssw : final
#---------------------------------------------------------------------
import Mobigen.Common.Log as Log
Log.Init()
import Mobigen.Common.SFProtocol.SFProtocol as sfp
import os, sys, getopt
from socket import *
import signal
SHUTDOWN = False
def shutdown(sigNum=0, frame=0):
global SHUTDOWN
SHUTDOWN = True
signal.signal(signal.SIGTERM, shutdown)
signal.signal(signal.SIGINT, shutdown)
signal.signal(signal.SIGHUP, shutdown)
def main():
global SHUTDOWN
