• Home
• com.softlayer.api
• softlayer-api-client
• 0.2.7
• source code
• Image.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.softlayer.api.service.virtual.disk.Image Maven / Gradle / Ivy

package com.softlayer.api.service.virtual.disk;

import com.softlayer.api.ApiClient;
import com.softlayer.api.ResponseHandler;
import com.softlayer.api.annotation.ApiMethod;
import com.softlayer.api.annotation.ApiProperty;
import com.softlayer.api.annotation.ApiType;
import com.softlayer.api.service.Entity;
import com.softlayer.api.service.virtual.disk.image.Software;
import com.softlayer.api.service.virtual.disk.image.Type;
import com.softlayer.api.service.virtual.guest.block.Device;
import com.softlayer.api.service.virtual.guest.block.device.Template;
import com.softlayer.api.service.virtual.storage.Repository;
import java.util.ArrayList;
import java.util.GregorianCalendar;
import java.util.List;
import java.util.concurrent.Future;

/**
 * The virtual disk image data type presents the structure in which a virtual disk image will be presented. 

 * 

 * Virtual block devices are assigned to disk images. 
 *
 * @see SoftLayer_Virtual_Disk_Image
 */
@ApiType("SoftLayer_Virtual_Disk_Image")
public class Image extends Entity {

    /**
     * The billing item for a virtual disk image.
     */
    @ApiProperty
    protected com.softlayer.api.service.billing.item.virtual.disk.Image billingItem;

    public com.softlayer.api.service.billing.item.virtual.disk.Image getBillingItem() {
        return billingItem;
    }

    public void setBillingItem(com.softlayer.api.service.billing.item.virtual.disk.Image billingItem) {
        this.billingItem = billingItem;
    }

    /**
     * The block devices that a disk image is attached to. Block devices connect computing instances to disk images.
     */
    @ApiProperty
    protected List blockDevices;

    public List getBlockDevices() {
        if (blockDevices == null) {
            blockDevices = new ArrayList();
        }
        return blockDevices;
    }

    @ApiProperty
    protected Boolean bootableVolumeFlag;

    public Boolean getBootableVolumeFlag() {
        return bootableVolumeFlag;
    }

    public void setBootableVolumeFlag(Boolean bootableVolumeFlag) {
        this.bootableVolumeFlag = bootableVolumeFlag;
    }

    @ApiProperty
    protected List coalescedDiskImages;

    public List getCoalescedDiskImages() {
        if (coalescedDiskImages == null) {
            coalescedDiskImages = new ArrayList();
        }
        return coalescedDiskImages;
    }

    @ApiProperty
    protected Boolean copyOnWriteFlag;

    public Boolean getCopyOnWriteFlag() {
        return copyOnWriteFlag;
    }

    public void setCopyOnWriteFlag(Boolean copyOnWriteFlag) {
        this.copyOnWriteFlag = copyOnWriteFlag;
    }

    /**
     * Return imported disk type
     */
    @ApiProperty
    protected String importedDiskType;

    public String getImportedDiskType() {
        return importedDiskType;
    }

    public void setImportedDiskType(String importedDiskType) {
        this.importedDiskType = importedDiskType;
    }

    /**
     * Return if image is encrypted
     */
    @ApiProperty
    protected Boolean isEncrypted;

    public Boolean getIsEncrypted() {
        return isEncrypted;
    }

    public void setIsEncrypted(Boolean isEncrypted) {
        this.isEncrypted = isEncrypted;
    }

    @ApiProperty
    protected Boolean localDiskFlag;

    public Boolean getLocalDiskFlag() {
        return localDiskFlag;
    }

    public void setLocalDiskFlag(Boolean localDiskFlag) {
        this.localDiskFlag = localDiskFlag;
    }

    /**
     * Whether this disk image is meant for storage of custom user data supplied with a Cloud Computing Instance order.
     */
    @ApiProperty
    protected Boolean metadataFlag;

    public Boolean getMetadataFlag() {
        return metadataFlag;
    }

    public void setMetadataFlag(Boolean metadataFlag) {
        this.metadataFlag = metadataFlag;
    }

    /**
     * References to the software that resides on a disk image.
     */
    @ApiProperty
    protected List softwareReferences;

    public List getSoftwareReferences() {
        if (softwareReferences == null) {
            softwareReferences = new ArrayList();
        }
        return softwareReferences;
    }

    /**
     * The original disk image that the current disk image was cloned from.
     */
    @ApiProperty
    protected Image sourceDiskImage;

    public Image getSourceDiskImage() {
        return sourceDiskImage;
    }

