def acquire (self, spec, ttype=None) :
"""
acquire(desc)
Create a new :class:`saga.resource.Resource` handle for a
resource specified by the description.
:type spec: :class:`Description`
:param spec: specifies the resource
Depending on the `RTYPE` attribute in the description, the
returned resource may be a :class:`saga.resource.Compute`,
:class:`saga.resource.Storage` or :class:`saga.resource.Network`
instance. The returned resource will be in NEW, PENDING or ACTIVE
state.
"""
if isinstance (spec, surl.Url) or \
isinstance (spec, basestring) :
id = surl.Url (spec)
return self._adaptor.acquire_by_id (id, ttype=ttype)
else :
# make sure at least 'executable' is defined
if spec.rtype is None:
raise se.BadParameter ("No resource type defined in resource description")
spec_copy = descr.Description ()
spec._attributes_deep_copy (spec_copy)
return self._adaptor.acquire (spec_copy, ttype=ttype)
def run_job (self, cmd, host=None, ttype=None) :
"""
run_job(cmd, host=None)
"""
if not self.valid :
raise se.IncorrectState ("This instance was already closed.")
if not cmd:
raise se.BadParameter('run_job needs a command to run. Duh!')
try:
# lets see if the adaptor implements run_job
return self._adaptor.run_job (cmd, host, ttype=ttype)
except:
# fall back to the default implementation below
pass
# The adaptor has no run_job -- we here provide a generic implementation
# FIXME: split should be more clever and respect POSIX shell syntax.
args = cmd.split()
jd = descr.Description()
jd.executable = args[0]
jd.arguments = args[1:]
job = self.create_job(jd)
job.run()
return job
def cognitive_description_proc(bot, update):
user = update.message.from_user
photo_file = bot.get_file(update.message.photo[-1].file_id)
photo_file.download("test_photo.jpg")
#logger.info("Photo of %s: %s" % (user.first_name, 'test_photo.jpg'))
output = description.Description('test_photo.jpg')
update.message.reply_text(output)
return ConversationHandler.END
def test_search(self, paras, expected):
st = setup.Setup()
lg = login.Login()
lg.set_driver(st.driver)
driver = lg.login_action('admin', 'admin')
driver.find_element_by_link_text('※ 规格说明 ※').click()
re = description.Description()
re.set_driver(driver)
re.search(paras)
time.sleep(2)
driver.quit()
def test_delete(self, paras, expected):
st = setup.Setup()
lg = login.Login()
lg.set_driver(st.driver)
driver = lg.login_action('admin', 'admin')
driver.find_element_by_link_text('※ 规格说明 ※').click()
re = description.Description()
re.set_driver(driver)
re.dele(paras)
time.sleep(2)
assert_type = expected.split('=')[0]
expected_str = expected.split('=')[1]
# 根据excel中的字段判断调用哪种断言
if assert_type == 'assert_msg':
self.assert_add_msg(driver, expected_str)
driver.quit()
def create_job (self, job_desc, ttype=None) :
"""
create_job(job_desc)
Create a new job.Job instance from a :class:`~saga.job.Description`. The
resulting job instance is in :data:`~saga.job.NEW` state.
:param job_desc: job description to create the job from
:type job_desc: :data:`saga.job.Description`
:param ttype: |param_ttype|
:rtype: :class:`saga.job.Job` or |rtype_ttype|
create_job() accepts a job description, which described the
application instance to be created by the backend. The create_job()
method is not actually attempting to *run* the job, but merely parses
the job description for syntactic and semantic consistency. The job
returned object is thus not in 'Pending' or 'Running', but rather in
'New' state. The actual submission is performed by calling run() on
the job object.
Example::
# A job.Description object describes the executable/application and its requirements
job_desc = saga.job.Description()
job_desc.executable = '/bin/sleep'
job_desc.arguments = ['10']
job_desc.output = 'myjob.out'
job_desc.error = 'myjob.err'
service = saga.job.Service('local://localhost')
job = service.create_job(job_desc)
# Run the job and wait for it to finish
job.run()
print "Job ID : %s" % (job.job_id)
job.wait()
# Get some info about the job
print "Job State : %s" % (job.state)
print "Exitcode : %s" % (job.exit_code)
service.close()
"""
if not self.valid :
raise se.IncorrectState ("This instance was already closed.")
jd_copy = descr.Description()
job_desc._attributes_deep_copy (jd_copy)
# do some sanity checks: if the adaptor has specified a set of supported
# job description attributes, we scan the given description for any
# mismatches, and complain then.
adaptor_info = self._adaptor._adaptor.get_info ()
if 'capabilities' in adaptor_info and \
'jdes_attributes' in adaptor_info['capabilities'] :
# this is the list of key supported by the adaptor. These
# attributes may be set to non-default values
supported_keys = adaptor_info['capabilities']['jdes_attributes']
# use an empty job description to compare default values
jd_default = descr.Description ()
for key in jd_copy.list_attributes () :
val = jd_copy .get_attribute (key)
default = jd_default.get_attribute (key)
# Also, we make string compares case insensitive
if isinstance (val, basestring) : val = val .lower ()
if isinstance (default, basestring) : default = default.lower ()
# supported keys are also valid, as are keys with default or
# None values
if key not in supported_keys and \
val != default and \
val :
msg = "'JobDescription.%s' (%s) is not supported by adaptor %s" \
% (key, val, adaptor_info['name'])
raise se.BadParameter._log (self._logger, msg)
# make sure at least 'executable' is defined
if jd_copy.executable is None:
raise se.BadParameter("No executable defined")
# convert environment to string
if jd_copy.attribute_exists ('Environment') :
for (key, value) in jd_copy.environment.iteritems():
jd_copy.environment[key] = str(value)
return self._adaptor.create_job (jd_copy, ttype=ttype)
def descriptionButton(self):
self.object = description.Description(self.image, self.path)