import com.microsoft.azure.management.compute.DataDisk; //导入依赖的package包/类
@Override
protected VirtualMachineImpl wrapModel(String name) {
    VirtualMachineInner inner = new VirtualMachineInner();
    inner.withStorageProfile(new StorageProfile()
            .withOsDisk(new OSDisk())
            .withDataDisks(new ArrayList<DataDisk>()));
    inner.withOsProfile(new OSProfile());
    inner.withHardwareProfile(new HardwareProfile());
    inner.withNetworkProfile(new NetworkProfile()
            .withNetworkInterfaces(new ArrayList<NetworkInterfaceReferenceInner>()));
    return new VirtualMachineImpl(name,
            inner,
            this.manager(),
            this.storageManager,
            this.networkManager,
            this.rbacManager);
}
 

import com.microsoft.azure.management.compute.DataDisk; //导入依赖的package包/类
private void initializeDataDisks() {
    if (this.inner().storageProfile().dataDisks() == null) {
        this.inner()
                .storageProfile()
                .withDataDisks(new ArrayList<DataDisk>());
    }

    this.isUnmanagedDiskSelected = false;
    this.managedDataDisks.clear();
    this.unmanagedDataDisks = new ArrayList<>();
    if (!isManagedDiskEnabled()) {
        for (DataDisk dataDiskInner : this.storageProfile().dataDisks()) {
            this.unmanagedDataDisks.add(new UnmanagedDataDiskImpl(dataDiskInner, this));
        }
    }
}
 

import com.microsoft.azure.management.compute.DataDisk; //导入依赖的package包/类
private void setAttachableNewDataDisks(Func0<Integer> nextLun) {
    List<DataDisk> dataDisks = vm.inner().storageProfile().dataDisks();
    for (Map.Entry<String, DataDisk> entry : this.newDisksToAttach.entrySet()) {
        Disk managedDisk = vm.<Disk>taskResult(entry.getKey());
        DataDisk dataDisk = entry.getValue();
        dataDisk.withCreateOption(DiskCreateOptionTypes.ATTACH);
        if (dataDisk.lun() == -1) {
            dataDisk.withLun(nextLun.call());
        }
        dataDisk.withManagedDisk(new ManagedDiskParametersInner());
        dataDisk.managedDisk().withId(managedDisk.id());
        if (dataDisk.caching() == null) {
            dataDisk.withCaching(getDefaultCachingType());
        }
        // Don't set default storage account type for the attachable managed disks, it is already
        // defined in the managed disk and not allowed to change.
        dataDisk.withName(null);
        dataDisks.add(dataDisk);
    }
}
 

import com.microsoft.azure.management.compute.DataDisk; //导入依赖的package包/类
private void setAttachableExistingDataDisks(Func0<Integer> nextLun) {
    List<DataDisk> dataDisks = vm.inner().storageProfile().dataDisks();
    for (DataDisk dataDisk : this.existingDisksToAttach) {
        dataDisk.withCreateOption(DiskCreateOptionTypes.ATTACH);
        if (dataDisk.lun() == -1) {
            dataDisk.withLun(nextLun.call());
        }
        if (dataDisk.caching() == null) {
            dataDisk.withCaching(getDefaultCachingType());
        }
        // Don't set default storage account type for the attachable managed disks, it is already
        // defined in the managed disk and not allowed to change.
        dataDisk.withName(null);
        dataDisks.add(dataDisk);
    }
}
 

import com.microsoft.azure.management.compute.DataDisk; //导入依赖的package包/类
private void setImplicitDataDisks(Func0<Integer> nextLun) {
    List<DataDisk> dataDisks = vm.inner().storageProfile().dataDisks();
    for (DataDisk dataDisk : this.implicitDisksToAssociate) {
        dataDisk.withCreateOption(DiskCreateOptionTypes.EMPTY);
        if (dataDisk.lun() == -1) {
            dataDisk.withLun(nextLun.call());
        }
        if (dataDisk.caching() == null) {
            dataDisk.withCaching(getDefaultCachingType());
        }
        if (dataDisk.managedDisk() == null) {
            dataDisk.withManagedDisk(new ManagedDiskParametersInner());
        }
        if (dataDisk.managedDisk().storageAccountType() == null) {
            dataDisk.managedDisk().withStorageAccountType(getDefaultStorageAccountType());
        }
        dataDisk.withName(null);
        dataDisks.add(dataDisk);
    }
}
 

