func (command *commandSetMetadata) Execute(resource *handler.Resource) {
params := resource.Params.(*paramsSetMetadata)
containerName := params.containerName
currentMetadata, err := containers.Get(command.Ctx.ServiceClient, containerName).ExtractMetadata()
if err != nil {
resource.Err = err
return
}
i := 0
keys := make([]string, len(currentMetadata))
for k := range currentMetadata {
keys[i] = k
i++
}
updateOpts := containers.UpdateOpts{
Metadata: params.metadata,
DeleteMetadata: keys,
}
updateResponse := containers.Update(command.Ctx.ServiceClient, containerName, updateOpts)
if updateResponse.Err != nil {
resource.Err = updateResponse.Err
return
}
metadata, err := containers.Get(command.Ctx.ServiceClient, containerName).ExtractMetadata()
if err != nil {
resource.Err = err
return
}
resource.Result = metadata
}
func (command *commandUpload) Execute(resource *handler.Resource) {
params := resource.Params.(*paramsUpload)
containerName := params.container
objectName := params.object
opts := params.opts
var readSeeker io.ReadSeeker
var err error
if stream := params.stream; stream {
readSeeker = os.Stdin
} else if fileName := params.fileName; fileName != "" {
// this file will be closed by Gophercloud, if not closed before then
readSeeker, err = os.Open(fileName)
if err != nil {
resource.Err = err
return
}
} else {
content := params.content
readSeeker = strings.NewReader(content)
}
rawResponse := objects.Create(command.Ctx.ServiceClient, containerName, objectName, readSeeker, opts)
if rawResponse.Err != nil {
resource.Err = rawResponse.Err
return
}
resource.Result = fmt.Sprintf("Successfully uploaded object [%s] to container [%s]\n", objectName, containerName)
}
func (command *commandList) Execute(resource *handler.Resource) {
opts := resource.Params.(*paramsList).opts
pager := osVolumes.List(command.Ctx.ServiceClient, opts)
var volumes []map[string]interface{}
err := pager.EachPage(func(page pagination.Page) (bool, error) {
info, err := osVolumes.ExtractVolumes(page)
if err != nil {
return false, err
}
result := make([]map[string]interface{}, len(info))
for j, volume := range info {
result[j] = volumeSingle(&volume)
}
volumes = append(volumes, result...)
return true, nil
})
if err != nil {
resource.Err = err
return
}
if len(volumes) == 0 {
resource.Result = nil
} else {
resource.Result = volumes
}
}
func (command *commandListAddresses) Execute(resource *handler.Resource) {
serverID := resource.Params.(*paramsListAddresses).serverID
pager := servers.ListAddresses(command.Ctx.ServiceClient, serverID)
var result []map[string]interface{}
err := pager.EachPage(func(page pagination.Page) (bool, error) {
addressesMap, err := servers.ExtractAddresses(page)
if err != nil {
return false, err
}
for t, addresses := range addressesMap {
for _, address := range addresses {
m := map[string]interface{}{
"Type": t,
"Version": address.Version,
"Address": address.Address,
}
result = append(result, m)
}
}
return true, nil
})
if err != nil {
resource.Err = err
return
}
resource.Result = result
}
func (command *commandUpdateMetadata) Execute(resource *handler.Resource) {
params := resource.Params.(*paramsUpdateMetadata)
containerName := params.containerName
getResponse := containers.Get(command.Ctx.ServiceClient, containerName)
if getResponse.Err != nil {
resource.Err = getResponse.Err
return
}
updateOpts := containers.UpdateOpts{
Metadata: params.metadata,
}
updateResponse := containers.Update(command.Ctx.ServiceClient, containerName, updateOpts)
if updateResponse.Err != nil {
resource.Err = updateResponse.Err
return
}
metadata, err := containers.Get(command.Ctx.ServiceClient, containerName).ExtractMetadata()
if err != nil {
resource.Err = err
return
}
updatedMetadata := make(map[string]string, len(params.metadata))
for k := range params.metadata {
k = strings.Title(k)
updatedMetadata[k] = metadata[k]
}
resource.Result = updatedMetadata
}
func (command *commandGetMetadata) PreCSV(resource *handler.Resource) {
resource.Result = map[string]interface{}{
"Metadata": resource.Result,
}
resource.Keys = []string{"Metadata"}
resource.FlattenMap("Metadata")
}
func (command *commandDeleteMetadata) Execute(resource *handler.Resource) {
params := resource.Params.(*paramsDeleteMetadata)
containerName := params.containerName
objectName := params.objectName
currentMetadata, err := objects.Get(command.Ctx.ServiceClient, containerName, objectName, nil).ExtractMetadata()
if err != nil {
resource.Err = err
return
}
for _, k := range params.metadataKeys {
currentMetadata[k] = ""
}
updateOpts := osObjects.UpdateOpts{
Metadata: currentMetadata,
}
updateResponse := objects.Update(command.Ctx.ServiceClient, containerName, objectName, updateOpts)
if updateResponse.Err != nil {
resource.Err = updateResponse.Err
return
}
resource.Result = fmt.Sprintf("Successfully deleted metadata with keys [%s] from object [%s].\n", strings.Join(params.metadataKeys, ", "), objectName)
}
func (command *commandDownload) JSON(resource *handler.Resource) {
bytes, err := ioutil.ReadAll(resource.Result.(io.Reader))
if err != nil {
resource.Err = err
return
}
resource.Result = string(bytes)
}
func (command *commandDelete) Execute(resource *handler.Resource) {
portID := resource.Params.(*paramsDelete).portID
err := ports.Delete(command.Ctx.ServiceClient, portID).ExtractErr()
if err != nil {
resource.Err = err
return
}
resource.Result = fmt.Sprintf("Successfully deleted port [%s]\n", portID)
}
func (command *commandGet) Execute(resource *handler.Resource) {
imageID := resource.Params.(*paramsGet).image
image, err := images.Get(command.Ctx.ServiceClient, imageID).Extract()
if err != nil {
resource.Err = err
return
}
resource.Result = structs.Map(image)
}
func (command *commandUpdateMetadata) Execute(resource *handler.Resource) {
params := resource.Params.(*paramsUpdateMetadata)
metadata, err := osServers.UpdateMetadata(command.Ctx.ServiceClient, params.serverID, params.opts).Extract()
if err != nil {
resource.Err = err
return
}
resource.Result = metadata
}
func (command *commandGet) Execute(resource *handler.Resource) {
securityGroupID := resource.Params.(*paramsGet).securityGroupID
securityGroup, err := securityGroups.Get(command.Ctx.ServiceClient, securityGroupID).Extract()
if err != nil {
resource.Err = err
return
}
resource.Result = securityGroupSingle(securityGroup)
}
func (command *commandResize) Execute(resource *handler.Resource) {
params := resource.Params.(*paramsResize)
err := servers.Resize(command.Ctx.ServiceClient, params.serverID, params.opts).ExtractErr()
if err != nil {
resource.Err = err
return
}
resource.Result = fmt.Sprintf("Successfully resized instance [%s] to flavor [%s]\n", params.serverID, params.opts.FlavorRef)
}
func (command *commandGet) Execute(resource *handler.Resource) {
volumeID := resource.Params.(*paramsGet).volumeID
volume, err := osVolumes.Get(command.Ctx.ServiceClient, volumeID).Extract()
if err != nil {
resource.Err = err
return
}
resource.Result = volumeSingle(volume)
}
func (command *commandGet) Execute(resource *handler.Resource) {
serverID := resource.Params.(*paramsGet).server
server, err := servers.Get(command.Context().ServiceClient, serverID).Extract()
if err != nil {
resource.Err = err
return
}
resource.Result = serverSingle(server)
}
func (command *commandGetMetadata) Execute(resource *handler.Resource) {
serverID := resource.Params.(*paramsGetMetadata).serverID
metadata, err := servers.Metadata(command.Ctx.ServiceClient, serverID).Extract()
if err != nil {
resource.Err = err
return
}
resource.Result = metadata
}
func (command *commandGet) Execute(resource *handler.Resource) {
flavorID := resource.Params.(*paramsGet).flavor
flavor, err := flavors.Get(command.Ctx.ServiceClient, flavorID).Extract()
if err != nil {
resource.Err = err
return
}
resource.Result = structs.Map(flavor)
}
func (command *commandCreate) Execute(resource *handler.Resource) {
opts := resource.Params.(*paramsCreate).opts
volume, err := osVolumes.Create(command.Ctx.ServiceClient, opts).Extract()
if err != nil {
resource.Err = err
return
}
resource.Result = volumeSingle(volume)
}
func (command *commandCreate) Execute(resource *handler.Resource) {
opts := resource.Params.(*paramsCreate).opts
securityGroup, err := securityGroups.Create(command.Ctx.ServiceClient, *opts).Extract()
if err != nil {
resource.Err = err
return
}
resource.Result = securityGroupSingle(securityGroup)
}
func (command *commandDelete) Execute(resource *handler.Resource) {
volumeID := resource.Params.(*paramsDelete).volumeID
err := osVolumes.Delete(command.Ctx.ServiceClient, volumeID).ExtractErr()
if err != nil {
resource.Err = err
return
}
resource.Result = fmt.Sprintf("Deleting volume [%s]\n", volumeID)
}
func (command *commandGet) Execute(resource *handler.Resource) {
portID := resource.Params.(*paramsGet).portID
port, err := ports.Get(command.Ctx.ServiceClient, portID).Extract()
if err != nil {
resource.Err = err
return
}
resource.Result = portSingle(port)
}
func (command *commandCreate) Execute(resource *handler.Resource) {
opts := resource.Params.(*paramsCreate).opts
network, err := networks.Create(command.Ctx.ServiceClient, opts).Extract()
if err != nil {
resource.Err = err
return
}
resource.Result = networkSingle(network)
}
func (command *commandDelete) Execute(resource *handler.Resource) {
snapshotID := resource.Params.(*paramsDelete).snapshotID
err := osSnapshots.Delete(command.Ctx.ServiceClient, snapshotID).ExtractErr()
if err != nil {
resource.Err = err
return
}
resource.Result = fmt.Sprintf("Deleting snapshot [%s]\n", snapshotID)
}
func (command *commandDelete) Execute(resource *handler.Resource) {
keypairName := resource.Params.(*paramsDelete).keypair
err := keypairs.Delete(command.Ctx.ServiceClient, keypairName).ExtractErr()
if err != nil {
resource.Err = err
return
}
resource.Result = fmt.Sprintf("Successfully deleted keypair [%s]\n", keypairName)
}
func (command *commandGenerate) Execute(resource *handler.Resource) {
opts := resource.Params.(*paramsGenerate).opts
keypair, err := keypairs.Create(command.Ctx.ServiceClient, opts).Extract()
if err != nil {
resource.Err = err
return
}
resource.Result = structs.Map(keypair)
}
func (command *commandReboot) Execute(resource *handler.Resource) {
params := resource.Params.(*paramsReboot)
err := servers.Reboot(command.Context().ServiceClient, params.serverID, params.how).ExtractErr()
if err != nil {
resource.Err = err
return
}
resource.Result = fmt.Sprintf("Successfully rebooted instance [%s]\n", params.serverID)
}
func (command *commandDelete) Execute(resource *handler.Resource) {
securityGroupID := resource.Params.(*paramsDelete).securityGroupID
err := securityGroups.Delete(command.Ctx.ServiceClient, securityGroupID).ExtractErr()
if err != nil {
resource.Err = err
return
}
resource.Result = fmt.Sprintf("Successfully deleted security group [%s]\n", securityGroupID)
}
func (command *commandCreate) Execute(resource *handler.Resource) {
opts := resource.Params.(*paramsCreate).opts
snapshot, err := osSnapshots.Create(command.Ctx.ServiceClient, opts).Extract()
if err != nil {
resource.Err = err
return
}
resource.Result = snapshotSingle(snapshot)
}
func (command *commandGet) Execute(resource *handler.Resource) {
snapshotID := resource.Params.(*paramsGet).snapshotID
snapshot, err := osSnapshots.Get(command.Ctx.ServiceClient, snapshotID).Extract()
if err != nil {
resource.Err = err
return
}
resource.Result = snapshotSingle(snapshot)
}
func (command *commandGet) Execute(resource *handler.Resource) {
networkID := resource.Params.(*paramsGet).networkID
network, err := networks.Get(command.Ctx.ServiceClient, networkID).Extract()
if err != nil {
resource.Err = err
return
}
resource.Result = networkSingle(network)
}