import com.microsoft.azure.management.network.NetworkInterface; //导入依赖的package包/类
@Override
public VirtualMachineImpl withNewPrimaryPublicIPAddress(String leafDnsLabel) {
    PublicIPAddress.DefinitionStages.WithGroup definitionWithGroup = this.networkManager.publicIPAddresses()
            .define(this.namer.randomName("pip", 15))
            .withRegion(this.regionName());
    PublicIPAddress.DefinitionStages.WithCreate definitionAfterGroup;
    if (this.creatableGroup != null) {
        definitionAfterGroup = definitionWithGroup.withNewResourceGroup(this.creatableGroup);
    } else {
        definitionAfterGroup = definitionWithGroup.withExistingResourceGroup(this.resourceGroupName());
    }
    this.implicitPipCreatable = definitionAfterGroup.withLeafDomainLabel(leafDnsLabel);
    // Create NIC with creatable PIP
    //
    Creatable<NetworkInterface> nicCreatable = this.nicDefinitionWithCreate
            .withNewPrimaryPublicIPAddress(this.implicitPipCreatable);
    this.creatablePrimaryNetworkInterfaceKey = this.addDependency(nicCreatable);
    return this;
}
 

import com.microsoft.azure.management.network.NetworkInterface; //导入依赖的package包/类
@Override
public Completable deleteByResourceGroupAsync(String groupName, String name) {
    // Clear NIC references if any
    NetworkSecurityGroupImpl nsg = (NetworkSecurityGroupImpl) getByResourceGroup(groupName, name);
    if (nsg != null) {
        Set<String> nicIds = nsg.networkInterfaceIds();
        if (nicIds != null) {
            for (String nicRef : nsg.networkInterfaceIds()) {
                NetworkInterface nic = this.manager().networkInterfaces().getById(nicRef);
                if (nic == null) {
                    continue;
                } else if (!nsg.id().equalsIgnoreCase(nic.networkSecurityGroupId())) {
                    continue;
                } else {
                    nic.update().withoutNetworkSecurityGroup().apply();
                }
            }
        }
    }

    return this.deleteInnerAsync(groupName, name);
}
 

import com.microsoft.azure.management.network.NetworkInterface; //导入依赖的package包/类
@Override
public Set<String> getVirtualMachineIds() {
    Set<String> vmIds = new HashSet<>();
    Map<String, String> nicConfigs = this.backendNicIPConfigurationNames();
    if (nicConfigs != null) {
        for (String nicId : nicConfigs.keySet()) {
            try {
                NetworkInterface nic = this.parent().manager().networkInterfaces().getById(nicId);
                if (nic == null || nic.virtualMachineId() == null) {
                    continue;
                } else {
                    vmIds.add(nic.virtualMachineId());
                }
            } catch (CloudException | IllegalArgumentException e) {
                continue;
            }
        }
    }

    return vmIds;
}
 

import com.microsoft.azure.management.network.NetworkInterface; //导入依赖的package包/类
@Override
public NicIPConfiguration getNetworkInterfaceIPConfiguration() {
    if (this.inner().ipConfiguration() == null) {
        return null;
    }
    String nicIPConfigId = this.inner().ipConfiguration().id();
    if (nicIPConfigId == null) {
        return null;
    }

    String nicIPConfigName = ResourceUtils.nameFromResourceId(nicIPConfigId);
    String nicId = ResourceUtils.parentResourceIdFromResourceId(nicIPConfigId);
    NetworkInterface nic = this.parent().parent().parent().manager().networkInterfaces().getById(nicId);
    if (nic == null) {
        return null;
    } else {
        return nic.ipConfigurations().get(nicIPConfigName);
    }
}
 

import com.microsoft.azure.management.network.NetworkInterface; //导入依赖的package包/类
/**
 * Creates a VM definition from a given {@link VmSpec} and with a given
 * network interface.
 *
 * @param vmSpec
 * @param vmNetworkInterface
 * @return
 */
