def test_get_or_create_isolated_security_group(self):
sg_name = Mock()
sg = Mock()
vpc = Mock()
management_sg_id = Mock()
security_group_service = Mock()
isolated_sg_name = 'all alone in the watch tower'
security_group_service.get_security_group_by_name = Mock(
return_value=None)
security_group_service.create_security_group = Mock(return_value=sg)
security_group_service.sandbox_default_sg_name = Mock(
return_value=sg_name)
security_group_service.sandbox_isolated_sg_name = Mock(
return_value=isolated_sg_name)
prepare_conn = PrepareConnectivityOperation(
self.vpc_serv, security_group_service, self.key_pair_serv,
self.tag_service, self.route_table_service, self.crypto_service,
self.cancellation_service, self.subnet_service, self.subnet_waiter)
res = prepare_conn._get_or_create_sandbox_isolated_security_group(
ec2_session=self.ec2_session,
management_sg_id=management_sg_id,
reservation=self.reservation,
vpc=vpc)
security_group_service.get_security_group_by_name.assert_called_once_with(
vpc=vpc, name=isolated_sg_name)
security_group_service.create_security_group.assert_called_once_with(
ec2_session=self.ec2_session,
vpc_id=vpc.id,
security_group_name=isolated_sg_name)
security_group_service.sandbox_isolated_sg_name.assert_called_once_with(
self.reservation.reservation_id)
self.assertEqual(sg, res)
def test_get_or_create_vpc(self):
cidr = Mock()
vpc = Mock()
vpc_service = Mock()
vpc_service.find_vpc_for_reservation = Mock(return_value=None)
vpc_service.create_vpc_for_reservation = Mock(return_value=vpc)
prepare_conn = PrepareConnectivityOperation(
vpc_service, self.sg_serv, self.key_pair_serv, self.tag_service,
self.route_table_service, self.crypto_service,
self.cancellation_service, self.subnet_service, self.subnet_waiter)
result = prepare_conn._get_or_create_vpc(cidr=cidr,
ec2_session=self.ec2_session,
reservation=self.reservation)
vpc_service.find_vpc_for_reservation.assert_called_once_with(
ec2_session=self.ec2_session,
reservation_id=self.reservation.reservation_id)
vpc_service.create_vpc_for_reservation.assert_called_once_with(
ec2_session=self.ec2_session,
reservation=self.reservation,
cidr=cidr)
self.assertEqual(vpc, result)
def test_get_or_create_default_sandbox_security_group(self):
sg_name = Mock()
sg = Mock()
vpc = Mock()
management_sg_id = Mock()
isolated_sg = Mock()
security_group_service = Mock()
security_group_service.sandbox_default_sg_name = Mock(
return_value=sg_name)
security_group_service.get_security_group_by_name = Mock(
return_value=None)
security_group_service.create_security_group = Mock(return_value=sg)
security_group_service.set_shared_reservation_security_group_rules = Mock(
)
tags = Mock()
self.tag_service.get_sandbox_default_security_group_tags = Mock(
return_value=tags)
prepare_conn = PrepareConnectivityOperation(
self.vpc_serv, security_group_service, self.key_pair_serv,
self.tag_service, self.route_table_service, self.crypto_service,
self.cancellation_service, self.subnet_service, self.subnet_waiter)
res = prepare_conn._get_or_create_sandbox_default_security_group(
ec2_session=self.ec2_session,
management_sg_id=management_sg_id,
reservation=self.reservation,
vpc=vpc,
isolated_sg=isolated_sg)
security_group_service.get_security_group_by_name.assert_called_once_with(
vpc=vpc, name=sg_name)
security_group_service.create_security_group.assert_called_once_with(
ec2_session=self.ec2_session,
vpc_id=vpc.id,
security_group_name=sg_name)
self.tag_service.get_sandbox_default_security_group_tags.assert_called_once_with(
name=sg_name, reservation=self.reservation)
self.tag_service.set_ec2_resource_tags.assert_called_once_with(
sg, tags)
security_group_service.set_shared_reservation_security_group_rules.assert_called_once_with(
security_group=sg,
management_sg_id=management_sg_id,
isolated_sg=isolated_sg)
self.assertEqual(sg, res)
def setUp(self):
self.vpc_serv = Mock()
self.vpc_serv.get_all_internet_gateways = Mock(return_value=[])
self.sg_serv = Mock()
self.key_pair_serv = Mock()
self.ec2_session = Mock()
self.ec2_client = Mock()
self.s3_session = Mock()
self.aws_dm = Mock()
self.tag_service = Mock()
self.reservation = Mock()
self.route_table_service = Mock()
self.crypto_service = Mock()
self.cancellation_service = Mock()
self.cancellation_context = Mock()
self.subnet_service = Mock()
self.subnet_waiter = Mock()
self.prepare_conn = PrepareConnectivityOperation(
self.vpc_serv, self.sg_serv, self.key_pair_serv, self.tag_service,
self.route_table_service, self.crypto_service,
self.cancellation_service, self.subnet_service, self.subnet_waiter)
def test_create_key_pair(self):
key_pair_service = Mock()
key_pair_service.load_key_pair_by_name = Mock(return_value=None)
prepare_conn = PrepareConnectivityOperation(
self.vpc_serv, self.sg_serv, key_pair_service, self.tag_service,
self.route_table_service, self.crypto_service,
self.cancellation_service, self.subnet_service, self.subnet_waiter)
key_pair = Mock()
key_pair_service.create_key_pair = Mock(return_value=key_pair)
access_key = prepare_conn._get_or_create_key_pair(
self.ec2_session, self.s3_session, 'bucket', 'res_id')
key_pair_service.load_key_pair_by_name.assert_called_once_with(
s3_session=self.s3_session,
bucket_name='bucket',
reservation_id='res_id')
key_pair_service.create_key_pair.assert_called_once_with(
ec2_session=self.ec2_session,
s3_session=self.s3_session,
bucket='bucket',
reservation_id='res_id')
self.assertEquals(access_key, key_pair.key_material)
class TestPrepareConnectivity(TestCase):
def setUp(self):
self.vpc_serv = Mock()
self.vpc_serv.get_all_internet_gateways = Mock(return_value=[])
self.sg_serv = Mock()
self.key_pair_serv = Mock()
self.ec2_session = Mock()
self.ec2_client = Mock()
self.s3_session = Mock()
self.aws_dm = Mock()
self.tag_service = Mock()
self.reservation = Mock()
self.route_table_service = Mock()
self.crypto_service = Mock()
self.cancellation_service = Mock()
self.cancellation_context = Mock()
self.subnet_service = Mock()
self.subnet_waiter = Mock()
self.prepare_conn = PrepareConnectivityOperation(
self.vpc_serv, self.sg_serv, self.key_pair_serv, self.tag_service,
self.route_table_service, self.crypto_service,
self.cancellation_service, self.subnet_service, self.subnet_waiter)
def test_prepare_conn_must_receive_network_action(self):
with self.assertRaises(Exception) as error:
self.prepare_conn.prepare_connectivity(
ec2_client=self.ec2_client,
ec2_session=self.ec2_session,
s3_session=self.s3_session,
reservation=self.reservation,
aws_ec2_datamodel=self.aws_dm,
actions=[NetworkAction()],
cancellation_context=self.cancellation_context,
logger=Mock())
self.assertEqual(error.exception.message,
"Actions list must contain a PrepareNetworkAction.")
def test_prepare_conn_execute_the_network_action_first(self):
# Arrage
actions = []
actions.append(
NetworkAction(id="SubA", connection_params=PrepareSubnetParams()))
actions.append(
NetworkAction(id="Net", connection_params=PrepareNetworkParams()))
actions.append(
NetworkAction(id="SubB", connection_params=PrepareSubnetParams()))
# Act
results = self.prepare_conn.prepare_connectivity(
ec2_client=self.ec2_client,
ec2_session=self.ec2_session,
s3_session=self.s3_session,
reservation=self.reservation,
aws_ec2_datamodel=self.aws_dm,
actions=actions,
cancellation_context=self.cancellation_context,
logger=Mock())
# Assert
self.assertEqual(len(results), 3)
self.assertEqual(results[0].actionId, "Net")
self.assertEqual(results[1].actionId, "SubA")
self.assertEqual(results[2].actionId, "SubB")
def test_prepare_conn_execute_the_subnet_actions(self):
# Arrage
actions = []
actions.append(
NetworkAction(id="Net", connection_params=PrepareNetworkParams()))
actions.append(
NetworkAction(id="SubA", connection_params=PrepareSubnetParams()))
actions.append(
NetworkAction(id="SubB", connection_params=PrepareSubnetParams()))
# Act
with patch(
'cloudshell.cp.aws.domain.conncetivity.operations.prepare.PrepareSubnetExecutor'
) as ctor:
obj = Mock()
obj.execute = Mock(return_value=["ResA", "ResB"])
ctor.return_value = obj
results = self.prepare_conn.prepare_connectivity(
ec2_client=self.ec2_client,
ec2_session=self.ec2_session,
s3_session=self.s3_session,
reservation=self.reservation,
aws_ec2_datamodel=self.aws_dm,
actions=actions,
cancellation_context=self.cancellation_context,
logger=Mock())
# Assert
self.assertEqual(len(results), 3)
self.assertEqual(results[1], "ResA")
self.assertEqual(results[2], "ResB")
def test_prepare_conn_command(self):
# Arrange
action = NetworkAction(id="1234",
connection_params=PrepareNetworkParams())
self.vpc_serv.get_peering_connection_by_reservation_id = Mock(
return_value=None)
access_key = Mock()
self.prepare_conn._get_or_create_key_pair = Mock(
return_value=access_key)
crypto_dto = Mock()
self.crypto_service.encrypt = Mock(return_value=crypto_dto)
self.route_table_service.get_all_route_tables = Mock(
return_value=MagicMock())
results = self.prepare_conn.prepare_connectivity(
ec2_client=self.ec2_client,
ec2_session=self.ec2_session,
s3_session=self.s3_session,
reservation=self.reservation,
aws_ec2_datamodel=self.aws_dm,
actions=[action],
cancellation_context=self.cancellation_context,
logger=Mock())
self.prepare_conn._get_or_create_key_pair.assert_called_once_with(
ec2_session=self.ec2_session,
s3_session=self.s3_session,
bucket=self.aws_dm.key_pairs_location,
reservation_id=self.reservation.reservation_id)
self.crypto_service.encrypt.assert_called_once_with(access_key)
self.assertEqual(results[0].actionId, action.id)
self.assertTrue(results[0].success)
self.assertEqual(results[0].infoMessage,
'PrepareNetwork finished successfully')
self.assertEqual(results[0].errorMessage, '')
self.assertEqual(results[0].access_key, crypto_dto.encrypted_input)
self.assertEqual(results[0].secret_key,
crypto_dto.encrypted_asymmetric_key)
self.cancellation_service.check_if_cancelled.assert_called()
def test_prepare_conn_command_no_management_vpc(self):
request = Mock()
aws_dm = Mock()
cancellation_context = Mock()
aws_dm.aws_management_vpc_id = None
self.assertRaises(ValueError, self.prepare_conn.prepare_connectivity,
self.ec2_client, self.ec2_session, self.s3_session,
self.reservation, aws_dm, request,
cancellation_context, Mock())
def test_prepare_conn_error_no_vpc_with_vpc_count(self):
self.vpc_serv.find_vpc_for_reservation = Mock(return_value=None)
vpc_count = 50
self.vpc_serv.get_active_vpcs_count = Mock(return_value=vpc_count)
# Arrage
actions = []
actions.append(
NetworkAction(id="SubA", connection_params=PrepareSubnetParams()))
actions.append(
NetworkAction(id="Net", connection_params=PrepareNetworkParams()))
actions.append(
NetworkAction(id="SubB", connection_params=PrepareSubnetParams()))
# Assert
self.assertRaisesRegexp(ValueError,
'(/{0}/)|(limit.$)'.format(vpc_count),
self.prepare_conn.prepare_connectivity,
ec2_client=self.ec2_client,
ec2_session=self.ec2_session,
s3_session=self.s3_session,
reservation=self.reservation,
aws_ec2_datamodel=self.aws_dm,
actions=actions,
cancellation_context=self.cancellation_context,
logger=Mock())
def test_prepare_conn_error_no_vpc(self):
self.vpc_serv.find_vpc_for_reservation = Mock(return_value=None)
self.vpc_serv.get_active_vpcs_count = Mock(return_value=None)
# Arrage
actions = []
actions.append(
NetworkAction(id="SubA", connection_params=PrepareSubnetParams()))
actions.append(
NetworkAction(id="Net", connection_params=PrepareNetworkParams()))
actions.append(
NetworkAction(id="SubB", connection_params=PrepareSubnetParams()))
# Assert
self.assertRaisesRegexp(ValueError,
'^((?!limit).)*$',
self.prepare_conn.prepare_connectivity,
ec2_client=self.ec2_client,
ec2_session=self.ec2_session,
s3_session=self.s3_session,
reservation=self.reservation,
aws_ec2_datamodel=self.aws_dm,
actions=actions,
cancellation_context=self.cancellation_context,
logger=Mock())
def test_prepare_conn_command_fault_res(self):
action = NetworkAction()
action.id = "1234"
action.connection_params = PrepareNetworkParams()
cancellation_context = Mock()
results = self.prepare_conn.prepare_connectivity(
ec2_client=self.ec2_client,
ec2_session=self.ec2_session,
s3_session=self.s3_session,
reservation=self.reservation,
aws_ec2_datamodel=self.aws_dm,
actions=[action],
cancellation_context=cancellation_context,
logger=Mock())
self.assertEqual(results[0].actionId, action.id)
self.assertFalse(results[0].success)
self.assertEqual(results[0].infoMessage, '')
self.assertIsNotNone(results[0].errorMessage)
def test_create_key_pair(self):
key_pair_service = Mock()
key_pair_service.load_key_pair_by_name = Mock(return_value=None)
prepare_conn = PrepareConnectivityOperation(
self.vpc_serv, self.sg_serv, key_pair_service, self.tag_service,
self.route_table_service, self.crypto_service,
self.cancellation_service, self.subnet_service, self.subnet_waiter)
key_pair = Mock()
key_pair_service.create_key_pair = Mock(return_value=key_pair)
access_key = prepare_conn._get_or_create_key_pair(
self.ec2_session, self.s3_session, 'bucket', 'res_id')
key_pair_service.load_key_pair_by_name.assert_called_once_with(
s3_session=self.s3_session,
bucket_name='bucket',
reservation_id='res_id')
key_pair_service.create_key_pair.assert_called_once_with(
ec2_session=self.ec2_session,
s3_session=self.s3_session,
bucket='bucket',
reservation_id='res_id')
self.assertEquals(access_key, key_pair.key_material)
def test_get_or_create_security_groups(self):
sg = Mock()
vpc = Mock()
sg_name = Mock()
isolated_sg = Mock()
management_sg_id = Mock()
security_group_service = Mock()
security_group_service.get_security_group_name = Mock(
return_value=sg_name)
security_group_service.get_security_group_by_name = Mock(
return_value=None)
security_group_service.create_security_group = Mock(return_value=sg)
prepare_conn = PrepareConnectivityOperation(
self.vpc_serv, security_group_service, self.key_pair_serv,
self.tag_service, self.route_table_service, self.crypto_service,
self.cancellation_service, self.subnet_service, self.subnet_waiter)
prepare_conn._get_or_create_sandbox_isolated_security_group = Mock(
return_value=isolated_sg)
res = prepare_conn._get_or_create_default_security_groups(
self.ec2_session, self.reservation, vpc, management_sg_id)
security_group_service.get_security_group_by_name.assert_called_with(
vpc=vpc, name=security_group_service.sandbox_default_sg_name())
security_group_service.create_security_group.assert_called_with(
ec2_session=self.ec2_session,
vpc_id=vpc.id,
security_group_name=security_group_service.sandbox_default_sg_name(
))
self.tag_service.get_sandbox_default_security_group_tags.assert_called_once_with(
name=security_group_service.sandbox_default_sg_name(),
reservation=self.reservation)
security_group_service.set_shared_reservation_security_group_rules.assert_called_once_with(
security_group=sg,
management_sg_id=management_sg_id,
isolated_sg=isolated_sg)
self.assertEqual(
[isolated_sg, sg],
res) # create two security groups, default and isolated
def test_get_or_create_default_sandbox_security_group(self):
sg_name = Mock()
sg = Mock()
vpc = Mock()
management_sg_id = Mock()
isolated_sg = Mock()
security_group_service = Mock()
security_group_service.sandbox_default_sg_name = Mock(
return_value=sg_name)
security_group_service.get_security_group_by_name = Mock(
return_value=None)
security_group_service.create_security_group = Mock(return_value=sg)
security_group_service.set_shared_reservation_security_group_rules = Mock(
)
tags = Mock()
self.tag_service.get_sandbox_default_security_group_tags = Mock(
return_value=tags)
prepare_conn = PrepareConnectivityOperation(
self.vpc_serv, security_group_service, self.key_pair_serv,
self.tag_service, self.route_table_service, self.crypto_service,
self.cancellation_service, self.subnet_service, self.subnet_waiter)
res = prepare_conn._get_or_create_sandbox_default_security_group(
ec2_session=self.ec2_session,
management_sg_id=management_sg_id,
reservation=self.reservation,
vpc=vpc,
isolated_sg=isolated_sg)
security_group_service.get_security_group_by_name.assert_called_once_with(
vpc=vpc, name=sg_name)
security_group_service.create_security_group.assert_called_once_with(
ec2_session=self.ec2_session,
vpc_id=vpc.id,
security_group_name=sg_name)
self.tag_service.get_sandbox_default_security_group_tags.assert_called_once_with(
name=sg_name, reservation=self.reservation)
self.tag_service.set_ec2_resource_tags.assert_called_once_with(
sg, tags)
security_group_service.set_shared_reservation_security_group_rules.assert_called_once_with(
security_group=sg,
management_sg_id=management_sg_id,
isolated_sg=isolated_sg)
self.assertEqual(sg, res)
def test_get_or_create_isolated_security_group(self):
sg_name = Mock()
sg = Mock()
vpc = Mock()
management_sg_id = Mock()
security_group_service = Mock()
isolated_sg_name = 'all alone in the watch tower'
security_group_service.get_security_group_by_name = Mock(
return_value=None)
security_group_service.create_security_group = Mock(return_value=sg)
security_group_service.sandbox_default_sg_name = Mock(
return_value=sg_name)
security_group_service.sandbox_isolated_sg_name = Mock(
return_value=isolated_sg_name)
prepare_conn = PrepareConnectivityOperation(
self.vpc_serv, security_group_service, self.key_pair_serv,
self.tag_service, self.route_table_service, self.crypto_service,
self.cancellation_service, self.subnet_service, self.subnet_waiter)
res = prepare_conn._get_or_create_sandbox_isolated_security_group(
ec2_session=self.ec2_session,
management_sg_id=management_sg_id,
reservation=self.reservation,
vpc=vpc)
security_group_service.get_security_group_by_name.assert_called_once_with(
vpc=vpc, name=isolated_sg_name)
security_group_service.create_security_group.assert_called_once_with(
ec2_session=self.ec2_session,
vpc_id=vpc.id,
security_group_name=isolated_sg_name)
security_group_service.sandbox_isolated_sg_name.assert_called_once_with(
self.reservation.reservation_id)
self.assertEqual(sg, res)
def test_get_or_create_vpc(self):
cidr = Mock()
vpc = Mock()
vpc_service = Mock()
vpc_service.find_vpc_for_reservation = Mock(return_value=None)
vpc_service.create_vpc_for_reservation = Mock(return_value=vpc)
prepare_conn = PrepareConnectivityOperation(
vpc_service, self.sg_serv, self.key_pair_serv, self.tag_service,
self.route_table_service, self.crypto_service,
self.cancellation_service, self.subnet_service, self.subnet_waiter)
result = prepare_conn._get_or_create_vpc(cidr=cidr,
ec2_session=self.ec2_session,
reservation=self.reservation)
vpc_service.find_vpc_for_reservation.assert_called_once_with(
ec2_session=self.ec2_session,
reservation_id=self.reservation.reservation_id)
vpc_service.create_vpc_for_reservation.assert_called_once_with(
ec2_session=self.ec2_session,
reservation=self.reservation,
cidr=cidr)
self.assertEqual(vpc, result)
def __init__(self):
self.command_result_parser = CommandResultsParser()
self.cancellation_service = CommandCancellationService()
self.tag_service = TagService()
self.ec2_instance_waiter = InstanceWaiter(cancellation_service=self.cancellation_service)
self.instance_service = InstanceService(self.tag_service, self.ec2_instance_waiter)
self.ec2_storage_service = EC2StorageService()
self.model_parser = AWSModelsParser()
self.cloudshell_session_helper = CloudshellDriverHelper()
self.aws_session_manager = AWSSessionProvider()
self.password_waiter = PasswordWaiter(self.cancellation_service)
self.vm_custom_params_extractor = VmCustomParamsExtractor()
self.ami_credentials_service = InstanceCredentialsService(self.password_waiter)
self.security_group_service = SecurityGroupService(self.tag_service)
self.subnet_waiter = SubnetWaiter()
self.subnet_service = SubnetService(self.tag_service, self.subnet_waiter)
self.s3_service = S3BucketService()
self.vpc_peering_waiter = VpcPeeringConnectionWaiter()
self.key_pair_service = KeyPairService(self.s3_service)
self.vpc_waiter = VPCWaiter()
self.route_tables_service = RouteTablesService(self.tag_service)
self.cryptography_service = CryptographyService()
self.network_interface_service = NetworkInterfaceService(subnet_service=self.subnet_service)
self.elastic_ip_service = ElasticIpService()
self.vm_details_provider = VmDetailsProvider()
self.vpc_service = VPCService(tag_service=self.tag_service,
subnet_service=self.subnet_service,
instance_service=self.instance_service,
vpc_waiter=self.vpc_waiter,
vpc_peering_waiter=self.vpc_peering_waiter,
sg_service=self.security_group_service,
route_table_service=self.route_tables_service)
self.prepare_connectivity_operation = \
PrepareConnectivityOperation(vpc_service=self.vpc_service,
security_group_service=self.security_group_service,
key_pair_service=self.key_pair_service,
tag_service=self.tag_service,
route_table_service=self.route_tables_service,
cryptography_service=self.cryptography_service,
cancellation_service=self.cancellation_service,
subnet_service=self.subnet_service,
subnet_waiter=self.subnet_waiter)
self.deploy_ami_operation = DeployAMIOperation(instance_service=self.instance_service,
ami_credential_service=self.ami_credentials_service,
security_group_service=self.security_group_service,
tag_service=self.tag_service,
vpc_service=self.vpc_service,
key_pair_service=self.key_pair_service,
subnet_service=self.subnet_service,
elastic_ip_service=self.elastic_ip_service,
network_interface_service=self.network_interface_service,
cancellation_service=self.cancellation_service,
device_index_strategy=AllocateMissingValuesDeviceIndexStrategy(),
vm_details_provider=self.vm_details_provider)
self.refresh_ip_operation = RefreshIpOperation(instance_service=self.instance_service)
self.power_management_operation = PowerOperation(instance_service=self.instance_service,
instance_waiter=self.ec2_instance_waiter)
self.delete_ami_operation = DeleteAMIOperation(instance_service=self.instance_service,
ec2_storage_service=self.ec2_storage_service,
security_group_service=self.security_group_service,
tag_service=self.tag_service,
elastic_ip_service=self.elastic_ip_service)
self.clean_up_operation = CleanupConnectivityOperation(vpc_service=self.vpc_service,
key_pair_service=self.key_pair_service,
route_table_service=self.route_tables_service)
self.deployed_app_ports_operation = DeployedAppPortsOperation(self.vm_custom_params_extractor,
security_group_service=self.security_group_service,
instance_service=self.instance_service)
self.access_key_operation = GetAccessKeyOperation(key_pair_service=self.key_pair_service)
self.set_app_security_groups_operation = SetAppSecurityGroupsOperation(instance_service=self.instance_service,
tag_service=self.tag_service,
security_group_service=self.security_group_service)
self.vm_details_operation = VmDetailsOperation(instance_service=self.instance_service,
vm_details_provider=self.vm_details_provider)
class AWSShell(object):
def __init__(self):
self.command_result_parser = CommandResultsParser()
self.cancellation_service = CommandCancellationService()
self.tag_service = TagService()
self.ec2_instance_waiter = InstanceWaiter(cancellation_service=self.cancellation_service)
self.instance_service = InstanceService(self.tag_service, self.ec2_instance_waiter)
self.ec2_storage_service = EC2StorageService()
self.model_parser = AWSModelsParser()
self.cloudshell_session_helper = CloudshellDriverHelper()
self.aws_session_manager = AWSSessionProvider()
self.password_waiter = PasswordWaiter(self.cancellation_service)
self.vm_custom_params_extractor = VmCustomParamsExtractor()
self.ami_credentials_service = InstanceCredentialsService(self.password_waiter)
self.security_group_service = SecurityGroupService(self.tag_service)
self.subnet_waiter = SubnetWaiter()
self.subnet_service = SubnetService(self.tag_service, self.subnet_waiter)
self.s3_service = S3BucketService()
self.vpc_peering_waiter = VpcPeeringConnectionWaiter()
self.key_pair_service = KeyPairService(self.s3_service)
self.vpc_waiter = VPCWaiter()
self.route_tables_service = RouteTablesService(self.tag_service)
self.cryptography_service = CryptographyService()
self.network_interface_service = NetworkInterfaceService(subnet_service=self.subnet_service)
self.elastic_ip_service = ElasticIpService()
self.vm_details_provider = VmDetailsProvider()
self.vpc_service = VPCService(tag_service=self.tag_service,
subnet_service=self.subnet_service,
instance_service=self.instance_service,
vpc_waiter=self.vpc_waiter,
vpc_peering_waiter=self.vpc_peering_waiter,
sg_service=self.security_group_service,
route_table_service=self.route_tables_service)
self.prepare_connectivity_operation = \
PrepareConnectivityOperation(vpc_service=self.vpc_service,
security_group_service=self.security_group_service,
key_pair_service=self.key_pair_service,
tag_service=self.tag_service,
route_table_service=self.route_tables_service,
cryptography_service=self.cryptography_service,
cancellation_service=self.cancellation_service,
subnet_service=self.subnet_service,
subnet_waiter=self.subnet_waiter)
self.deploy_ami_operation = DeployAMIOperation(instance_service=self.instance_service,
ami_credential_service=self.ami_credentials_service,
security_group_service=self.security_group_service,
tag_service=self.tag_service,
vpc_service=self.vpc_service,
key_pair_service=self.key_pair_service,
subnet_service=self.subnet_service,
elastic_ip_service=self.elastic_ip_service,
network_interface_service=self.network_interface_service,
cancellation_service=self.cancellation_service,
device_index_strategy=AllocateMissingValuesDeviceIndexStrategy(),
vm_details_provider=self.vm_details_provider)
self.refresh_ip_operation = RefreshIpOperation(instance_service=self.instance_service)
self.power_management_operation = PowerOperation(instance_service=self.instance_service,
instance_waiter=self.ec2_instance_waiter)
self.delete_ami_operation = DeleteAMIOperation(instance_service=self.instance_service,
ec2_storage_service=self.ec2_storage_service,
security_group_service=self.security_group_service,
tag_service=self.tag_service,
elastic_ip_service=self.elastic_ip_service)
self.clean_up_operation = CleanupConnectivityOperation(vpc_service=self.vpc_service,
key_pair_service=self.key_pair_service,
route_table_service=self.route_tables_service)
self.deployed_app_ports_operation = DeployedAppPortsOperation(self.vm_custom_params_extractor,
security_group_service=self.security_group_service,
instance_service=self.instance_service)
self.access_key_operation = GetAccessKeyOperation(key_pair_service=self.key_pair_service)
self.set_app_security_groups_operation = SetAppSecurityGroupsOperation(instance_service=self.instance_service,
tag_service=self.tag_service,
security_group_service=self.security_group_service)
self.vm_details_operation = VmDetailsOperation(instance_service=self.instance_service,
vm_details_provider=self.vm_details_provider)
def cleanup_connectivity(self, command_context, request):
"""
Will delete the reservation vpc and all related resources including all remaining instances
:param ResourceCommandContext command_context:
:param request: The json request
:return: json string response
:rtype: str
"""
with AwsShellContext(context=command_context, aws_session_manager=self.aws_session_manager) as shell_context:
with ErrorHandlingContext(shell_context.logger):
shell_context.logger.info('Cleanup Connectivity')
connectivity_actions = self._request_str_to_actions_list(request)
result = self.clean_up_operation \
.cleanup(ec2_client=shell_context.aws_api.ec2_client,
ec2_session=shell_context.aws_api.ec2_session,
s3_session=shell_context.aws_api.s3_session,
aws_ec2_data_model=shell_context.aws_ec2_resource_model,
reservation_id=command_context.reservation.reservation_id,
actions=connectivity_actions,
logger=shell_context.logger)
return self.command_result_parser.set_command_result(
{'driverResponse': {'actionResults': [result]}})
def prepare_connectivity(self, command_context, request, cancellation_context):
"""
Will create a vpc for the reservation and will peer it with the management vpc
:param ResourceCommandContext command_context: The Command Context
:param request: The json request
:return: json string response
:param CancellationContext cancellation_context:
:rtype: str
"""
with AwsShellContext(context=command_context, aws_session_manager=self.aws_session_manager) as shell_context:
with ErrorHandlingContext(shell_context.logger):
shell_context.logger.info('Prepare Connectivity')
# parse request
connectivity_actions = self._request_str_to_actions_list(request)
results = self.prepare_connectivity_operation.prepare_connectivity(
ec2_client=shell_context.aws_api.ec2_client,
ec2_session=shell_context.aws_api.ec2_session,
s3_session=shell_context.aws_api.s3_session,
reservation=self.model_parser.convert_to_reservation_model(command_context.reservation),
aws_ec2_datamodel=shell_context.aws_ec2_resource_model,
actions=connectivity_actions,
cancellation_context=cancellation_context,
logger=shell_context.logger)
return self.command_result_parser.set_command_result({'driverResponse': {'actionResults': results}})
def _request_str_to_actions_list(self, request):
decoded_request = jsonpickle.decode(request)
if not decoded_request.get('driverRequest') or not decoded_request.get('driverRequest').get('actions'):
raise ValueError('Invalid connectivity request')
return NetworkActionsParser.parse_network_actions_data(decoded_request['driverRequest']['actions'])
def power_on_ami(self, command_context):
"""
Will power on the ami
:param ResourceRemoteCommandContext command_context:
"""
with AwsShellContext(context=command_context, aws_session_manager=self.aws_session_manager) as shell_context:
with ErrorHandlingContext(shell_context.logger):
shell_context.logger.info('Power On')
resource = command_context.remote_endpoints[0]
data_holder = self.model_parser.convert_app_resource_to_deployed_app(resource)
self.power_management_operation.power_on(ec2_session=shell_context.aws_api.ec2_session,
ami_id=data_holder.vmdetails.uid)
shell_context.cloudshell_session.SetResourceLiveStatus(resource.fullname, "Online", "Active")
def power_off_ami(self, command_context):
"""
Will power on the ami
:param ResourceRemoteCommandContext command_context:
"""
with AwsShellContext(context=command_context, aws_session_manager=self.aws_session_manager) as shell_context:
with ErrorHandlingContext(shell_context.logger):
shell_context.logger.info('Power Off')
resource = command_context.remote_endpoints[0]
data_holder = self.model_parser.convert_app_resource_to_deployed_app(resource)
self.power_management_operation.power_off(ec2_session=shell_context.aws_api.ec2_session,
ami_id=data_holder.vmdetails.uid)
shell_context.cloudshell_session.SetResourceLiveStatus(resource.fullname, "Offline", "Powered Off")
def delete_instance(self, command_context):
"""
Will delete the ami instance
:param ResourceRemoteCommandContext command_context:
"""
with AwsShellContext(context=command_context, aws_session_manager=self.aws_session_manager) as shell_context:
with ErrorHandlingContext(shell_context.logger):
shell_context.logger.info('Delete instance')
resource = command_context.remote_endpoints[0]
data_holder = self.model_parser.convert_app_resource_to_deployed_app(resource)
self.delete_ami_operation.delete_instance(logger=shell_context.logger,
ec2_session=shell_context.aws_api.ec2_session,
instance_id=data_holder.vmdetails.uid)
def get_application_ports(self, command_context):
"""
Will return the application ports in a nicely formated manner
:param ResourceRemoteCommandContext command_context:
:rtype: str
"""
with AwsShellContext(context=command_context, aws_session_manager=self.aws_session_manager) as shell_context:
with ErrorHandlingContext(shell_context.logger):
shell_context.logger.info('Get Application Ports')
resource = command_context.remote_endpoints[0]
# Get instance id
deployed_instance_id = self.model_parser.try_get_deployed_connected_resource_instance_id(
command_context)
# Get Allow all Storage Traffic on deployed resource
allow_all_storage_traffic = self.model_parser.get_allow_all_storage_traffic_from_connected_resource_details(command_context)
return self.deployed_app_ports_operation.get_app_ports_from_cloud_provider(
ec2_session=shell_context.aws_api.ec2_session,
instance_id=deployed_instance_id,
resource=resource,
allow_all_storage_traffic=allow_all_storage_traffic)
def deploy_ami(self, command_context, deployment_request, cancellation_context):
"""
Will deploy Amazon Image on the cloud provider
:param ResourceCommandContext command_context:
:param JSON Obj deployment_request:
:param CancellationContext cancellation_context:
"""
with AwsShellContext(context=command_context, aws_session_manager=self.aws_session_manager) as shell_context:
with ErrorHandlingContext(shell_context.logger):
shell_context.logger.info('Deploying AMI')
aws_ami_deployment_model = self.model_parser.convert_to_deployment_resource_model(deployment_request,
command_context.resource)
deploy_data = self.deploy_ami_operation \
.deploy(ec2_session=shell_context.aws_api.ec2_session,
s3_session=shell_context.aws_api.s3_session,
name=aws_ami_deployment_model.app_name,
reservation=self.model_parser.convert_to_reservation_model(command_context.reservation),
aws_ec2_cp_resource_model=shell_context.aws_ec2_resource_model,
ami_deployment_model=aws_ami_deployment_model,
ec2_client=shell_context.aws_api.ec2_client,
cancellation_context=cancellation_context,
logger=shell_context.logger)
return self.command_result_parser.set_command_result(deploy_data)
def refresh_ip(self, command_context):
"""
:param ResourceRemoteCommandContext command_context:
"""
with AwsShellContext(context=command_context, aws_session_manager=self.aws_session_manager) as shell_context:
with ErrorHandlingContext(shell_context.logger):
shell_context.logger.info('Refresh IP')
# Get Private Ip on deployed resource
private_ip_on_resource = self.model_parser.get_private_ip_from_connected_resource_details(
command_context)
# Get Public IP on deployed resource
public_ip_on_resource = self.model_parser.get_public_ip_from_connected_resource_details(command_context)
# Get instance id
deployed_instance_id = self.model_parser.try_get_deployed_connected_resource_instance_id(
command_context)
# Get connected resource name
resource_fullname = self.model_parser.get_connectd_resource_fullname(command_context)
self.refresh_ip_operation.refresh_ip(cloudshell_session=shell_context.cloudshell_session,
ec2_session=shell_context.aws_api.ec2_session,
deployed_instance_id=deployed_instance_id,
private_ip_on_resource=private_ip_on_resource,
public_ip_on_resource=public_ip_on_resource,
resource_fullname=resource_fullname)
def get_access_key(self, command_context):
"""
Returns the pem file for the connected resource
:param ResourceRemoteCommandContext command_context:
:rtype str:
"""
with AwsShellContext(context=command_context, aws_session_manager=self.aws_session_manager) as shell_context:
with ErrorHandlingContext(shell_context.logger):
shell_context.logger.info('GetAccessKey')
reservation_id = self._get_reservation_id(command_context)
return self.access_key_operation.get_access_key(s3_session=shell_context.aws_api.s3_session,
aws_ec2_resource_model=shell_context.aws_ec2_resource_model,
reservation_id=reservation_id)
def set_app_security_groups(self, context, request):
"""
Set security groups (inbound rules only)
:param context: todo - set the type of the parameter
:param request: The json request
:return:
"""
with AwsShellContext(context=context, aws_session_manager=self.aws_session_manager) as shell_context:
with ErrorHandlingContext(shell_context.logger):
shell_context.logger.info('Set App Security Groups')
reservation = self.model_parser.convert_to_reservation_model(context.reservation)
app_security_group_models = self.model_parser.convert_to_app_security_group_models(request)
result = self.set_app_security_groups_operation.set_apps_security_groups(
app_security_group_models=app_security_group_models,
reservation=reservation,
ec2_session=shell_context.aws_api.ec2_session,
logger=shell_context.logger)
json_result = SetAppSecurityGroupActionResult.to_json(result)
return json_result
def get_vm_details(self, context):
"""
Get vm details for specific deployed app
:type context: ResourceRemoteCommandContext
:rtype str
"""
with AwsShellContext(context=context, aws_session_manager=self.aws_session_manager) as shell_context:
with ErrorHandlingContext(shell_context.logger):
shell_context.logger.info('Get VmDetails')
instance_id = self.model_parser.try_get_deployed_connected_resource_instance_id(context)
vm_details = self.vm_details_operation.get_vm_details(instance_id, shell_context.aws_api.ec2_session)
return self.command_result_parser.set_command_result(vm_details)
@staticmethod
def _get_reservation_id(context):
reservation_id = None
reservation = getattr(context, 'reservation', getattr(context, 'remote_reservation', None))
if reservation:
reservation_id = reservation.reservation_id
return reservation_id