def setup(self):
# internal management classes
self.vMonitor = RRDVermontMonitor(self.xpaths, self.names, self.moninterval)
self.rInterface = RemoteInterface(self.dir, self.cfgfile, self.logfile, self.vMonitor, self.names)
# RPC server
self.server = VCRPCServer((self.bindAddress, self.listenPort), allow_none=True, logRequests=False)
self.server.allow_reuse_address = True
self.server.allowedIp = self.allowedIp #IGNORE:W0201
self.server.register_instance(self.rInterface)
class VermontController:
"""
@ivar dir
@ivar cfgfile
@ivar logfile
@ivar moninterval
@ivar allowedIp
@ivar rrdxpaths
@ivar rrdnames
@ivar server
@ivar rInterface
@ivar vMonitor
@ivar controllerlogfile
@ivar bindAddress
@ivar listenPort
"""
def __init__(self, configfile):
self.dir = None
self.cfgfile = None
self.logfile = None
self.moninterval = None
self.allowedIp = None
self.xpaths = []
self.names = []
self.server = None
self.vMonitor = None
self.rInterface = None
self.controllerlogfile = None
try:
VermontLogger.init("vcontroller", "", True)
self._readConfig(configfile)
VermontLogger.init("vcontroller", self.controllerlogfile, True)
except:
print "failed to read configuration file!"
logger().error(traceback.format_exc())
def _readConfig(self, configfile):
cp = ConfigParser.ConfigParser()
cp.read(configfile)
self.dir = cp.get("Global", "VermontDir")
self.cfgfile = cp.get("Global", "ConfigFile")
self.controllerlogfile = cp.get("Global", "ControllerLogFile")
#self.controllerlogfile = cp.get("Global", "/var/log/monkit/vcontroller.log")
self.logfile = cp.get("Global", "VermontLogFile")
if self.logfile.startswith("/"):
__cwd = os.getcwd() + self.dir
self.logfile = os.path.relpath(self.logfile, __cwd)
self.moninterval = int(cp.get("Stats", "Interval"))
self.allowedIp = cp.get("Global", "AllowedManagerIP")
self.bindAddress = cp.get("Global", "BindAddress")
self.listenPort = int(cp.get("Global", "ListenPort"))
logger().info("Using interval %s" % self.moninterval)
i = 1
self.xpaths = []
self.names = []
try:
while True:
self.xpaths.append(cp.get("Stats", "XPath_%d" % i))
self.names.append(cp.get("Stats", "Name_%d" % i))
i += 1
except: #IGNORE:W0704
pass
def setup(self):
# internal management classes
self.vMonitor = RRDVermontMonitor(self.xpaths, self.names, self.moninterval)
self.rInterface = RemoteInterface(self.dir, self.cfgfile, self.logfile, self.vMonitor, self.names)
# RPC server
self.server = VCRPCServer((self.bindAddress, self.listenPort), allow_none=True, logRequests=False)
self.server.allow_reuse_address = True
self.server.allowedIp = self.allowedIp #IGNORE:W0201
self.server.register_instance(self.rInterface)
def serve(self):
thread.start_new_thread(VermontController._workerThread, (self, ))
self.server.serve_forever()
def _workerThread(self):
while True:
logger().info("VermontController._workerThread: collecting monitoring data now")
self.rInterface.retrieveStatus()
if self.rInterface.running:
# try to read in statistics data several times ...
xml = None
trycount = 0
while xml is None:
#if trycount>=100:
#raise RuntimeError("Failed to read sensor data!")
try:
logger().debug("trying to read sensor data ...")
self.rInterface.retrieveSensorData()
xml = NonvalidatingReader.parseString(self.rInterface.sensorDataText)
except:
logger().error(traceback.format_exc())
logger().info("failed to read sensor data xml, trying again ...")
time.sleep(1)
trycount += 1
self.vMonitor.collect_data(xml)
else:
logger().info("VermontController._workerThread: skipping stat recording, as instance is not running")
time.sleep(self.moninterval)
import DatabaseModel
from config import SSH_HOST
import config
# The host to which the computer is connected need to be recognized with the pem keys!!
# How to run this script:
# PYTHONPATH='.' luigi --module luigi_pipeline AnnotateAlignment --pid 1 --sid 4 --input /Volumes/data/dev/nanopore/pipeline/storage/rawreads.fasta --barcode /Volumes/data/dev/nanopore/pipeline/storage/barcodes.fasta
remote_storage_root = config.remote_storage
# Get the parameters stored in the database using the given sample id.
parameters = DatabaseModel.parameters()
report = DatabaseModel.status()
results = DatabaseModel.Results()
remoteInterface = RemoteInterface()
######################################################################################################################################
######################################################################################################################################
class CreateEnv(luigi.Task):
stage = 'CREATING ENVIRONMENT IN CLUSTER'
def output(self):
parameters.setParameters(parameters.data)
status = RemoteTarget(parameters.data['remote_storage'], SSH_HOST)
# if status: stage.pushStatus(parameters.data['id'], stage.CreateEnv)
return status
def run(self):