public Creatable<VirtualMachine> renderVmDefinition(VmSpec vmSpec, NetworkInterface vmNetworkInterface) {
    String vmName = vmSpec.getVmName();

    Azure api = ApiUtils.acquireApiClient(this.apiAccess);
    WithOS rawVmDef = api.virtualMachines().define(vmName) //
            .withRegion(this.region) //
            .withExistingResourceGroup(this.resourceGroup) //
            .withExistingPrimaryNetworkInterface(vmNetworkInterface);

    if (vmSpec.getLinuxSettings().isPresent()) {
        return linuxVmDefinition(vmSpec, rawVmDef);
    } else {
        return windowsVmDefinition(vmSpec, rawVmDef);
    }
}
 

import com.microsoft.azure.management.network.NetworkInterface; //导入依赖的package包/类
@Override
public NetworkInterface doRequest(Azure api) throws NotFoundException, AzureException {
    LOG.debug("creating network interface {} ...", this.nicName);

    String networkName = this.networkSettings.getVirtualNetwork();
    Network network = new GetNetworkRequest(apiAccess(), this.resourceGroup, networkName).call();

    if (!network.subnets().keySet().contains(this.networkSettings.getSubnetName())) {
        throw new NotFoundException(String.format("virtual network '%s' does not have a subnet named '%s'",
                this.networkSettings.getVirtualNetwork(), this.networkSettings.getSubnetName()));
    }

    NetworkInterface networkInterface;
    try {
        WithCreate nicDef = nicDefinition(api, network);
        networkInterface = nicDef.create();
    } catch (Exception e) {
        throw new AzureException("failed to create network interface card: " + e.getMessage(), e);
    }

    return networkInterface;
}
 

import com.microsoft.azure.management.network.NetworkInterface; //导入依赖的package包/类
private NetworkInterface primaryNicMock() {
    NetworkInterface nicMock = mock(NetworkInterface.class);

    when(nicMock.primaryPrivateIP()).thenReturn(this.privateIp);

    NicIPConfiguration primaryIpConfigMock = mock(NicIPConfiguration.class);
    when(nicMock.primaryIPConfiguration()).thenReturn(primaryIpConfigMock);

    if (this.publicIp != null) {
        PublicIPAddress publicIpAddrMock = mock(PublicIPAddress.class);
        when(primaryIpConfigMock.getPublicIPAddress()).thenReturn(publicIpAddrMock);
        when(publicIpAddrMock.ipAddress()).thenReturn(this.publicIp);
    }

    return nicMock;
}
 

import com.microsoft.azure.management.network.NetworkInterface; //导入依赖的package包/类
/**
 * Print network interface.
 *
 * @param resource a network interface
 */
public static void print(NetworkInterface resource) {
    StringBuilder info = new StringBuilder();
    info.append("NetworkInterface: ").append(resource.id())
            .append("Name: ").append(resource.name())
            .append("\n\tResource group: ").append(resource.resourceGroupName())
            .append("\n\tRegion: ").append(resource.region())
            .append("\n\tTags: ").append(resource.tags())
            .append("\n\tInternal DNS name label: ").append(resource.internalDnsNameLabel())
            .append("\n\tInternal FQDN: ").append(resource.internalFqdn())
            .append("\n\tInternal domain name suffix: ").append(resource.internalDomainNameSuffix())
            .append("\n\tNetwork security group: ").append(resource.networkSecurityGroupId())
            .append("\n\tApplied DNS servers: ").append(resource.appliedDnsServers().toString())
            .append("\n\tDNS server IPs: ");

    // Output dns servers
    for (String dnsServerIp : resource.dnsServers()) {
        info.append("\n\t\t").append(dnsServerIp);
    }

    info.append("\n\tIP forwarding enabled? ").append(resource.isIPForwardingEnabled())
            .append("\n\tAccelerated networking enabled? ").append(resource.isAcceleratedNetworkingEnabled())
            .append("\n\tMAC Address:").append(resource.macAddress())
            .append("\n\tPrivate IP:").append(resource.primaryPrivateIP())
            .append("\n\tPrivate allocation method:").append(resource.primaryPrivateIPAllocationMethod())
            .append("\n\tPrimary virtual network ID: ").append(resource.primaryIPConfiguration().networkId())
            .append("\n\tPrimary subnet name:").append(resource.primaryIPConfiguration().subnetName());

    System.out.println(info.toString());
}
 

