def __init__(self, url, session=None, logger=None, opts=None, posix=True):
if logger: self.logger = logger
else: self.logger = rul.getLogger('saga', 'PTYShell')
if session: self.session = session
else: self.session = ss.Session(default=True)
if opts: self.options = opts
else: self.options = dict()
self.logger.debug("PTYShell init %s" % self)
self.url = url # describes the shell to run
self.posix = posix # /bin/sh compatible?
self.latency = 0.0 # set by factory
self.cp_slave = None # file copy channel
self.initialized = False
self.pty_id = PTYShell._pty_id
PTYShell._pty_id += 1
self.cfg = self.session.get_config('saga.utils.pty')
# get prompt pattern from options, config, or use default
if 'prompt_pattern' in self.options:
self.prompt = self.options['prompt_pattern']
elif 'prompt_pattern' in self.cfg:
self.prompt = self.cfg['prompt_pattern'].get_value()
else:
self.prompt = DEFAULT_PROMPT
self.prompt_re = re.compile("^(.*?)%s" % self.prompt, re.DOTALL)
self.logger.info("PTY prompt pattern: %s" % self.prompt)
# we need a local dir for file staging caches. At this point we use
# $HOME, but should make this configurable (FIXME)
self.base = os.environ['HOME'] + '/.saga/adaptors/shell/'
try:
os.makedirs(self.base)
except OSError as e:
if e.errno == errno.EEXIST and os.path.isdir(self.base):
pass
else:
raise se.NoSuccess("could not create staging dir: %s" % e)
self.factory = supsf.PTYShellFactory()
self.pty_info = self.factory.initialize(self.url,
self.session,
self.prompt,
self.logger,
posix=self.posix)
self.pty_shell = self.factory.run_shell(self.pty_info)
self._trace('init : %s' % self.pty_shell.command)
self.initialize()
def __init__(self,
url=None,
session=None,
_adaptor=None,
_adaptor_state={},
_ttype=None):
"""
__init__(url)
Create a new Manager instance. Connect to a remote resource management endpoint.
:type url: :class:`saga.Url`
:param url: resource management endpoint
"""
# param checks
_url = surl.Url(url)
scheme = _url.scheme.lower()
if not session:
session = ss.Session(default=True)
self._base = super(Manager, self)
self._base.__init__(scheme,
_adaptor,
_adaptor_state,
_url,
session,
ttype=_ttype)
def __init__(self,
rm=None,
session=None,
_adaptor=None,
_adaptor_state={},
_ttype=None):
"""
__init__(rm, session)
Create a new job.Service instance.
:param rm: resource manager URL
:type rm: string or :class:`saga.Url`
:param session: an optional session object with security contexts
:type session: :class:`saga.Session`
:rtype: :class:`saga.job.Service`
"""
# job service instances are resource hogs. Before attempting to create
# a new instance, we attempt to clear out all old instances. There is
# some collateral damage: we cannot run the Python GC over only the
# job.Service instances, but have to run it globally -- however,
# compared to the latency introduced by the job service setup, this
# should be a minor inconvenienve (tm)
try:
import gc
gc.collect()
except:
pass
# param checks
self.valid = False
url = surl.Url(rm)
if not url.scheme:
url.scheme = 'fork'
if not url.host:
url.host = 'localhost'
if not session:
session = ss.Session(default=True)
scheme = url.scheme.lower()
self._super = super(Service, self)
self._super.__init__(scheme,
_adaptor,
_adaptor_state,
url,
session,
ttype=_ttype)
self.valid = True
def __init__(self, url, session=None, logger=None, init=None, opts={}):
# print 'new pty shell to %s' % url
if logger: self.logger = logger
else: self.logger = rul.getLogger('saga', 'PTYShell')
if session: self.session = session
else: self.session = ss.Session(default=True)
self.logger.debug("PTYShell init %s" % self)
self.url = url # describes the shell to run
self.init = init # call after reconnect
self.opts = opts # options...
self.latency = 0.0 # set by factory
self.cp_slave = None # file copy channel
self.initialized = False
# get prompt pattern from config
self.cfg = self.session.get_config('saga.utils.pty')
if 'prompt_pattern' in self.cfg:
self.prompt = self.cfg['prompt_pattern'].get_value()
self.prompt_re = re.compile("^(.*?)%s" % self.prompt, re.DOTALL)
else:
self.prompt = "[\$#%>\]]\s*$"
self.prompt_re = re.compile("^(.*?)%s" % self.prompt, re.DOTALL)
self.logger.info("PTY prompt pattern: %s" % self.prompt)
# we need a local dir for file staging caches. At this point we use
# $HOME, but should make this configurable (FIXME)
self.base = os.environ['HOME'] + '/.saga/adaptors/shell/'
try:
os.makedirs(self.base)
except OSError as e:
if e.errno == errno.EEXIST and os.path.isdir(self.base):
pass
else:
raise se.NoSuccess("could not create staging dir: %s" % e)
self.factory = supsf.PTYShellFactory()
self.pty_info = self.factory.initialize(self.url, self.session,
self.prompt, self.logger)
self.pty_shell = self.factory.run_shell(self.pty_info)
self.initialize()
def __init__(self,
url=None,
flags=None,
session=None,
_adaptor=None,
_adaptor_state={},
_ttype=None):
'''
:param url: Url of the (remote) entry
:type url: :class:`saga.Url`
flags: flags enum
session: saga.Session
ret: obj
Construct a new entry object
The specified entry is expected to exist -- otherwise a DoesNotExist
exception is raised. Also, the URL must point to an entry (not to
a directory), otherwise a BadParameter exception is raised.
Example::
# get an entry handle
entry = saga.namespace.Entry("sftp://localhost/tmp/data/data.bin")
# print the entry's url
print entry.get_url ()
'''
self._session = session
self._is_recursive = False # recursion guard (FIXME: NOT THREAD SAFE)
# param checks
if not session:
session = ss.Session(default=True)
if not flags: flags = 0
url = surl.Url(url)
scheme = url.scheme.lower()
self._base = super(Entry, self)
self._base.__init__(scheme,
_adaptor,
_adaptor_state,
url,
flags,
session,
ttype=_ttype)
def create (cls, url=None, flags=None, session=None, ttype=None) :
'''
url: saga.Url
flags: saga.namespace.flags enum
session: saga.Session
ttype: saga.task.type enum
ret: saga.Task
'''
# param checks
if not flags : flags = 0
if not session :
session = ss.Session (default=True)
return cls (url, flags, session, _ttype=ttype)._init_task
def create (cls, rm=None, session=None, ttype=SYNC) :
"""
create(rm=None, session=None)
Create a new job.Service instance asynchronously.
:param rm: resource manager URL
:type rm: string or :class:`saga.Url`
:param session: an optional session object with security contexts
:type session: :class:`saga.Session`
:rtype: :class:`saga.Task`
"""
# param checks
if not session :
session = ss.Session (default=True)
url = surl.Url (rm)
scheme = url.scheme.lower ()
return cls (url, session, _ttype=ttype)._init_task
def benchmark_init(name, func_pre, func_core, func_post):
_benchmark = {}
s = sess.Session(default=True)
sut.lout('session was set up\n')
# check if a config file was specified via '-c' command line option, and
# read it, return the dict
config_name = None
for i, arg in enumerate(sys.argv[1:]):
if arg == '-c' and len(sys.argv) > i + 2:
config_name = sys.argv[i + 2]
if not config_name:
benchmark_eval(_benchmark, 'no configuration specified (-c <conf>')
tc = sutc.TestConfig()
tc.read_config(config_name)
test_cfg = tc.get_test_config()
bench_cfg = tc.get_benchmark_config()
session = tc.session
# SAGA_BENCHMARK_ environments will overwrite config settings
if 'SAGA_BENCHMARK_CONCURRENCY' in os.environ:
bench_cfg['concurrency'] = os.environ['SAGA_BENCHMARK_CONCURRENCY']
if 'SAGA_BENCHMARK_ITERATIONS' in os.environ:
bench_cfg['iterations'] = os.environ['SAGA_BENCHMARK_ITERATIONS']
if 'SAGA_BENCHMARK_LOAD' in os.environ:
bench_cfg['load'] = os.environ['SAGA_BENCHMARK_LOAD']
# check benchmark settings for completeness, set some defaults
if not 'concurrency' in bench_cfg:
benchmark_eval(_benchmark, 'no concurrency configured')
if not 'iterations' in bench_cfg:
benchmark_eval(_benchmark, 'no iterations configured')
if not 'url' in bench_cfg:
if 'job_service_url' in test_cfg:
bench_cfg['url'] = test_cfg['job_service_url']
elif 'filesystem_url' in test_cfg:
bench_cfg['url'] = test_cfg['filesystem_url']
else:
bench_cfg['url'] = 'n/a'
_benchmark['url'] = bench_cfg['url']
_benchmark['session'] = session
_benchmark['test_cfg'] = test_cfg
_benchmark['bench_cfg'] = bench_cfg
_benchmark['bench_cfg']['pre'] = func_pre
_benchmark['bench_cfg']['core'] = func_core
_benchmark['bench_cfg']['post'] = func_post
_benchmark['bench_cfg']['name'] = name
_benchmark['bench_cfg']['cname'] = config_name
benchmark_run(_benchmark)
benchmark_eval(_benchmark)
def __init__ (self, id=None, session=None,
_adaptor=None, _adaptor_state={}, _ttype=None) :
"""
__init__(id=None, session=None)
Create / reconnect to a resource.
:param id: id of the resource
:type id: :class:`saga.Url`
:param session: :class:`saga.Session`
Resource class instances are usually created by calling :func:`acquire`
on the :class:`saga.resource.Manager` class. Already acquired resources
are identified by a string typed identifier. This constructor accepts
such an identifier to create another representation of the same
resource. As the resource itself is new newly acquired, it can be in
any state. In particular, it can be in a final state, and thus be
unusable. Further, the resource may already have expired or failed, and
the information about it may have been purged -- in that case the id
will not be valid any longer, and a :class:`saga.BadParameter` exception
will be raised.
The session parameter is interpreted exactly as the session parameter on
the :class:`saga.resource.Manager` constructor.
"""
# set attribute interface properties
import saga.attributes as sa
self._attributes_extensible (False)
self._attributes_camelcasing (True)
# register properties with the attribute interface
self._attributes_register (const.ID , None, sa.ENUM, sa.SCALAR, sa.READONLY)
self._attributes_register (const.RTYPE , None, sa.ENUM, sa.SCALAR, sa.READONLY)
self._attributes_register (const.STATE , None, sa.ENUM, sa.SCALAR, sa.READONLY)
self._attributes_register (const.STATE_DETAIL, None, sa.STRING, sa.SCALAR, sa.READONLY)
self._attributes_register (const.ACCESS , None, sa.URL, sa.SCALAR, sa.READONLY)
self._attributes_register (const.MANAGER , None, sa.URL, sa.SCALAR, sa.READONLY)
self._attributes_register (const.DESCRIPTION , None, sa.ANY, sa.SCALAR, sa.READONLY)
self._attributes_set_enums (const.STATE, [const.UNKNOWN ,
const.PENDING ,
const.ACTIVE ,
const.CANCELED,
const.EXPIRED ,
const.FAILED ,
const.FINAL ])
self._attributes_set_enums (const.RTYPE, [const.COMPUTE ,
const.STORAGE ,
const.NETWORK ])
self._attributes_set_getter (const.ID , self.get_id )
self._attributes_set_getter (const.RTYPE , self.get_rtype )
self._attributes_set_getter (const.STATE , self.get_state )
self._attributes_set_getter (const.STATE_DETAIL, self.get_state_detail)
self._attributes_set_getter (const.ACCESS , self.get_access )
self._attributes_set_getter (const.MANAGER , self.get_manager )
self._attributes_set_getter (const.DESCRIPTION , self.get_description )
# FIXME: we need the ID to be or to include an URL, as we don't have
# a scheme otherwise, which means we can't select an adaptor. Duh! :-/
# FIXME: documentation for attributes is missing.
# param checks
scheme = None
if not id :
if not 'resource_schema' in _adaptor_state :
raise se.BadParameter ("Cannot initialize resource without id" \
% self.rtype)
else :
scheme = _adaptor_state['resource_schema']
else :
url = surl.Url (id)
scheme = url.scheme.lower ()
if not session :
session = ss.Session (default=True)
self._base = super (Resource, self)
self._base.__init__ (scheme, _adaptor, _adaptor_state,
id, session, ttype=_ttype)
