Examples with NetworkState com.vmware.photon.controller.model.resources.NetworkService.NetworkState used on opensource projects

Example 11 with NetworkState

use of com.vmware.photon.controller.model.resources.NetworkService.NetworkState in project photon-model by vmware.

the class AWSNetworkStateEnumerationAdapterService method updateTagLinks.

private DeferredResult<AWSNetworkStateCreationContext> updateTagLinks(AWSNetworkStateCreationContext context) {
    if ((context.awsVpcs == null || context.awsVpcs.isEmpty()) && (context.awsSubnets == null || context.awsSubnets.isEmpty())) {
        logFine(() -> "No local vpcs or subnets to be updated so there are no tags to update.");
        return DeferredResult.completed(context);
    } else {
        List<DeferredResult<Set<String>>> updateNetworkSubnetTagLinksOps = new ArrayList<>();
        // update tag links for the existing NetworkStates
        for (String vpcId : context.awsVpcs.keySet()) {
            if (!context.localNetworkStateMap.containsKey(vpcId)) {
                // this is not a network to update
                continue;
            }
            Vpc vpc = context.awsVpcs.get(vpcId);
            NetworkState existingNetworkState = context.localNetworkStateMap.get(vpcId);
            Map<String, String> remoteTags = new HashMap<>();
            for (Tag awsVpcTag : vpc.getTags()) {
                if (!awsVpcTag.getKey().equals(AWSConstants.AWS_TAG_NAME)) {
                    remoteTags.put(awsVpcTag.getKey(), awsVpcTag.getValue());
                }
            }
            updateNetworkSubnetTagLinksOps.add(updateLocalTagStates(this, existingNetworkState, remoteTags, null));
        }
        // update tag links for the existing SubnetStates
        for (String subnetId : context.awsSubnets.keySet()) {
            if (!context.localSubnetStateMap.containsKey(subnetId)) {
                // this is not a subnet to update
                continue;
            }
            Subnet subnet = context.awsSubnets.get(subnetId);
            SubnetState existingSubnetState = context.localSubnetStateMap.get(subnetId);
            Map<String, String> remoteTags = new HashMap<>();
            for (Tag awsSubnetTag : subnet.getTags()) {
                if (!awsSubnetTag.getKey().equals(AWSConstants.AWS_TAG_NAME)) {
                    remoteTags.put(awsSubnetTag.getKey(), awsSubnetTag.getValue());
                }
            }
            updateNetworkSubnetTagLinksOps.add(updateLocalTagStates(this, existingSubnetState, remoteTags, null));
        }
        return DeferredResult.allOf(updateNetworkSubnetTagLinksOps).thenApply(ignore -> context);
    }
}

Example 12 with NetworkState

use of com.vmware.photon.controller.model.resources.NetworkService.NetworkState in project photon-model by vmware.

the class AWSNetworkStateEnumerationAdapterService method createNetworkStateOperations.

/**
 * Create the network state operations for all the VPCs that need to be created or updated in
 * the system.
 */