import com.microsoft.azure.management.network.NetworkInterface; //导入依赖的package包/类
@Override
public VirtualMachineImpl withExistingPrimaryPublicIPAddress(PublicIPAddress publicIPAddress) {
    Creatable<NetworkInterface> nicCreatable = this.nicDefinitionWithCreate
            .withExistingPrimaryPublicIPAddress(publicIPAddress);
    this.creatablePrimaryNetworkInterfaceKey = this.addDependency(nicCreatable);
    return this;
}
 

import com.microsoft.azure.management.network.NetworkInterface; //导入依赖的package包/类
private NetworkInterface.DefinitionStages.WithPrimaryPublicIPAddress prepareNetworkInterface(String name) {
    NetworkInterface.DefinitionStages.WithGroup definitionWithGroup = this.networkManager
            .networkInterfaces()
            .define(name)
            .withRegion(this.regionName());
    NetworkInterface.DefinitionStages.WithPrimaryNetwork definitionWithNetwork;
    if (this.creatableGroup != null) {
        definitionWithNetwork = definitionWithGroup.withNewResourceGroup(this.creatableGroup);
    } else {
        definitionWithNetwork = definitionWithGroup.withExistingResourceGroup(this.resourceGroupName());
    }
    return definitionWithNetwork
            .withNewPrimaryNetwork("vnet" + name)
            .withPrimaryPrivateIPAddressDynamic();
}
 

import com.microsoft.azure.management.network.NetworkInterface; //导入依赖的package包/类
private NetworkInterface.DefinitionStages.WithPrimaryNetwork preparePrimaryNetworkInterface(String name) {
    NetworkInterface.DefinitionStages.WithGroup definitionWithGroup = this.networkManager.networkInterfaces()
            .define(name)
            .withRegion(this.regionName());
    NetworkInterface.DefinitionStages.WithPrimaryNetwork definitionAfterGroup;
    if (this.creatableGroup != null) {
        definitionAfterGroup = definitionWithGroup.withNewResourceGroup(this.creatableGroup);
    } else {
        definitionAfterGroup = definitionWithGroup.withExistingResourceGroup(this.resourceGroupName());
    }
    return definitionAfterGroup;
}
 

import com.microsoft.azure.management.network.NetworkInterface; //导入依赖的package包/类
public static void printPIP(PublicIPAddress resource) {
    StringBuilder info = new StringBuilder().append("Public IP Address: ").append(resource.id())
            .append("\n\tName: ").append(resource.name())
            .append("\n\tResource group: ").append(resource.resourceGroupName())
            .append("\n\tRegion: ").append(resource.region())
            .append("\n\tTags: ").append(resource.tags())
            .append("\n\tIP Address: ").append(resource.ipAddress())
            .append("\n\tLeaf domain label: ").append(resource.leafDomainLabel())
            .append("\n\tFQDN: ").append(resource.fqdn())
            .append("\n\tReverse FQDN: ").append(resource.reverseFqdn())
            .append("\n\tIdle timeout (minutes): ").append(resource.idleTimeoutInMinutes())
            .append("\n\tIP allocation method: ").append(resource.ipAllocationMethod().toString())
            .append("\n\tIP version: ").append(resource.version().toString());

    // Show the associated load balancer if any
    info.append("\n\tLoad balancer association: ");
    if (resource.hasAssignedLoadBalancer()) {
        final LoadBalancerPublicFrontend frontend = resource.getAssignedLoadBalancerFrontend();
        final LoadBalancer lb = frontend.parent();
        info.append("\n\t\tLoad balancer ID: ").append(lb.id())
            .append("\n\t\tFrontend name: ").append(frontend.name());
    } else {
        info.append("(None)");
    }

    // Show the associated NIC if any
    info.append("\n\tNetwork interface association: ");
    if (resource.hasAssignedNetworkInterface()) {
        final NicIPConfiguration nicIp = resource.getAssignedNetworkInterfaceIPConfiguration();
        final NetworkInterface nic = nicIp.parent();
        info.append("\n\t\tNetwork interface ID: ").append(nic.id())
            .append("\n\t\tIP config name: ").append(nicIp.name());
    } else {
        info.append("(None)");
    }

    System.out.println(info.toString());
}
 