import com.microsoft.azure.management.compute.DataDisk; //导入依赖的package包/类
@Override
public Map<Integer, VirtualMachineUnmanagedDataDisk> unmanagedDataDisks() {
    Map<Integer, VirtualMachineUnmanagedDataDisk> dataDisks = new HashMap<>();
    if (!isManagedDiskEnabled()) {
        List<DataDisk> innerDataDisks = this.inner().storageProfile().dataDisks();
        if (innerDataDisks != null) {
            for (DataDisk innerDataDisk : innerDataDisks) {
                dataDisks.put(innerDataDisk.lun(), new UnmanagedDataDiskImpl(innerDataDisk, null));
            }
        }
    }
    return Collections.unmodifiableMap(dataDisks);
}
 

import com.microsoft.azure.management.compute.DataDisk; //导入依赖的package包/类
@Override
public VirtualMachineImpl withNewDataDisk(Creatable<Disk> creatable) {
    throwIfManagedDiskDisabled(ManagedUnmanagedDiskErrors.VM_BOTH_UNMANAGED_AND_MANAGED_DISK_NOT_ALLOWED);
    this.managedDataDisks.newDisksToAttach.put(this.addDependency(creatable),
            new DataDisk().withLun(-1));
    return this;
}
 

import com.microsoft.azure.management.compute.DataDisk; //导入依赖的package包/类
@Override
public VirtualMachineImpl withExistingDataDisk(Disk disk) {
    throwIfManagedDiskDisabled(ManagedUnmanagedDiskErrors.VM_BOTH_UNMANAGED_AND_MANAGED_DISK_NOT_ALLOWED);
    ManagedDiskParametersInner managedDiskParameters = new ManagedDiskParametersInner();
    managedDiskParameters.withId(disk.id());
    this.managedDataDisks.existingDisksToAttach.add(new DataDisk()
            .withLun(-1)
            .withManagedDisk(managedDiskParameters));
    return this;
}
 

import com.microsoft.azure.management.compute.DataDisk; //导入依赖的package包/类
@Override
public VirtualMachineImpl withNewDataDiskFromImage(int imageLun, int newSizeInGB, CachingTypes cachingType) {
    this.managedDataDisks.newDisksFromImage.add(new DataDisk()
            .withLun(imageLun)
            .withDiskSizeGB(newSizeInGB)
            .withCaching(cachingType));
    return this;
}
 

import com.microsoft.azure.management.compute.DataDisk; //导入依赖的package包/类
private void setImageBasedDataDisks() {
    List<DataDisk> dataDisks = vm.inner().storageProfile().dataDisks();
    for (DataDisk dataDisk : this.newDisksFromImage) {
        dataDisk.withCreateOption(DiskCreateOptionTypes.FROM_IMAGE);
        // Don't set default storage account type for the disk, either user has to specify it explicitly or let
        // CRP pick it from the image
        dataDisk.withName(null);
        dataDisks.add(dataDisk);
    }
}
 

import com.microsoft.azure.management.compute.DataDisk; //导入依赖的package包/类
private void removeDataDisks() {
    List<DataDisk> dataDisks = vm.inner().storageProfile().dataDisks();
    for (Integer lun : this.diskLunsToRemove) {
        int indexToRemove = 0;
        for (DataDisk dataDisk : dataDisks) {
            if (dataDisk.lun() == lun) {
                dataDisks.remove(indexToRemove);
                break;
            }
            indexToRemove++;
        }
    }
}
 

import com.microsoft.azure.management.compute.DataDisk; //导入依赖的package包/类
protected static UnmanagedDataDiskImpl prepareDataDisk(String name,
                                                       VirtualMachineImpl parent) {
    DataDisk dataDiskInner = new DataDisk();
    dataDiskInner.withLun(-1)
            .withName(name)
            .withVhd(null);
    return new UnmanagedDataDiskImpl(dataDiskInner, parent);
}
 

import com.microsoft.azure.management.compute.DataDisk; //导入依赖的package包/类
private DiskState createDataDiskState(EnumerationContext ctx, DataDisk dataDisk, boolean isManaged) {
    DiskState diskState = new DiskState();
    String id = UUID.randomUUID().toString();
    diskState.documentSelfLink = UriUtils.buildUriPath(DiskService.FACTORY_LINK, id);
    diskState.name = dataDisk.name();
    if (isManaged) {
        diskState.id = dataDisk.managedDisk().id();
    } else {
        diskState.id = AzureUtils.canonizeId(dataDisk.vhd().uri());
    }
    diskState.capacityMBytes = dataDisk.diskSizeGB() * 1024;
    diskState.status = DiskService.DiskStatus.ATTACHED;
    diskState.tenantLinks = ctx.parentCompute.tenantLinks;
    diskState.resourcePoolLink = ctx.request.resourcePoolLink;
    diskState.computeHostLink = ctx.parentCompute.documentSelfLink;
    diskState.endpointLink = ctx.request.endpointLink;
    AdapterUtils.addToEndpointLinks(diskState, ctx.request.endpointLink);

    diskState.customProperties = new HashMap<>();
    diskState.customProperties.put(AZURE_DATA_DISK_CACHING, dataDisk.caching().name());
    diskState.customProperties.put(DISK_CONTROLLER_NUMBER, String.valueOf(dataDisk.lun()));

    diskState.customProperties.put(AZURE_MANAGED_DISK_TYPE,
            dataDisk.managedDisk().storageAccountType().toString());

    return diskState;
}
 

