def _test_linux_userdata_agent(cfy, manager, attributes, os_name, tenant,
install_userdata=None, name=None,
install_method='init_script'):
file_path = '/tmp/test_file'
userdata = '#! /bin/bash\necho {0} > {1}\nchmod 777 {1}'.format(
EXPECTED_FILE_CONTENT, file_path)
if install_userdata:
userdata = create_multi_mimetype_userdata([userdata,
install_userdata])
inputs = {
'image': attributes['{os}_image_name'.format(os=os_name)],
'user': attributes['{os}_username'.format(os=os_name)],
'flavor': attributes['small_flavor_name'],
'os_family': 'linux',
'userdata': userdata,
'file_path': file_path,
'install_method': install_method,
'name': name,
'keypair_name': attributes.keypair_name,
'private_key_path': manager.remote_private_key_path,
'network_name': attributes.network_name
}
_test_userdata_agent(cfy, manager, inputs, tenant)
def _test_linux_userdata_agent(cfy, manager, attributes, os_name, tenant,
install_userdata=None, name=None,
install_method='init_script'):
file_path = '/tmp/test_file'
userdata = '#! /bin/bash\necho {0} > {1}\nchmod 777 {1}'.format(
EXPECTED_FILE_CONTENT, file_path)
if install_userdata:
userdata = create_multi_mimetype_userdata([userdata,
install_userdata])
inputs = {
'image': attributes['{os}_image_name'.format(os=os_name)],
'user': attributes['{os}_username'.format(os=os_name)],
'flavor': attributes['small_flavor_name'],
'os_family': 'linux',
'userdata': userdata,
'file_path': file_path,
'install_method': install_method,
'name': name,
'keypair_name': attributes.keypair_name,
'private_key_path': manager.remote_private_key_path,
'network_name': attributes.network_name
}
_test_userdata_agent(cfy, manager, inputs, tenant)
def _handle_userdata(existing_userdata):
if existing_userdata is None:
existing_userdata = ''
elif isinstance(existing_userdata, dict) or \
isinstance(existing_userdata, list):
existing_userdata = json.dumps(existing_userdata)
elif not isinstance(existing_userdata, basestring):
existing_userdata = str(existing_userdata)
install_agent_userdata = ctx.agent.init_script()
os_family = ctx.node.properties['os_family']
if not existing_userdata and not install_agent_userdata:
return
# Windows instances require no more than one
# Powershell script, which must be surrounded by
# Powershell tags.
if install_agent_userdata and os_family == 'windows':
# Get the powershell content from install_agent_userdata
install_agent_userdata = \
extract_powershell_content(install_agent_userdata)
# Get the powershell content from existing_userdata
# (If it exists.)
existing_userdata_powershell = \
extract_powershell_content(existing_userdata)
# Combine the powershell content from two sources.
install_agent_userdata = \
'#ps1_sysnative\n{0}\n{1}\n{2}\n{3}\n'.format(
PS_OPEN,
existing_userdata_powershell,
install_agent_userdata,
PS_CLOSE)
# Additional work on the existing_userdata.
# Remove duplicate Powershell content.
# Get rid of unnecessary newlines.
existing_userdata = \
existing_userdata.replace(
existing_userdata_powershell,
'').replace(
PS_OPEN,
'').replace(
PS_CLOSE,
'').strip()
if not existing_userdata or existing_userdata.isspace():
final_userdata = install_agent_userdata
elif not install_agent_userdata:
final_userdata = existing_userdata
else:
final_userdata = compute.create_multi_mimetype_userdata(
[existing_userdata, install_agent_userdata])
return final_userdata
def _handle_userdata(existing_userdata):
if existing_userdata is None:
existing_userdata = ''
elif isinstance(existing_userdata, dict) or \
isinstance(existing_userdata, list):
existing_userdata = json.dumps(existing_userdata)
elif not isinstance(existing_userdata, basestring):
existing_userdata = str(existing_userdata)
install_agent_userdata = ctx.agent.init_script()
os_family = ctx.node.properties['os_family']
if not (existing_userdata or install_agent_userdata):
return ''
# Windows instances require no more than one
# Powershell script, which must be surrounded by
# Powershell tags.
if install_agent_userdata and os_family == 'windows':
# Get the powershell content from install_agent_userdata
install_agent_userdata = \
extract_powershell_content(install_agent_userdata)
# Get the powershell content from existing_userdata
# (If it exists.)
existing_userdata_powershell = \
extract_powershell_content(existing_userdata)
# Combine the powershell content from two sources.
install_agent_userdata = \
'#ps1_sysnative\n{0}\n{1}\n{2}\n{3}\n'.format(
PS_OPEN,
existing_userdata_powershell,
install_agent_userdata,
PS_CLOSE)
# Additional work on the existing_userdata.
# Remove duplicate Powershell content.
# Get rid of unnecessary newlines.
existing_userdata = \
existing_userdata.replace(
existing_userdata_powershell,
'').replace(
PS_OPEN,
'').replace(
PS_CLOSE,
'').strip()
if not existing_userdata or existing_userdata.isspace():
final_userdata = install_agent_userdata
elif not install_agent_userdata:
final_userdata = existing_userdata
else:
final_userdata = compute.create_multi_mimetype_userdata(
[existing_userdata, install_agent_userdata])
return final_userdata
def _test_linux_userdata_agent(self, image, flavor, user, install_method,
install_userdata=None, name=None):
file_path = '/tmp/test_file'
userdata = '#! /bin/bash\necho {0} > {1}\nchmod 777 {1}'.format(
self.expected_file_content, file_path)
if install_userdata:
userdata = create_multi_mimetype_userdata([userdata,
install_userdata])
self._test_userdata_agent(image=image,
flavor=flavor,
user=user,
os_family='linux',
userdata=userdata,
file_path=file_path,
install_method=install_method,
name=name)
def _handle_userdata(self, parameters):
existing_userdata = parameters.get('user_data')
install_agent_userdata = ctx.agent.init_script()
if not (existing_userdata or install_agent_userdata):
return parameters
if not existing_userdata:
final_userdata = install_agent_userdata
elif not install_agent_userdata:
final_userdata = existing_userdata
else:
final_userdata = compute.create_multi_mimetype_userdata(
[existing_userdata, install_agent_userdata])
parameters['user_data'] = final_userdata
return parameters
def test_windows_userdata_agent(self,
install_method='init_script',
name=None,
install_userdata=None):
user = '******'
file_path = 'C:\\Users\\{0}\\test_file'.format(user)
userdata = '#ps1_sysnative \nSet-Content {1} "{0}"'.format(
self.expected_file_content, file_path)
if install_userdata:
userdata = create_multi_mimetype_userdata([userdata,
install_userdata])
self._test_userdata_agent(image=self.env.windows_image_name,
flavor=self.env.medium_flavor_id,
user=user,
os_family='windows',
userdata=userdata,
file_path=file_path,
install_method=install_method,
name=name)
def _handle_userdata(self, parameters):
existing_userdata = parameters.get('user_data')
install_agent_userdata = ctx.agent.init_script()
if not (existing_userdata or install_agent_userdata):
return parameters
if not existing_userdata:
final_userdata = install_agent_userdata
elif not install_agent_userdata:
final_userdata = existing_userdata
else:
final_userdata = compute.create_multi_mimetype_userdata(
[existing_userdata, install_agent_userdata])
parameters['user_data'] = final_userdata
return parameters
def test_windows_userdata_agent(cfy,
manager,
attributes,
install_method='init_script',
name=None,
install_userdata=None,
os_name='windows_2012',
tenant=None):
user = attributes.windows_2012_username
file_path = 'C:\\Users\\{0}\\test_file'.format(user)
userdata = '#ps1_sysnative\n' \
'Set-Content {1} "{0}"'.format(EXPECTED_FILE_CONTENT, file_path)
if install_userdata:
userdata = create_multi_mimetype_userdata([userdata,
install_userdata])
if not tenant:
tenant = prepare_and_get_test_tenant(
'inst_userdata_{}'.format(os_name),
manager,
cfy,
)
else:
if not tenant:
tenant = prepare_and_get_test_tenant(
'userdata_{}'.format(os_name),
manager,
cfy,
)
inputs = {
'image': attributes.windows_2012_image_name,
'user': user,
'flavor': attributes.medium_flavor_name,
'os_family': 'windows',
'userdata': userdata,
'file_path': file_path,
'install_method': install_method,
'name': name,
'keypair_name': attributes.keypair_name,
'private_key_path': manager.remote_private_key_path,
'network_name': attributes.network_name
}
_test_userdata_agent(cfy, manager, inputs, tenant)
def test_windows_provided_userdata_agent(cfy,
manager,
attributes,
tmpdir,
logger):
name = 'cloudify_agent'
tenant = prepare_and_get_test_tenant(
'userdataprov_windows_2012',
manager,
cfy,
)
install_userdata = _install_script(
name=name,
windows=True,
user=attributes.windows_2012_username,
manager=manager,
attributes=attributes,
tmpdir=tmpdir,
logger=logger,
tenant=tenant,
)
user = attributes.windows_2012_username
file_path = 'C:\\Users\\{0}\\test_file'.format(user)
userdata = '#ps1_sysnative\n' \
'Set-Content {1} "{0}"'.format(EXPECTED_FILE_CONTENT, file_path)
userdata = create_multi_mimetype_userdata([userdata,
install_userdata])
inputs = {
'image': attributes.windows_2012_image_name,
'user': user,
'flavor': attributes.medium_flavor_name,
'os_family': 'windows',
'userdata': userdata,
'file_path': file_path,
'install_method': 'provided',
'name': name,
'keypair_name': attributes.keypair_name,
'private_key_path': manager.remote_private_key_path,
'network_name': attributes.network_name
}
_test_userdata_agent(cfy, manager, inputs, tenant)
def handle_userdata(server):
existing_userdata = server.get('userdata')
install_agent_userdata = ctx.agent.init_script()
if not (existing_userdata or install_agent_userdata):
return
if isinstance(existing_userdata, dict):
ud_type = existing_userdata['type']
if ud_type not in userdata_handlers:
raise exceptions.NonRecoverableError(
"Invalid type '{0}' for server userdata)".format(ud_type))
existing_userdata = userdata_handlers[ud_type](existing_userdata)
if not existing_userdata:
final_userdata = install_agent_userdata
elif not install_agent_userdata:
final_userdata = existing_userdata
else:
final_userdata = compute.create_multi_mimetype_userdata(
[existing_userdata, install_agent_userdata])
server['userdata'] = final_userdata
def handle_userdata(server):
existing_userdata = server.get('userdata')
install_agent_userdata = ctx.agent.init_script()
if not (existing_userdata or install_agent_userdata):
return
if isinstance(existing_userdata, dict):
ud_type = existing_userdata['type']
if ud_type not in userdata_handlers:
raise exceptions.NonRecoverableError(
"Invalid type '{0}' for server userdata)".format(ud_type))
existing_userdata = userdata_handlers[ud_type](existing_userdata)
if not existing_userdata:
final_userdata = install_agent_userdata
elif not install_agent_userdata:
final_userdata = existing_userdata
else:
final_userdata = compute.create_multi_mimetype_userdata(
[existing_userdata, install_agent_userdata])
server['userdata'] = final_userdata
def create_compute(ctx, **kwargs):
ctx.logger.info("MTP creating compute")
add_url = "/mtpbase/abstract-compute-resources"
mtp_compute_props = ctx.node.properties['mtp_compute']
mtp_config = get_mtp_config(ctx)
service_id = ""
for prop in mtp_compute_props['metadata']:
if prop['key'] == 'ServiceId':
service_id = prop['value']
break
rel_networks = get_relationships_by_openstack_type(ctx, 'mtp_subnet_vl')
if 'interfaceData' not in mtp_compute_props:
if len(rel_networks) > 0:
for rel_network in rel_networks:
id_network = str(rel_network.target.instance.
runtime_properties[MTP_EXTERNAL_RESOURCE]
['networkData']['metadata']['id'])
mtp_compute_props.update({"interfaceData": []})
mtp_compute_props["interfaceData"].append({
"networkId": id_network,
"ipAddress": '',
"macAddress": ''
})
else:
for idx, interfaceData in enumerate(
mtp_compute_props['interfaceData']):
id_network = interfaceData['networkId']
is_found = False
for rel_network in rel_networks:
if id_network == rel_network.target.node.name:
id_network = str(rel_network.target.instance.
runtime_properties[MTP_EXTERNAL_RESOURCE]
['networkData']['metadata']['id'])
interfaceData['networkId'] = id_network
is_found = True
break
if not is_found:
del (mtp_compute_props['interfaceData'][idx])
rel_floating_ips = get_relationships_by_openstack_type(
ctx, 'mtp_floating_ip')
if len(rel_floating_ips) > 1:
raise NonRecoverableError("Floating set more than one")
if len(rel_floating_ips) != 0:
rel_floating_ip = rel_floating_ips[0]
floating_ip_ip = \
rel_floating_ip.target.instance.runtime_properties['external_resource']['networkPortData']['metadata'][
'floating_ip']
floating_ip_network = rel_floating_ip.target.node.properties[
'mtp_floating_ip']['networkResourceName']
mtp_compute_props['metadata'].update(
{'admin-network-name': floating_ip_network})
mtp_compute_props['metadata'].update({'floating-ip': floating_ip_ip})
existing_userdata = mtp_compute_props['userData']['content']
install_agent_userdata = ctx.agent.init_script()
if existing_userdata != "":
final_userdata = compute.create_multi_mimetype_userdata(
[existing_userdata, install_agent_userdata])
else:
final_userdata = install_agent_userdata
mtp_compute_props['userData']['content'] = final_userdata
ctx.logger.info("request body:" + json.dumps(mtp_compute_props, indent=4))
json_string = json.dumps(mtp_compute_props)
http_session = requests.session()
url = mtp_config['url'] + add_url
headers = {"Content-Type": "application/json"}
try:
response_str = http_session.post(url,
data=json_string,
headers=headers,
timeout=REQUEST_TIMEOUT)
except requests.exceptions.RequestException as e:
ctx.logger.info(e)
return ctx.operation.retry(message='Connection error to url ' +
mtp_config['url'])
http_session.close()
ctx.logger.info("response.status_code = " + str(response_str.status_code))
ctx.logger.info("response.text = " + str(response_str.text))
if response_str.status_code not in [200, 201, 202, 203]:
raise NonRecoverableError(
"Request to create compute returned wrong code " +
str(response_str.status_code) + response_str.text)
response = json.loads(response_str.text)
try:
interfaces_in = response['virtualNetworkInterface']
interfaces_out = {}
service_id_str = str(service_id) + "_"
for interface in interfaces_in:
interface_name = str(interface['networkName'])
interface_name = interface_name.replace(service_id_str, "")
interfaces_out.update({interface_name: interface})
response['virtualNetworkInterface'] = interfaces_out
ctx.instance.runtime_properties.update(
{MTP_ID_PROPERTY: response['computeId']})
ctx.instance.runtime_properties.update(
{MTP_NAME_PROPERTY: response['computeName']})
ctx.instance.runtime_properties.update(
{MTP_TYPE_PROPERTY: "mtp_compute"})
ctx.instance.runtime_properties.update(
{MTP_EXTERNAL_RESOURCE: response})
except TypeError as e:
raise NonRecoverableError(
"Request to create compute returned wrong response format " +
response_str.text)
def handle_userdata(existing_userdata):
"""
This method will be responsible for handle user data provided by the
user on the following cases:
1. When user specify "user_data" to create server on openstack
2. When "install_method" for agent is set to "Init-script" the plugin
should be able to inject/update "user_data" for server
:param existing_userdata:
:return: final_userdata
"""
# Check the agent init script so that it can be injected to the target
# machine to install the agent daemon
install_agent_userdata = ctx.agent.init_script()
# Get the "os_family" type, by default all node instances extend
# "cloudify.nodes.Compute" node will have "os_family" set to "Linux"
# It can be override for Windows which is need to be handled differently
os_family = ctx.node.properties['os_family']
if not (existing_userdata or install_agent_userdata):
return None
if not existing_userdata:
existing_userdata = ''
if install_agent_userdata and os_family == 'windows':
# Get the powershell content from install_agent_userdata
install_agent_userdata = \
extract_powershell_content(install_agent_userdata)
# Get the powershell content from existing_userdata
# (If it exists.)
existing_userdata_powershell = \
extract_powershell_content(existing_userdata)
# Combine the powershell content from two sources.
install_agent_userdata = \
'#ps1_sysnative\n{0}\n{1}\n{2}\n{3}\n'.format(
PS_OPEN,
existing_userdata_powershell,
install_agent_userdata,
PS_CLOSE)
# Additional work on the existing_userdata.
# Remove duplicate Powershell content.
# Get rid of unnecessary newlines.
existing_userdata = \
existing_userdata.replace(
existing_userdata_powershell,
'').replace(
PS_OPEN,
'').replace(
PS_CLOSE,
'').strip()
if not existing_userdata or existing_userdata.isspace():
final_userdata = install_agent_userdata
elif not install_agent_userdata:
final_userdata =\
compute.create_multi_mimetype_userdata([existing_userdata])
else:
final_userdata = compute.create_multi_mimetype_userdata(
[existing_userdata, install_agent_userdata])
final_userdata = base64.b64encode(final_userdata)
return final_userdata