import com.microsoft.azure.management.network.NetworkInterface; //导入依赖的package包/类
@Override
public NetworkInterface updateResource(NetworkInterface resource) throws Exception {
    resource =  resource.update()
            .withoutIPForwarding()
            .withoutAcceleratedNetworking()
            .withSubnet("subnet2")
            .updateIPConfiguration("primary")  // Updating the primary IP configuration
                .withPrivateIPAddressDynamic() // Equivalent to ..update().withPrimaryPrivateIPAddressDynamic()
                .withoutPublicIPAddress()      // Equivalent to ..update().withoutPrimaryPublicIPAddress()
                .parent()
            .withTag("tag1", "value1")
            .withTag("tag2", "value2")
            .apply();

    // Verifications
    Assert.assertFalse(resource.isAcceleratedNetworkingEnabled());
    Assert.assertFalse(resource.isIPForwardingEnabled());
    NicIPConfiguration primaryIpConfig = resource.primaryIPConfiguration();
    Assert.assertNotNull(primaryIpConfig);
    Assert.assertTrue(primaryIpConfig.isPrimary());
    Assert.assertTrue("subnet2".equalsIgnoreCase(primaryIpConfig.subnetName()));
    Assert.assertNull(primaryIpConfig.publicIPAddressId());
    Assert.assertTrue(resource.tags().containsKey("tag1"));

    Assert.assertEquals(1,  resource.ipConfigurations().size());
    return resource;
}
 

import com.microsoft.azure.management.network.NetworkInterface; //导入依赖的package包/类
@Override
public NicIPConfiguration getAssignedNetworkInterfaceIPConfiguration() {
    if (this.hasAssignedNetworkInterface()) {
        final String refId = this.inner().ipConfiguration().id();
        final String parentId = ResourceUtils.parentResourceIdFromResourceId(refId);
        final NetworkInterface nic = this.myManager.networkInterfaces().getById(parentId);
        final String childName = ResourceUtils.nameFromResourceId(refId);
        return nic.ipConfigurations().get(childName);
    } else {
        return null;
    }
}
 

import com.microsoft.azure.management.network.NetworkInterface; //导入依赖的package包/类
@Override
public Collection<NicIPConfiguration> listNetworkInterfaceIPConfigurations() {
    Collection<NicIPConfiguration> ipConfigs = new ArrayList<>();
    Map<String, NetworkInterface> nics = new TreeMap<>();
    List<IPConfigurationInner> ipConfigRefs = this.inner().ipConfigurations();
    if (ipConfigRefs == null) {
        return ipConfigs;
    }

    for (IPConfigurationInner ipConfigRef : ipConfigRefs) {
        String nicID = ResourceUtils.parentResourceIdFromResourceId(ipConfigRef.id());
        String ipConfigName = ResourceUtils.nameFromResourceId(ipConfigRef.id());
        // Check if NIC already cached
        NetworkInterface nic = nics.get(nicID.toLowerCase());
        if (nic == null) {
            //  NIC not previously found, so ask Azure for it
            nic = this.parent().manager().networkInterfaces().getById(nicID);
        }

        if (nic == null) {
            // NIC doesn't exist so ignore this bad reference
            continue;
        }

        // Cache the NIC
        nics.put(nic.id().toLowerCase(), nic);

        // Get the IP config
        NicIPConfiguration ipConfig = nic.ipConfigurations().get(ipConfigName);
        if (ipConfig == null) {
            // IP config not found, so ignore this bad reference
            continue;
        }

        ipConfigs.add(ipConfig);
    }

    return Collections.unmodifiableCollection(ipConfigs);
}
 

