def initialise_session(session):
"""
Initialises a session with the uts server. (Not 100% sure if this is required).
"""
first_url = BASE_URL + 'student'
response = session.get(first_url)
if response.status_code != 200:
request_failed(failed_response=response,
message='Unable to initialise session')
return session
def create_vm(**_):
random_suffix_value = utils.random_suffix_generator()
vm_name = ctx.node.properties[constants.VM_PREFIX]+random_suffix_value
ctx.logger.info("Creating new virtual machine: {0}".format(vm_name))
storage_account_name = ctx.instance.runtime_properties[constants.STORAGE_ACCOUNT_KEY]
headers, location, subscription_id = auth.get_credentials()
resource_group_name = ctx.instance.runtime_properties[constants.RESOURCE_GROUP_KEY]
try:
virtual_machine_params = get_virtual_machine_params(location, random_suffix_value, resource_group_name,
storage_account_name, subscription_id, vm_name)
virtual_machine_url = constants.azure_url+'/subscriptions/'+subscription_id+'/resourceGroups/'+resource_group_name+'/providers/Microsoft.Compute/virtualMachines/'+vm_name+'?validating=true&api-version='+constants.api_version
response_vm = requests.put(url=virtual_machine_url, data=virtual_machine_params, headers=headers)
if response_vm.text:
ctx.logger.info("create_vm:{0} response_vm.text is {1}".format(vm_name, response_vm.text))
if utils.request_failed("{0}:{1}".format('create_vm', vm_name), response_vm):
raise NonRecoverableError("Virtual Machine {0} could not be created".format(vm_name))
elif response_vm:
ctx.logger.info("create_vm:{0} response_vm is {1}".format(vm_name, response_vm))
else:
ctx.logger.info("create_vm:{0} response_vm is empty".format(vm_name))
ctx.instance.runtime_properties[constants.VM_KEY] = vm_name
except:
ctx.logger.info("Virtual Machine {0} could not be created".format(vm_name))
raise NonRecoverableError("Virtual Machine {0} could not be created".format(vm_name))
def login(session, student_number, password):
"""
Logs the user in and returns a login token which is used as a GET parameter for further requests.
"""
initialise_session(session)
data = {'username': student_number, 'password': password}
login_url = BASE_URL + 'rest/student/login'
response = session.post(login_url, data=data)
if response.status_code == 200:
print('Login successful')
return response.json()['token']
else:
request_failed(failed_response=response, message='Login failed.')
def create_resource_group(**_):
resource_group_name = utils.set_resource_name(_get_resource_group_name, 'Resource group',
constants.RESOURCE_GROUP_KEY, constants.EXISTING_RESOURCE_GROUP_KEY,
constants.RESOURCE_GROUP_PREFIX)
if resource_group_name is None:
# Using an existing resource group, so don't create anything
return
headers, location, subscription_id = auth.get_credentials()
resource_group_url = constants.azure_url+'/subscriptions/'+subscription_id+'/resourceGroups/'+resource_group_name+'?api-version='+constants.api_version_resource_group
try:
ctx.logger.info("Creating a new Resource group: {}".format(resource_group_name))
resource_group_params = json.dumps({"name": resource_group_name, "location": location})
response_rg = requests.put(url=resource_group_url, data=resource_group_params, headers=headers)
if response_rg.text:
ctx.logger.info("create_resource_group {0} response_rg.text is {1}".format(resource_group_name, response_rg.text))
if utils.request_failed("{0}:{1}".format('create_resource_group', resource_group_name), response_rg):
raise NonRecoverableError("Resource group {0} could not be created".format(resource_group_name))
ctx.instance.runtime_properties[constants.RESOURCE_GROUP_KEY] = resource_group_name
except:
ctx.logger.info("Resource Group {0} could not be created".format(resource_group_name))
raise NonRecoverableError("Resource Group {0} could not be created".format(resource_group_name))
def register_subject(session, login_token, student_code, class_key):
"""
Registers the user for a specific class.
:param session: authenticated request.Session object
:param login_token: login token
:param student_code: student number
:param class_key: class details in the form "{subject code}|{class type}|{activity code}" e.g.
"31927_SPR_U_1_S|Cmp1|02"
:return:
"""
enrol_subject_url = BASE_URL + 'rest/student/changeActivity/'
params = {'ss': login_token}
class_key_split = class_key.split('|')
subject_code = class_key_split[0]
class_type = class_key_split[1]
class_id = class_key_split[2]
data = {
'token': 'a', # I have no idea why this needs to be sent.
'student_code': student_code,
'subject_code': subject_code,
'activity_group_code': class_type,
'activity_code': class_id
}
response = session.post(enrol_subject_url, params=params, data=data)
if response.status_code == 200:
print('Updated the subject. Successfully registered for: %s.' %
class_key)
print('Sending email notification now.')
send_mail(subject='Updated the subject!',
message_body='Updated the subject!')
sys.exit(0)
else:
request_failed(response, message='Unable to register for subject.')
def _start_vm_call(headers, vm_name, subscription_id, resource_group_name):
ctx.logger.info("In _vm_is_started checking {}".format(vm_name))
start_vm_url = constants.azure_url+'/subscriptions/'+subscription_id+'/resourceGroups/'+resource_group_name+'/providers/Microsoft.Compute/virtualMachines/'+vm_name+'/start?api-version='+constants.api_version
response_start_vm = requests.post(start_vm_url, headers=headers)
if response_start_vm.text:
ctx.logger.info("_start_vm_call {} response_start_vm.text is {}".format(vm_name, response_start_vm.text))
ctx.logger.info("_start_vm_call:{} status code is {}".format(vm_name, response_start_vm.status_code))
if utils.request_failed("{}:{}".format('_start_vm_call', vm_name), response_start_vm):
raise NonRecoverableError("Virtual Machine {} could not be started".format(vm_name))
if response_start_vm.status_code:
ctx.logger.info("_start_vm_call:{} - Status code is {}".format(vm_name, response_start_vm.status_code))
if response_start_vm.status_code == 202:
ctx.instance.runtime_properties[constants.REQUEST_ACCEPTED] = True
return True
elif response_start_vm.status_code == 200:
ctx.instance.runtime_properties[constants.REQUEST_ACCEPTED] = True
return True
else:
return False
raise NonRecoverableError("_start_vm_call:{} - No Status code for vm {}".format(vm_name, response_start_vm.status_code))
def create_security_group(**_):
if constants.USE_EXTERNAL_RESOURCE in ctx.node.properties and ctx.node.properties[constants.USE_EXTERNAL_RESOURCE]:
if constants.EXISTING_SECURITY_GROUP_KEY in ctx.node.properties:
existing_security_group_name = ctx.node.properties[constants.EXISTING_SECURITY_GROUP_KEY]
if existing_security_group_name:
security_group_exists = _get_security_group_name(existing_security_group_name)
if not security_group_exists:
raise NonRecoverableError("Security group {} doesn't exist your Azure account".format(existing_security_group_name))
else:
raise NonRecoverableError("The value of '{}' in the input, is empty".format(constants.EXISTING_SECURITY_GROUP_KEY))
else:
raise NonRecoverableError("'{}' was specified, but '{}' doesn't exist in the input".format('use_external_resource',constants.EXISTING_SECURITY_GROUP_KEY))
ctx.instance.runtime_properties[constants.SECURITY_GROUP_KEY] = ctx.node.properties[constants.EXISTING_SECURITY_GROUP_KEY]
return
headers, location, subscription_id = auth.get_credentials()
resource_group_name = ctx.instance.runtime_properties[constants.RESOURCE_GROUP_KEY]
if constants.SECURITY_GROUP_KEY in ctx.instance.runtime_properties:
security_group_name = ctx.instance.runtime_properties[constants.SECURITY_GROUP_KEY]
else:
random_suffix_value = utils.random_suffix_generator()
security_group_name = constants.SECURITY_GROUP_PREFIX+random_suffix_value
security_group_url = constants.azure_url+'/subscriptions/'+subscription_id+'/resourceGroups/'+resource_group_name+'/providers/microsoft.network/networkSecurityGroups/'+security_group_name+'?api-version='+constants.api_version
try:
ctx.logger.info("Creating a new security group: {0}".format(security_group_name))
security_group_params = json.dumps({
"location": location,
"tags": {
"key": "value"
},
"properties": {
"securityRules": [
{
"name": constants.nsg_rule_name,
"properties": {
"description": constants.NSG_RULES_DESCRIPTION,
"protocol": ctx.node.properties['security_group_protocol'],
"sourcePortRange": ctx.node.properties['security_group_sourcePortRange'] ,
"destinationPortRange": ctx.node.properties['security_group_destinationPortRange'],
"sourceAddressPrefix": ctx.node.properties['security_group_sourceAddressPrefix'],
"destinationAddressPrefix": ctx.node.properties['security_group_destinationAddressPrefix'],
"access": ctx.node.properties['security_group_access'],
"priority": ctx.node.properties['security_group_priority'],
"direction": ctx.node.properties['security_group_direction']
}
}
]
}
})
response_nsg = requests.put(url=security_group_url, data=security_group_params, headers=headers)
if response_nsg.text:
ctx.logger.info("create_security_group {0} response_nsg.text is {1}".format(security_group_name, response_nsg.text))
if utils.request_failed("{0}:{1}".format('create_security_group', security_group_name), response_nsg):
raise NonRecoverableError("create_security_group {0} could not be created".format(security_group_name))
ctx.instance.runtime_properties[constants.SECURITY_GROUP_KEY] = security_group_name
except:
ctx.logger.info("Security Group {0} could not be created".format(security_group_name))
raise NonRecoverableError("Security Group {} could not be created".format(security_group_name))