def spawn_client(self, conn, addr):
''' spawning client '''
make_dir(EnvFileLoc().server_tempdir,
self._logger) # make working directory
workdir = tempfile.mkdtemp(prefix='%s_%s_' % (addr[0], addr[1]),
dir=EnvFileLoc().server_tempdir)
self._logger.info("Working directory is set to %s" % workdir)
mProboRunServerMode(conn, workdir, addr, self._ur_filename, self._PORT)
def launch(args, csocket=None):
''' Launch mProbo '''
# creating logger
if csocket != None: # "logger id"s of clients should be different
logger_id = generate_random_str(EnvMisc().logger_prefix + '_', 10)
else:
logger_id = EnvMisc().logger_prefix
logger = logging.getLogger(logger_id)
ch1 = logging.StreamHandler(
open(os.path.join(args.workdir,
EnvFileLoc().logfile), 'w'))
ch1.setLevel(logging.INFO)
logger.addHandler(ch1)
# interrupt handler
if csocket == None:
signal.signal(signal.SIGINT, sigint_handler)
try: # normal mode without any error or user interrupt
# Run checks
logger.info(davemsg.LOGO_001.format(today=printToday()))
try:
if ehdnsxmgor(featureinfo()) != True:
inv = True
except:
sys.exit()
#if args.gui: # launch GUI
# logger.info(mcode.INFO_010)
# run_mProbo_GUI()
# logger.info(mcode.INFO_011)
# sys.exit()
# run mProbo
amschk_obj = RunChecker(args, csocket, logger_id)()
# finishing message
if not args.extract: # checker mode
map(logger.info, print_end_msg(mcode.INFO_009, '=='))
else: # extraction mode
map(logger.info, print_end_msg(mcode.INFO_009_1, '=='))
except: # handle user interrupt
m = traceback.format_exc()
logger.info(m.splitlines()[-1])
edc = lambda ss, cc: ''.join(
chr(ord(s) ^ ord(c)) for s, c in zip(ss, cc * 1000))
#m = edc(m, mcode.INFO_009)
with open(EnvFileLoc().dump_file, 'w') as f:
f.write(m)
logger.removeHandler(ch1)
def pass_args_server():
''' process shell command args for mProbo_server '''
def_userfile = os.path.join(os.environ['DAVE_INST_DIR'],
EnvFileLoc().server_userfile)
def_no_clients = EnvMisc().no_clients
def_port = int(EnvMisc().server_port)
parser = argparse.ArgumentParser(
description='Launch mProbo server application')
parser.add_argument(
'-u',
'--user',
help='User IP registration file. The default is "%s".' % def_userfile,
default=def_userfile)
parser.add_argument('-n',
'--number',
help='Number of clients. The default is "%s".' %
def_no_clients,
default=def_no_clients)
parser.add_argument('-p',
'--port',
help="Port in server/client mode. The default is %d." %
def_port,
type=int,
default=def_port)
return parser
def __init__(self, args, csocket, logger_id='logger_id'):
self._testfile = args.test # test configuration file name
self._simfile = args.sim # simulator configuration file name
self._workdir = args.workdir # working directory
self._rptfile = os.path.abspath(os.path.join(self._workdir,args.rpt)) # report file name
self._cache = args.use_cache # use cached data if True
self._no_otfc = args.no_otf_check # no on-the-fly check for pin consistency
self._np = args.process # num. of threads for simulations
self._goldenonly = args.extract # run in extraction mode
self._port_xref = args.port_xref # port cross reference filename of modules
self._csocket = csocket # client socket if any
self._logger_id = logger_id # logger id string
self._logger = DaVELogger.get_logger('%s.%s.%s' % (logger_id, __name__, self.__class__.__name__))
self._mp = LinearModelParameter()
self._inv = not ehdnsxmgor(featureinfo())
self._tcfg = TestConfig(self._testfile, port_xref = self._port_xref, logger_id=logger_id) # get test cfg obj
self._scfg = SimulatorConfig(self._simfile, self._goldenonly, logger_id=logger_id) # get sim cfg obj
self._rptgen = ReportGenerator(filename=self._rptfile, logger_id=logger_id) # reportgenerator obj
self._root_rundir = os.path.join(self._workdir, EnvFileLoc().root_rundir) # for e.g. workdir/.mProbo, this will store all the data for the checking
make_dir(self._workdir, self._logger)
make_dir(self._root_rundir, self._logger)
if self._inv: dlrtmvkdldjem()
def __init__(self, pref_filename, vlog_tb='', logger_id='logger_id'):
self._logger = DaVELogger.get_logger(
'%s.%s.%s' %
(logger_id, __name__, self.__class__.__name__)) # logger
_envfile = EnvFileLoc()
if vlog_tb != '':
self.load_testbench(vlog_tb)
self._pref = WireCrossReference(
pref_filename) # port reference class obj.
def upload(self, data):
''' Receive files from a client '''
mprobo_rundir = EnvFileLoc().root_rundir
files = data[len(self._CMD['upload']) + 1:].split()
files = [
f[f.rfind('%s' % mprobo_rundir):]
if f.rfind('%s' % mprobo_rundir) >= 0 else f for f in files
]
new_data = ' '.join([self._CMD['upload']] + files)
self._csocket.send(new_data)
for f in files:
self._fileC2S(f)
self.clear_command()
def __init__(self, test_cfg, sim_cfg, testdir='/tmp', rpt=None, goldensim_only=False, revisedsim_only=False, use_cache=False, no_thread=1, no_otfc=False, csocket=None, logger_id='logger_id'):
'''
test_cfg : test configuration cls object of a single test
sim_cfg_(golden,revised) : simulator configuration cls object for golden, revised
testdir : top directory of this test run
rpt : report cls object
'''
# get system reserved words
self._tenv = EnvTestcfgOption()
self._tenvf = EnvFileLoc()
self._tenvs = EnvSimcfg()
self._logger_id = logger_id
self._logger = DaVELogger.get_logger('%s.%s.%s' % (logger_id, __name__, self.__class__.__name__)) # logger
self._inv = not ehdnsxmgor(featureinfo())
self._csocket = csocket # client socket for server-client mode
self._rptgen = rpt # report gen obj
self._cache = use_cache
self._np = no_thread # no of threads
self._no_otfc = no_otfc # no on-the-fly check for pin consistency
sim_cfg_golden = sim_cfg.get_golden()
sim_cfg_revised = sim_cfg.get_revised()
# You can run only either golden sim or revised sim if you need by setting golden(revised)sim_only args
# But, you can't turn them on both
assert not (goldensim_only and revisedsim_only), mcode.ERR_003
self.goldensim_only = goldensim_only
self.revisedsim_only = revisedsim_only
# make directories for golden and revised models
self.testdir = testdir
self._make_dir()
# Simulator configuration of both golden and revised model.
self._sim_cfg_golden = sim_cfg_golden
self._sim_cfg_revised = sim_cfg_revised
# Test configuration
self._test_cfg = test_cfg # get test configuration for this unit test
self._testname = self._test_cfg.get_test_name() # get a test name
# generate intermediate testbench
self._tb_golden = TestBench(
self._test_cfg,
self._sim_cfg_golden,
self.testdir,
logger_id=self._logger_id
).get_raw_filename()
self._tb_revised = TestBench(
self._test_cfg,
self._sim_cfg_revised,
self.testdir,
logger_id=self._logger_id
).get_raw_filename()
# display wires used in the instances, let user make sure they are all declared.
#self._print_wires(self._tb_golden)
# get a porthandler / create port objects from test cfg info.
self._ph = PortHandler(logger_id=self._logger_id)
self._create_port(self._test_cfg)
# get vector generator obj.
self._tvh = TestVectorGenerator(self._ph, self._test_cfg, logger_id=self._logger_id)
# running vector instance
self._rv_golden = RunVector(self._test_cfg, self._sim_cfg_golden, self._ph, self._tb_golden, self._cache, self._csocket, logger_id=self._logger_id)
self._rv_revised = RunVector(self._test_cfg, self._sim_cfg_revised, self._ph, self._tb_revised, self._cache, self._csocket, logger_id=self._logger_id)
# get a linear regressor obj.s for pin discrepancy check
self._lrg_simple = LinearRegressionSM(self._ph, logger_id=self._logger_id)
self._lrr_simple = LinearRegressionSM(self._ph, logger_id=self._logger_id)
# get a linear regressor obj.s for pin discrepancy check (suggested)
self._lrg_sgt_simple = LinearRegressionSM(self._ph, logger_id=self._logger_id)
self._lrr_sgt_simple = LinearRegressionSM(self._ph, logger_id=self._logger_id)
# get a linear regressor obj.s
self._lrg = LinearRegressionSM(self._ph, logger_id=self._logger_id)
self._lrr = LinearRegressionSM(self._ph, logger_id=self._logger_id)
# regressor obj for selected model
self._lrg_sgt = LinearRegressionSM(self._ph, logger_id=self._logger_id)
self._lrr_sgt = LinearRegressionSM(self._ph, logger_id=self._logger_id)
if self._cache:
self._tvh.load_test_vector(self._ph, self.testdir)
else:
self._tvh.dump_test_vector(self._ph, self.testdir)
# report port information
if self._rptgen != None:
self._rptgen.load_porthandler_obj(self._ph) # port object of this test
self._rptgen.print_port_info() # print out
def send_result(self):
self._server.issue_command(
'@download %s %s/extracted_linear_model.yaml %s' %
(self._rpt_filename, EnvFileLoc().root_rundir,
EnvFileLoc().logfile))
class mProboRunServerMode(object):
_RUNARG_FILE = EnvFileLoc().client_runarg_file
def __init__(self, conn, workdir, addr, ur_filename, port):
self._logger = DaVELogger.get_logger(
'%s.%s.%s' %
(logger_id, __name__, self.__class__.__name__)) # logger
self._server = mProboServer(conn, workdir, addr,
logger_id) # make communication channel
self._addr = addr
self._workdir = workdir
self.check_connection()
is_valid, no_acct, company = self.validate_user(addr[0], ur_filename)
t = strftime("%a, %d %b %Y %H:%M:%S", localtime())
self._logger.info("[CONN] Got a connection from %s (%s) at %s" %
(str(addr), company, t))
if is_valid:
fn_match_ip = lambda x: x == addr[0]
ip_addrs = filter(fn_match_ip,
get_established_foreign_ip_address(port))
no_runs = len(ip_addrs)
if no_runs <= no_acct:
self.upload_configuration_files() # get test.cfg & sim.cfg
self._runargs = self.get_runargs() # get args of mProbo
self.run() # run mProbo
self.send_result() #
self._logger.info("Temporary working directory: %s" %
self._workdir)
else:
self._server.issue_command(
"@max_license [CONN] Maximum # of licenses for the IP (%s): %s reached. Connection closed"
% (addr[0], no_acct))
self._logger.info(
"[CONN] Maximum # of licenses for the IP (%s): %s reached. Connection closed"
% (addr[0], no_acct))
else:
self._logger.info("[CONN] Invalid IP: %s. Connection closed" %
addr[0])
self.close_connection()
#self.cleanup_workdir()
thread.exit()
def validate_user(self, ip_addr, ur_filename):
is_valid = False
with open(ur_filename, 'r') as f:
for l in f.readlines():
field = l.strip().split()
if field[0].startswith('*'): continue
if fnmatch.fnmatch(ip_addr, field[0]):
return True, int(field[1]), field[2].replace('_', ' ')
self._server.issue_command('@invalid_user User validation failed.')
return False, 0, ''
def check_connection(self):
''' Check connection '''
self._server.issue_command('@connect')
def upload_configuration_files(self):
''' upload test/sim configuration files to the server '''
#self._server.issue_command('@upload %s %s' % (EnvRunArg().testcfg_filename, EnvRunArg().simcfg_filename))
self._server.issue_command(
'@upload %s %s %s' % ('test_pp.cfg', 'sim_pp.cfg', 'circuit.scs'))
def get_runargs(self):
''' get mProbo run arguments'''
self._server.issue_command('@upload %s' % self._RUNARG_FILE)
argfile = os.path.join(self._workdir, self._RUNARG_FILE)
with open(argfile, 'r') as f:
args = f.read()
rmfile(argfile)
#args = args + ' -w {wdir} -t {test} -s {sim}'.format(wdir=self._workdir,test=os.path.join(self._workdir,EnvRunArg().testcfg_filename), sim=os.path.join(self._workdir,EnvRunArg().simcfg_filename))
args = args + ' -w {wdir} -t {test} -s {sim}'.format(
wdir=self._workdir,
test=os.path.join(self._workdir, 'test_pp.cfg'),
sim=os.path.join(self._workdir, 'sim_pp.cfg'))
return args.split()
def run(self):
''' run mprobo '''
self._logger.info("Run mProbo")
args = pass_args().parse_args(self._runargs)
self._rpt_filename = args.rpt
launch(args, self._server)
def send_result(self):
self._server.issue_command(
'@download %s %s/extracted_linear_model.yaml %s' %
(self._rpt_filename, EnvFileLoc().root_rundir,
EnvFileLoc().logfile))
def close_connection(self):
''' close connection '''
self._server.issue_command('@close')
self._logger.info("[CONN] Connection %s closed" % str(self._addr))
def cleanup_workdir(self):
''' delete workdir '''
shutil.rmtree(self._workdir)
import shutil
import fnmatch
import argparse
import signal
from time import strftime, localtime
from dave.common.davelogger import DaVELogger
from dave.common.misc import rmfile, make_dir, assert_file
from dave.common.netstat import get_established_foreign_ip_address
from dave.mprobo.environ import EnvRunArg, EnvFileLoc, EnvMisc
from dave.mprobo.server import mProboServer
from dave.mprobo.launcher import launch, pass_args
#----------------------------------
# creating logger
logger_id = EnvMisc().logger_prefix + '_server'
logging.basicConfig(filename=EnvFileLoc().server_logfile,
filemode='w',
level=logging.DEBUG)
logger = logging.getLogger(logger_id)
ch = logging.StreamHandler(sys.stdout)
ch.setLevel(logging.DEBUG)
logger.addHandler(ch)
#----------------------------------
def pass_args_server():
''' process shell command args for mProbo_server '''
def_userfile = os.path.join(os.environ['DAVE_INST_DIR'],
EnvFileLoc().server_userfile)
def_no_clients = EnvMisc().no_clients
def_port = int(EnvMisc().server_port)
#!/usr/bin/env python
import logging
import sys
from dave.mprobo.launcher import launch, pass_args
from dave.mprobo.environ import EnvFileLoc, EnvMisc
__doc__ = ''' mProbo launcher in stand-alone mode [c.f. mProbo_server(client).py] '''
# logger
logging.basicConfig(filename=EnvFileLoc().debug_file,
filemode='w',
level=logging.DEBUG)
logger = logging.getLogger(EnvMisc().logger_prefix)
ch = logging.StreamHandler(sys.stdout)
ch.setLevel(logging.INFO)
logger.addHandler(ch)
def main():
args = pass_args().parse_args() # get command-line arguments
launch(args, csocket=None) # launch application
if __name__ == "__main__":
main()