    public void setSourceDiskImage(Image sourceDiskImage) {
        this.sourceDiskImage = sourceDiskImage;
    }

    /**
     * The storage repository that a disk image resides in.
     */
    @ApiProperty
    protected Repository storageRepository;

    public Repository getStorageRepository() {
        return storageRepository;
    }

    public void setStorageRepository(Repository storageRepository) {
        this.storageRepository = storageRepository;
    }

    /**
     * The type of storage repository that a disk image resides in.
     */
    @ApiProperty
    protected com.softlayer.api.service.virtual.storage.repository.Type storageRepositoryType;

    public com.softlayer.api.service.virtual.storage.repository.Type getStorageRepositoryType() {
        return storageRepositoryType;
    }

    public void setStorageRepositoryType(com.softlayer.api.service.virtual.storage.repository.Type storageRepositoryType) {
        this.storageRepositoryType = storageRepositoryType;
    }

    /**
     * The template that attaches a disk image to a [[SoftLayer_Virtual_Guest_Block_Device_Template_Group|archive]].
     */
    @ApiProperty
    protected Template templateBlockDevice;

    public Template getTemplateBlockDevice() {
        return templateBlockDevice;
    }

    public void setTemplateBlockDevice(Template templateBlockDevice) {
        this.templateBlockDevice = templateBlockDevice;
    }

    /**
     * A virtual disk image's type.
     */
    @ApiProperty
    protected Type type;

    public Type getType() {
        return type;
    }

    public void setType(Type type) {
        this.type = type;
    }

    /**
     * A disk image's size measured in gigabytes. 
     */
    @ApiProperty(canBeNullOrNotSet = true)
    protected Long capacity;

    public Long getCapacity() {
        return capacity;
    }

    public void setCapacity(Long capacity) {
        capacitySpecified = true;
        this.capacity = capacity;
    }

    protected boolean capacitySpecified;

    public boolean isCapacitySpecified() {
        return capacitySpecified;
    }

    public void unsetCapacity() {
        capacity = null;
        capacitySpecified = false;
    }

    /**
     * A disk image's unique md5 checksum. 
     */
    @ApiProperty(canBeNullOrNotSet = true)
    protected String checksum;

    public String getChecksum() {
        return checksum;
    }

    public void setChecksum(String checksum) {
        checksumSpecified = true;
        this.checksum = checksum;
    }

    protected boolean checksumSpecified;

    public boolean isChecksumSpecified() {
        return checksumSpecified;
    }

    public void unsetChecksum() {
        checksum = null;
        checksumSpecified = false;
    }

    /**
     * The date a disk image was created. 
     */
    @ApiProperty(canBeNullOrNotSet = true)
    protected GregorianCalendar createDate;

    public GregorianCalendar getCreateDate() {
        return createDate;
    }

    public void setCreateDate(GregorianCalendar createDate) {
        createDateSpecified = true;
        this.createDate = createDate;
    }

    protected boolean createDateSpecified;

    public boolean isCreateDateSpecified() {
        return createDateSpecified;
    }

    public void unsetCreateDate() {
        createDate = null;
        createDateSpecified = false;
    }

