def setUp(self):
self.name = 'name'
self.uuid = 'uuid'
self.name_gen = Mock(return_value=self.name)
self.pv_service = Mock()
self.si = Mock()
self.clone_parmas = Mock()
self.clone_res = Mock()
self.clone_res.error = None
self.clone_res.vm = Mock()
self.clone_res.vm.summary = Mock()
self.clone_res.vm.summary.config = Mock()
self.clone_res.vm.summary.config.uuid = self.uuid
self.pv_service.CloneVmParameters = Mock(
return_value=self.clone_parmas)
self.pv_service.clone_vm = Mock(return_value=self.clone_res)
self.image_deployer = Mock()
self.image_deployer.deploy_image = Mock(return_value=True)
self.vm = Mock()
self.vm.config = Mock()
self.vm.config.uuid = self.uuid
self.pv_service.find_vm_by_name = Mock(return_value=self.vm)
self.cs_helper = Mock()
self.model_parser = ResourceModelParser()
self.deployer = VirtualMachineDeployer(self.pv_service, self.name_gen,
self.image_deployer,
self.cs_helper,
self.model_parser)
def test_refresh_ip_choose_ipv4(self):
nic1 = Mock()
nic1.network = 'A Network'
nic1.ipAddress = ['192.168.1.1']
nic2 = Mock()
nic2.network = 'A Network'
nic2.ipAddress = ['2001:0db8:0a0b:12f0:0000:0000:0000:0001']
guest = Mock()
guest.toolsStatus = 'toolsOk'
guest.net = [nic1, nic2]
vm = Mock()
vm.guest = guest
pyvmomi_service = Mock()
pyvmomi_service.find_by_uuid = Mock(return_value=vm)
ip_regex = self._create_custom_param('ip_regex', '')
refresh_ip_timeout = self._create_custom_param('refresh_ip_timeout',
'10')
resource_instance = create_autospec(ResourceInfo)
resource_instance.ResourceModelName = 'Generic Deployed App'
resource_instance.ResourceAttributes = {
'vm_uuis': '123',
'cloud_provider': 'vCenter'
}
resource_instance.VmDetails = create_autospec(ResourceInfoVmDetails)
resource_instance.VmDetails.VmCustomParams = [
ip_regex, refresh_ip_timeout
]
refresh_ip_command = RefreshIpCommand(pyvmomi_service,
ResourceModelParser(), Mock())
session = Mock()
session.UpdateResourceAddress = Mock(return_value=True)
session.GetResourceDetails = Mock(return_value=resource_instance)
si = Mock()
center_resource_model = VMwarevCenterResourceModel()
center_resource_model.default_datacenter = 'QualiSB'
center_resource_model.holding_network = 'anetwork'
cancellation_context = Mock()
# Act
refresh_ip_command.refresh_ip(
si=si,
session=session,
vcenter_data_model=center_resource_model,
vm_uuid='machine1',
resource_name='default_network',
cancellation_context=cancellation_context,
logger=Mock())
# Assert
self.assertTrue(
session.UpdateResourceAddress.called_with('machine1',
'192.168.1.1'))
def __init__(self):
# self.cs_helper = CloudshellDriverHelper()
self.model_parser = ResourceModelParser()
self.ip_manager = VMIPManager()
self.task_waiter = SynchronousTaskWaiter()
self.pv_service = pyVmomiService(SmartConnect, Disconnect,
self.task_waiter)
def test_get_vcenter_data_model_empty_vcenter_name(self):
# Arrange
data_model_retriever = VCenterDataModelRetriever(ResourceModelParser())
api = Mock()
vcenter_resource = create_autospec(ResourceContextDetails)
vcenter_resource.model = 'VMWare vCenter'
vcenter_resource.attrib = {
'user': '******',
'password': '******',
'default_dvswitch': '',
'holding_network': '',
'vm_cluster': '',
'vm_resource_pool': '',
'vm_storage': '',
'vm_location': '',
'shutdown_method': '',
'ovf_tool_path': '',
'execution_server_selector': '',
'reserved_networks': '',
'default_datacenter': '',
'promiscuous_mode': ''
}
api.GetResourceDetails = Mock(return_value=vcenter_resource)
# Act + Assert
self.assertRaises(ValueError,
data_model_retriever.get_vcenter_data_model, api, '')
def test_get_vcenter_data_model(self):
# Arrange
data_model_retriever = VCenterDataModelRetriever(ResourceModelParser())
api = Mock()
vcenter_resource = create_autospec(ResourceContextDetails)
vcenter_resource.model = 'VMWare vCenter'
vcenter_resource.attrib = {
'user': '******',
'password': '******',
'default_dvswitch': '',
'holding_network': '',
'vm_cluster': '',
'vm_resource_pool': '',
'vm_storage': '',
'vm_location': '',
'shutdown_method': '',
'ovf_tool_path': '',
'execution_server_selector': '',
'reserved_networks': '',
'default_datacenter': '',
'promiscuous_mode': '',
'behavior_during_save': '',
'saved_sandbox_storage': ''
}
api.GetResourceDetails = Mock(return_value=vcenter_resource)
# Act
vcenter_data_model = data_model_retriever.get_vcenter_data_model(
api, 'VMWare Center')
# Assert
self.assertEqual(vcenter_data_model.user, 'uzer')
def test_parse_resource__info_model_missing_attribute(self):
resource_model_parser = ResourceModelParser()
attributes = {'Access Mode': 'Trunk'}
self.assertRaises(ValueError,
resource_model_parser.convert_to_resource_model,
attributes, VLANAutoResourceModel)
def __init__(self):
super(PaloAltoStaticShellDriver, self).__init__()
self._cli = None
self.cs_helper = CloudshellDriverHelper()
self.model_parser = ResourceModelParser()
self.ip_manager = VMIPManager()
self.task_waiter = SynchronousTaskWaiter()
self.pv_service = pyVmomiService(SmartConnect, Disconnect,
self.task_waiter)
def test_refresh_ip_choose_ip_by_regex(self):
nic1 = Mock()
nic1.network = 'A Network'
nic1.ipAddress = ['192.168.1.1']
nic2 = Mock()
nic2.network = 'A Network'
nic2.ipAddress = ['111.111.111.111']
guest = Mock()
guest.toolsStatus = 'toolsOk'
guest.net = [nic1, nic2]
vm = Mock()
vm.guest = guest
pyvmomi_service = Mock()
pyvmomi_service.find_by_uuid = Mock(return_value=vm)
ip_regex = self._create_custom_param('ip_regex', '192\.168\..*')
refresh_ip_timeout = self._create_custom_param('refresh_ip_timeout',
'10')
resource_model = create_autospec(GenericDeployedAppResourceModel)
resource_model.fullname = 'Generic Deployed App'
resource_model.vm_uuid = '123',
resource_model.cloud_provider = 'vCenter'
resource_model.vm_custom_params = [ip_regex, refresh_ip_timeout]
refresh_ip_command = RefreshIpCommand(pyvmomi_service,
ResourceModelParser(), Mock())
session = Mock()
session.UpdateResourceAddress = Mock(return_value=True)
session.GetResourceDetails = Mock(return_value=resource_model)
si = Mock()
center_resource_model = VMwarevCenterResourceModel()
center_resource_model.default_datacenter = 'QualiSB'
center_resource_model.holding_network = 'anetwork'
cancellation_context = Mock()
# Act
refresh_ip_command.refresh_ip(
si=si,
session=session,
vcenter_data_model=center_resource_model,
resource_model=resource_model,
cancellation_context=cancellation_context,
logger=Mock(),
app_request_json=Mock())
# Assert
self.assertTrue(
session.UpdateResourceAddress.called_with('machine1',
'192.168.1.1'))
def test_resource_models(self):
ns = {
'default':
'http://schemas.qualisystems.com/ResourceManagement/DataModelSchema.xsd'
}
#It didn't work with //..//..//.. so ?I used os.path.dirname X times
datamodel_path = os.path.join(
os.path.dirname(
os.path.dirname(
os.path.dirname(os.path.dirname(
os.path.dirname(__file__))))),
'vCenterShellPackage/DataModel/datamodel.xml')
tree = ET.parse(datamodel_path)
root = tree.getroot()
resource_models = root.findall('.//default:ResourceModel', ns)
self.assertGreater(len(resource_models), 0)
validation_errors = []
for resource_model in resource_models:
model_name = ResourceModelParser().get_resource_model_class_name(
resource_model.attrib['Name'])
try:
klass = ResourceModelParser().get_class(
'cloudshell.cp.vcenter.models.' + model_name)
except ValueError as value_error:
validation_errors.append(
'Failed to parse Model Name {0} with error {1}.'.format(
model_name, value_error.message))
continue
attribute_names = self.get_model_attributes(ns, resource_model)
for attribute_name in attribute_names:
if not hasattr(klass, attribute_name):
validation_errors.append(
'attribute {0} is missing on class {1}'.format(
attribute_name, model_name))
for validation_error in validation_errors:
print validation_error
self.assertSequenceEqual(validation_errors, [])
def test_parse_resource_info_model_with_specified_type_by_string(self):
resource_model_parser = ResourceModelParser()
attributes = {
'Access Mode': 'Trunk',
'VLAN ID': '123',
'Allocation Ranges': '2-4094',
'Virtual Network': '',
'Isolation Level': 'Exclusive'
}
self.assertRaises(ValueError,
resource_model_parser.convert_to_resource_model,
attributes, 'VLANAutoResourceModel')
def test_parse_resource_info_model(self):
resource_model_parser = ResourceModelParser()
attributes = {
'Access Mode': 'Trunk',
'VLAN Id': '123',
'Allocation Ranges': '2-4094',
'Virtual Network': '',
'Isolation Level': 'Exclusive'
}
resource_model = resource_model_parser.convert_to_resource_model(
attributes, VLANAutoResourceModel)
self.assertEqual(resource_model.access_mode, 'Trunk')
self.assertEqual(resource_model.vlan_id, '123')
self.assertEqual(resource_model.isolation_level, 'Exclusive')
self.assertEqual(resource_model.allocation_ranges, '2-4094')
self.assertEqual(resource_model.virtual_network, '')
self.assertEqual(resource_model.virtual_network_attribute,
'Virtual Network')
def test_parse_resource_info_model_class_does_not_exist(self):
resource_model_parser = ResourceModelParser()
self.assertRaises(ValueError,
resource_model_parser.convert_to_resource_model, {},
None)
def __init__(self):
"""
Initialize the driver session, this function is called everytime a new instance of the driver is created
in here the driver is going to be bootstrapped
:param context: models.QualiDriverModels.InitCommandContext
"""
self.cs_helper = CloudshellDriverHelper()
synchronous_task_waiter = SynchronousTaskWaiter()
pv_service = pyVmomiService(connect=SmartConnect,
disconnect=Disconnect,
task_waiter=synchronous_task_waiter)
self.resource_model_parser = ResourceModelParser()
port_group_name_generator = DvPortGroupNameGenerator()
vnic_to_network_mapper = VnicToNetworkMapper(
quali_name_generator=port_group_name_generator)
resource_remover = CloudshellResourceRemover()
ovf_service = OvfImageDeployerService(self.resource_model_parser)
self.vm_loader = VMLoader(pv_service)
vm_deployer = VirtualMachineDeployer(
pv_service=pv_service,
name_generator=generate_unique_name,
ovf_service=ovf_service,
cs_helper=self.cs_helper,
resource_model_parser=ResourceModelParser())
dv_port_group_creator = DvPortGroupCreator(
pyvmomi_service=pv_service,
synchronous_task_waiter=synchronous_task_waiter)
virtual_machine_port_group_configurer = \
VirtualMachinePortGroupConfigurer(pyvmomi_service=pv_service,
synchronous_task_waiter=synchronous_task_waiter,
vnic_to_network_mapper=vnic_to_network_mapper,
vnic_service=VNicService(),
name_gen=port_group_name_generator)
virtual_switch_to_machine_connector = VirtualSwitchToMachineConnector(
dv_port_group_creator, virtual_machine_port_group_configurer)
# Command Wrapper
self.command_wrapper = CommandWrapper(
pv_service=pv_service,
cloud_shell_helper=self.cs_helper,
resource_model_parser=self.resource_model_parser,
context_based_logger_factory=ContextBasedLoggerFactory())
# Deploy Command
self.deploy_command = DeployCommand(deployer=vm_deployer)
# Virtual Switch Revoke
self.virtual_switch_disconnect_command = \
VirtualSwitchToMachineDisconnectCommand(
pyvmomi_service=pv_service,
port_group_configurer=virtual_machine_port_group_configurer,
resource_model_parser=self.resource_model_parser)
# Virtual Switch Connect
virtual_switch_connect_command = \
VirtualSwitchConnectCommand(
pv_service=pv_service,
virtual_switch_to_machine_connector=virtual_switch_to_machine_connector,
dv_port_group_name_generator=DvPortGroupNameGenerator(),
vlan_spec_factory=VlanSpecFactory(),
vlan_id_range_parser=VLanIdRangeParser())
self.connection_orchestrator = ConnectionCommandOrchestrator(
connector=virtual_switch_connect_command,
disconnector=self.virtual_switch_disconnect_command,
resource_model_parser=self.resource_model_parser)
# Destroy VM Command
self.destroy_virtual_machine_command = \
DestroyVirtualMachineCommand(pv_service=pv_service,
resource_remover=resource_remover,
disconnector=self.virtual_switch_disconnect_command)
# Power Command
self.vm_power_management_command = \
VirtualMachinePowerManagementCommand(pyvmomi_service=pv_service,
synchronous_task_waiter=synchronous_task_waiter)
ip_manager = VMIPManager()
# Refresh IP command
self.refresh_ip_command = RefreshIpCommand(
pyvmomi_service=pv_service,
resource_model_parser=ResourceModelParser(),
ip_manager=ip_manager)
# Save Snapshot
self.snapshot_saver = SaveSnapshotCommand(
pyvmomi_service=pv_service, task_waiter=synchronous_task_waiter)
# Snapshot Restorer
self.snapshot_restorer = SnapshotRestoreCommand(
pyvmomi_service=pv_service, task_waiter=synchronous_task_waiter)
self.snapshots_retriever = RetrieveSnapshotsCommand(
pyvmomi_service=pv_service)
def setUp(self):
self._si = None
self.virtual_machine_path = 'SergiiT'
self.virtual_machine_name = 'JustTestNeedToBeRemoved'
self.vm_uuid = "422254d5-5226-946e-26fb-60c21898b731"
self.vcenter_name = "QualiSB"
self.dv_switch_path = 'QualiSB'
self.network_path = 'QualiSB'
self.dv_switch_name = 'dvSwitch-SergiiT'
self.dv_port_group_name = 'aa-dvPortGroup3B'
self.network = Mock()
self.network.key = "network-key"
self.network.config.distributedVirtualSwitch.uuid = "422254d5-5226-946e-26fb-60c21898b73f"
self.py_vmomi_service = Mock()
self.vm = Mock()
self.vm.config.hardware = Mock()
self.vnic = Mock(spec=vim.vm.device.VirtualEthernetCard)
self.vnic.deviceInfo = Mock()
self.vm.config.hardware.device = [self.vnic]
self.py_vmomi_service.find_by_uuid = lambda a, b, c: self.vm
self.py_vmomi_service.find_network_by_name = Mock(
return_value=self.network)
self.synchronous_task_waiter = Mock()
self.synchronous_task_waiter.wait_for_task = Mock(
return_value="TASK OK")
self.si = Mock()
resource_model_parser = ResourceModelParser()
# vc_model_retriever = VCenterDataModelRetriever(helpers, resource_model_parser, cloudshell_data_retriever_service)
# vc_data_model = vc_model_retriever.get_vcenter_data_model()
vc_data_model = Mock()
name_generator = generate_unique_name
# vnic_to_network_mapper = VnicToNetworkMapper(name_generator, vc_data_model.default_network)
vnic_to_network_mapper = VnicToNetworkMapper(name_generator)
helpers = Mock()
cs_retriever_service = Mock()
session = Mock()
resource_context = Mock()
connection_details = Mock()
helpers.get_resource_context_details = Mock(
return_value=resource_context)
helpers.get_api_session = Mock(return_value=session)
cs_retriever_service.getVCenterConnectionDetails = Mock(
return_value=connection_details)
self.connection_details_retriever = ResourceConnectionDetailsRetriever(
helpers)
self.configurer = VirtualMachinePortGroupConfigurer(
self.py_vmomi_service, self.synchronous_task_waiter,
vnic_to_network_mapper, Mock(), Mock())
# pyvmomi_service, synchronous_task_waiter, vnic_to_network_mapper, vnic_common
self.creator = DvPortGroupCreator(self.py_vmomi_service,
self.synchronous_task_waiter)
self.connector = VirtualSwitchToMachineConnector(
self.creator, self.configurer)
def __init__(self):
self.model_parser = ResourceModelParser()
self.ip_manager = VMIPManager()
self.task_waiter = SynchronousTaskWaiter()
self.logger = get_qs_logger('VM AutoLoad')
self.pv_service = pyVmomiService(SmartConnect, Disconnect, self.task_waiter)
def __init__(self):
self.parser = ResourceModelParser()
self.pv_service = pyVmomiService(SmartConnect, Disconnect,
SynchronousTaskWaiter())
self.context_based_logger_factory = ContextBasedLoggerFactory()
def __init__(self):
self.resource_model_parser = ResourceModelParser()
self.cs_helper = CloudshellDriverHelper()