private void createNetworkStateOperations(AWSNetworkStateCreationContext context, AWSNetworkStateCreationStage next) {
    if (context.vpcs.isEmpty()) {
        logFine(() -> "No new VPCs have been discovered.");
        handleNetworkStateChanges(context, next);
        return;
    }
    final List<Operation> networkOperations = new ArrayList<>();
    for (String remoteVPCId : context.vpcs.keySet()) {
        NetworkState networkState = context.vpcs.get(remoteVPCId);
        final Operation networkStateOp;
        if (context.localNetworkStateMap.containsKey(remoteVPCId)) {
            // If the local network state already exists for the VPC -> Update it.
            networkState.documentSelfLink = context.localNetworkStateMap.get(remoteVPCId).documentSelfLink;
            // don't overwrite resourcePoolLink
            networkState.resourcePoolLink = null;
            if (networkState.tagLinks == null || networkState.tagLinks.isEmpty()) {
                setTagLinksToResourceState(networkState, context.networkInternalTagsMap, false);
            } else {
                context.networkInternalTagLinksSet.stream().filter(tagLink -> !networkState.tagLinks.contains(tagLink)).map(tagLink -> networkState.tagLinks.add(tagLink)).collect(Collectors.toSet());
            }
            networkStateOp = createPatchOperation(this, networkState, networkState.documentSelfLink);
        } else {
            Vpc awsVpc = context.awsVpcs.get(remoteVPCId);
            // Add both external and internal tags.
            setResourceTags(networkState, awsVpc.getTags());
            setTagLinksToResourceState(networkState, context.networkInternalTagsMap, false);
            networkStateOp = createPostOperation(this, networkState, NetworkService.FACTORY_LINK);
        }
        networkOperations.add(networkStateOp);
    }
    JoinedCompletionHandler joinCompletion = (ops, excs) -> {
        if (excs != null) {
            Entry<Long, Throwable> excEntry = excs.entrySet().iterator().next();
            Throwable exc = excEntry.getValue();
            Operation op = ops.get(excEntry.getKey());
            logSevere(() -> String.format("Error %s-ing a Network state: %s", op.getAction(), Utils.toString(excs)));
            finishWithFailure(context, exc);
            return;
        }
        logFine(() -> "Created/updated all network states.");
        ops.values().stream().filter(op -> op.getStatusCode() != Operation.STATUS_CODE_NOT_MODIFIED).forEach(op -> {
            NetworkState networkState = op.getBody(NetworkState.class);
            context.vpcs.put(networkState.id, networkState);
        });
        handleNetworkStateChanges(context, next);
    };
    OperationJoin.create(networkOperations).setCompletion(joinCompletion).sendWith(this);
}

Example 13 with NetworkState

use of com.vmware.photon.controller.model.resources.NetworkService.NetworkState in project photon-model by vmware.

the class TestUtils method postNetwork.

public static void postNetwork(VerificationHost host, NetworkState state, Operation response) throws Throwable {
    URI networkFactory = UriUtils.buildUri(host, NetworkService.FACTORY_LINK);
    host.testStart(1);
    Operation startPost = Operation.createPost(networkFactory).setBody(state).setCompletion((o, e) -> {
        if (e != null) {
            host.failIteration(e);
            return;
        }
        response.setBody(o.getBody(NetworkState.class));
        host.completeIteration();
    });
    host.send(startPost);
    host.testWait();
}

Example 14 with NetworkState

use of com.vmware.photon.controller.model.resources.NetworkService.NetworkState in project photon-model by vmware.

the class TestAzureEnumerationTask method validateVirtualNetworkGateways.

/**
 * Validates that the Gateway information discovered from Azure has been propagated to the
 * NetworkState custom properties.
 */
private void validateVirtualNetworkGateways(AzureNicSpecs nicSpecs) throws Throwable {
    if (this.isMock) {
        return;
    }
    // Query all network states in the system
    Map<String, NetworkState> networkStatesMap = ProvisioningUtils.getResourceStates(this.host, NetworkService.FACTORY_LINK, NetworkState.class);
    AtomicBoolean isGatewayFound = new AtomicBoolean(false);
    networkStatesMap.values().forEach(networkState -> {
        if (networkState.name.contains(nicSpecs.network.name)) {
            List<SubnetState> subnetStates = getSubnetStates(this.host, networkState);
            assertFalse(subnetStates.isEmpty());
            subnetStates.stream().filter(subnetState -> AzureConstants.GATEWAY_SUBNET_NAME.equalsIgnoreCase(subnetState.name)).forEach(subnetState -> {
                this.host.log(Level.INFO, "Validating gateway for network" + "(name %s, id: %s)", networkState.name, networkState.id);
                assertNotNull("Custom properties are null.", networkState.customProperties);
                assertNotNull("Virtual gateway property not found.", networkState.customProperties.get(ComputeProperties.FIELD_VIRTUAL_GATEWAY));
                assertNotNull("SubnetState custom properties are null.", subnetState.customProperties);
                assertEquals("Gateway SubnetState is not marked currectly with " + "infrastructure use custom property.", Boolean.TRUE.toString(), subnetState.customProperties.get(ComputeProperties.INFRASTRUCTURE_USE_PROP_NAME));
                isGatewayFound.set(true);
            });
        }
    });
    assertTrue("Gateway custom property was not found at all.", isGatewayFound.get());
}

