def mmain():
manager = multiprocessing.Manager()
global PROCESSES
PROCESSES = {}
global PLUGINS
PLUGINS = manager.list()
global CONTEXT
CONTEXT = manager.dict()
for plugin in os.listdir('plugins'):
try:
dir = os.path.join('plugins', plugin)
if not os.path.isdir(dir):
continue
print 'Loading plugin {}'.format(plugin)
p = Plugin(dir)
PLUGINS.append(p)
print 'Successfully loaded plugin: {}'.format(p)
except Exception:
traceback.print_exc(file=sys.stdout)
print 'Failed to load plugin {}'.format(plugin)
global http_server
http_server = WSGIServer(('', 5000), app)
#http_server.log = open('http.log', 'w')
http_server.serve_forever()
def load_plugins(self):
info_files = []
for root in sucker.PLUGIN_DIRS:
for path in os.listdir(root):
info_files.append(os.path.abspath(os.path.join(root, path, '%s.sucker-plugin' % path)))
for info_file in info_files:
if os.path.isfile(info_file):
with open(info_file) as f:
info_str = f.read()
info_str = '[DEFAULT]\n' + info_str
info_conf = ConfigParser.ConfigParser()
info_conf.readfp(io.BytesIO(info_str))
try:
plug_path, plug_tail = os.path.split(info_file)
plug_name = info_conf.get('DEFAULT', 'name')
plug_type = info_conf.get('DEFAULT', 'type')
plug_module = info_conf.get('DEFAULT', 'module')
self.plugins[plug_name] = Plugin(plug_path, self.shell)
except ConfigParser.NoOptionError as err:
msg = err.message
msg = msg[msg.find("'")+1:]
msg = msg[:msg.find("'")]
print _("Can not load %s plugin from %s." % (path, plug_path))
print _("Option `%s` not found in .sucker-plugin file." % msg)
for key in self.plugins:
self.plugins[key].activate()
def __init__(self, opt):
if 'plugin' not in opt:
raise ValueError('no plugin selected');
self.botId = self._pickAName();
self.params = opt;
self.logger = Plugin().load("plugins/Logger_"+opt['plugin']+".py")
self.logger.constructor(self.params)
def classFactory(iface):
#used for symlinked test environment
import sys, os, inspect
cmdfolder = os.path.realpath(
os.path.abspath(
os.path.split(inspect.getfile(inspect.currentframe()))[0]))
if cmdfolder not in sys.path:
sys.path.insert(0, cmdfolder)
from Plugin import Plugin
return Plugin(iface)
def newPlugin(bundleId):
pluginId = request.get_json().get('pluginId', None)
pluginName = request.get_json().get('name', None)
if pluginId == None or pluginName == None:
abort(404)
plugin = Plugin(pluginId, bundleId, pluginName)
config.pluginTable.insert(plugin.__dict__)
requestResult = config.pluginTable.find_one({"pluginId": pluginId})
return mongodoc_jsonify(requestResult)
def analyseBundle(bundleId):
bundle = config.bundleTable.find_one({"bundleId": bundleId})
if bundle == None:
logging.error("No matching bundle has been found")
abort(make_response("No matching bundle has been found", 400))
if bundle["archivePath"] == None:
logging.error("The bundle as no directory path")
abort(make_response("The bundle as no directory path", 400))
headers = {'content-type': 'application/gzip'}
analyseReturn = requests.post(config.uriAnalyser + "/bundle/" +
str(bundleId),
data=open(bundle["archivePath"], 'r').read(),
headers=headers).json()
# logging.error("analyzeBundle analyseReturn: " + str(analyseReturn))
pluginIdOffset = config.pluginTable.count()
while 1:
analyseReturn = requests.get(config.uriAnalyser + "/bundle/" +
str(bundleId)).json()
if analyseReturn['status'] == "done":
bundleData = analyseReturn['datas']
break
sleep(1)
for index, plugin in enumerate(bundleData['plugins']):
pluginId = pluginIdOffset + index
currentPlugin = Plugin(pluginId, bundleId)
currentPlugin.clips = plugin['clips']
currentPlugin.parameters = plugin['parameters']
currentPlugin.properties = plugin['properties']
currentPlugin.rawIdentifier = plugin['rawIdentifier']
currentPlugin.version = plugin['version']
# Gets Label/ShortLabel and ensures a non-empty value.
currentPlugin.label = currentPlugin.getPropValueFromKeys(
('OfxPropLabel', 'OfxPropShortLabel', 'OfxPropLongLabel'),
currentPlugin.rawIdentifier)
currentPlugin.shortLabel = currentPlugin.getPropValueFromKeys(
('OfxPropShortLabel', 'OfxPropLongLabel'), currentPlugin.label)
bundle['plugins'].append(pluginId)
config.pluginTable.insert(currentPlugin.__dict__)
return mongodoc_jsonify(bundle)
def get_available_encoders(plugins_dir):
plugins = []
# For each dir in plugin dir
for plugin_dir in listdir(plugins_dir):
plugin_dir = path.join(plugins_dir, plugin_dir)
if path.isdir(plugin_dir):
# Check if it has a file...plugin.yaml
plugin_config = path.join(plugin_dir, "plugin.yaml")
if path.exists(plugin_config):
print("Plugin Found!")
# Each plugin.yaml represents a plugin
try:
plugins.append(Plugin(plugin_config))
except ValueError as ve:
print(ve)
return plugins
def load_plugin(id):
p = [p for p in PLUGINS if p.id == id][0]
print 'returning plugin {}'.format(p)
return p
for plugin in os.listdir('plugins'):
try:
dir = os.path.join('plugins', plugin)
if not os.path.isdir(dir):
continue
if id == plugin:
print 'Loading plugin {}'.format(plugin)
p = Plugin(dir)
print 'Successfully loaded plugin: {}'.format(p)
return p
except Exception as e:
print 'Failed to load plugin {}. Error: {}'.format(plugin, e)
print 'Failed to find plugin id {}'.format(id)
return None
def classFactory(iface):
return Plugin(iface)
if __name__ == '__main__':
write2output("\nINFO: Parsing input files\n")
parser = argparse.ArgumentParser(
description='Monte Carlo Protein design program. Possible arguments:' +
'--dir inputfile\n')
parser.add_argument('--input',
dest='inputfile',
required=False,
default='input.dat',
type=str)
args = parser.parse_args()
main_config = Parser(args.inputfile).parameters
if main_config['MC_criterion'] == 'external':
plugins = [Plugin(i[0], i[1]) for i in main_config['plugin']]
else:
plugins = []
# if 'conformation' in main_config.parameters:
if 'conformation' in main_config.keys():
snaps = [
Snap(config['prefix'], config['pdbname'], config['psfname'],
int(main_config['cpus'] / len(main_config['conformation'])),
config['weight'], main_config['enviroment'],
main_config['solvent'], main_config['MC_criterion'],
main_config['threshold'], main_config['logfile'],
main_config['immutables'], config['enzyme_resids_list'],
config['prms'], config['rtfs'], main_config['segname'],
config['constraint_pairs'], config['constraint_forces'],
config['constraint_lengths'], plugins,
def __init__(self, opt):
if 'plugin' not in opt:
raise ValueError("no plugin selected")
self.params = opt;
self.backend = Plugin().load("plugins/Backend_"+opt['plugin']+".py")
self.backend.constructor(self.params)