import com.microsoft.azure.management.compute.DataDisk; //导入依赖的package包/类
VirtualMachineDataDiskImpl(DataDisk dataDiskInner) {
    super(dataDiskInner);
}
 

import com.microsoft.azure.management.compute.DataDisk; //导入依赖的package包/类
protected UnmanagedDataDiskImpl(DataDisk inner, VirtualMachineImpl parent) {
    super(inner, parent);
}
 

import com.microsoft.azure.management.compute.DataDisk; //导入依赖的package包/类
/**
 * Creates and returns a new diskState object which is updated with id, LUN, status and documentSelfLink
 */
private DeferredResult<Operation> createDiskToUpdate(AzureInstanceContext ctx, Optional<DiskState> diskOpt,
                                                     DataDisk azureDataDisk) {
    // update VHD uri or disk id respectively for un-managed and managed disks
    DiskState diskState = diskOpt.get();
    final DiskState diskStateToUpdate = new DiskState();
    diskStateToUpdate.documentSelfLink = diskState.documentSelfLink;

    if (ctx.useManagedDisks()) {
        diskStateToUpdate.id = azureDataDisk.managedDisk().id();
    } else {
        diskStateToUpdate.id = azureDataDisk.vhd().uri();
    }

    // The LUN value of disk
    if (diskStateToUpdate.customProperties == null) {
        diskStateToUpdate.customProperties = new HashMap<>();
    }
    diskStateToUpdate.customProperties.put(DISK_CONTROLLER_NUMBER, String.valueOf(azureDataDisk.lun()));

    diskStateToUpdate.status = DiskService.DiskStatus.ATTACHED;

    Operation updateDiskState = Operation
            .createPatch(ctx.service, diskStateToUpdate.documentSelfLink)
            .setBody(diskStateToUpdate);

    DeferredResult<Operation> updateDR = ctx.service.sendWithDeferredResult(updateDiskState)
            .whenComplete((op, exc) -> {
                if (exc != null) {
                    logSevere(() -> String.format(
                            "Updating data DiskState [%s] with VHD URI [%s]: FAILED with %s",
                            diskState.name, diskStateToUpdate.id, Utils.toString(exc)));

                } else {
                    logFine(() -> String.format(
                            "Updating data DiskState [%s] with VHD URI [%s]: SUCCESS",
                            diskState.name, diskStateToUpdate.id));
                }
            });

    return updateDR;
}
 

import com.microsoft.azure.management.compute.DataDisk; //导入依赖的package包/类
/**
 * Update status and LUN of DiskState
 */
private DeferredResult<Operation> updateDiskState(AzureComputeDiskDay2Context context) {
    DiskState diskState = context.diskState;

    if (context.request.operation.equals(ResourceOperation.ATTACH_DISK.operation)) {
        diskState.status = DiskService.DiskStatus.ATTACHED;
    } else if (context.request.operation.equals(ResourceOperation.DETACH_DISK.operation)) {
        diskState.status = DiskService.DiskStatus.AVAILABLE;
        diskState.customProperties.remove(DISK_CONTROLLER_NUMBER);
    }

    if (!context.request.isMockRequest) {
        DataDisk dataDisk = context.provisionedVm.inner().storageProfile().dataDisks()
                .stream()
                .filter(dd -> diskState.name.equalsIgnoreCase(dd.name()))
                .findFirst()
                .orElse(null);

        if (dataDisk != null) {
            if (diskState.customProperties == null) {
                diskState.customProperties = new HashMap<>();
            }
            diskState.customProperties.put(DISK_CONTROLLER_NUMBER,
                    String.valueOf(dataDisk.lun()));
        }
    }

    Operation diskPatchOp = null;

    if (context.request.operation.equals(ResourceOperation.ATTACH_DISK.operation)) {
        diskPatchOp = Operation
                .createPatch(UriUtils.buildUri(this.getHost(), diskState.documentSelfLink))
                .setBody(diskState)
                .setReferer(this.getUri());
    } else if (context.request.operation.equals(ResourceOperation.DETACH_DISK.operation)) {
        diskPatchOp = Operation
                .createPut(UriUtils.buildUri(this.getHost(), diskState.documentSelfLink))
                .setBody(diskState)
                .setReferer(this.getUri());
    }

    return this.sendWithDeferredResult(diskPatchOp);
}