    /**
     * A brief description of a virtual disk image. 
     */
    @ApiProperty(canBeNullOrNotSet = true)
    protected String description;

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        descriptionSpecified = true;
        this.description = description;
    }

    protected boolean descriptionSpecified;

    public boolean isDescriptionSpecified() {
        return descriptionSpecified;
    }

    public void unsetDescription() {
        description = null;
        descriptionSpecified = false;
    }

    /**
     * A disk image's unique ID. 
     */
    @ApiProperty(canBeNullOrNotSet = true)
    protected Long id;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        idSpecified = true;
        this.id = id;
    }

    protected boolean idSpecified;

    public boolean isIdSpecified() {
        return idSpecified;
    }

    public void unsetId() {
        id = null;
        idSpecified = false;
    }

    /**
     * The date a disk image was last modified. 
     */
    @ApiProperty(canBeNullOrNotSet = true)
    protected GregorianCalendar modifyDate;

    public GregorianCalendar getModifyDate() {
        return modifyDate;
    }

    public void setModifyDate(GregorianCalendar modifyDate) {
        modifyDateSpecified = true;
        this.modifyDate = modifyDate;
    }

    protected boolean modifyDateSpecified;

    public boolean isModifyDateSpecified() {
        return modifyDateSpecified;
    }

    public void unsetModifyDate() {
        modifyDate = null;
        modifyDateSpecified = false;
    }

    /**
     * A descriptive name used to identify a disk image to a user. 
     */
    @ApiProperty(canBeNullOrNotSet = true)
    protected String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        nameSpecified = true;
        this.name = name;
    }

    protected boolean nameSpecified;

    public boolean isNameSpecified() {
        return nameSpecified;
    }

    public void unsetName() {
        name = null;
        nameSpecified = false;
    }

    /**
     * The ID of the the disk image that this disk image is based on, if applicable. 
     */
    @ApiProperty(canBeNullOrNotSet = true)
    protected Long parentId;

    public Long getParentId() {
        return parentId;
    }

    public void setParentId(Long parentId) {
        parentIdSpecified = true;
        this.parentId = parentId;
    }

    protected boolean parentIdSpecified;

    public boolean isParentIdSpecified() {
        return parentIdSpecified;
    }

    public void unsetParentId() {
        parentId = null;
        parentIdSpecified = false;
    }

    /**
     * The [[SoftLayer_Virtual_Storage_Repository|storage repository]] that a disk image is in. 
     */
    @ApiProperty(canBeNullOrNotSet = true)
    protected Long storageRepositoryId;

    public Long getStorageRepositoryId() {
        return storageRepositoryId;
    }

    public void setStorageRepositoryId(Long storageRepositoryId) {
        storageRepositoryIdSpecified = true;
        this.storageRepositoryId = storageRepositoryId;
    }

    protected boolean storageRepositoryIdSpecified;

    public boolean isStorageRepositoryIdSpecified() {
        return storageRepositoryIdSpecified;
    }

    public void unsetStorageRepositoryId() {
        storageRepositoryId = null;
        storageRepositoryIdSpecified = false;
    }

    /**
     * A disk image's [[SoftLayer_Virtual_Disk_Image_Type|type]] ID 
     */
    @ApiProperty(canBeNullOrNotSet = true)
    protected Long typeId;

    public Long getTypeId() {
        return typeId;
    }

    public void setTypeId(Long typeId) {
        typeIdSpecified = true;
        this.typeId = typeId;
    }

    protected boolean typeIdSpecified;

    public boolean isTypeIdSpecified() {
        return typeIdSpecified;
    }

    public void unsetTypeId() {
        typeId = null;
        typeIdSpecified = false;
    }

    /**
     * The unit of storage in which the size of the image is measured. Defaults to "GB" for gigabytes. 
     */
    @ApiProperty(canBeNullOrNotSet = true)
    protected String units;

    public String getUnits() {
        return units;
    }

    public void setUnits(String units) {
        unitsSpecified = true;
        this.units = units;
    }

    protected boolean unitsSpecified;

    public boolean isUnitsSpecified() {
        return unitsSpecified;
    }

    public void unsetUnits() {
        units = null;
        unitsSpecified = false;
    }

    /**
     * A disk image's unique ID on a virtualization platform. 
     */
    @ApiProperty(canBeNullOrNotSet = true)
    protected String uuid;

    public String getUuid() {
        return uuid;
    }

    public void setUuid(String uuid) {
        uuidSpecified = true;
        this.uuid = uuid;
    }

    protected boolean uuidSpecified;

    public boolean isUuidSpecified() {
        return uuidSpecified;
    }

    public void unsetUuid() {
        uuid = null;
        uuidSpecified = false;
    }

    /**
     * A count of the block devices that a disk image is attached to. Block devices connect computing instances to disk images.
     */
    @ApiProperty
    protected Long blockDeviceCount;

    public Long getBlockDeviceCount() {
        return blockDeviceCount;
    }

    public void setBlockDeviceCount(Long blockDeviceCount) {
        this.blockDeviceCount = blockDeviceCount;
    }

    /**
     * A count of 
     */
    @ApiProperty
    protected Long coalescedDiskImageCount;

    public Long getCoalescedDiskImageCount() {
        return coalescedDiskImageCount;
    }

    public void setCoalescedDiskImageCount(Long coalescedDiskImageCount) {
        this.coalescedDiskImageCount = coalescedDiskImageCount;
    }

    /**
     * A count of references to the software that resides on a disk image.
     */
    @ApiProperty
    protected Long softwareReferenceCount;

    public Long getSoftwareReferenceCount() {
        return softwareReferenceCount;
    }

    public void setSoftwareReferenceCount(Long softwareReferenceCount) {
        this.softwareReferenceCount = softwareReferenceCount;
    }

    public Service asService(ApiClient client) {
        return service(client, id);
    }

    public static Service service(ApiClient client) {
        return client.createService(Service.class, null);
    }

    public static Service service(ApiClient client, Long id) {
        return client.createService(Service.class, id == null ? null : id.toString());
    }

    /**
     * @see SoftLayer_Virtual_Disk_Image
     */
    @com.softlayer.api.annotation.ApiService("SoftLayer_Virtual_Disk_Image")
    public static interface Service extends com.softlayer.api.Service {

        public ServiceAsync asAsync();
        public Mask withNewMask();
        public Mask withMask();
        public void setMask(Mask mask);

        /**
         * @see SoftLayer_Virtual_Disk_Image::editObject
         */
        @ApiMethod(instanceRequired = true)
        public Boolean editObject(Image templateObject);

        /**
         * Returns a collection of boot modes that are supported for primary disks. 
         *
         * @see SoftLayer_Virtual_Disk_Image::getAvailableBootModes
         */
        @ApiMethod
        public List getAvailableBootModes();

        /**
         * @see SoftLayer_Virtual_Disk_Image::getObject
         */
        @ApiMethod(instanceRequired = true)
        public Image getObject();

        /**
         * @see SoftLayer_Virtual_Disk_Image::getPublicIsoImages
         */
        @ApiMethod
        public List getPublicIsoImages();

        /**
         * The billing item for a virtual disk image.
         *
         * @see SoftLayer_Virtual_Disk_Image::getBillingItem
         */
        @ApiMethod(instanceRequired = true)
        public com.softlayer.api.service.billing.item.virtual.disk.Image getBillingItem();

        /**
         * The block devices that a disk image is attached to. Block devices connect computing instances to disk images.
         *
         * @see SoftLayer_Virtual_Disk_Image::getBlockDevices
         */
        @ApiMethod(instanceRequired = true)
        public List getBlockDevices();

        /**
         * @see SoftLayer_Virtual_Disk_Image::getBootableVolumeFlag
         */
        @ApiMethod(instanceRequired = true)
        public Boolean getBootableVolumeFlag();

        /**
         * @see SoftLayer_Virtual_Disk_Image::getCoalescedDiskImages
         */
        @ApiMethod(instanceRequired = true)
        public List getCoalescedDiskImages();

        /**
         * @see SoftLayer_Virtual_Disk_Image::getCopyOnWriteFlag
         */
        @ApiMethod(instanceRequired = true)
        public Boolean getCopyOnWriteFlag();

        /**
         * Return imported disk type
         *
         * @see SoftLayer_Virtual_Disk_Image::getImportedDiskType
         */
        @ApiMethod(instanceRequired = true)
        public String getImportedDiskType();

        /**
         * Return if image is encrypted
         *
         * @see SoftLayer_Virtual_Disk_Image::getIsEncrypted
         */
        @ApiMethod(instanceRequired = true)
        public Boolean getIsEncrypted();

        /**
         * @see SoftLayer_Virtual_Disk_Image::getLocalDiskFlag
         */
        @ApiMethod(instanceRequired = true)
        public Boolean getLocalDiskFlag();

        /**
         * Whether this disk image is meant for storage of custom user data supplied with a Cloud Computing Instance order.
         *
         * @see SoftLayer_Virtual_Disk_Image::getMetadataFlag
         */
        @ApiMethod(instanceRequired = true)
        public Boolean getMetadataFlag();

        /**
         * References to the software that resides on a disk image.
         *
         * @see SoftLayer_Virtual_Disk_Image::getSoftwareReferences
         */
        @ApiMethod(instanceRequired = true)
        public List getSoftwareReferences();

        /**
         * The original disk image that the current disk image was cloned from.
         *
         * @see SoftLayer_Virtual_Disk_Image::getSourceDiskImage
         */
        @ApiMethod(instanceRequired = true)
        public Image getSourceDiskImage();

        /**
         * The storage repository that a disk image resides in.
         *
         * @see SoftLayer_Virtual_Disk_Image::getStorageRepository
         */
        @ApiMethod(instanceRequired = true)
        public Repository getStorageRepository();

        /**
         * The type of storage repository that a disk image resides in.
         *
         * @see SoftLayer_Virtual_Disk_Image::getStorageRepositoryType
         */
        @ApiMethod(instanceRequired = true)
        public com.softlayer.api.service.virtual.storage.repository.Type getStorageRepositoryType();

        /**
         * The template that attaches a disk image to a [[SoftLayer_Virtual_Guest_Block_Device_Template_Group|archive]].
         *
         * @see SoftLayer_Virtual_Disk_Image::getTemplateBlockDevice
         */
        @ApiMethod(instanceRequired = true)
        public Template getTemplateBlockDevice();

        /**
         * A virtual disk image's type.
         *
         * @see SoftLayer_Virtual_Disk_Image::getType
         */
        @ApiMethod(instanceRequired = true)
        public Type getType();

    }

    public static interface ServiceAsync extends com.softlayer.api.ServiceAsync {

        public Mask withNewMask();
        public Mask withMask();
        public void setMask(Mask mask);

        /**
         * Async version of {@link Service#editObject}
         */
        public Future editObject(Image templateObject);

        public Future editObject(Image templateObject, ResponseHandler callback);

        /**
         * Async version of {@link Service#getAvailableBootModes}
         */
        public Future> getAvailableBootModes();

        public Future getAvailableBootModes(ResponseHandler> callback);

        /**
         * Async version of {@link Service#getObject}
         */
        public Future getObject();

        public Future getObject(ResponseHandler callback);

        /**
         * Async version of {@link Service#getPublicIsoImages}
         */
        public Future> getPublicIsoImages();

        public Future getPublicIsoImages(ResponseHandler> callback);

        /**
         * Async version of {@link Service#getBillingItem}
         */
        public Future getBillingItem();

        /**
         * Async callback version of {@link Service#getBillingItem}
         */
        public Future getBillingItem(ResponseHandler callback);

        /**
         * Async version of {@link Service#getBlockDevices}
         */
        public Future> getBlockDevices();

        /**
         * Async callback version of {@link Service#getBlockDevices}
         */
        public Future getBlockDevices(ResponseHandler> callback);

        /**
         * Async version of {@link Service#getBootableVolumeFlag}
         */
        public Future getBootableVolumeFlag();

        /**
         * Async callback version of {@link Service#getBootableVolumeFlag}
         */
        public Future getBootableVolumeFlag(ResponseHandler callback);

        /**
         * Async version of {@link Service#getCoalescedDiskImages}
         */
        public Future> getCoalescedDiskImages();

        /**
         * Async callback version of {@link Service#getCoalescedDiskImages}
         */
        public Future getCoalescedDiskImages(ResponseHandler> callback);

        /**
         * Async version of {@link Service#getCopyOnWriteFlag}
         */
        public Future getCopyOnWriteFlag();

        /**
         * Async callback version of {@link Service#getCopyOnWriteFlag}
         */
        public Future getCopyOnWriteFlag(ResponseHandler callback);

        /**
         * Async version of {@link Service#getImportedDiskType}
         */
        public Future getImportedDiskType();

        /**
         * Async callback version of {@link Service#getImportedDiskType}
         */
        public Future getImportedDiskType(ResponseHandler callback);

        /**
         * Async version of {@link Service#getIsEncrypted}
         */
        public Future getIsEncrypted();

        /**
         * Async callback version of {@link Service#getIsEncrypted}
         */
        public Future getIsEncrypted(ResponseHandler callback);

        /**
         * Async version of {@link Service#getLocalDiskFlag}
         */
        public Future getLocalDiskFlag();

        /**
         * Async callback version of {@link Service#getLocalDiskFlag}
         */
        public Future getLocalDiskFlag(ResponseHandler callback);

        /**
         * Async version of {@link Service#getMetadataFlag}
         */
        public Future getMetadataFlag();

        /**
         * Async callback version of {@link Service#getMetadataFlag}
         */
        public Future getMetadataFlag(ResponseHandler callback);

        /**
         * Async version of {@link Service#getSoftwareReferences}
         */
        public Future> getSoftwareReferences();

        /**
         * Async callback version of {@link Service#getSoftwareReferences}
         */
        public Future getSoftwareReferences(ResponseHandler> callback);

        /**
         * Async version of {@link Service#getSourceDiskImage}
         */
        public Future getSourceDiskImage();

        /**
         * Async callback version of {@link Service#getSourceDiskImage}
         */
        public Future getSourceDiskImage(ResponseHandler callback);

        /**
         * Async version of {@link Service#getStorageRepository}
         */
        public Future getStorageRepository();

        /**
         * Async callback version of {@link Service#getStorageRepository}
         */
        public Future getStorageRepository(ResponseHandler callback);

        /**
         * Async version of {@link Service#getStorageRepositoryType}
         */
        public Future getStorageRepositoryType();

        /**
         * Async callback version of {@link Service#getStorageRepositoryType}
         */
        public Future getStorageRepositoryType(ResponseHandler callback);

        /**
         * Async version of {@link Service#getTemplateBlockDevice}
         */
        public Future