Example 15 with NetworkState

use of com.vmware.photon.controller.model.resources.NetworkService.NetworkState in project photon-model by vmware.

the class TestAzureEnumerationTask method testEnumeration.

@Test
public void testEnumeration() throws Throwable {
    this.storageDescription = createDefaultStorageAccountDescription(this.host, this.mockedStorageAccountName, computeHost, endpointState);
    this.resourceGroupState = createDefaultResourceGroupState(this.host, this.mockedStorageAccountName, computeHost, endpointState, ResourceGroupStateType.AzureResourceGroup);
    this.diskState = createDefaultDiskState(this.host, this.mockedStorageAccountName, this.mockedStorageAccountName, computeHost, endpointState);
    // create an Azure VM compute resource (this also creates a disk and a storage account)
    this.vmState = createDefaultVMResource(this.host, azureVMName, computeHost, endpointState, NIC_SPEC);
    // kick off a provision task to do the actual VM creation
    ProvisionComputeTaskState provisionTask = new ProvisionComputeTaskState();
    provisionTask.computeLink = this.vmState.documentSelfLink;
    provisionTask.isMockRequest = this.isMock;
    provisionTask.taskSubStage = SubStage.CREATING_HOST;
    ProvisionComputeTaskState outTask = TestUtils.doPost(this.host, provisionTask, ProvisionComputeTaskState.class, UriUtils.buildUri(this.host, ProvisionComputeTaskService.FACTORY_LINK));
    this.host.waitForFinishedTask(ProvisionComputeTaskState.class, outTask.documentSelfLink);
    // Check resources have been created
    // expected VM count = 2 (1 compute host instance + 1 vm compute state)
    ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, 2, ComputeService.FACTORY_LINK, false);
    ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, 1, StorageDescriptionService.FACTORY_LINK, false);
    ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, 1, ResourceGroupService.FACTORY_LINK, false);
    ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, 1, DiskService.FACTORY_LINK, false);
    this.numberOfVMsToDelete++;
    if (this.isMock) {
        runEnumeration();
        deleteVMs(this.host, this.vmState.documentSelfLink, this.isMock, 1);
        this.vmState = null;
        ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, 1, ComputeService.FACTORY_LINK, false);
        deleteServiceDocument(this.host, this.storageDescription.documentSelfLink);
        this.storageDescription = null;
        ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, 0, StorageDescriptionService.FACTORY_LINK, true);
        deleteServiceDocument(this.host, this.resourceGroupState.documentSelfLink);
        this.resourceGroupState = null;
        ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, 0, ResourceGroupService.FACTORY_LINK, false);
        deleteServiceDocument(this.host, this.diskState.documentSelfLink);
        this.diskState = null;
        ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, 0, DiskService.FACTORY_LINK, false);
        return;
    }
    createStaleResource();
    tagAzureResources();
    // stale resources + 1 compute host instance + 1 vm compute state
    ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, STALE_VM_RESOURCES_COUNT + 2, ComputeService.FACTORY_LINK, false);
    ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, STALE_STORAGE_ACCOUNTS_COUNT + 1, StorageDescriptionService.FACTORY_LINK, false);
    ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, STALE_CONTAINERS_COUNT + STALE_RG_COUNT + 1, ResourceGroupService.FACTORY_LINK, false);
    ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, STALE_DISKS_COUNT + 1, DiskService.FACTORY_LINK, false);
    // 1 network per each stale vm resource + 1 network for original vm compute state.
    ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, STALE_VM_RESOURCES_COUNT + 1, NetworkService.FACTORY_LINK, false);
    // 1 subnet per network, 1 network per each stale vm resource + 1 subnet for the original
    // compute state.
    ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, STALE_VM_RESOURCES_COUNT + 1, SubnetService.FACTORY_LINK, false);
    // 1 network per each stale vm resource + 1 network for original vm compute state.
    ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, STALE_VM_RESOURCES_COUNT + 1, NetworkInterfaceService.FACTORY_LINK, false);
    ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, STALE_SECURITY_GROUPS_COUNT, SecurityGroupService.FACTORY_LINK, false);
    this.vmCount = getAzureVMCount(this.computeManagementClient);
    this.host.log(Level.INFO, "Initial VM Count: %d", this.vmCount);
    runEnumeration();
    assertRemoteResources();
    assertInternalTagResources();
    assertStaleResources();
    // VM count + 1 compute host instance
    this.vmCount = this.vmCount + 1;
    ServiceDocumentQueryResult result = ProvisioningUtils.queryDocumentsAndAssertExpectedCount(this.host, this.vmCount, ComputeService.FACTORY_LINK, false);
    // validate type field for enumerated VMs
    result.documents.entrySet().stream().map(e -> Utils.fromJson(e.getValue(), ComputeState.class)).filter(c -> !c.documentSelfLink.equals(computeHost.documentSelfLink));
    // validate internal tags for enumerated VMs
    TagService.TagState expectedInternalTypeTag = newTagState(TAG_KEY_TYPE, AzureConstants.AzureResourceType.azure_vm.toString(), EnumSet.of(SYSTEM), endpointState.tenantLinks);
    result.documents.entrySet().stream().map(e -> Utils.fromJson(e.getValue(), ComputeState.class)).filter(c -> c.type.equals(ComputeType.VM_GUEST)).forEach(c -> {
        assertNotNull("ComputeState tagLinks is NULL", c.tagLinks);
        assertTrue(String.format("ComputeState doesn't contain tagLink: %s", expectedInternalTypeTag.documentSelfLink), c.tagLinks.contains(expectedInternalTypeTag.documentSelfLink));
    });
    // 1 network per each stale vm resource + 1 network for original vm compute state.
    ServiceDocumentQueryResult networkResults = ProvisioningUtils.queryAllFactoryResources(this.host, NetworkService.FACTORY_LINK);
    // validate internal tags for enumerated networks
    TagService.TagState expectedNetworkInternalTypeTag = newTagState(TAG_KEY_TYPE, NETWORK_TAG_TYPE_VALUE, false, endpointState.tenantLinks);
    networkResults.documents.entrySet().stream().map(e -> Utils.fromJson(e.getValue(), NetworkState.class)).forEach(c -> {
        assertNotNull("NetworkState tagLinks is NULL", c.tagLinks);
        assertTrue(String.format("NetworkState doesn't contain tagLink: %s", expectedNetworkInternalTypeTag.documentSelfLink), c.tagLinks.contains(expectedNetworkInternalTypeTag.documentSelfLink));
    });
    // 1 subnet per network, 1 network per each stale vm resource + 1 subnet for the original
    // compute state.
    ServiceDocumentQueryResult subnetResults = ProvisioningUtils.queryAllFactoryResources(this.host, SubnetService.FACTORY_LINK);
    // validate internal tags for enumerated subnets
    TagService.TagState expectedSubnetInternalTypeTag = newTagState(TAG_KEY_TYPE, SUBNET_TAG_TYPE_VALUE, false, endpointState.tenantLinks);
    subnetResults.documents.entrySet().stream().map(e -> Utils.fromJson(e.getValue(), SubnetState.class)).forEach(c -> {
        assertNotNull("SubnetState tagLinks is NULL", c.tagLinks);
        assertTrue(String.format("SubnetState doesn't contain tagLink: %s", expectedSubnetInternalTypeTag.documentSelfLink), c.tagLinks.contains(expectedSubnetInternalTypeTag.documentSelfLink));
    });
    ServiceDocumentQueryResult nicResults = ProvisioningUtils.queryAllFactoryResources(this.host, NetworkInterfaceService.FACTORY_LINK);
    // validate internal tags for enumerated network interfaces
    TagService.TagState expectedNicInternalTypeTag = newTagState(TAG_KEY_TYPE, NETWORK_INTERFACE_TAG_TYPE_VALUE, false, endpointState.tenantLinks);
    nicResults.documents.entrySet().stream().map(e -> Utils.fromJson(e.getValue(), NetworkInterfaceState.class)).filter(c -> c.regionId != null).forEach(c -> {
        assertNotNull("NetworkInterfaceState tagLinks is NULL", c.tagLinks);
        assertTrue(String.format("NetworkInterfaceState doesn't contain tagLink: %s", expectedNicInternalTypeTag.documentSelfLink), c.tagLinks.contains(expectedNicInternalTypeTag.documentSelfLink));
    });
    // validate internal tags for disks
    ServiceDocumentQueryResult diskResults = ProvisioningUtils.queryAllFactoryResources(this.host, DiskService.FACTORY_LINK);
    TagService.TagState expectedManagedDiskInternalTypeTag = newTagState(TAG_KEY_TYPE, azure_managed_disk.toString(), false, endpointState.tenantLinks);
    diskResults.documents.entrySet().stream().map(e -> Utils.fromJson(e.getValue(), DiskState.class)).filter(d -> d.customProperties != null && d.customProperties.containsKey(AzureConstants.AZURE_MANAGED_DISK_TYPE)).forEach(c -> {
        assertNotNull("tagLinks is null for disk", c.tagLinks);
        assertTrue("disk doesn't contain correct internal tagLink", c.tagLinks.contains(expectedManagedDiskInternalTypeTag.documentSelfLink));
    });
    // validate environment name field for enumerated VMs
    result.documents.entrySet().stream().map(e -> Utils.fromJson(e.getValue(), ComputeState.class)).forEach(c -> assertEquals(ComputeDescription.ENVIRONMENT_NAME_AZURE, c.environmentName));
    // validate Security Group tagLinks
    ServiceDocumentQueryResult securityGroupResults = ProvisioningUtils.queryAllFactoryResources(this.host, SecurityGroupService.FACTORY_LINK);
    securityGroupResults.documents.entrySet().stream().map(e -> Utils.fromJson(e.getValue(), SecurityGroupService.SecurityGroupState.class)).forEach(c -> {
        if (c.tagLinks != null) {
            for (String tag : c.tagLinks) {
                assertTrue(tag.startsWith(TagService.FACTORY_LINK));
            }
        }
    });
    for (Entry<String, Object> key : result.documents.entrySet()) {
        ComputeState document = Utils.fromJson(key.getValue(), ComputeState.class);
        if (!document.documentSelfLink.equals(computeHost.documentSelfLink) && !document.documentSelfLink.equals(this.vmState.documentSelfLink) && document.id.toLowerCase().contains(CUSTOM_DIAGNOSTIC_ENABLED_VM.toLowerCase())) {
            this.enumeratedComputeLink = document.documentSelfLink;
            break;
        }
    }
    try {
        // Test stats for the VM that was just enumerated from Azure.
        this.host.log(Level.INFO, "Collecting stats for VM [%s]-[%s]", CUSTOM_DIAGNOSTIC_ENABLED_VM, this.enumeratedComputeLink);
        this.host.setTimeoutSeconds(300);
        if (this.enumeratedComputeLink != null) {
            this.host.waitFor("Error waiting for VM stats", () -> {
                try {
                    issueStatsRequest(this.enumeratedComputeLink, false);
                } catch (Throwable t) {
                    return false;
                }
                return true;
            });
        }
        // Test stats for the compute host.
        this.host.log(Level.INFO, "Collecting stats for host [%s]", computeHost.documentSelfLink);
        this.host.waitFor("Error waiting for host stats", () -> {
            try {
                issueStatsRequest(computeHost.documentSelfLink, true);
            } catch (Throwable t) {
                return false;
            }
            return true;
        });
    } catch (Throwable te) {
        this.host.log(Level.SEVERE, te.getMessage());
    }
    // delete vm directly on azure
    this.computeManagementClient.virtualMachines().beginDelete(azureVMName, azureVMName);
    runEnumeration();
    assertResourceDisassociated(this.host, ComputeService.FACTORY_LINK, azureVMName, true);
    // clean up
    this.vmState = null;
    this.resourceManagementClient.resourceGroups().beginDelete(azureVMName);
}