com.softlayer.api.service.network.contentdelivery.Account Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of softlayer-api-client Show documentation
Show all versions of softlayer-api-client Show documentation
API client for accessing the SoftLayer API
package com.softlayer.api.service.network.contentdelivery;
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.billing.Item;
import com.softlayer.api.service.container.bandwidth.GraphOutputs;
import com.softlayer.api.service.container.bandwidth.GraphOutputsExtended;
import com.softlayer.api.service.container.network.authentication.Data;
import com.softlayer.api.service.container.network.contentdelivery.PointsOfPresence;
import com.softlayer.api.service.container.network.contentdelivery.SupportedProtocol;
import com.softlayer.api.service.container.network.contentdelivery.authentication.Parameter;
import com.softlayer.api.service.container.network.contentdelivery.authentication.ServiceEndpoint;
import com.softlayer.api.service.container.network.contentdelivery.bandwidth.Summary;
import com.softlayer.api.service.container.network.contentdelivery.originpull.Mapping;
import com.softlayer.api.service.container.network.contentdelivery.purgeservice.Response;
import com.softlayer.api.service.container.network.contentdelivery.report.Usage;
import com.softlayer.api.service.container.network.directory.Listing;
import com.softlayer.api.service.container.utility.file.Attachment;
import com.softlayer.api.service.network.contentdelivery.account.Status;
import com.softlayer.api.service.network.contentdelivery.authentication.Address;
import java.util.ArrayList;
import java.util.GregorianCalendar;
import java.util.List;
import java.util.concurrent.Future;
/**
* The SoftLayer_Network_ContentDelivery_Account data type models an individual CDN account. CDN accounts contain references to the SoftLayer customer account they belong to, login credentials for upload services, and a CDN account's status. Please contact SoftLayer sales to purchase or cancel a CDN account
*
* @see SoftLayer_Network_ContentDelivery_Account
*/
@ApiType("SoftLayer_Network_ContentDelivery_Account")
public class Account extends Entity {
/**
* The customer account that a CDN account belongs to.
*/
@ApiProperty
protected com.softlayer.api.service.Account account;
public com.softlayer.api.service.Account getAccount() {
return account;
}
public void setAccount(com.softlayer.api.service.Account account) {
this.account = account;
}
/**
* The CDN account id that this CDN account is associated with.
*/
@ApiProperty
protected String associatedCdnAccountId;
public String getAssociatedCdnAccountId() {
return associatedCdnAccountId;
}
public void setAssociatedCdnAccountId(String associatedCdnAccountId) {
this.associatedCdnAccountId = associatedCdnAccountId;
}
/**
* The IP addresses that are used for the content authentication service.
*/
@ApiProperty
protected List authenticationIpAddresses;
public List getAuthenticationIpAddresses() {
if (authenticationIpAddresses == null) {
authenticationIpAddresses = new ArrayList();
}
return authenticationIpAddresses;
}
/**
* The current billing item for a CDN account.
*/
@ApiProperty
protected Item billingItem;
public Item getBillingItem() {
return billingItem;
}
public void setBillingItem(Item billingItem) {
this.billingItem = billingItem;
}
/**
* The name of a CDN account.
*/
@ApiProperty
protected String cdnAccountName;
public String getCdnAccountName() {
return cdnAccountName;
}
public void setCdnAccountName(String cdnAccountName) {
this.cdnAccountName = cdnAccountName;
}
/**
* A brief note on a CDN account.
*/
@ApiProperty
protected String cdnAccountNote;
public String getCdnAccountNote() {
return cdnAccountNote;
}
public void setCdnAccountNote(String cdnAccountNote) {
this.cdnAccountNote = cdnAccountNote;
}
/**
* The solution type of a CDN account.
*/
@ApiProperty
protected String cdnSolutionName;
public String getCdnSolutionName() {
return cdnSolutionName;
}
public void setCdnSolutionName(String cdnSolutionName) {
this.cdnSolutionName = cdnSolutionName;
}
/**
* Indicates if CDN account is dependent on other service. If set, this CDN account is limited to these services: createOriginPullMapping, deleteOriginPullRule, getOriginPullMappingInformation, getCdnUrls, purgeCache, loadContent, manageHttpCompression
*/
@ApiProperty
protected Boolean dependantServiceFlag;
public Boolean getDependantServiceFlag() {
return dependantServiceFlag;
}
public void setDependantServiceFlag(Boolean dependantServiceFlag) {
this.dependantServiceFlag = dependantServiceFlag;
}
/**
* Indicates if it is a legacy CDN or not
*/
@ApiProperty
protected Boolean legacyCdnFlag;
public Boolean getLegacyCdnFlag() {
return legacyCdnFlag;
}
public void setLegacyCdnFlag(Boolean legacyCdnFlag) {
this.legacyCdnFlag = legacyCdnFlag;
}
/**
* Indicates if CDN logging is enabled.
*/
@ApiProperty
protected String logEnabledFlag;
public String getLogEnabledFlag() {
return logEnabledFlag;
}
public void setLogEnabledFlag(String logEnabledFlag) {
this.logEnabledFlag = logEnabledFlag;
}
/**
* Indicates if customer is allowed to access the CDN provider's management portal.
*/
@ApiProperty
protected Boolean providerPortalAccessFlag;
public Boolean getProviderPortalAccessFlag() {
return providerPortalAccessFlag;
}
public void setProviderPortalAccessFlag(Boolean providerPortalAccessFlag) {
this.providerPortalAccessFlag = providerPortalAccessFlag;
}
/**
* A CDN account's status presented in a more detailed data type.
*/
@ApiProperty
protected Status status;
public Status getStatus() {
return status;
}
public void setStatus(Status status) {
this.status = status;
}
/**
* Indicates if the token authentication service is enabled or not.
*/
@ApiProperty
protected Boolean tokenAuthenticationEnabledFlag;
public Boolean getTokenAuthenticationEnabledFlag() {
return tokenAuthenticationEnabledFlag;
}
public void setTokenAuthenticationEnabledFlag(Boolean tokenAuthenticationEnabledFlag) {
this.tokenAuthenticationEnabledFlag = tokenAuthenticationEnabledFlag;
}
/**
* The internal identifier of the customer account that a CDN account belongs to.
*/
@ApiProperty(canBeNullOrNotSet = true)
protected Long accountId;
public Long getAccountId() {
return accountId;
}
public void setAccountId(Long accountId) {
accountIdSpecified = true;
this.accountId = accountId;
}
protected boolean accountIdSpecified;
public boolean isAccountIdSpecified() {
return accountIdSpecified;
}
public void unsetAccountId() {
accountId = null;
accountIdSpecified = false;
}
/**
* The date that a CDN account 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 CDN account's internal identifier.
*/
@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 internal identifier of a CDN status
*/
@ApiProperty(canBeNullOrNotSet = true)
protected Long statusId;
public Long getStatusId() {
return statusId;
}
public void setStatusId(Long statusId) {
statusIdSpecified = true;
this.statusId = statusId;
}
protected boolean statusIdSpecified;
public boolean isStatusIdSpecified() {
return statusIdSpecified;
}
public void unsetStatusId() {
statusId = null;
statusIdSpecified = false;
}
/**
* A count of the IP addresses that are used for the content authentication service.
*/
@ApiProperty
protected Long authenticationIpAddressCount;
public Long getAuthenticationIpAddressCount() {
return authenticationIpAddressCount;
}
public void setAuthenticationIpAddressCount(Long authenticationIpAddressCount) {
this.authenticationIpAddressCount = authenticationIpAddressCount;
}
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());
}
/**
* SoftLayer_Network_ContentDelivery_Account controls a single CDN user account and that account's content hosted on SoftLayer's CDN hosting infrastructure. Individual customer accounts can have more than one CDN account.
*
* Every CDN account has the capability to configure and upload content to SoftLayer's CDN infrastructure. When a user requests content from the CDN they retrieve data from the node in closest physical proximity to them, assuring failover in the case of single node failure and the lowest network latency possible.
*
* CDN supports three distinct types of content, streaming Flash, streaming Windows Media and traditional HTTP. Each of these types of service are automatically set depending on the folder you upload your content to. Each of these types of content are accessed from different URLs. URL examples can be found on the [https://manage.softlayer.com customer portal].
*
* CDN supports directory creation, [[SoftLayer_Network_ContentDelivery_Account::getBandwidthData|bandwidth reporting]], and an [[SoftLayer_Network_ContentDelivery_Account::createOriginPullRule|Origin Pull]] rule if you wish to manage your content directly on one of your servers. Files uploaded to CDN are accessed by users in directories relative to your account's root directory. For instance, if the file "/images/header.jpg" exists in your CDN space then it can be accessed at the URL "http://.http.cdn.softlayer.net/00/images/header.jpg "
*
* CDN accounts support FTP transfers in addition to API-based uploads. To access a CDN account's FTP space on the SoftLayer private network, log into '''ftp.cdnlayer.service.softlayer.com''' with an FTP client using your CDN account name and a password set either in the SoftLayer [https://manage.softlayer.com customer portal] or by via the [[SoftLayer_Network_ContentDelivery_Account::setFtpPassword|setFtpPassword]] method
*
* CDN supports the content authentication service. CDN's content authentication service is the technology that allows only authorized user to access your content. It performs a token based authentication before delivering content. An authentication token can be obtained from the SoftLayer customer portal or API and it needs to be appended to the CDN URL. When an end-user requests a file, CDN server will check the validity of the token passed via HTTP GET string with a remote web service provided by SoftLayer. Then the content will be delivered if the value returned from the web service is good otherwise the connection will be rejected. The token authentication web service call is made in real time and it will hold the incoming connection until receiving a value returned from the website.
*
* There are several scenarios where this authentication capability could be useful. Websites can prevent other rogue websites from linking to their videos. Content owners can prevent users from passing around HTTP links, thus forcing them to login to view contents. See [[SoftLayer_Network_ContentDelivery_Authentication_Token|SoftLayer_Network_ContentDelivery_Authentication_Token]] and [[SoftLayer_Network_ContentDelivery_Authentication_Address|SoftLayer_Network_ContentDelivery_Authentication_Address]] for more details on the content authentication service.
*
*
*
* @see SoftLayer_Network_ContentDelivery_Account
*/
@com.softlayer.api.annotation.ApiService("SoftLayer_Network_ContentDelivery_Account")
public static interface Service extends com.softlayer.api.Service {
public ServiceAsync asAsync();
public Mask withNewMask();
public Mask withMask();
public void setMask(Mask mask);
/**
* Internap servers attempts to validate a token before serving a protected content. SoftLayer customer does not need to invoke this method. Please refer to [[SoftLayer_Network_ContentDelivery_Authentication_Token|Authentication Token]] object for more details on Content Authentication Service.
*
* @see SoftLayer_Network_ContentDelivery_Account::authenticateResourceRequest
*/
@ApiMethod
public Boolean authenticateResourceRequest(Parameter parameter);
/**
* You can further organize your contents on the CDN FTP server by creating sub directories. This method creates a directory on the CDN FTP server. A user must have CDN_FILE_MANAGE privilege to use this method. A directory name must be an absolute path and you can only create sub directories in /media folder.
*
* @see SoftLayer_Network_ContentDelivery_Account::createDirectory
*/
@ApiMethod(instanceRequired = true)
public Boolean createDirectory(String directoryName);
/**
* This method allows you to create a default CDN FTP user record on the ftp.cdnlayer.service.softlayer.com server. As with a CDN FTP user account, you can upload contents to the CDN host server through the SoftLayer private network. SoftLayer currently allows only one FTP user for each CDN account. Your default CDN FTP user record is created upon successful creation of a CDN account. You may not need to use this method at all. This is provided in support of the previous CDN customers. SoftLayer may offer multiple CDN FTP users for a single CDN account in the future.
*
* Optionally, you can provide a new password when invoking this method and a new password must follow the rules below:
* * ...must be between 8 and 20 characters long
* * ...must be an alphanumeric value
* * ...can contain these characters: - _ ! % # $ ^ & *
*
* @see SoftLayer_Network_ContentDelivery_Account::createFtpUser
*/
@ApiMethod(instanceRequired = true)
public Boolean createFtpUser(String newPassword);
/**
* With Origin Pull, content is pulled from your origin server as needed and then delivered to visitors. You do not need to upload your files to the CDN FTP: you can utilize the files that currently exist on your origin server. It will take 10 to 15 minutes for this to take effect after you create an Origin Pull rule. Origin Pull is only supported for HTTP protocol and you would continue to use the CDN FTP for Flash and Windows Media streaming services.
*
* A valid origin host can include a directory information. You may include an authentication username and password along with an origin host. If you set an authentication username and password, CDN servers will include "Authorization:" header in every request. You may use the "Authorization:" header to grant access to CDN servers or you may use it to distinguish CDN servers from normal visitors. Here is a list of valid origin hosts:
* * www.website.com
* * www.website.com/cdn_content
* * cdn_user:[email protected]
* * cdn_user:[email protected]/images
*
*
* An authentication username should be an alphanumeric string and allowed special characters are . - _
An authentication password should be an alphanumeric string and allowed special characters are . - _ ! # $ % ^ & *
Both username and password must be between 3 to 10 characters long.
*
* CDN nodes will cache your contents and you can control cache lifetime by modifying your web server's configuration. This method also creates a FTP directory restriction upon successful Origin Pull set up. You will not be able to access /media/http directory since contents will be pulled from your origin server. An origin domain must be a valid domain name and it can contain path information. This can help you organize contents on your origin server. For example, you could set an origin domain as: mydomain.com/cdn_contents
*
* A CNAME record allows you to have a customized URL. You can get rid of your CDN account name from the URL. A valid CNAME for the Origin Pull method must point to .http.cdn.softlayer.net.
*
* There are 2 types of origin pull mappings. The one with a CNAME record or the one without a CNAME record and they work very differently.
*
* gzip is supported if your web server sends a proper gzip header. For more details, visit our [http://knowledgelayer.softlayer.com/topic/cdn KnowledgeLayer]
*
* @see SoftLayer_Network_ContentDelivery_Account::createOriginPullMapping
*/
@ApiMethod(instanceRequired = true)
public Boolean createOriginPullMapping(Mapping mappingObject);
/**
* This method is deprecated, please use [[[[SoftLayer_Network_ContentDelivery_Account::createOriginPullMapping|createOriginPullMapping]] method instead.
*
* @see SoftLayer_Network_ContentDelivery_Account::createOriginPullRule
*/
@ApiMethod(instanceRequired = true)
public Boolean createOriginPullRule(String originDomain, String cnameRecord);
/**
* You need to specify a directory on your CDN FTP or on your origin host in which your secure content resides to enable the token authentication . It will take about about 30 minutes for a newly configured token authentication directory to take effect.
*
* @see SoftLayer_Network_ContentDelivery_Account::createTokenAuthenticationDirectory
*/
@ApiMethod(instanceRequired = true)
public Boolean createTokenAuthenticationDirectory(String directory, String mediaType);
/**
* This method deletes your FTP user record on the ftp.cdnlayer.service.softlayer.com server. Refer to the service overview of [[SoftLayer_Network_ContentDelivery_Account::createFtpUser|createFtpUser]] method for more information on the CDN FTP server.
*
* @see SoftLayer_Network_ContentDelivery_Account::deleteFtpUser
*/
@ApiMethod(instanceRequired = true)
public Boolean deleteFtpUser();
/**
* This method removes an Origin Pull domain rule. Once an Origin Pull rule is removed, you will be able to access the /media/http directory. It will take 10 to 15 minutes for this to take effect after you remove your Origin Pull rule. Cached contents on CDN POPs may live longer than 15 minutes.
*
* @see SoftLayer_Network_ContentDelivery_Account::deleteOriginPullRule
*/
@ApiMethod(instanceRequired = true)
public Boolean deleteOriginPullRule(String originMappingId);
/**
* This method disables CDN access log.
*
* @see SoftLayer_Network_ContentDelivery_Account::disableLogging
*/
@ApiMethod(instanceRequired = true)
public Boolean disableLogging();
/**
* This method enables CDN access log.
*
* @see SoftLayer_Network_ContentDelivery_Account::enableLogging
*/
@ApiMethod(instanceRequired = true)
public Boolean enableLogging();
/**
* This method returns bandwidth data for each POP. [[SoftLayer_Container_Network_ContentDelivery_Bandwidth_PointsOfPresence_Summary|POP Bandwidth]] object contains a starting time, ending time, total bytes, POP name and bandwidth unit.
*
* POP bandwidth data is updated everyday at 22:50 CST (or CDT). It queries and stores POP data from the day before. It is a more resource intensive process than a regular CDN bandwidth update thus we run this once a day. Since the POP bandwidth data is delayed for a day, there is no correction process for POP data. The POP bandwidth is not associated with any billing process and is mainly used to generate a POP bandwidth graph.
*
* @see SoftLayer_Network_ContentDelivery_Account::getAllPopsBandwidthData
*/
@ApiMethod(instanceRequired = true)
public List getAllPopsBandwidthData(GregorianCalendar beginDateTime, GregorianCalendar endDateTime);
/**
* This method returns a bandwidth graph for every POP wrapped in [[SoftLayer_Container_Bandwidth_GraphOutputsExtended|Bandwidth Graph]] object. A POP bandwidth graph shows bandwidth consumption per each POP in a bar graph. [[SoftLayer_Container_Bandwidth_GraphOutputsExtended|Bandwidth Graph]] object contains a begin time, end time, title of the graph, binary date, in and outbound total bandwidth in bytes
*
* @see SoftLayer_Network_ContentDelivery_Account::getAllPopsBandwidthImage
*/
@ApiMethod(instanceRequired = true)
public GraphOutputsExtended getAllPopsBandwidthImage(String title, GregorianCalendar beginDateTime, GregorianCalendar endDateTime, String unit);
/**
* CDN servers will invoke a Web Service method to validate a content authentication token. This method returns all token validation web service endpoints set for a CDN account. You can override the default web service by calling [[SoftLayer_Network_ContentDelivery_Authentication_Token|setContentAuthenticationWsdl setContentAuthenticationWsdl]] method.
*
* @see SoftLayer_Network_ContentDelivery_Account::getAuthenticationServiceEndpoints
*/
@ApiMethod(instanceRequired = true)
public List getAuthenticationServiceEndpoints();
/**
* This method returns bandwidth data for a given time range. It returns an array of [[SoftLayer_Container_Network_ContentDelivery_Bandwidth_Summary|bandwidth summary]] objects. [[SoftLayer_Container_Network_ContentDelivery_Bandwidth_Summary|Bandwidth summary]] object contains a beginning time, ending time, and bandwidth in bytes.
*
* A Beginning and ending date parameters have to be a timestamp in "yyyy-mm-dd HH24:mi:ss" format and it assumes the time is in Central Standard Time (CST) or Central Daylight Time (CDT) time zone. CDN bandwidth data is stored in Greenwich Mean Time (GMT) internally and converts a beginning and ending time to GMT before querying.
*
* Unlike server bandwidth, CDN bandwidth returns total bytes consumed within an hour. For example, if you pass "2008-10-10 00:00:00" for a beginning time and "2008-10-10 05:00:00" for an ending time, your return value will have 6 elements of bandwidth summary objects. The first bandwidth summary object will have the total bytes consumed between 2008-10-10 00:00:00 and 2008-10-10 05:00:00. And the last object will have the bandwidth consumed between 2008-10-10 05:00:00 and 2008-10-10 00:59:59. The bandwidth data is updated at 10 minutes after every hour. The queried data is on a two hour time delay. The two hour delay is required to gather bandwidth data from each POP and that is the minimum delay required to create a feasible graph. It usually takes about 8 hours to reconcile all the data from every CDN POP. This hourly data is corrected after 24 hours if necessary. If you consume a large amount of bandwidth, your bandwidth data will be updated the next day.
*
* @see SoftLayer_Network_ContentDelivery_Account::getBandwidthData
*/
@ApiMethod(instanceRequired = true)
public List getBandwidthData(GregorianCalendar beginDateTime, GregorianCalendar endDateTime);
/**
* This method returns bandwidth data for a given time range. It returns an array of [[SoftLayer_Container_Network_ContentDelivery_Report_Usage|bandwidth usage report]] objects.
*
* These will be first sorted by timestamp, and there will be one entry with that timestamp for each enabled region. The region type 'NONE' is provided only when non-region-specific data is returned. [[SoftLayer_Container_Network_ContentDelivery_Report_Usage|bandwidth usage report]] objects with a region will never contain non-region-specific data. Non-region-specific values are standardTotal and sslTotal; standardTotal is computed by adding the HTTP Large, Windows Media, Flash and Application Delivery Network bandwidth. The sslTotal is computed by adding the HTTP Large SSL bandwidth and the Application Delivery Network SSL bandwidth.
*
* A Beginning and ending date parameters have to be a timestamp in "yyyy-mm-dd HH24:mi:ss" format and it assumes the time is in Central Standard Time (CST) or Central Daylight Time (CDT) time zone. CDN bandwidth data is stored in Greenwich Mean Time (GMT) internally and converts a beginning and ending time to GMT before querying.
*
* Unlike server bandwidth, CDN bandwidth returns total bytes consumed within an hour. For example, if you pass "2008-10-10 00:00:00" for a beginning time and "2008-10-10 05:00:00" for an ending time, your return value will have 6 elements of bandwidth summary objects. The first bandwidth summary object will have the total bytes consumed between 2008-10-10 00:00:00 and 2008-10-10 05:00:00. And the last object will have the bandwidth consumed between 2008-10-10 05:00:00 and 2008-10-10 00:59:59. The bandwidth data is updated at 10 minutes after every hour. The queried data is on a two hour time delay. The two hour delay is required to gather bandwidth data from each POP and that is the minimum delay required to create a feasible graph. It usually takes about 8 hours to reconcile all the data from every CDN POP. This hourly data is corrected after 24 hours if necessary. If you consume a large amount of bandwidth, your bandwidth data will be updated the next day.
*
* @see SoftLayer_Network_ContentDelivery_Account::getBandwidthDataWithTypes
*/
@ApiMethod(instanceRequired = true)
public List getBandwidthDataWithTypes(GregorianCalendar beginDateTime, GregorianCalendar endDateTime, String period);
/**
* This method returns a bandwidth graph wrapped in [[SoftLayer_Container_Bandwidth_GraphOutputsExtended|Bandwidth Graph]] object. [[SoftLayer_Container_Bandwidth_GraphOutputsExtended|Bandwidth Graph]] object contains a starting time, ending time, graph title, graph binary data, and in and outbound total bytes.
*
* @see SoftLayer_Network_ContentDelivery_Account::getBandwidthImage
*/
@ApiMethod(instanceRequired = true)
public GraphOutputsExtended getBandwidthImage(String title, GregorianCalendar beginDateTime, GregorianCalendar endDateTime);
/**
* An origin pull mapping is a combination of your customer origin record and a CNAME (optional) record. You can now keep track of your customer origin records separate from your CNAME records. This service returns your customer origin records.
*
* @see SoftLayer_Network_ContentDelivery_Account::getCustomerOrigins
*/
@ApiMethod(instanceRequired = true)
public List getCustomerOrigins(String mediaType);
/**
* This method returns an array of [[SoftLayer_Container_Network_Directory_Listing|Directory Listing]] objects. You must have CDN_FILE_MANAGE privilege and you can only retrieve directory information within /media directory. A [[SoftLayer_Container_Network_Directory_Listing|Directory Listing]] object contains type (indicating whether it is a file or a directory), name and file count if it is a directory.
*
* @see SoftLayer_Network_ContentDelivery_Account::getDirectoryInformation
*/
@ApiMethod(instanceRequired = true)
public List getDirectoryInformation(String directoryName);
/**
* This method returns disk space usage data for your CDN FTP.
*
* @see SoftLayer_Network_ContentDelivery_Account::getDiskSpaceUsageDataByDate
*/
@ApiMethod(instanceRequired = true)
public List getDiskSpaceUsageDataByDate(GregorianCalendar beginDateTime, GregorianCalendar endDateTime);
/**
* This method returns a disk usage graph wrapped in [[SoftLayer_Container_Bandwidth_GraphOutputsExtended|Bandwidth Graph]] object. [[SoftLayer_Container_Bandwidth_GraphOutputsExtended|Bandwidth Graph]] object contains a starting time, ending time, graph title, graph binary data, and in and outbound total bytes.
*
* @see SoftLayer_Network_ContentDelivery_Account::getDiskSpaceUsageImageByDate
*/
@ApiMethod(instanceRequired = true)
public GraphOutputs getDiskSpaceUsageImageByDate(GregorianCalendar beginDateTime, GregorianCalendar endDateTime);
/**
* This method returns your login credentials to the CDN FTP server (ftp.cdnlayer.service.softlayer.com server). You must have CDN_FILE_MANAGE privilege. Refer to the service overview of [[SoftLayer_Network_ContentDelivery_Account::createFtpUser|createFtpUser]] method for more information on the CDN FTP server.
*
* If you want to download raw log files, prefix the username with "LOGS-" (without quotes) when logging in. SoftLayer designed CDN accounts so they can have multiple CDN FTP users. However, this method returns the default CDN FTP user information: multi user support may be implemented in the future.
*
* @see SoftLayer_Network_ContentDelivery_Account::getFtpAttributes
*/
@ApiMethod(instanceRequired = true)
public Data getFtpAttributes();
/**
* This method returns CDN URLs for static file (http), Flash streaming (rtmp) and Window Media (mms) streaming services. You can generate your CDN URLs based on the information retrieved by this method.
*
* @see SoftLayer_Network_ContentDelivery_Account::getMediaUrls
*/
@ApiMethod(instanceRequired = true)
public List getMediaUrls();
/**
* getObject retrieves the SoftLayer_Network_ContentDelivery_Account object whose ID number corresponds to the ID number of the initial parameter passed to the SoftLayer_Network_ContentDelivery_Account service. You can only retrieve CDN accounts assigned to your SoftLayer customer account.
*
* @see SoftLayer_Network_ContentDelivery_Account::getObject
*/
@ApiMethod(instanceRequired = true)
public Account getObject();
/**
* This method returns a list of origin pull configuration data.
*
* @see SoftLayer_Network_ContentDelivery_Account::getOriginPullMappingInformation
*/
@ApiMethod(instanceRequired = true)
public List getOriginPullMappingInformation();
/**
* This method returns CDN URLs that supports Origin Pull mappings.
*
* @see SoftLayer_Network_ContentDelivery_Account::getOriginPullSupportedMediaUrls
*/
@ApiMethod(instanceRequired = true)
public List getOriginPullSupportedMediaUrls();
/**
* This method returns the domain name of your Origin Pull rule. It assumes you have already setup an Origin Pull rule. Otherwise, it will throw an exception. A returning value is the value of the first parameter (origin pull domain) you provided to [[SoftLayer_Network_ContentDelivery_Account::createOriginPullRule|createOriginPullRule]] method. See Error Handling section below for possible errors.
*
* @see SoftLayer_Network_ContentDelivery_Account::getOriginPullUrl
*/
@ApiMethod(instanceRequired = true)
public String getOriginPullUrl();
/**
* This method returns an array of CDN POPs (Points of Presence) object. [[SoftLayer_Container_Network_ContentDelivery_PointsOfPresence|POP object]] object contains the POP id and name.
*
* @see SoftLayer_Network_ContentDelivery_Account::getPopNames
*/
@ApiMethod(instanceRequired = true)
public List getPopNames();
/**
* This method returns your login credentials to the CDN provider portal.
*
* @see SoftLayer_Network_ContentDelivery_Account::getProviderPortalCredentials
*/
@ApiMethod(instanceRequired = true)
public Data getProviderPortalCredentials();
/**
* This method returns all token authentication directories.
*
* @see SoftLayer_Network_ContentDelivery_Account::getTokenAuthenticationDirectories
*/
@ApiMethod(instanceRequired = true)
public List getTokenAuthenticationDirectories();
/**
* This method returns your login credentials to the public CDN FTP.
*
* @see SoftLayer_Network_ContentDelivery_Account::getVendorFtpAttributes
*/
@ApiMethod(instanceRequired = true)
public Data getVendorFtpAttributes();
/**
* Whether you are using Origin Pull or POP Pull, your content will be transferred and cached on CDN POP (node) on the initial request. If you wish to load your content to all CDN POPs, you may use this service to accomplish that. Please keep in mind, it will take about 10 to 15 minutes to load content to all CDN POPs depending on the load.
*
* You can only specify 5 URLs at a time.
*
* @see SoftLayer_Network_ContentDelivery_Account::loadContent
*/
@ApiMethod(instanceRequired = true)
public Boolean loadContent(List objectUrls);
/**
* HTTP Compression is used to reduce the bandwidth used to deliver an object. You can specify list of content types that needs to be compressed. If you omit the content type parameter, these values will be used by default:
* * text/plain
* * text/html
* * text/css
* * application/x-javascript
* * text/javascript
*
*
* Note that files larger than 1MB will never be served with compression regardless of whether their content-type is enabled for compression.
*
* @see SoftLayer_Network_ContentDelivery_Account::manageHttpCompression
*/
@ApiMethod(instanceRequired = true)
public Boolean manageHttpCompression(Boolean enableFlag, List mimeTypes);
/**
* CDN's cache mechanism works similar to that of web browsers. When CDN pulls a file from your origin server or from your CDN FTP directory for the first time, it creates a cache file on itself. CDN re-uses cache files to save trips to the origin server and thus it speeds up delivering content to visitors. This method removes cached objects on every server in the CDN network. If you see a stale content or a file that send an incorrect header, purging cache will correct the issue. CDN will pull a fresh content from your origin server or your CDN FTP.
*
* This method takes an array of URLs. A URL must be exact as it is being requested by clients. An example URLs may look like this:
* * http://.http.cdn.softlayer.net/mycdnname/some_file.txt
*
*
* If you created a CNAME that points to CDN host, use your CNAME URL instead.
* * http://image.mydomain.com/some_file.txt
*
*
* It takes approximately 3-5 minutes for the system to delete the requested object on every CDN server from submission .
*
* @see SoftLayer_Network_ContentDelivery_Account::purgeCache
*/
@ApiMethod(instanceRequired = true)
public List purgeCache(List objectUrls);
/**
* If you want to turn off the token authentication, use this method to remove a directory from the token authentication directory.
*
* @see SoftLayer_Network_ContentDelivery_Account::removeAuthenticationDirectory
*/
@ApiMethod(instanceRequired = true)
public Boolean removeAuthenticationDirectory(String directory, String mediaType);
/**
* With this method you can remove a file or a directory on the CDN FTP server. If a source name ends with a slash (/), this method assumes it is a directory. A source name must be an absolute path. It does not check to see if a file or directory exists before deletion. You can only remove files and directories that are in /media folder. Be sure to catch an exception for the detail on an error.
*
* @see SoftLayer_Network_ContentDelivery_Account::removeFile
*/
@ApiMethod(instanceRequired = true)
public Boolean removeFile(String source);
/**
* CDN servers will invoke a Web Service method to validate a content authentication token. CDN uses the default Web Service provided by SoftLayer to validate a token. A customer can use their own implementation of the token authentication Web Service. A valid SOAP WSDL will look similar [https://manage.softlayer.com/CdnService/authenticationWsdlExample/wsdl this].
*
* @see SoftLayer_Network_ContentDelivery_Account::setAuthenticationServiceEndpoint
*/
@ApiMethod(instanceRequired = true)
public Boolean setAuthenticationServiceEndpoint(String webserviceEndpoint, String protocol);
/**
* With a CDN FTP, you can upload contents to CDN host server. Once you uploaded contents, your contents will be fetched by the CDN POP (Points of Presence) servers as needed.
*
* CDN supports three protocols: Flash streaming (rtmp), Window Media streaming (mms) and HTTP. Once you log in to the CDN FTP server, you will see three directories under /media directory. You have to upload your contents to a proper directory to use the different services. Refer to [[SoftLayer_Network_ContentDelivery_Account|CDN Account]] service overview for details on the CDN FTP server. "gzip" is supported if you compress your content before uploading and you have to change its extension to ".gz". [SoftLayer_Network_ContentDelivery_Account::createOriginPullRule|Origin Pull] also supports "gzip" contents and you don't have to modify file extension with Origin Pull. Once uploaded, your contents should be available almost immediately to visitors. However, it may take about 30 minutes to propagate files to the entire CDN network after uploading. For more details, visit our [hhttp://knowledgelayer.softlayer.com/topic/cdn KnowledgeLayer]
*
* This method updates the password for your CDN FTP account on the ftp.cdnlayer.service.softlayer.com server. You must provide an alphanumeric value for a new password. - _ ! % # $ ^ & * characters are allowed beside an alphanumeric string.
*
* @see SoftLayer_Network_ContentDelivery_Account::setFtpPassword
*/
@ApiMethod(instanceRequired = true)
public Boolean setFtpPassword(String newPassword);
/**
* This method allows you to edit CDN account note. The maximum length for CDN account note is 30 characters.
*
* @see SoftLayer_Network_ContentDelivery_Account::updateNote
*/
@ApiMethod(instanceRequired = true)
public Boolean updateNote(String note);
/**
* With this method, you can upload binary data to the CDN FTP server. This method supports files up to 20 Mega Bytes. You need to use the CDN FTP (ftp.cdnlayer.service.softlayer.com) to upload files larger than 20 MB. This method takes [[SoftLayer_Container_Utility_File_Attachment]] a first parameter. A target name must be an absolute path and you can only upload a file to a directory that is in /media folder.
*
* @see SoftLayer_Network_ContentDelivery_Account::uploadStream
*/
@ApiMethod(instanceRequired = true)
public Boolean uploadStream(Attachment source, String target);
/**
* The customer account that a CDN account belongs to.
*
* @see SoftLayer_Network_ContentDelivery_Account::getAccount
*/
@ApiMethod(instanceRequired = true)
public com.softlayer.api.service.Account getAccount();
/**
* The CDN account id that this CDN account is associated with.
*
* @see SoftLayer_Network_ContentDelivery_Account::getAssociatedCdnAccountId
*/
@ApiMethod(instanceRequired = true)
public String getAssociatedCdnAccountId();
/**
* The IP addresses that are used for the content authentication service.
*
* @see SoftLayer_Network_ContentDelivery_Account::getAuthenticationIpAddresses
*/
@ApiMethod(instanceRequired = true)
public List getAuthenticationIpAddresses();
/**
* The current billing item for a CDN account.
*
* @see SoftLayer_Network_ContentDelivery_Account::getBillingItem
*/
@ApiMethod(instanceRequired = true)
public Item getBillingItem();
/**
* The name of a CDN account.
*
* @see SoftLayer_Network_ContentDelivery_Account::getCdnAccountName
*/
@ApiMethod(instanceRequired = true)
public String getCdnAccountName();
/**
* A brief note on a CDN account.
*
* @see SoftLayer_Network_ContentDelivery_Account::getCdnAccountNote
*/
@ApiMethod(instanceRequired = true)
public String getCdnAccountNote();
/**
* The solution type of a CDN account.
*
* @see SoftLayer_Network_ContentDelivery_Account::getCdnSolutionName
*/
@ApiMethod(instanceRequired = true)
public String getCdnSolutionName();
/**
* Indicates if CDN account is dependent on other service. If set, this CDN account is limited to these services: createOriginPullMapping, deleteOriginPullRule, getOriginPullMappingInformation, getCdnUrls, purgeCache, loadContent, manageHttpCompression
*
* @see SoftLayer_Network_ContentDelivery_Account::getDependantServiceFlag
*/
@ApiMethod(instanceRequired = true)
public Boolean getDependantServiceFlag();
/**
* Indicates if it is a legacy CDN or not
*
* @see SoftLayer_Network_ContentDelivery_Account::getLegacyCdnFlag
*/
@ApiMethod(instanceRequired = true)
public Boolean getLegacyCdnFlag();
/**
* Indicates if CDN logging is enabled.
*
* @see SoftLayer_Network_ContentDelivery_Account::getLogEnabledFlag
*/
@ApiMethod(instanceRequired = true)
public String getLogEnabledFlag();
/**
* Indicates if customer is allowed to access the CDN provider's management portal.
*
* @see SoftLayer_Network_ContentDelivery_Account::getProviderPortalAccessFlag
*/
@ApiMethod(instanceRequired = true)
public Boolean getProviderPortalAccessFlag();
/**
* A CDN account's status presented in a more detailed data type.
*
* @see SoftLayer_Network_ContentDelivery_Account::getStatus
*/
@ApiMethod(instanceRequired = true)
public Status getStatus();
/**
* Indicates if the token authentication service is enabled or not.
*
* @see SoftLayer_Network_ContentDelivery_Account::getTokenAuthenticationEnabledFlag
*/
@ApiMethod(instanceRequired = true)
public Boolean getTokenAuthenticationEnabledFlag();
}
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#authenticateResourceRequest}
*/
public Future authenticateResourceRequest(Parameter parameter);
public Future authenticateResourceRequest(Parameter parameter, ResponseHandler callback);
/**
* Async version of {@link Service#createDirectory}
*/
public Future createDirectory(String directoryName);
public Future createDirectory(String directoryName, ResponseHandler callback);
/**
* Async version of {@link Service#createFtpUser}
*/
public Future createFtpUser(String newPassword);
public Future createFtpUser(String newPassword, ResponseHandler callback);
/**
* Async version of {@link Service#createOriginPullMapping}
*/
public Future createOriginPullMapping(Mapping mappingObject);
public Future createOriginPullMapping(Mapping mappingObject, ResponseHandler callback);
/**
* Async version of {@link Service#createOriginPullRule}
*/
public Future createOriginPullRule(String originDomain, String cnameRecord);
public Future createOriginPullRule(String originDomain, String cnameRecord, ResponseHandler callback);
/**
* Async version of {@link Service#createTokenAuthenticationDirectory}
*/
public Future createTokenAuthenticationDirectory(String directory, String mediaType);
public Future createTokenAuthenticationDirectory(String directory, String mediaType, ResponseHandler callback);
/**
* Async version of {@link Service#deleteFtpUser}
*/
public Future deleteFtpUser();
public Future deleteFtpUser(ResponseHandler callback);
/**
* Async version of {@link Service#deleteOriginPullRule}
*/
public Future deleteOriginPullRule(String originMappingId);
public Future deleteOriginPullRule(String originMappingId, ResponseHandler callback);
/**
* Async version of {@link Service#disableLogging}
*/
public Future disableLogging();
public Future disableLogging(ResponseHandler callback);
/**
* Async version of {@link Service#enableLogging}
*/
public Future enableLogging();
public Future enableLogging(ResponseHandler callback);
/**
* Async version of {@link Service#getAllPopsBandwidthData}
*/
public Future> getAllPopsBandwidthData(GregorianCalendar beginDateTime, GregorianCalendar endDateTime);
public Future getAllPopsBandwidthData(GregorianCalendar beginDateTime, GregorianCalendar endDateTime, ResponseHandler> callback);
/**
* Async version of {@link Service#getAllPopsBandwidthImage}
*/
public Future getAllPopsBandwidthImage(String title, GregorianCalendar beginDateTime, GregorianCalendar endDateTime, String unit);
public Future getAllPopsBandwidthImage(String title, GregorianCalendar beginDateTime, GregorianCalendar endDateTime, String unit, ResponseHandler callback);
/**
* Async version of {@link Service#getAuthenticationServiceEndpoints}
*/
public Future> getAuthenticationServiceEndpoints();
public Future getAuthenticationServiceEndpoints(ResponseHandler> callback);
/**
* Async version of {@link Service#getBandwidthData}
*/
public Future> getBandwidthData(GregorianCalendar beginDateTime, GregorianCalendar endDateTime);
public Future getBandwidthData(GregorianCalendar beginDateTime, GregorianCalendar endDateTime, ResponseHandler> callback);
/**
* Async version of {@link Service#getBandwidthDataWithTypes}
*/
public Future> getBandwidthDataWithTypes(GregorianCalendar beginDateTime, GregorianCalendar endDateTime, String period);
public Future getBandwidthDataWithTypes(GregorianCalendar beginDateTime, GregorianCalendar endDateTime, String period, ResponseHandler> callback);
/**
* Async version of {@link Service#getBandwidthImage}
*/
public Future getBandwidthImage(String title, GregorianCalendar beginDateTime, GregorianCalendar endDateTime);
public Future getBandwidthImage(String title, GregorianCalendar beginDateTime, GregorianCalendar endDateTime, ResponseHandler callback);
/**
* Async version of {@link Service#getCustomerOrigins}
*/
public Future> getCustomerOrigins(String mediaType);
public Future getCustomerOrigins(String mediaType, ResponseHandler> callback);
/**
* Async version of {@link Service#getDirectoryInformation}
*/
public Future> getDirectoryInformation(String directoryName);
public Future getDirectoryInformation(String directoryName, ResponseHandler> callback);
/**
* Async version of {@link Service#getDiskSpaceUsageDataByDate}
*/
public Future> getDiskSpaceUsageDataByDate(GregorianCalendar beginDateTime, GregorianCalendar endDateTime);
public Future getDiskSpaceUsageDataByDate(GregorianCalendar beginDateTime, GregorianCalendar endDateTime, ResponseHandler> callback);
/**
* Async version of {@link Service#getDiskSpaceUsageImageByDate}
*/
public Future getDiskSpaceUsageImageByDate(GregorianCalendar beginDateTime, GregorianCalendar endDateTime);
public Future getDiskSpaceUsageImageByDate(GregorianCalendar beginDateTime, GregorianCalendar endDateTime, ResponseHandler callback);
/**
* Async version of {@link Service#getFtpAttributes}
*/
public Future getFtpAttributes();
public Future getFtpAttributes(ResponseHandler callback);
/**
* Async version of {@link Service#getMediaUrls}
*/
public Future> getMediaUrls();
public Future getMediaUrls(ResponseHandler> callback);
/**
* Async version of {@link Service#getObject}
*/
public Future getObject();
public Future getObject(ResponseHandler callback);
/**
* Async version of {@link Service#getOriginPullMappingInformation}
*/
public Future> getOriginPullMappingInformation();
public Future getOriginPullMappingInformation(ResponseHandler> callback);
/**
* Async version of {@link Service#getOriginPullSupportedMediaUrls}
*/
public Future> getOriginPullSupportedMediaUrls();
public Future getOriginPullSupportedMediaUrls(ResponseHandler> callback);
/**
* Async version of {@link Service#getOriginPullUrl}
*/
public Future getOriginPullUrl();
public Future getOriginPullUrl(ResponseHandler callback);
/**
* Async version of {@link Service#getPopNames}
*/
public Future> getPopNames();
public Future getPopNames(ResponseHandler> callback);
/**
* Async version of {@link Service#getProviderPortalCredentials}
*/
public Future getProviderPortalCredentials();
public Future getProviderPortalCredentials(ResponseHandler callback);
/**
* Async version of {@link Service#getTokenAuthenticationDirectories}
*/
public Future> getTokenAuthenticationDirectories();
public Future getTokenAuthenticationDirectories(ResponseHandler> callback);
/**
* Async version of {@link Service#getVendorFtpAttributes}
*/
public Future getVendorFtpAttributes();
public Future getVendorFtpAttributes(ResponseHandler callback);
/**
* Async version of {@link Service#loadContent}
*/
public Future loadContent(List objectUrls);
public Future loadContent(List objectUrls, ResponseHandler callback);
/**
* Async version of {@link Service#manageHttpCompression}
*/
public Future manageHttpCompression(Boolean enableFlag, List mimeTypes);
public Future manageHttpCompression(Boolean enableFlag, List mimeTypes, ResponseHandler callback);
/**
* Async version of {@link Service#purgeCache}
*/
public Future> purgeCache(List objectUrls);
public Future purgeCache(List objectUrls, ResponseHandler> callback);
/**
* Async version of {@link Service#removeAuthenticationDirectory}
*/
public Future removeAuthenticationDirectory(String directory, String mediaType);
public Future removeAuthenticationDirectory(String directory, String mediaType, ResponseHandler callback);
/**
* Async version of {@link Service#removeFile}
*/
public Future removeFile(String source);
public Future removeFile(String source, ResponseHandler callback);
/**
* Async version of {@link Service#setAuthenticationServiceEndpoint}
*/
public Future setAuthenticationServiceEndpoint(String webserviceEndpoint, String protocol);
public Future setAuthenticationServiceEndpoint(String webserviceEndpoint, String protocol, ResponseHandler callback);
/**
* Async version of {@link Service#setFtpPassword}
*/
public Future setFtpPassword(String newPassword);
public Future setFtpPassword(String newPassword, ResponseHandler callback);
/**
* Async version of {@link Service#updateNote}
*/
public Future updateNote(String note);
public Future updateNote(String note, ResponseHandler callback);
/**
* Async version of {@link Service#uploadStream}
*/
public Future uploadStream(Attachment source, String target);
public Future uploadStream(Attachment source, String target, ResponseHandler callback);
/**
* Async version of {@link Service#getAccount}
*/
public Future getAccount();
/**
* Async callback version of {@link Service#getAccount}
*/
public Future getAccount(ResponseHandler callback);
/**
* Async version of {@link Service#getAssociatedCdnAccountId}
*/
public Future getAssociatedCdnAccountId();
/**
* Async callback version of {@link Service#getAssociatedCdnAccountId}
*/
public Future getAssociatedCdnAccountId(ResponseHandler callback);
/**
* Async version of {@link Service#getAuthenticationIpAddresses}
*/
public Future> getAuthenticationIpAddresses();
/**
* Async callback version of {@link Service#getAuthenticationIpAddresses}
*/
public Future getAuthenticationIpAddresses(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#getCdnAccountName}
*/
public Future
getCdnAccountName();
/**
* Async callback version of {@link Service#getCdnAccountName}
*/
public Future getCdnAccountName(ResponseHandler callback);
/**
* Async version of {@link Service#getCdnAccountNote}
*/
public Future getCdnAccountNote();
/**
* Async callback version of {@link Service#getCdnAccountNote}
*/
public Future getCdnAccountNote(ResponseHandler callback);
/**
* Async version of {@link Service#getCdnSolutionName}
*/
public Future getCdnSolutionName();
/**
* Async callback version of {@link Service#getCdnSolutionName}
*/
public Future getCdnSolutionName(ResponseHandler callback);
/**
* Async version of {@link Service#getDependantServiceFlag}
*/
public Future getDependantServiceFlag();
/**
* Async callback version of {@link Service#getDependantServiceFlag}
*/
public Future getDependantServiceFlag(ResponseHandler callback);
/**
* Async version of {@link Service#getLegacyCdnFlag}
*/
public Future getLegacyCdnFlag();
/**
* Async callback version of {@link Service#getLegacyCdnFlag}
*/
public Future getLegacyCdnFlag(ResponseHandler callback);
/**
* Async version of {@link Service#getLogEnabledFlag}
*/
public Future getLogEnabledFlag();
/**
* Async callback version of {@link Service#getLogEnabledFlag}
*/
public Future getLogEnabledFlag(ResponseHandler callback);
/**
* Async version of {@link Service#getProviderPortalAccessFlag}
*/
public Future getProviderPortalAccessFlag();
/**
* Async callback version of {@link Service#getProviderPortalAccessFlag}
*/
public Future getProviderPortalAccessFlag(ResponseHandler callback);
/**
* Async version of {@link Service#getStatus}
*/
public Future getStatus();
/**
* Async callback version of {@link Service#getStatus}
*/
public Future getStatus(ResponseHandler callback);
/**
* Async version of {@link Service#getTokenAuthenticationEnabledFlag}
*/
public Future getTokenAuthenticationEnabledFlag();
/**
* Async callback version of {@link Service#getTokenAuthenticationEnabledFlag}
*/
public Future getTokenAuthenticationEnabledFlag(ResponseHandler callback);
}
public static class Mask extends com.softlayer.api.service.Entity.Mask {
public com.softlayer.api.service.Account.Mask account() {
return withSubMask("account", com.softlayer.api.service.Account.Mask.class);
}
public Mask associatedCdnAccountId() {
withLocalProperty("associatedCdnAccountId");
return this;
}
public com.softlayer.api.service.network.contentdelivery.authentication.Address.Mask authenticationIpAddresses() {
return withSubMask("authenticationIpAddresses", com.softlayer.api.service.network.contentdelivery.authentication.Address.Mask.class);
}
public com.softlayer.api.service.billing.Item.Mask billingItem() {
return withSubMask("billingItem", com.softlayer.api.service.billing.Item.Mask.class);
}
public Mask cdnAccountName() {
withLocalProperty("cdnAccountName");
return this;
}
public Mask cdnAccountNote() {
withLocalProperty("cdnAccountNote");
return this;
}
public Mask cdnSolutionName() {
withLocalProperty("cdnSolutionName");
return this;
}
public Mask dependantServiceFlag() {
withLocalProperty("dependantServiceFlag");
return this;
}
public Mask legacyCdnFlag() {
withLocalProperty("legacyCdnFlag");
return this;
}
public Mask logEnabledFlag() {
withLocalProperty("logEnabledFlag");
return this;
}
public Mask providerPortalAccessFlag() {
withLocalProperty("providerPortalAccessFlag");
return this;
}
public com.softlayer.api.service.network.contentdelivery.account.Status.Mask status() {
return withSubMask("status", com.softlayer.api.service.network.contentdelivery.account.Status.Mask.class);
}
public Mask tokenAuthenticationEnabledFlag() {
withLocalProperty("tokenAuthenticationEnabledFlag");
return this;
}
public Mask accountId() {
withLocalProperty("accountId");
return this;
}
public Mask createDate() {
withLocalProperty("createDate");
return this;
}
public Mask id() {
withLocalProperty("id");
return this;
}
public Mask statusId() {
withLocalProperty("statusId");
return this;
}
public Mask authenticationIpAddressCount() {
withLocalProperty("authenticationIpAddressCount");
return this;
}
}
}