def usermode_processor(client,
serverid="UsermodeProcessor",
cfg=None,
accepts_list=None,
stop_event=None,
omero_home=path.getcwd()):
"""
Creates and activates a usermode processor for the given client.
It is the responsibility of the client to call "cleanup()" on
the ProcessorI implementation which is returned.
cfg is the path to an --Ice.Config-valid file or files. If none
is given, the value of ICE_CONFIG will be taken from the environment
if available. Otherwise, all properties will be taken from the client
instance.
accepts_list is the list of IObject instances which will be passed to
omero.api.IScripts.validateScript. If none is given, only the current
Experimenter's own object will be passed.
stop_event is an threading.Event. One will be acquired from
omero.util.concurrency.get_event if none is provided.
"""
if cfg is None:
cfg = os.environ.get("ICE_CONFIG")
if accepts_list is None:
uid = client.sf.getAdminService().getEventContext().userId
accepts_list = [omero.model.ExperimenterI(uid, False)]
if stop_event is None:
stop_event = omero.util.concurrency.get_event(name="UsermodeProcessor")
id = Ice.Identity()
id.name = "%s-%s" % (serverid, uuid.uuid4())
id.category = client.getCategory()
ctx = omero.util.ServerContext(serverid, client.ic, stop_event)
impl = omero.processor.ProcessorI(ctx,
use_session=client.sf,
accepts_list=accepts_list,
cfg=cfg,
omero_home=omero_home,
category=id.category)
ctx.add_servant(client.adapter, impl, ice_identity=id)
return impl
def __init__(self,
ctx,
interpreter,
properties,
params,
iskill=False,
Popen=subprocess.Popen,
callback_cast=omero.grid.ProcessCallbackPrx.uncheckedCast,
omero_home=path.getcwd()):
"""
Popen and callback_Cast are primarily for testing.
"""
omero.util.SimpleServant.__init__(self, ctx)
self.omero_home = omero_home #: Location for OMERO_HOME/lib/python
#: Executable which will be used on the script
self.interpreter = interpreter
#: Properties used to create an Ice.Config
self.properties = properties
#: JobParams for this script. Possibly None if a ParseJob
self.params = params
#: Whether or not, cleanup should kill the session
self.iskill = iskill
#: Function which should be used for creating processes
self.Popen = Popen
#: Function used to cast all ProcessCallback proxies
self.callback_cast = callback_cast
# Non arguments (mutable state)
self.rcode = None #: return code from popen
self.callbacks = {} #: dictionary from id strings to callback proxies
self.popen = None #: process. if None then this instance isn't alive.
self.pid = None #: pid of the process. Once set, isn't nulled.
self.started = None #: time the process started
self.stopped = None #: time of deactivation
#: status which will be sent on set_job_status
self.final_status = None
# Non arguments (immutable state)
#: session this instance is tied to
self.uuid = properties["omero.user"]
# More fields set by these methods
self.make_files()
self.make_env()
self.make_config()
self.logger.info("Created %s in %s" % (self.uuid, self.dir))
def __init__(self,
ctx,
needs_session=True,
use_session=None,
accepts_list=None,
cfg=None,
omero_home=path.getcwd(),
category=None):
if accepts_list is None:
accepts_list = []
self.category = category #: Category to be used w/ ProcessI
self.omero_home = omero_home
# Extensions for user-mode processors (ticket:1672)
self.use_session = use_session
"""
If set, this session will be returned from internal_session and
the "needs_session" setting ignored.
"""
if self.use_session:
needs_session = False
self.accepts_list = accepts_list
"""
A list of contexts which will be accepted by this user-mode
processor.
"""
omero.util.Servant.__init__(self, ctx, needs_session=needs_session)
if cfg is None:
self.cfg = os.path.join(omero_home, "etc", "ice.config")
self.cfg = os.path.abspath(self.cfg)
else:
self.cfg = cfg
# Keep this session alive until the processor is finished
self.resources.add(UseSessionHolder(use_session))
def _create(self,
sql_directory,
db_vers,
db_patch,
password_hash,
args,
location=None):
sql_directory = self._sql_directory(db_vers, db_patch)
if not sql_directory.exists():
self.ctx.die(
2, "Invalid Database version/patch: %s does not"
" exist" % sql_directory)
if args and args.file:
output = args.file
script = "<filename here>"
else:
script = "%s__%s.sql" % (db_vers, db_patch)
location = old_div(path.getcwd(), script)
try:
output = open(location, 'w', encoding='utf-8')
except TypeError:
output = open(location, 'w')
self.ctx.out("Saving to " + location)
try:
dbprofile = self._db_profile()
header = old_div(sql_directory, ("%s-header.sql" % dbprofile))
footer = old_div(sql_directory, ("%s-footer.sql" % dbprofile))
if header.exists():
# 73 multiple DB support. OMERO 4.3+
cfg = {
"TIME": time.ctime(time.time()),
"DIR": sql_directory,
"SCRIPT": script
}
self._copy(header, output, str, cfg)
self._copy(old_div(sql_directory, "schema.sql"), output, str)
self._copy(old_div(sql_directory, "views.sql"), output, str)
self._copy(
footer, output,
self._make_replace(password_hash, db_vers, db_patch), cfg)
else:
# OMERO 4.2.x and before
output.write("""
--
-- GENERATED %s from %s
--
-- This file was created by the `omero db script` command
-- and contains an MD5 version of your OMERO root users's password.
-- You should think about deleting it as soon as possible.
--
-- To create your database:
--
-- createdb omero
-- psql omero < %s
--
BEGIN;
""" % (time.ctime(time.time()), sql_directory, script))
self._copy(old_div(sql_directory, "schema.sql"), output, str)
self._copy(
old_div(sql_directory, "data.sql"), output,
self._make_replace(password_hash, db_vers, db_patch))
self._copy(old_div(sql_directory, "views.sql"), output, str)
output.write("COMMIT;\n")
finally:
output.flush()
if output != sys.stdout:
output.close()