def test_agent_installation_userdata(self):
ctx = ctx_mock()
ctx.agent.init_script = lambda: 'SCRIPT'
with mock.patch('nova_plugin.userdata.ctx', ctx):
server_conf = {}
userdata.handle_userdata(server_conf)
self.assertEqual(server_conf, {'userdata': 'SCRIPT'})
def test_existing_and_agent_installation_userdata(self):
ctx = ctx_mock()
ctx.agent.init_script = lambda: '#! SCRIPT'
with mock.patch('nova_plugin.userdata.ctx', ctx):
server_conf = {'userdata': '#! EXISTING'}
userdata.handle_userdata(server_conf)
self.assertTrue(server_conf['userdata'].startswith(
'Content-Type: multi'))
def create(nova_client, neutron_client, args, **kwargs):
"""
Creates a server. Exposes the parameters mentioned in
http://docs.openstack.org/developer/python-novaclient/api/novaclient.v1_1
.servers.html#novaclient.v1_1.servers.ServerManager.create
"""
external_server = use_external_resource(ctx, nova_client,
SERVER_OPENSTACK_TYPE)
if external_server:
_set_network_and_ip_runtime_properties(external_server)
if ctx._local:
return
else:
network_ids = \
get_openstack_ids_of_connected_nodes_by_openstack_type(
ctx, NETWORK_OPENSTACK_TYPE)
port_ids = get_openstack_ids_of_connected_nodes_by_openstack_type(
ctx, PORT_OPENSTACK_TYPE)
try:
_validate_external_server_nics(
neutron_client,
network_ids,
port_ids
)
_validate_external_server_keypair(nova_client)
return
except Exception:
delete_runtime_properties(ctx, RUNTIME_PROPERTIES_KEYS)
raise
provider_context = provider(ctx)
def rename(name):
return transform_resource_name(ctx, name)
server = {
'name': get_resource_id(ctx, SERVER_OPENSTACK_TYPE),
}
server.update(copy.deepcopy(ctx.node.properties['server']))
server.update(copy.deepcopy(args))
_handle_boot_volume(server, ctx)
handle_image_from_relationship(server, 'image', ctx)
if 'meta' not in server:
server['meta'] = dict()
transform_resource_name(ctx, server)
ctx.logger.debug(
"server.create() server before transformations: {0}".format(server))
if ('block_device_mapping' in server or
'block_device_mapping_v2' in server) \
and 'image' not in server:
# python-novaclient requires an image field even if BDM is used.
server['image'] = ctx.node.properties.get('image')
else:
_handle_image_or_flavor(server, nova_client, 'image')
_handle_image_or_flavor(server, nova_client, 'flavor')
if provider_context.agents_security_group:
security_groups = server.get('security_groups', [])
asg = provider_context.agents_security_group['name']
if asg not in security_groups:
security_groups.append(asg)
server['security_groups'] = security_groups
elif not server.get('security_groups', []):
# Make sure that if the server is connected to a security group
# from CREATE time so that there the user can control
# that there is never a time that a running server is not protected.
security_group_names = \
get_openstack_names_of_connected_nodes_by_openstack_type(
ctx,
SECURITY_GROUP_OPENSTACK_TYPE)
server['security_groups'] = security_group_names
# server keypair handling
keypair_id = get_openstack_id_of_single_connected_node_by_openstack_type(
ctx, KEYPAIR_OPENSTACK_TYPE, True)
if 'key_name' in server:
if keypair_id:
raise NonRecoverableError("server can't both have the "
'"key_name" nested property and be '
'connected to a keypair via a '
'relationship at the same time')
server['key_name'] = rename(server['key_name'])
elif keypair_id:
server['key_name'] = _get_keypair_name_by_id(nova_client, keypair_id)
elif provider_context.agents_keypair:
server['key_name'] = provider_context.agents_keypair['name']
else:
server['key_name'] = None
ctx.logger.info(
'server must have a keypair, yet no keypair was connected to the '
'server node, the "key_name" nested property '
"wasn't used, and there is no agent keypair in the provider "
"context. Agent installation can have issues.")
_fail_on_missing_required_parameters(
server,
('name', 'flavor'),
'server')
_prepare_server_nics(neutron_client, ctx, server)
# server group handling
server_group_id = \
get_openstack_id_of_single_connected_node_by_openstack_type(
ctx, SERVER_GROUP_OPENSTACK_TYPE, True)
if server_group_id:
scheduler_hints = server.get('scheduler_hints', {})
scheduler_hints['group'] = server_group_id
server['scheduler_hints'] = scheduler_hints
ctx.logger.debug(
"server.create() server after transformations: {0}".format(server))
userdata.handle_userdata(server)
ctx.logger.info("Creating VM with parameters: {0}".format(str(server)))
# Store the server dictionary contents in runtime properties
assign_payload_as_runtime_properties(ctx, SERVER_OPENSTACK_TYPE, server)
ctx.logger.debug(
"Asking Nova to create server. All possible parameters are: [{0}]"
.format(','.join(server.keys())))
try:
s = nova_client.servers.create(**server)
except nova_exceptions.BadRequest as e:
if 'Block Device Mapping is Invalid' in str(e):
return ctx.operation.retry(
message='Block Device Mapping is not created yet',
retry_after=30)
raise
ctx.instance.runtime_properties[OPENSTACK_ID_PROPERTY] = s.id
ctx.instance.runtime_properties[OPENSTACK_TYPE_PROPERTY] = \
SERVER_OPENSTACK_TYPE
ctx.instance.runtime_properties[OPENSTACK_NAME_PROPERTY] = server['name']
def create(nova_client, neutron_client, args, **kwargs):
"""
Creates a server. Exposes the parameters mentioned in
http://docs.openstack.org/developer/python-novaclient/api/novaclient.v1_1
.servers.html#novaclient.v1_1.servers.ServerManager.create
"""
network_ids = get_openstack_ids_of_connected_nodes_by_openstack_type(
ctx, NETWORK_OPENSTACK_TYPE)
port_ids = get_openstack_ids_of_connected_nodes_by_openstack_type(
ctx, PORT_OPENSTACK_TYPE)
external_server = use_external_resource(ctx, nova_client,
SERVER_OPENSTACK_TYPE)
if external_server:
try:
_validate_external_server_nics(
neutron_client,
network_ids,
port_ids
)
_validate_external_server_keypair(nova_client)
_set_network_and_ip_runtime_properties(external_server)
return
except Exception:
delete_runtime_properties(ctx, RUNTIME_PROPERTIES_KEYS)
raise
provider_context = provider(ctx)
def rename(name):
return transform_resource_name(ctx, name)
server = {
'name': get_resource_id(ctx, SERVER_OPENSTACK_TYPE),
}
server.update(copy.deepcopy(ctx.node.properties['server']))
server.update(copy.deepcopy(args))
transform_resource_name(ctx, server)
ctx.logger.debug(
"server.create() server before transformations: {0}".format(server))
management_network_id = None
management_network_name = None
if ('management_network_name' in ctx.node.properties) and \
ctx.node.properties['management_network_name']:
management_network_name = \
ctx.node.properties['management_network_name']
management_network_name = rename(management_network_name)
management_network_id = neutron_client.cosmo_get_named(
'network', management_network_name)['id']
else:
int_network = provider_context.int_network
if int_network:
management_network_id = int_network['id']
management_network_name = int_network['name'] # Already transform.
if management_network_id is not None:
server['nics'] = \
server.get('nics', []) + [{'net-id': management_network_id}]
_handle_image_or_flavor(server, nova_client, 'image')
_handle_image_or_flavor(server, nova_client, 'flavor')
if provider_context.agents_security_group:
security_groups = server.get('security_groups', [])
asg = provider_context.agents_security_group['name']
if asg not in security_groups:
security_groups.append(asg)
server['security_groups'] = security_groups
# server keypair handling
keypair_id = get_openstack_id_of_single_connected_node_by_openstack_type(
ctx, KEYPAIR_OPENSTACK_TYPE, True)
if 'key_name' in server:
if keypair_id:
raise NonRecoverableError("server can't both have the "
'"key_name" nested property and be '
'connected to a keypair via a '
'relationship at the same time')
server['key_name'] = rename(server['key_name'])
elif keypair_id:
server['key_name'] = _get_keypair_name_by_id(nova_client, keypair_id)
elif provider_context.agents_keypair:
server['key_name'] = provider_context.agents_keypair['name']
else:
raise NonRecoverableError(
'server must have a keypair, yet no keypair was connected to the '
'server node, the "key_name" nested property '
"wasn't used, and there is no agent keypair in the provider "
"context")
_fail_on_missing_required_parameters(
server,
('name', 'flavor', 'image', 'key_name'),
'server')
if management_network_id is None and (network_ids or port_ids):
# Known limitation
raise NonRecoverableError(
"Nova server with NICs requires "
"'management_network_name' in properties or id "
"from provider context, which was not supplied")
# Multi-NIC by networks - start
nics = [{'net-id': net_id} for net_id in network_ids]
if nics:
if management_network_id in network_ids:
# de-duplicating the management network id in case it appears in
# network_ids. There has to be a management network if a
# network is connected to the server.
# note: if the management network appears more than once in
# network_ids it won't get de-duplicated and the server creation
# will fail.
nics.remove({'net-id': management_network_id})
server['nics'] = server.get('nics', []) + nics
# Multi-NIC by networks - end
# Multi-NIC by ports - start
nics = [{'port-id': port_id} for port_id in port_ids]
if nics:
port_network_ids = get_port_network_ids_(neutron_client, port_ids)
if management_network_id in port_network_ids:
# de-duplicating the management network id in case it appears in
# port_ids. There has to be a management network if a
# network is connected to the server.
# note: if the management network appears more than once in
# network_ids it won't get de-duplicated and the server creation
# will fail.
server['nics'].remove({'net-id': management_network_id})
server['nics'] = server.get('nics', []) + nics
# Multi-NIC by ports - end
ctx.logger.debug(
"server.create() server after transformations: {0}".format(server))
if 'meta' not in server:
server['meta'] = dict()
if management_network_id is not None:
server['meta']['cloudify_management_network_id'] = \
management_network_id
if management_network_name is not None:
server['meta']['cloudify_management_network_name'] = \
management_network_name
userdata.handle_userdata(server)
ctx.logger.info("Creating VM with parameters: {0}".format(str(server)))
ctx.logger.debug(
"Asking Nova to create server. All possible parameters are: {0})"
.format(','.join(server.keys())))
try:
s = nova_client.servers.create(**server)
except nova_exceptions.BadRequest as e:
if str(e).startswith(MUST_SPECIFY_NETWORK_EXCEPTION_TEXT):
raise NonRecoverableError(
"Can not provision server: management_network_name or id"
" is not specified but there are several networks that the "
"server can be connected to.")
raise
ctx.instance.runtime_properties[OPENSTACK_ID_PROPERTY] = s.id
ctx.instance.runtime_properties[OPENSTACK_TYPE_PROPERTY] = \
SERVER_OPENSTACK_TYPE
ctx.instance.runtime_properties[OPENSTACK_NAME_PROPERTY] = server['name']
def create(nova_client, neutron_client, args, **kwargs):
"""
Creates a server. Exposes the parameters mentioned in
http://docs.openstack.org/developer/python-novaclient/api/novaclient.v1_1
.servers.html#novaclient.v1_1.servers.ServerManager.create
"""
network_ids = get_openstack_ids_of_connected_nodes_by_openstack_type(
ctx, NETWORK_OPENSTACK_TYPE)
port_ids = get_openstack_ids_of_connected_nodes_by_openstack_type(
ctx, PORT_OPENSTACK_TYPE)
external_server = use_external_resource(ctx, nova_client,
SERVER_OPENSTACK_TYPE)
if external_server:
try:
_validate_external_server_nics(
neutron_client,
network_ids,
port_ids
)
_validate_external_server_keypair(nova_client)
_set_network_and_ip_runtime_properties(external_server)
return
except Exception:
delete_runtime_properties(ctx, RUNTIME_PROPERTIES_KEYS)
raise
provider_context = provider(ctx)
def rename(name):
return transform_resource_name(ctx, name)
server = {
'name': get_resource_id(ctx, SERVER_OPENSTACK_TYPE),
}
server.update(copy.deepcopy(ctx.node.properties['server']))
server.update(copy.deepcopy(args))
transform_resource_name(ctx, server)
ctx.logger.debug(
"server.create() server before transformations: {0}".format(server))
management_network_id = None
management_network_name = None
if ('management_network_name' in ctx.node.properties) and \
ctx.node.properties['management_network_name']:
management_network_name = \
ctx.node.properties['management_network_name']
management_network_name = rename(management_network_name)
management_network_id = neutron_client.cosmo_get_named(
'network', management_network_name)['id']
else:
int_network = provider_context.int_network
if int_network:
management_network_id = int_network['id']
management_network_name = int_network['name'] # Already transform.
if management_network_id is not None:
server['nics'] = \
server.get('nics', []) + [{'net-id': management_network_id}]
_handle_image_or_flavor(server, nova_client, 'image')
_handle_image_or_flavor(server, nova_client, 'flavor')
if provider_context.agents_security_group:
security_groups = server.get('security_groups', [])
asg = provider_context.agents_security_group['name']
if asg not in security_groups:
security_groups.append(asg)
server['security_groups'] = security_groups
# server keypair handling
keypair_id = get_openstack_id_of_single_connected_node_by_openstack_type(
ctx, KEYPAIR_OPENSTACK_TYPE, True)
if 'key_name' in server:
if keypair_id:
raise NonRecoverableError("server can't both have the "
'"key_name" nested property and be '
'connected to a keypair via a '
'relationship at the same time')
server['key_name'] = rename(server['key_name'])
elif keypair_id:
server['key_name'] = _get_keypair_name_by_id(nova_client, keypair_id)
elif provider_context.agents_keypair:
server['key_name'] = provider_context.agents_keypair['name']
else:
raise NonRecoverableError(
'server must have a keypair, yet no keypair was connected to the '
'server node, the "key_name" nested property '
"wasn't used, and there is no agent keypair in the provider "
"context")
_fail_on_missing_required_parameters(
server,
('name', 'flavor', 'image', 'key_name'),
'server')
if management_network_id is None and (network_ids or port_ids):
# Known limitation
raise NonRecoverableError(
"Nova server with NICs requires "
"'management_network_name' in properties or id "
"from provider context, which was not supplied")
# Multi-NIC by networks - start
nics = [{'net-id': net_id} for net_id in network_ids]
if nics:
if management_network_id in network_ids:
# de-duplicating the management network id in case it appears in
# network_ids. There has to be a management network if a
# network is connected to the server.
# note: if the management network appears more than once in
# network_ids it won't get de-duplicated and the server creation
# will fail.
nics.remove({'net-id': management_network_id})
server['nics'] = server.get('nics', []) + nics
# Multi-NIC by networks - end
# Multi-NIC by ports - start
nics = [{'port-id': port_id} for port_id in port_ids]
if nics:
port_network_ids = get_port_network_ids_(neutron_client, port_ids)
if management_network_id in port_network_ids:
# de-duplicating the management network id in case it appears in
# port_ids. There has to be a management network if a
# network is connected to the server.
# note: if the management network appears more than once in
# network_ids it won't get de-duplicated and the server creation
# will fail.
server['nics'].remove({'net-id': management_network_id})
server['nics'] = server.get('nics', []) + nics
# Multi-NIC by ports - end
ctx.logger.debug(
"server.create() server after transformations: {0}".format(server))
if 'meta' not in server:
server['meta'] = dict()
if management_network_id is not None:
server['meta']['cloudify_management_network_id'] = \
management_network_id
if management_network_name is not None:
server['meta']['cloudify_management_network_name'] = \
management_network_name
userdata.handle_userdata(server)
ctx.logger.info("Creating VM with parameters: {0}".format(str(server)))
ctx.logger.debug(
"Asking Nova to create server. All possible parameters are: {0})"
.format(','.join(server.keys())))
try:
s = nova_client.servers.create(**server)
except nova_exceptions.BadRequest as e:
if str(e).startswith(MUST_SPECIFY_NETWORK_EXCEPTION_TEXT):
raise NonRecoverableError(
"Can not provision server: management_network_name or id"
" is not specified but there are several networks that the "
"server can be connected to.")
raise
ctx.instance.runtime_properties[OPENSTACK_ID_PROPERTY] = s.id
ctx.instance.runtime_properties[OPENSTACK_TYPE_PROPERTY] = \
SERVER_OPENSTACK_TYPE
ctx.instance.runtime_properties[OPENSTACK_NAME_PROPERTY] = server['name']
def create(nova_client, neutron_client, args, **kwargs):
"""
Creates a server. Exposes the parameters mentioned in
http://docs.openstack.org/developer/python-novaclient/api/novaclient.v1_1
.servers.html#novaclient.v1_1.servers.ServerManager.create
"""
external_server = use_external_resource(ctx, nova_client,
SERVER_OPENSTACK_TYPE)
if external_server:
network_ids = get_openstack_ids_of_connected_nodes_by_openstack_type(
ctx, NETWORK_OPENSTACK_TYPE)
port_ids = get_openstack_ids_of_connected_nodes_by_openstack_type(
ctx, PORT_OPENSTACK_TYPE)
try:
_validate_external_server_nics(
neutron_client,
network_ids,
port_ids
)
_validate_external_server_keypair(nova_client)
_set_network_and_ip_runtime_properties(external_server)
return
except Exception:
delete_runtime_properties(ctx, RUNTIME_PROPERTIES_KEYS)
raise
provider_context = provider(ctx)
def rename(name):
return transform_resource_name(ctx, name)
server = {
'name': get_resource_id(ctx, SERVER_OPENSTACK_TYPE),
}
server.update(copy.deepcopy(ctx.node.properties['server']))
server.update(copy.deepcopy(args))
if 'meta' not in server:
server['meta'] = dict()
transform_resource_name(ctx, server)
ctx.logger.debug(
"server.create() server before transformations: {0}".format(server))
_handle_image_or_flavor(server, nova_client, 'image')
_handle_image_or_flavor(server, nova_client, 'flavor')
if provider_context.agents_security_group:
security_groups = server.get('security_groups', [])
asg = provider_context.agents_security_group['name']
if asg not in security_groups:
security_groups.append(asg)
server['security_groups'] = security_groups
# server keypair handling
keypair_id = get_openstack_id_of_single_connected_node_by_openstack_type(
ctx, KEYPAIR_OPENSTACK_TYPE, True)
if 'key_name' in server:
if keypair_id:
raise NonRecoverableError("server can't both have the "
'"key_name" nested property and be '
'connected to a keypair via a '
'relationship at the same time')
server['key_name'] = rename(server['key_name'])
elif keypair_id:
server['key_name'] = _get_keypair_name_by_id(nova_client, keypair_id)
elif provider_context.agents_keypair:
server['key_name'] = provider_context.agents_keypair['name']
else:
raise NonRecoverableError(
'server must have a keypair, yet no keypair was connected to the '
'server node, the "key_name" nested property '
"wasn't used, and there is no agent keypair in the provider "
"context")
_fail_on_missing_required_parameters(
server,
('name', 'flavor', 'image', 'key_name'),
'server')
_prepare_server_nics(neutron_client, ctx, server)
ctx.logger.debug(
"server.create() server after transformations: {0}".format(server))
userdata.handle_userdata(server)
ctx.logger.info("Creating VM with parameters: {0}".format(str(server)))
ctx.logger.debug(
"Asking Nova to create server. All possible parameters are: {0})"
.format(','.join(server.keys())))
try:
s = nova_client.servers.create(**server)
except nova_exceptions.BadRequest as e:
if str(e).startswith(MUST_SPECIFY_NETWORK_EXCEPTION_TEXT):
raise NonRecoverableError(
"Can not provision server: management_network_name or id"
" is not specified but there are several networks that the "
"server can be connected to.")
raise
ctx.instance.runtime_properties[OPENSTACK_ID_PROPERTY] = s.id
ctx.instance.runtime_properties[OPENSTACK_TYPE_PROPERTY] = \
SERVER_OPENSTACK_TYPE
ctx.instance.runtime_properties[OPENSTACK_NAME_PROPERTY] = server['name']
def create(nova_client, neutron_client, args, **kwargs):
"""
Creates a server. Exposes the parameters mentioned in
http://docs.openstack.org/developer/python-novaclient/api/novaclient.v1_1
.servers.html#novaclient.v1_1.servers.ServerManager.create
"""
external_server = use_external_resource(ctx, nova_client,
SERVER_OPENSTACK_TYPE)
if external_server:
_set_network_and_ip_runtime_properties(external_server)
if ctx._local:
return
else:
network_ids = \
get_openstack_ids_of_connected_nodes_by_openstack_type(
ctx, NETWORK_OPENSTACK_TYPE)
port_ids = get_openstack_ids_of_connected_nodes_by_openstack_type(
ctx, PORT_OPENSTACK_TYPE)
try:
_validate_external_server_nics(
neutron_client,
network_ids,
port_ids
)
_validate_external_server_keypair(nova_client)
return
except Exception:
delete_runtime_properties(ctx, RUNTIME_PROPERTIES_KEYS)
raise
provider_context = provider(ctx)
def rename(name):
return transform_resource_name(ctx, name)
server = {
'name': get_resource_id(ctx, SERVER_OPENSTACK_TYPE),
}
server.update(copy.deepcopy(ctx.node.properties['server']))
server.update(copy.deepcopy(args))
_handle_boot_volume(server, ctx)
handle_image_from_relationship(server, 'image', ctx)
if 'meta' not in server:
server['meta'] = dict()
transform_resource_name(ctx, server)
ctx.logger.debug(
"server.create() server before transformations: {0}".format(server))
if ('block_device_mapping' in server or
'block_device_mapping_v2' in server) \
and 'image' not in server:
# python-novaclient requires an image field even if BDM is used.
server['image'] = ctx.node.properties.get('image')
else:
_handle_image_or_flavor(server, nova_client, 'image')
_handle_image_or_flavor(server, nova_client, 'flavor')
if provider_context.agents_security_group:
security_groups = server.get('security_groups', [])
asg = provider_context.agents_security_group['name']
if asg not in security_groups:
security_groups.append(asg)
server['security_groups'] = security_groups
elif not server.get('security_groups', []):
# Make sure that if the server is connected to a security group
# from CREATE time so that there the user can control
# that there is never a time that a running server is not protected.
security_group_names = \
get_openstack_names_of_connected_nodes_by_openstack_type(
ctx,
SECURITY_GROUP_OPENSTACK_TYPE)
server['security_groups'] = security_group_names
# server keypair handling
keypair_id = get_openstack_id_of_single_connected_node_by_openstack_type(
ctx, KEYPAIR_OPENSTACK_TYPE, True)
if 'key_name' in server:
if keypair_id:
raise NonRecoverableError("server can't both have the "
'"key_name" nested property and be '
'connected to a keypair via a '
'relationship at the same time')
server['key_name'] = rename(server['key_name'])
elif keypair_id:
server['key_name'] = _get_keypair_name_by_id(nova_client, keypair_id)
elif provider_context.agents_keypair:
server['key_name'] = provider_context.agents_keypair['name']
else:
server['key_name'] = None
ctx.logger.info(
'server must have a keypair, yet no keypair was connected to the '
'server node, the "key_name" nested property '
"wasn't used, and there is no agent keypair in the provider "
"context. Agent installation can have issues.")
_fail_on_missing_required_parameters(
server,
('name', 'flavor'),
'server')
_prepare_server_nics(neutron_client, ctx, server)
# server group handling
server_group_id = \
get_openstack_id_of_single_connected_node_by_openstack_type(
ctx, SERVER_GROUP_OPENSTACK_TYPE, True)
if server_group_id:
scheduler_hints = server.get('scheduler_hints', {})
scheduler_hints['group'] = server_group_id
server['scheduler_hints'] = scheduler_hints
ctx.logger.debug(
"server.create() server after transformations: {0}".format(server))
userdata.handle_userdata(server)
ctx.logger.info("Creating VM with parameters: {0}".format(str(server)))
# Store the server dictionary contents in runtime properties
assign_payload_as_runtime_properties(ctx, SERVER_OPENSTACK_TYPE, server)
ctx.logger.debug(
"Asking Nova to create server. All possible parameters are: {0})"
.format(','.join(server.keys())))
try:
s = nova_client.servers.create(**server)
except nova_exceptions.BadRequest as e:
if 'Block Device Mapping is Invalid' in str(e):
return ctx.operation.retry(
message='Block Device Mapping is not created yet',
retry_after=30)
raise
ctx.instance.runtime_properties[OPENSTACK_ID_PROPERTY] = s.id
ctx.instance.runtime_properties[OPENSTACK_TYPE_PROPERTY] = \
SERVER_OPENSTACK_TYPE
ctx.instance.runtime_properties[OPENSTACK_NAME_PROPERTY] = server['name']
def test_existing_userdata(self):
server_conf = {'userdata': 'EXISTING'}
server_conf_copy = server_conf.copy()
userdata.handle_userdata(server_conf)
self.assertEqual(server_conf, server_conf_copy)
def test_no_userdata(self):
server_conf = {}
userdata.handle_userdata(server_conf)
self.assertEqual(server_conf, {})
