def doWork(self):
if self.options.remove_clouds and sys.version_info[0:3] < (2, 7, 0):
print('Error: The use of "--remove-cloud-specific" require Python >= 2.7', file=sys.stderr)
sys.exit(1)
client = HttpClient()
client.verboseLevel = self.verboseLevel
queue = [self.module]
while len(queue) > 0:
module = queue.pop(0)
print('Processing: %s' % module)
try:
root = self._retrieveModuleAsXml(client, module)
self._remove_transient_elements(root)
if self._is_image(root) and self.options.dump_image_ids:
self._dump_image_ids(root)
if self.options.remove_clouds:
self._remove_clouds(root)
if self.options.remove_group_members:
self._remove_group_members(root)
if self.options.reset_commit_message:
self._reset_commit_message(root)
self._writeModuleAsXml(root, module)
for child in self._getModuleChildren(module, root):
queue.append(child)
except Exception as e:
print(e)
if not self.options.continue_on_error:
sys.exit(1)
def _get_monitoring_status():
"Returns monitoring status as JSON."
nagios_user, nagios_pass = ss_get('nagios_creds').split(':')
h = HttpClient(username=nagios_user, password=nagios_pass)
_, res = h.get(NAGIOS_STATUS_URL, accept="application/json")
return json.loads(res)
def doWork(self):
client = HttpClient()
client.verboseLevel = self.verboseLevel
# read all files once to determine the upload URL for each file
# the URL is used to sort the files into an order that puts
# parents before children
projects = {}
images = {}
deployments = {}
for file in self.args:
self._check_file(file)
with open(file) as f:
contents = f.read()
dom = self._read_module_as_xml(contents)
attrs = SlipStreamHttpClient.DomExtractor.get_attributes(dom)
root_node_name = dom.tag
if root_node_name == 'list':
sys.stderr.write('Cannot update root project\n')
sys.exit(-1)
if not dom.tag in ('imageModule', 'projectModule',
'deploymentModule'):
sys.stderr.write('Invalid xml\n')
sys.exit(-1)
parts = [attrs['parentUri'], attrs['shortName']]
uri = '/' + '/'.join([part.strip('/') for part in parts])
url = self.options.endpoint + uri
if dom.tag == 'projectModule':
projects[url] = file
elif dom.tag == 'imageModule':
images[url] = file
elif dom.tag == 'deploymentModule':
deployments[url] = file
# now actually do the uploads in the correct order
# projects must be done first to get the structure, then
# images, and finally the deployments
for url in sorted(projects):
file = projects[url]
print('Uploading project: %s' % file)
self._put(url, file, client)
for url in sorted(images):
file = images[url]
print('Uploading image: %s' % file)
self._put(url, file, client)
for url in sorted(deployments):
file = deployments[url]
print('Uploading deployment: %s' % file)
self._put(url, file, client)
def doWork(self):
client = HttpClient(self.options.username, self.options.password)
client.verboseLevel = self.verboseLevel
# get all users
if self.options.getusers:
self.get_users(client)
elif self.options.putusers:
self.put_users(client)
def doWork(self):
client = HttpClient(self.options.username, self.options.password)
client.verboseLevel = self.verboseLevel
# get all users
if self.options.getusers:
self.get_users(client)
elif self.options.putusers:
self.put_users(client)
def doWork(self):
client = HttpClient()
client.verboseLevel = self.verboseLevel
uri = util.MODULE_RESOURCE_PATH
if self.module:
uri += '/' + self.module
url = self.options.endpoint + uri
client.delete(url)
def doWork(self):
client = HttpClient(self.options.username, self.options.password)
client.verboseLevel = self.verboseLevel
uri = util.MODULE_URL_PATH
if self.module:
uri += '/' + self.module
url = self.options.endpoint + uri
client.delete(url)
def doWork(self):
client = HttpClient()
client.verboseLevel = self.verboseLevel
uri = util.MODULE_RESOURCE_PATH
if self.module:
uri += '/' + self.module
url = self.options.endpoint + uri
_, content = client.get(url)
print(content)
def doWork(self):
client = HttpClient()
client.verboseLevel = self.verboseLevel
uri = util.USER_RESOURCE_PATH
if self.user:
uri += '/' + self.user
url = self.options.endpoint + uri
_, content = client.get(url)
print(content)
def doWork(self):
client = HttpClient(self.options.username, self.options.password)
client.verboseLevel = self.verboseLevel
uri = util.RUN_URL_PATH
if self.run:
uri += '/' + self.run
url = self.options.endpoint + uri
_, content = client.get(url)
print(content)
def doWork(self):
client = HttpClient()
client.verboseLevel = self.verboseLevel
self._retrieve_and_set_run(client)
self._check_allowed_to_scale(client)
self._set_scale_rtps(client)
self._set_scale_state(client)
self._set_run_provisioning(client)
def doWork(self):
client = HttpClient()
client.verboseLevel = self.verboseLevel
self._retrieve_and_set_run(client)
self._check_allowed_to_scale(client)
self._set_scale_rtps(client)
self._set_scale_state(client)
self._set_run_provisioning(client)
def test_unknown_http_return_code(self):
client = HttpClient()
client.verboseLevel = 0
client.session = Mock()
client.session.cookies = []
resp = Mock(spec_set=requests.Response())
resp.request = Mock()
resp.request.headers = {}
resp.status_code = 999
client.session.request = Mock(return_value=resp)
self.assertRaises(NetworkError, client.get, 'http://foo.bar',
retry=False)
def doWork(self):
client = HttpClient()
client.verboseLevel = self.verboseLevel
uri = util.RUN_RESOURCE_PATH + "/" + self.runId + "/" + self.nodeName
url = self.options.endpoint + uri
instances = str(self.instancesToRemove)[1:-1]
self.log("Removing node instances: %s..." % instances)
print(instances)
client.delete(url, "ids=" + instances)
def test_init_session_login_apikey(self):
ch = ConfigHolder()
ch.context = {}
ch.set('verboseLevel', 0)
ch.set('cookie_filename', '/dev/null')
ch.set('api_key', 'key')
ch.set('api_secret', 'secret')
client = HttpClient(ch)
client.init_session('http://foo.bar')
assert client.session is not None
assert client.session.login_params
assert 'key' in client.session.login_params
assert 'secret' in client.session.login_params
def testGetSetsCookie(self):
httpRequestMock = Mock(return_value=(httplib2.Response({'set-cookie': 'acookie'}), ''))
httpObjectMock = Mock()
httpObjectMock.request = httpRequestMock
mock = Mock(return_value=httpObjectMock)
HttpClient._getHttpObject = mock
client = HttpClient('username', 'password')
client.get('http://localhost:9999/url')
self.assertEqual('acookie', client.cookie)
def doWork(self):
client = HttpClient()
client.verboseLevel = self.verboseLevel
baseUri = util.RUN_RESOURCE_PATH + "/" + self.runId
nodeUri = baseUri + "/" + self.nodeName
url = self.options.endpoint + nodeUri
self.log("Adding %s node instance(s) to node type %s..." %
(self.numberToAdd, self.nodeName))
_, content = client.post(url, "n=" + str(self.numberToAdd))
addedIds = NodeInstanceRuntimeParameter.parse_added_node_instances(
content)
url = self.options.endpoint + baseUri + '/'
if self.numberToTolerate > 0:
self.log("Setting max-provisioning-failures to %s on node %s..." %
(self.numberToTolerate, self.nodeName))
runtime_param = self.nodeName + NodeDecorator.NODE_PROPERTY_SEPARATOR + \
NodeDecorator.MAX_PROVISIONING_FAILURES_KEY
client.put(url + runtime_param, str(self.numberToTolerate))
if self.runtimeParameters:
for rp in self.runtimeParameters:
name, values = NodeInstanceRuntimeParameter.parse_option_value(
rp)
mapped = NodeInstanceRuntimeParameter.generate_mapping_index_name_value(
self.nodeName, name, values, addedIds)
for k in mapped:
print(k, mapped[k])
client.put(url + k, mapped[k])
def testUnknownHttpReturnCode(self):
httpRequestMock = Mock(return_value=(httplib2.Response({'status': '999'}), ''))
httpObjectMock = Mock()
httpObjectMock.request = httpRequestMock
mock = Mock(return_value=httpObjectMock)
HttpClient._getHttpObject = mock
client = HttpClient('username', 'password')
client.cookie = 'acookie'
self.assertRaises(NetworkError, client.get, 'url')
def test_init_session_login_internal(self):
ch = ConfigHolder()
ch.context = {}
ch.set('verboseLevel', 0)
ch.set('cookie_filename', '/dev/null')
ch.set('username', 'foo')
ch.set('password', 'bar')
client = HttpClient(ch)
client.init_session('http://foo.bar')
assert client.session is not None
assert client.session.login_params
assert 'username' in client.session.login_params
assert 'password' in client.session.login_params
def test_init_session_login_apikey(self):
ch = ConfigHolder()
ch.context = {}
ch.set('verboseLevel', 0)
ch.set('cookie_filename', '/dev/null')
ch.set('api_key', 'key')
ch.set('api_secret', 'secret')
client = HttpClient(ch)
client.init_session('http://foo.bar')
assert client.session is not None
assert client.session.login_params
assert 'key' in client.session.login_params
assert 'secret' in client.session.login_params
def test_init_session_login_internal(self):
ch = ConfigHolder()
ch.context = {}
ch.set('verboseLevel', 0)
ch.set('cookie_filename', '/dev/null')
ch.set('username', 'foo')
ch.set('password', 'bar')
client = HttpClient(ch)
client.init_session('http://foo.bar')
assert client.session is not None
assert client.session.login_params
assert 'username' in client.session.login_params
assert 'password' in client.session.login_params
def test_unknown_http_return_code(self):
client = HttpClient()
client.verboseLevel = 0
client.session = Mock()
client.session.cookies = []
resp = Mock(spec_set=requests.Response())
resp.request = Mock()
resp.request.headers = {}
resp.status_code = 999
client.session.request = Mock(return_value=resp)
self.assertRaises(NetworkError,
client.get,
'http://foo.bar',
retry=False)
def __init__(self, configHolder):
self.category = None
self.run_dom = None
self.ignoreAbort = False
self.username = ''
self.password = ''
self.diid = ''
self.node_instance_name = ''
self.serviceurl = ''
self.verboseLevel = None
self.retry = True
configHolder.assign(self)
self._assemble_endpoints()
self.httpClient = HttpClient(configHolder=configHolder)
self.httpClient.init_session(self.serviceurl)
self.api = self.httpClient.get_ss_api()
def doWork(self):
client = HttpClient()
client.verboseLevel = self.verboseLevel
baseUri = util.RUN_RESOURCE_PATH + "/" + self.runId
nodeUri = baseUri + "/" + self.nodeName
url = self.options.endpoint + nodeUri
self.log("Adding %s node instance(s) to node type %s..." % (self.numberToAdd, self.nodeName))
_, content = client.post(url, "n=" + str(self.numberToAdd))
addedIds = NodeInstanceRuntimeParameter.parse_added_node_instances(content)
url = self.options.endpoint + baseUri + '/'
if self.numberToTolerate > 0:
self.log("Setting max-provisioning-failures to %s on node %s..." %
(self.numberToTolerate, self.nodeName))
runtime_param = self.nodeName + NodeDecorator.NODE_PROPERTY_SEPARATOR + \
NodeDecorator.MAX_PROVISIONING_FAILURES_KEY
client.put(url + runtime_param, str(self.numberToTolerate))
if self.runtimeParameters:
for rp in self.runtimeParameters:
name, values = NodeInstanceRuntimeParameter.parse_option_value(rp)
mapped = NodeInstanceRuntimeParameter.generate_mapping_index_name_value(self.nodeName, name, values, addedIds)
for k in mapped:
print(k, mapped[k])
client.put(url + k, mapped[k])
def doWork(self):
client = HttpClient()
client.verboseLevel = self.verboseLevel
dom = self.read_xml_and_exit_on_error(self.user)
if not dom.tag in ('user'):
sys.stderr.write('Invalid xml\n')
sys.exit(-1)
dom = self.read_xml_and_exit_on_error(self.user)
attrs = SlipStreamHttpClient.DomExtractor.get_attributes(dom)
user = attrs['name']
uri = util.USER_RESOURCE_PATH + '/' + user
url = self.options.endpoint + uri
client.put(url, self.user)
def testGetWithUsernamePassword(self):
httpRequestMock = Mock(return_value=(httplib2.Response({}), ''))
httpObjectMock = Mock()
httpObjectMock.request = httpRequestMock
mock = Mock(return_value=httpObjectMock)
HttpClient._getHttpObject = mock
client = HttpClient('username', 'password')
client.get('url')
args, kwargs = httpRequestMock.call_args
self.assertEqual(('url', 'GET', None), args)
self.assertTrue(kwargs['headers']['Authorization'].startswith('Basic '))
def doWork(self):
client = HttpClient(self.options.username, self.options.password)
client.verboseLevel = self.verboseLevel
dom = self.read_xml_and_exit_on_error(self.user)
if not dom.tag in ('user'):
sys.stderr.write('Invalid xml\n')
sys.exit(-1)
dom = self.read_xml_and_exit_on_error(self.user)
attrs = SlipStreamHttpClient.DomExtractor.getAttributes(dom)
user = attrs['name']
uri = util.USER_URL_PATH + '/' + user
url = self.options.endpoint + uri
client.put(url, self.user)
def testGetWithCookie(self):
httpRequestMock = Mock(return_value=(httplib2.Response({}), ''))
httpObjectMock = Mock()
httpObjectMock.request = httpRequestMock
mock = Mock(return_value=httpObjectMock)
HttpClient._getHttpObject = mock
client = HttpClient()
client.cookie = 'acookie'
client.get('url')
_, kwargs = httpRequestMock.call_args
headers = kwargs['headers']
self.assertEqual(headers['cookie'], 'acookie')
def test_post_with_data(self):
ch = ConfigHolder()
ch.context = {}
ch.set('verboseLevel', 0)
ch.set('cookie_filename', '/dev/null')
ch.set('api_key', 'key')
ch.set('api_secret', 'secret')
client = HttpClient(ch)
resp = requests.Response()
resp.status_code = 200
resp.get = Mock(return_value=None)
resp.request = Mock()
resp.request.headers = {}
requests.sessions.Session.send = Mock(return_value=resp)
client.post('http://example.com', 'a=b\nc=d')
args, kwargs = requests.sessions.Session.send.call_args
self.assertEqual(len(args), 1)
req = args[0]
self.assertEqual(req.body, 'a=b\nc=d')
def doWork(self):
client = HttpClient()
client.verboseLevel = self.verboseLevel
dom = self.read_xml_and_exit_on_error(self.module)
attrs = SlipStreamHttpClient.DomExtractor.get_attributes(dom)
root_node_name = dom.tag
if root_node_name == 'list':
sys.stderr.write('Cannot update root project\n')
sys.exit(-1)
if not dom.tag in ('imageModule', 'projectModule', 'deploymentModule'):
sys.stderr.write('Invalid xml\n')
sys.exit(-1)
parts = [attrs['parentUri'], attrs['shortName']]
uri = '/' + '/'.join([part.strip('/') for part in parts])
url = self.options.endpoint + uri
client.put(url, self.module)
def doWork(self):
client = HttpClient()
client.verboseLevel = self.verboseLevel
dom = self.read_xml_and_exit_on_error(self.module)
attrs = SlipStreamHttpClient.DomExtractor.get_attributes(dom)
root_node_name = dom.tag
if root_node_name == 'list':
sys.stderr.write('Cannot update root project\n')
sys.exit(-1)
if not dom.tag in ('imageModule', 'projectModule', 'deploymentModule'):
sys.stderr.write('Invalid xml\n')
sys.exit(-1)
parts = [attrs['parentUri'], attrs['shortName']]
uri = '/' + '/'.join([part.strip('/') for part in parts])
url = self.options.endpoint + uri
client.put(url, self.module)
def test_init_session_fail_no_creds(self):
ch = ConfigHolder()
ch.context = {}
ch.set('verboseLevel', 0)
ch.set('cookie_filename', '/dev/null')
client = HttpClient(ch)
client.init_session('http://foo.bar')
assert client.session is not None
assert client.session.login_params == {}
resp = Mock(spec=Response)
resp.status_code = 403
resp.cookies = None
resp.headers = {}
client.session._request = Mock(return_value=resp)
client.session.cimi_login = Mock(return_value=resp)
try:
client.get('http://foo.bar', retry=False)
except Exception as ex:
assert ex.code == 403
assert client.session.cimi_login.called is True
def test_post_with_data(self):
ch = ConfigHolder()
ch.context = {}
ch.set('verboseLevel', 0)
ch.set('cookie_filename', '/dev/null')
ch.set('api_key', 'key')
ch.set('api_secret', 'secret')
client = HttpClient(ch)
resp = requests.Response()
resp.status_code = 200
resp.get = Mock(return_value=None)
resp.request = Mock()
resp.request.headers = {}
requests.sessions.Session.send = Mock(return_value=resp)
client.post('http://example.com', 'a=b\nc=d')
args, kwargs = requests.sessions.Session.send.call_args
self.assertEqual(len(args), 1)
req = args[0]
self.assertEqual(req.body, 'a=b\nc=d')
def doWork(self):
if self.options.remove_clouds and sys.version_info[0:3] < (2, 7, 0):
print(
'Error: The use of "--remove-cloud-specific" require Python >= 2.7',
file=sys.stderr)
sys.exit(1)
client = HttpClient()
client.verboseLevel = self.verboseLevel
queue = [self.module]
while len(queue) > 0:
module = queue.pop(0)
print('Processing: %s' % module)
try:
root = self._retrieveModuleAsXml(client, module)
self._remove_transient_elements(root)
if self._is_image(root) and self.options.dump_image_ids:
self._dump_image_ids(root)
if self.options.remove_clouds:
self._remove_clouds(root)
if self.options.remove_group_members:
self._remove_group_members(root)
if self.options.reset_commit_message:
self._reset_commit_message(root)
self._writeModuleAsXml(root, module)
for child in self._getModuleChildren(module, root):
queue.append(child)
except Exception as e:
print(e)
if not self.options.continue_on_error:
sys.exit(1)
def test_init_session_fail_no_creds(self):
ch = ConfigHolder()
ch.context = {}
ch.set('verboseLevel', 0)
ch.set('cookie_filename', '/dev/null')
client = HttpClient(ch)
client.init_session('http://foo.bar')
assert client.session is not None
assert client.session.login_params == {}
resp = Mock(spec=Response)
resp.status_code = 403
resp.cookies = None
resp.headers = {}
client.session._request = Mock(return_value=resp)
client.session.cimi_login = Mock(return_value=resp)
try:
client.get('http://foo.bar', retry=False)
except Exception as ex:
assert ex.code == 403
assert client.session.cimi_login.called is True
def testCookieHeaderSet(self):
client = HttpClient(cookie='acookie')
headers = client._createAuthenticationHeader()
self.assertEqual('acookie', headers['cookie'])
class SlipStreamHttpClient(object):
URL_IGNORE_ABORT_ATTRIBUTE_QUERY = '?ignoreabort=true'
def __init__(self, configHolder):
self.category = None
self.run_dom = None
self.ignoreAbort = False
self.username = ''
self.password = ''
self.diid = ''
self.node_instance_name = ''
self.serviceurl = ''
self.verboseLevel = None
self.retry = True
configHolder.assign(self)
self._assemble_endpoints()
self.httpClient = HttpClient(configHolder=configHolder)
self.httpClient.init_session(self.serviceurl)
self.api = self.httpClient.get_ss_api()
def set_retry(self, retry):
self.retry = retry
def _assemble_endpoints(self):
self.runEndpoint = self.serviceurl + util.RUN_RESOURCE_PATH
self.run_url = self.runEndpoint + '/' + self.diid
self.userEndpoint = '%s/user/%s' % (self.serviceurl,
self.username)
self.configuration_endpoint = '%s%s' % (self.serviceurl,
util.CONFIGURATION_RESOURCE_PATH)
@staticmethod
def _strip_unwanted_attrs(resource):
unwanted = ('id', 'resourceURI', 'acl', 'operations',
'created', 'updated', 'name', 'description', 'properties')
for k in resource.keys():
if k in unwanted:
del resource[k]
return resource
def _get_user(self):
_, jresp = self.httpClient.get(self.serviceurl + '/api/user/%s' % self.username,
accept='application/json')
return self._strip_unwanted_attrs(json.loads(jresp))
def _get_user_params(self):
_, jresp = self.httpClient.get(self.serviceurl + '/api/user-param',
accept='application/json')
user_params = json.loads(jresp)
if user_params.get('count', 0) < 1:
raise Exception('No user params found for %s.' % self.username)
return self._strip_unwanted_attrs(user_params.get('userParam')[0])
def _get_cloud_cred(self, cloud_qualifier):
creds = self._get_cloud_creds(cloud_qualifier)
cred = self._strip_unwanted_attrs(creds.get('credentials')[0])
cred[UserInfo.CLOUD_USERNAME_KEY] = cred.get('key', '')
cred[UserInfo.CLOUD_PASSWORD_KEY] = cred.get('secret', '')
return cred
def _get_cloud_creds(self, cloud_qualifier):
_filter = "$filter=type^='cloud-cred' and connector/href='connector/%s'" % \
cloud_qualifier
_, jresp = self.httpClient.put(self.serviceurl + '/api/credential?%s' % _filter,
accept='application/json')
creds = json.loads(jresp)
if creds.get('count', 0) < 1:
raise Exception('No cloud creds found for %s with %s.' % (self.username, _filter))
return creds
def _get_connector_conf(self, cloud_qualifier):
_, jresp = self.httpClient.get(self.serviceurl + '/api/connector/%s' % cloud_qualifier,
accept='application/json')
return self._strip_unwanted_attrs(json.loads(jresp))
def get_user_info(self, cloud_qualifier):
user_info = UserInfo(cloud_qualifier)
user = self._get_user()
if 'password' in user:
del user['password']
user_info.set_user_params(user)
user_info.set_general_params(self._get_user_params())
if cloud_qualifier:
connector_conf = self._get_connector_conf(cloud_qualifier)
connector_conf.update(self._get_cloud_cred(cloud_qualifier))
user_info.set_cloud_params(connector_conf)
return user_info
def _extractModuleResourceUri(self, run):
rootElement = etree.fromstring(run.encode('utf-8'))
return rootElement.attrib[NodeDecorator.MODULE_RESOURCE_URI]
def get_nodes_instances(self, cloud_service_name=None):
'''Return dict {<node_instance_name>: NodeInstance, }
'''
nodes_instances = {}
self._retrieveAndSetRun()
nodes_instances_runtime_parameters = \
DomExtractor.extract_nodes_instances_runtime_parameters(self.run_dom, cloud_service_name)
nodes_runtime_parameters = DomExtractor.extract_nodes_runtime_parameters(self.run_dom)
for node_instance_name, node_instance_runtime_parameters in nodes_instances_runtime_parameters.items():
node_instance = NodeInstance(node_instance_runtime_parameters)
node_name = node_instance.get_node_name()
if nodes_runtime_parameters:
node_runtime_parameters = nodes_runtime_parameters.get(node_name, {})
if node_runtime_parameters:
node_instance.set_parameter(NodeDecorator.MAX_PROVISIONING_FAILURES_KEY,
node_runtime_parameters.get(NodeDecorator.MAX_PROVISIONING_FAILURES_KEY, '0'))
image_attributes = DomExtractor.extract_node_image_attributes(self.run_dom, node_name)
node_instance.set_image_attributes(image_attributes)
image_targets = DomExtractor.extract_node_image_targets(self.run_dom, node_name)
node_instance.set_image_targets(image_targets)
build_state = DomExtractor.extract_node_image_build_state(self.run_dom, node_name)
node_instance.set_build_state(build_state)
nodes_instances[node_instance_name] = node_instance
return nodes_instances
def _get_nodename(self):
'Node name derived from the node instance name.'
return self.node_instance_name.split(
NodeDecorator.NODE_MULTIPLICITY_SEPARATOR)[0]
def get_run_category(self):
self._retrieveAndSetRun()
return DomExtractor.extractCategoryFromRun(self.run_dom)
def get_run_type(self):
self._retrieveAndSetRun()
return DomExtractor.extractTypeFromRun(self.run_dom)
def get_run_mutable(self):
self._retrieveAndSetRun()
return DomExtractor.extract_mutable_from_run(self.run_dom)
def discard_run(self):
self.run_dom = None
def _retrieveAndSetRun(self):
if self.run_dom is None:
url = self.run_url
_, run = self._retrieve(url)
self.run_dom = etree.fromstring(run.encode('utf-8'))
def _retrieve(self, url):
return self._httpGet(url, 'application/xml')
def execute(self, resourceUri):
url = self.runEndpoint
return self._httpPost(url, resourceUri, 'text/plain')
def complete_state(self, node_instance_name):
url = '%s/%s:%s' % (self.run_url, node_instance_name,
NodeDecorator.COMPLETE_KEY)
url += SlipStreamHttpClient.URL_IGNORE_ABORT_ATTRIBUTE_QUERY
return self._httpPost(url, 'reset', 'text/plain')
def terminate_run(self):
return self._httpDelete(self.run_url)
def _fail(self, message):
self.setRuntimeParameter(
NodeDecorator.globalNamespacePrefix + NodeDecorator.ABORT_KEY, message)
def sendReport(self, report):
resource_id = self._create_external_object_report(report)
upload_url = self._generate_upload_url_external_object_report(resource_id)
self._upload_report(upload_url, report)
self._set_report_ready(resource_id)
def _create_external_object_report(self, report_path):
resp = self.api.cimi_add('externalObjects',
{'externalObjectTemplate': {'href': 'external-object-template/report',
'runUUID': self.diid,
'component': self.node_instance_name,
'filename': os.path.basename(report_path),
'contentType': 'application/tar+gzip'}})
return resp.json['resource-id']
def _generate_upload_url_external_object_report(self, resource_id):
resp = self.api.cimi_operation(resource_id, "http://sixsq.com/slipstream/1/action/upload")
return resp.json['uri']
def _upload_report(self, url, report):
self._printDetail('Uploading report to: %s' % url)
body = open(report, 'rb').read()
self._httpPut(url, body, 'application/tar+gzip', accept="*/*")
def _set_report_ready(self, resource_id):
self.api.cimi_operation(resource_id, "http://sixsq.com/slipstream/1/action/ready")
def isAbort(self):
return self.getGlobalAbortMessage() != ''
def getGlobalAbortMessage(self):
url = '%s/%s%s' % (self.run_url,
NodeDecorator.globalNamespacePrefix,
NodeDecorator.ABORT_KEY)
url += SlipStreamHttpClient.URL_IGNORE_ABORT_ATTRIBUTE_QUERY
_, content = self._httpGet(url, accept='text/plain')
return content.strip().strip('"').strip("'")
def get_run_parameters(self):
self._retrieveAndSetRun()
return DomExtractor.extract_run_parameters_from_run(self.run_dom)
def getRuntimeParameter(self, key, ignoreAbort=False):
url = self.run_url + '/' + key
if self.ignoreAbort or ignoreAbort:
url += SlipStreamHttpClient.URL_IGNORE_ABORT_ATTRIBUTE_QUERY
try:
_, content = self._httpGet(url, accept='text/plain')
except Exceptions.NotFoundError as ex:
raise Exceptions.NotFoundError('"%s" for %s' % (str(ex), key))
return content.strip().strip('"').strip("'")
def setRuntimeParameter(self, key, value, ignoreAbort=False):
url = self.run_url + '/' + key
if self.ignoreAbort or ignoreAbort:
url += SlipStreamHttpClient.URL_IGNORE_ABORT_ATTRIBUTE_QUERY
_, content = self._httpPut(url, util.removeASCIIEscape(value),
accept='text/plain')
return content.strip().strip('"').strip("'")
def unset_runtime_parameter(self, key, ignore_abort=False):
url = '%s/%s' % (self.run_url, key)
if (self.ignoreAbort or ignore_abort):
url += SlipStreamHttpClient.URL_IGNORE_ABORT_ATTRIBUTE_QUERY
self._httpDelete(url)
def _httpGet(self, url, accept='application/xml'):
return self.httpClient.get(url, accept, retry=self.retry)
def _httpPut(self, url, body=None, contentType='application/xml', accept='application/xml'):
return self.httpClient.put(url, body, contentType, accept, retry=self.retry)
def _httpPost(self, url, body=None, contentType='application/xml'):
return self.httpClient.post(url, body, contentType, retry=self.retry)
def _httpDelete(self, url, body=None):
return self.httpClient.delete(url, body=body, retry=self.retry)
def _printDetail(self, message):
util.printDetail(message, self.verboseLevel, util.VERBOSE_LEVEL_DETAILED)
def put_new_image_id(self, image_resource_uri, image_id):
url = self.serviceurl + '/' + image_resource_uri
self._printDetail('Set new image id: %s %s' % (url, image_id))
self._httpPut(url, image_id)
def launchDeployment(self, params):
body = '&'.join(params)
resp, _ = self._httpPost(self.runEndpoint, body,
contentType='text/plain')
return resp.headers['location']
def getRunState(self, uuid=None, ignoreAbort=True):
if not uuid and not self.diid:
raise Exceptions.ExecutionException("Run ID should be provided "
"to get state.")
state_key = NodeDecorator.globalNamespacePrefix + NodeDecorator.STATE_KEY
self.run_url = self.runEndpoint + '/' + (uuid or self.diid)
return self.getRuntimeParameter(state_key, ignoreAbort=ignoreAbort)
def remove_instances_from_run(self, node_name, ids, detele_ids_only=True):
"""ids : []
"""
url = '%s/%s' % (self.run_url, node_name)
body = "ids=%s" % ','.join(map(str, ids))
if detele_ids_only:
body = body + '&delete-ids-only=true'
self._httpDelete(url, body=body)
def get_server_configuration(self):
_, config = self._retrieve(self.configuration_endpoint)
return config
def login(self, username, password):
self.api.login_internal(username=username, password=password)
def logout(self):
self.api.logout()
def get_session(self):
return self.httpClient.get_session()
def get_api(self):
return self.api
def testBasicAuthenticationHeaderSet(self):
client = HttpClient('username', 'password')
headers = client._createAuthenticationHeader()
self.assertTrue(headers['Authorization'].startswith('Basic '))