func CreateStorageService(name, location string) (*StorageService, error) {
if len(name) == 0 {
return nil, fmt.Errorf(azure.ParamNotSpecifiedError, "name")
}
if len(location) == 0 {
return nil, fmt.Errorf(azure.ParamNotSpecifiedError, "location")
}
storageDeploymentConfig := createStorageServiceDeploymentConf(name, location)
deploymentBytes, err := xml.Marshal(storageDeploymentConfig)
if err != nil {
return nil, err
}
requestId, err := azure.SendAzurePostRequest(azureStorageServiceListURL, deploymentBytes)
if err != nil {
return nil, err
}
azure.WaitAsyncOperation(requestId)
storageService, err := GetStorageServiceByName(storageDeploymentConfig.ServiceName)
if err != nil {
return nil, err
}
return storageService, nil
}
func RestartRole(cloudserviceName, deploymentName, roleName string) error {
if len(cloudserviceName) == 0 {
return fmt.Errorf(azure.ParamNotSpecifiedError, "cloudserviceName")
}
if len(deploymentName) == 0 {
return fmt.Errorf(azure.ParamNotSpecifiedError, "deploymentName")
}
if len(roleName) == 0 {
return fmt.Errorf(azure.ParamNotSpecifiedError, "roleName")
}
restartRoleOperation := createRestartRoleOperation()
restartRoleOperationBytes, err := xml.Marshal(restartRoleOperation)
if err != nil {
return err
}
requestURL := fmt.Sprintf(azureOperationsURL, cloudserviceName, deploymentName, roleName)
requestId, azureErr := azure.SendAzurePostRequest(requestURL, restartRoleOperationBytes)
if azureErr != nil {
return azureErr
}
azure.WaitAsyncOperation(requestId)
return nil
}
func CreateAzureVM(azureVMConfiguration *Role, dnsName, location string) error {
if azureVMConfiguration == nil {
return fmt.Errorf(azure.ParamNotSpecifiedError, "azureVMConfiguration")
}
if len(dnsName) == 0 {
return fmt.Errorf(azure.ParamNotSpecifiedError, "dnsName")
}
if len(location) == 0 {
return fmt.Errorf(azure.ParamNotSpecifiedError, "location")
}
err := verifyDNSname(dnsName)
if err != nil {
return err
}
requestId, err := CreateHostedService(dnsName, location)
if err != nil {
return err
}
azure.WaitAsyncOperation(requestId)
if azureVMConfiguration.UseCertAuth {
err = uploadServiceCert(dnsName, azureVMConfiguration.CertPath)
if err != nil {
DeleteHostedService(dnsName)
return err
}
}
vMDeployment := createVMDeploymentConfig(azureVMConfiguration)
vMDeploymentBytes, err := xml.Marshal(vMDeployment)
if err != nil {
DeleteHostedService(dnsName)
return err
}
requestURL := fmt.Sprintf(azureDeploymentListURL, azureVMConfiguration.RoleName)
requestId, err = azure.SendAzurePostRequest(requestURL, vMDeploymentBytes)
if err != nil {
DeleteHostedService(dnsName)
return err
}
azure.WaitAsyncOperation(requestId)
return nil
}
func uploadServiceCert(dnsName, certPath string) error {
certificateConfig, err := createServiceCertDeploymentConf(certPath)
if err != nil {
return err
}
certificateConfigBytes, err := xml.Marshal(certificateConfig)
if err != nil {
return err
}
requestURL := fmt.Sprintf(azureCertificatListURL, dnsName)
requestId, azureErr := azure.SendAzurePostRequest(requestURL, certificateConfigBytes)
if azureErr != nil {
return azureErr
}
err = azure.WaitAsyncOperation(requestId)
return err
}
func CreateHostedService(dnsName, location string) (string, error) {
if len(dnsName) == 0 {
return "", fmt.Errorf(azure.ParamNotSpecifiedError, "dnsName")
}
if len(location) == 0 {
return "", fmt.Errorf(azure.ParamNotSpecifiedError, "location")
}
err := verifyDNSname(dnsName)
if err != nil {
return "", err
}
result, reason, err := CheckHostedServiceNameAvailability(dnsName)
if err != nil {
return "", err
}
if !result {
return "", fmt.Errorf("%s Hosted service name: %s", reason, dnsName)
}
err = locationClient.ResolveLocation(location)
if err != nil {
return "", err
}
hostedServiceDeployment := createHostedServiceDeploymentConfig(dnsName, location)
hostedServiceBytes, err := xml.Marshal(hostedServiceDeployment)
if err != nil {
return "", err
}
requestURL := azureHostedServiceListURL
requestId, err := azure.SendAzurePostRequest(requestURL, hostedServiceBytes)
if err != nil {
return "", err
}
return requestId, nil
}