def __init__(self, platformburl=None, platformbresourceserverclientid=None,
platformbresourceserversecret=None,
platformbcorrugateclientcolonsecret=None,
platformbcorrugateclient=None,
platformbhypervisorid=None,
platformbcorrugatesecret=None):
"""
:param platformburl: apiurl.
:param platformbresourceserverclientid: resourceserverclientid.
:param platformbresourceserversecret: resourceserversecret.
:param platformbcorrugateclientcolonsecret: corrugateclientcolonsecret.
:param platformbcorrugateclient: corrugateclient.
:param platformbhypervisorid: hypervisorid.
:param platformbcorrugatesecret: corrugatesecret.
"""
try:
self.url_base = platformburl
self.resource_server_clientid = platformbresourceserverclientid
self.resource_server_secret = platformbresourceserversecret
self.corrugate_client = platformbcorrugateclient
self.corrugate_secret = platformbcorrugatesecret
self.hypervisor_id = platformbhypervisorid
if not platformburl:
self.url_base = '{}'.format(get_config(KEY_PLATFORMB, "platformburl"))
self.servicea_url = 'https://kratos.{}'.format(self.url_base)
if not platformbresourceserverclientid:
rsc = get_config(KEY_PLATFORMB, "platformbresourceserverclientid")
self.resource_server_clientid = '{}'.format(rsc)
if not platformbresourceserversecret:
rss = get_config(KEY_PLATFORMB, "platformbresourceserversecret")
self.resource_server_secret = '{}'.format(rss)
# resource_server_colon_secret_b64 as rscs
rscs = Utils.get_b64_colon_secret(self.resource_server_clientid,
self.resource_server_secret)
self.resource_server_colon_secret_b64 = rscs
if not platformbcorrugateclient:
self.corrugate_client = '{}'.format(get_config(KEY_PLATFORMB, "platformbcorrugateclient"))
if not platformbcorrugatesecret:
self.corrugate_secret = '{}'.format(get_config(KEY_PLATFORMB, "platformbcorrugatesecret"))
# corrugate_colon_secret_b64 as ccs.
ccs = Utils.get_b64_colon_secret(self.corrugate_client,
self.corrugate_secret)
self.corrugate_colon_secret_b64 = ccs
if not platformbhypervisorid:
self.hypervisor_id = '{}'.format(get_config(KEY_PLATFORMB, "platformbhypervisorid"))
except KeyError as e:
message = 'Required variable {} missing'.format(e)
logger.critical(message)
raise KeyError(message)
def test_make_post_request(self, request_mock):
response_instance = MagicMock()
response_instance.status_code = 200
request_mock.post.return_value = response_instance
result = Utils.make_post_request("example.com", json_data={"name": "xyz"})
self.assertEqual(result.status_code, 200)
def test_make_get_request(self, request_mock):
response_instance = MagicMock()
response_instance.status_code = 200
request_mock.get.return_value = response_instance
result = Utils.make_get_request("example.com")
self.assertEqual(result.status_code, 200)
def authenticate(self, **kwargs):
"""
Authenticate against PlatformA.
Returns:
integer: Status code
"""
try:
response = Utils.post_JSON(self.url("auth"),
headers={},
payload={
"username": self.login,
"password": self.password
},
doing="Authenticating on Platforma")
self.XTM_TOKEN = response.json().get('Token', None)
user_info = response.json().get('User', None)
if user_info:
self.tenant_id = user_info.get('TenantID', None)
self.request_header["Authorization"] = 'Bearer %s' % self.XTM_TOKEN
return response.status_code
except Exception as e:
message = "Some unknown exception occurs - {}".format(e)
logging.debug(message)
return status.HTTP_417_EXPECTATION_FAILED
def get_task_status(self, **kwargs):
"""
Gets the request status using TaskInfo API
Args:
message_id (string): Request message id for the task.
Returns:
string: Returns status "Success" or "Failure"
"""
if kwargs is None or kwargs['parameters'] is None:
message = "For 'get_task_status' method parameters are not parsed."
logger.critical(message)
raise ValueError(message)
if "message_id" not in kwargs['parameters']:
message = "Key 'message_id' not in kwargs."
logger.critical(message)
raise ValueError(message)
message_id = kwargs['parameters']['message_id']
return_data = {"state": "Error"}
auth = self.authenticate()
if auth == 200:
task_completed = False
state_message = "Queued"
while not task_completed:
sleep(WAIT_TIME_BETWEEN_REQUESTS)
response = Utils.make_get_request(self.url("TaskInfo" + "/" +
str(message_id)),
headers=self.request_header,
verify=False)
if 'StateMessage' in response.json():
state_message = response.json()['StateMessage']
if state_message == "Success" or state_message == "Error":
task_completed = True
return_data["state"] = state_message
if state_message == "Success":
return_data["vm_id"] = response.json()['Result']
else:
message = "unable to authenticate to the PlatformA server," \
" got the below response from server {}".format(auth)
logging.debug(message)
raise Exception(message)
return return_data
def test_get_b64_colon_secret(self, b64):
b64.b64encode.return_value = "encoded"
result = Utils.get_b64_colon_secret("1", "we")
self.assertEqual(result, "encoded")
def test_post_form(self, make_post_request_mock):
response_instance = MagicMock()
response_instance.status_code = 200
make_post_request_mock.return_value = response_instance
result = Utils.post_form("example.com", {"name": "xyz"}, {"name": "abc"}, "task")
self.assertEqual(result.status_code, 200)
def test_result_redirect(self):
result = Utils.result_redirect(300)
self.assertEqual(result, True)
result = Utils.result_redirect(401)
self.assertEqual(result, False)
def test_result_success(self):
result = Utils.result_success(201)
self.assertEqual(result, True)
result = Utils.result_success(401)
self.assertEqual(result, False)