func resourceArmStorageContainerCreate(d *schema.ResourceData, meta interface{}) error {
armClient := meta.(*ArmClient)
resourceGroupName := d.Get("resource_group_name").(string)
storageAccountName := d.Get("storage_account_name").(string)
blobClient, accountExists, err := armClient.getBlobStorageClientForStorageAccount(resourceGroupName, storageAccountName)
if err != nil {
return err
}
if !accountExists {
return fmt.Errorf("Storage Account %q Not Found", storageAccountName)
}
name := d.Get("name").(string)
var accessType storage.ContainerAccessType
if d.Get("container_access_type").(string) == "private" {
accessType = storage.ContainerAccessType("")
} else {
accessType = storage.ContainerAccessType(d.Get("container_access_type").(string))
}
log.Printf("[INFO] Creating container %q in storage account %q.", name, storageAccountName)
_, err = blobClient.CreateContainerIfNotExists(name, accessType)
if err != nil {
return fmt.Errorf("Error creating container %q in storage account %q: %s", name, storageAccountName, err)
}
d.SetId(name)
return resourceArmStorageContainerRead(d, meta)
}
// resourceAzureStorageContainerCreate does all the necessary API calls to
// create the storage container on Azure.
func resourceAzureStorageContainerCreate(d *schema.ResourceData, meta interface{}) error {
azureClient := meta.(*Client)
storName := d.Get("storage_service_name").(string)
blobClient, err := azureClient.getStorageServiceBlobClient(storName)
if err != nil {
return err
}
log.Println("[INFO] Creating storage container on Azure.")
name := d.Get("name").(string)
accessType := storage.ContainerAccessType(d.Get("container_access_type").(string))
err = blobClient.CreateContainer(name, accessType)
if err != nil {
return fmt.Errorf("Failed to create storage container on Azure: %s", err)
}
d.SetId(name)
return resourceAzureStorageContainerRead(d, meta)
}
func (c *Controller) CreateServiceInstance(w http.ResponseWriter, r *http.Request) {
fmt.Println("Create Service Instance...")
statusCode, err := authentication(r)
if err != nil {
w.WriteHeader(statusCode)
return
}
var instance model.ServiceInstance
instance.DashboardUrl = "http://dashbaord_url"
err = utils.ProvisionDataFromRequest(r, &instance)
if err != nil {
fmt.Println("Failed to provision data from request")
w.WriteHeader(http.StatusInternalServerError)
return
}
acceptsIncomplete := r.URL.Query().Get("accepts_incomplete")
if acceptsIncomplete != "true" {
fmt.Println("Only asynchronous provisioning is supported")
response := make(map[string]string)
response["error"] = "AsyncRequired"
response["description"] = "This service plan requires client support for asynchronous service operations."
utils.WriteResponse(w, 422, response)
return
}
serviceInstanceGuid := utils.ExtractVarsFromRequest(r, "service_instance_guid")
instance.Id = serviceInstanceGuid
var containerAccessType storageclient.ContainerAccessType
switch instance.Parameters.(type) {
case map[string]interface{}:
param := instance.Parameters.(map[string]interface{})
if param["container_access_type"] != nil {
containerAccessType = storageclient.ContainerAccessType(param["container_access_type"].(string))
} else {
containerAccessType = storageclient.ContainerAccessTypePrivate
}
default:
containerAccessType = storageclient.ContainerAccessTypePrivate
}
resourceGroupName, storageAccountName, err := c.serviceClient.CreateInstance(serviceInstanceGuid, instance.Parameters)
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
return
}
instance.ResourceGroupName = resourceGroupName
instance.StorageAccountName = storageAccountName
instance.ContainerAccessType = containerAccessType
instance.State = "in progress"
instance.Description = "creating service instance..."
c.instanceMap[instance.Id] = &instance
err = utils.MarshalAndRecord(c.instanceMap, conf.DataPath, conf.ServiceInstancesFileName)
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
return
}
response := model.CreateServiceInstanceResponse{
DashboardUrl: instance.DashboardUrl,
}
utils.WriteResponse(w, http.StatusAccepted, response)
}