import com.microsoft.azure.management.network.NetworkInterface; //导入依赖的package包/类
@Override
protected void afterCreating() {
    if (this.nicsInBackends != null) {
        List<Exception> nicExceptions = new ArrayList<>();

        // Update the NICs to point to the backend pool
        for (Entry<String, String> nicInBackend : this.nicsInBackends.entrySet()) {
            String nicId = nicInBackend.getKey();
            String backendName = nicInBackend.getValue();
            try {
                NetworkInterface nic = this.manager().networkInterfaces().getById(nicId);
                NicIPConfiguration nicIP = nic.primaryIPConfiguration();
                nic.update()
                    .updateIPConfiguration(nicIP.name())
                        .withExistingLoadBalancerBackend(this, backendName)
                        .parent()
                    .apply();
            } catch (Exception e) {
                nicExceptions.add(e);
            }
        }

        if (!nicExceptions.isEmpty()) {
            throw new CompositeException(nicExceptions);
        }

        this.nicsInBackends.clear();
        this.refresh();
    }
}
 

import com.microsoft.azure.management.network.NetworkInterface; //导入依赖的package包/类
@Override
public Observable<NetworkInterface> refreshAsync() {
    return super.refreshAsync().map(new Func1<NetworkInterface, NetworkInterface>() {
        @Override
        public NetworkInterface call(NetworkInterface networkInterface) {
            NetworkInterfaceImpl impl = (NetworkInterfaceImpl) networkInterface;
            impl.clearCachedRelatedResources();
            impl.initializeChildrenFromInner();
            return impl;
        }
    });
}
 

import com.microsoft.azure.management.network.NetworkInterface; //导入依赖的package包/类
/**
 * Creates a network interface for the given VM, possibly with associated
 * security groups and public IP.
 *
 * @param vmSpec
 *            A VM to be created.
 * @return
 */
private NetworkInterface createNetworkInterface(VmSpec vmSpec) throws NotFoundException, AzureException {
    // create a network interface for VM (possibly with security groups
    // and public IP)
    String vmName = vmSpec.getVmName();
    LOG.debug("creating network interface {} for VM ...", vmName);
    NetworkInterface networkInterface = new CreateNetworkInterfaceRequest(this.apiAccess, this.resourceGroup,
            this.region, vmName, vmSpec.getNetwork()).call();
    return networkInterface;
}
 

import com.microsoft.azure.management.network.NetworkInterface; //导入依赖的package包/类
/**
 * Removes a collection of network interfaces (together with any associated
 * public IPs).
 *
 * @param networkInterfaces
 */
private void cleanupNetworkInterfaces(Collection<NetworkInterface> networkInterfaces) {
    for (NetworkInterface networkInterface : networkInterfaces) {
        try {
            LOG.info("cleaning up network interface {} ...", networkInterface.id());
            new DeleteNetworkInterfaceRequest(this.apiAccess, networkInterface.id()).call();
        } catch (Exception e) {
            LOG.warn("failed to clean up network interface {}: {}", networkInterface.id(), e.getMessage(), e);
        }
    }
}
 

import com.microsoft.azure.management.network.NetworkInterface; //导入依赖的package包/类
@Override
public NetworkInterface doRequest(Azure api) throws NotFoundException, AzureException {
    NetworkInterface nic;
    try {
        nic = api.networkInterfaces().getById(this.networkInterfaceId);
    } catch (Exception e) {
        throw new AzureException("failed to get network interface: " + e.getMessage(), e);
    }

    return Optional.ofNullable(nic).orElseThrow(() -> notFoundError());
}