func (r *router) snapshotsForService(
ctx types.Context,
w http.ResponseWriter,
req *http.Request,
store types.Store) error {
service := context.MustService(ctx)
run := func(
ctx types.Context,
svc types.StorageService) (interface{}, error) {
var reply types.SnapshotMap = map[string]*types.Snapshot{}
objs, err := svc.Driver().Snapshots(ctx, store)
if err != nil {
return nil, err
}
for _, obj := range objs {
reply[obj.ID] = obj
}
return reply, nil
}
return httputils.WriteTask(
ctx,
r.config,
w,
store,
service.TaskExecute(ctx, run, schema.SnapshotMapSchema),
http.StatusOK)
}
func (r *router) snapshotRemove(
ctx types.Context,
w http.ResponseWriter,
req *http.Request,
store types.Store) error {
service := context.MustService(ctx)
run := func(
ctx types.Context,
svc types.StorageService) (interface{}, error) {
return nil, svc.Driver().SnapshotRemove(
ctx,
store.GetString("snapshotID"),
store)
}
return httputils.WriteTask(
ctx,
r.config,
w,
store,
service.TaskExecute(ctx, run, nil),
http.StatusResetContent)
}
func (r *router) snapshotCopy(
ctx types.Context,
w http.ResponseWriter,
req *http.Request,
store types.Store) error {
service := context.MustService(ctx)
run := func(
ctx types.Context,
svc types.StorageService) (interface{}, error) {
return svc.Driver().SnapshotCopy(
ctx,
store.GetString("snapshotID"),
store.GetString("snapshotName"),
store.GetString("destinationID"),
store)
}
return httputils.WriteTask(
ctx,
r.config,
w,
store,
service.TaskExecute(ctx, run, schema.SnapshotSchema),
http.StatusCreated)
}
func (r *router) volumeDetach(
ctx types.Context,
w http.ResponseWriter,
req *http.Request,
store types.Store) error {
service := context.MustService(ctx)
if _, ok := context.InstanceID(ctx); !ok {
return utils.NewMissingInstanceIDError(service.Name())
}
run := func(
ctx types.Context,
svc types.StorageService) (interface{}, error) {
v, err := svc.Driver().VolumeDetach(
ctx,
store.GetString("volumeID"),
&types.VolumeDetachOpts{
Force: store.GetBool("force"),
Opts: store,
})
if err != nil {
return nil, err
}
if v == nil {
return nil, nil
}
if OnVolume != nil {
ok, err := OnVolume(ctx, req, store, v)
if err != nil {
return nil, err
}
if !ok {
return nil, utils.NewNotFoundError(v.ID)
}
}
if v.AttachmentState == 0 {
v.AttachmentState = types.VolumeAvailable
}
return v, nil
}
return httputils.WriteTask(
ctx,
r.config,
w,
store,
service.TaskExecute(ctx, run, nil),
http.StatusResetContent)
}
func (r *router) volumeAttach(
ctx types.Context,
w http.ResponseWriter,
req *http.Request,
store types.Store) error {
service := context.MustService(ctx)
if _, ok := context.InstanceID(ctx); !ok {
return utils.NewMissingInstanceIDError(service.Name())
}
run := func(
ctx types.Context,
svc types.StorageService) (interface{}, error) {
v, attTokn, err := svc.Driver().VolumeAttach(
ctx,
store.GetString("volumeID"),
&types.VolumeAttachOpts{
NextDevice: store.GetStringPtr("nextDeviceName"),
Force: store.GetBool("force"),
Opts: store,
})
if err != nil {
return nil, err
}
if OnVolume != nil {
ok, err := OnVolume(ctx, req, store, v)
if err != nil {
return nil, err
}
if !ok {
return nil, utils.NewNotFoundError(v.ID)
}
}
if v.AttachmentState == 0 {
v.AttachmentState = types.VolumeAttached
}
return &types.VolumeAttachResponse{
Volume: v,
AttachToken: attTokn,
}, nil
}
return httputils.WriteTask(
ctx,
r.config,
w,
store,
service.TaskExecute(ctx, run, schema.VolumeAttachResponseSchema),
http.StatusOK)
}
func (r *router) volumeCreate(
ctx types.Context,
w http.ResponseWriter,
req *http.Request,
store types.Store) error {
service := context.MustService(ctx)
run := func(
ctx types.Context,
svc types.StorageService) (interface{}, error) {
v, err := svc.Driver().VolumeCreate(
ctx,
store.GetString("name"),
&types.VolumeCreateOpts{
AvailabilityZone: store.GetStringPtr("availabilityZone"),
IOPS: store.GetInt64Ptr("iops"),
Size: store.GetInt64Ptr("size"),
Type: store.GetStringPtr("type"),
Encrypted: store.GetBoolPtr("encrypted"),
EncryptionKey: store.GetStringPtr("encryptionKey"),
Opts: store,
})
if err != nil {
return nil, err
}
if OnVolume != nil {
ok, err := OnVolume(ctx, req, store, v)
if err != nil {
return nil, err
}
if !ok {
return nil, utils.NewNotFoundError(v.ID)
}
}
if v.AttachmentState == 0 {
v.AttachmentState = types.VolumeAvailable
}
return v, nil
}
return httputils.WriteTask(
ctx,
r.config,
w,
store,
service.TaskExecute(ctx, run, schema.VolumeSchema),
http.StatusCreated)
}
func (r *router) serviceInspect(
ctx types.Context,
w http.ResponseWriter,
req *http.Request,
store types.Store) error {
service := context.MustService(ctx)
si, err := toServiceInfo(ctx, service, store)
if err != nil {
return err
}
httputils.WriteJSON(w, http.StatusOK, si)
return nil
}
func (r *router) volumeCopy(
ctx types.Context,
w http.ResponseWriter,
req *http.Request,
store types.Store) error {
service := context.MustService(ctx)
run := func(
ctx types.Context,
svc types.StorageService) (interface{}, error) {
v, err := svc.Driver().VolumeCopy(
ctx,
store.GetString("volumeID"),
store.GetString("volumeName"),
store)
if err != nil {
return nil, err
}
if OnVolume != nil {
ok, err := OnVolume(ctx, req, store, v)
if err != nil {
return nil, err
}
if !ok {
return nil, utils.NewNotFoundError(v.ID)
}
}
if v.AttachmentState == 0 {
v.AttachmentState = types.VolumeAvailable
}
return v, nil
}
return httputils.WriteTask(
ctx,
r.config,
w,
store,
service.TaskExecute(ctx, run, schema.VolumeSchema),
http.StatusCreated)
}
func (r *router) volumesForService(
ctx types.Context,
w http.ResponseWriter,
req *http.Request,
store types.Store) error {
filter, err := parseFilter(store)
if err != nil {
return err
}
if filter != nil {
store.Set("filter", filter)
}
service := context.MustService(ctx)
opts := &types.VolumesOpts{
Attachments: store.GetAttachments(),
Opts: store,
}
run := func(
ctx types.Context,
svc types.StorageService) (interface{}, error) {
return getFilteredVolumes(ctx, req, store, svc, opts, filter)
}
return httputils.WriteTask(
ctx,
r.config,
w,
store,
service.TaskExecute(ctx, run, schema.VolumeMapSchema),
http.StatusOK)
}
func (r *router) volumeDetachAllForService(
ctx types.Context,
w http.ResponseWriter,
req *http.Request,
store types.Store) error {
service := context.MustService(ctx)
if _, ok := context.InstanceID(ctx); !ok {
return utils.NewMissingInstanceIDError(service.Name())
}
var reply types.VolumeMap = map[string]*types.Volume{}
run := func(
ctx types.Context,
svc types.StorageService) (interface{}, error) {
driver := svc.Driver()
volumes, err := driver.Volumes(ctx, &types.VolumesOpts{Opts: store})
if err != nil {
return nil, err
}
for _, volume := range volumes {
v, err := driver.VolumeDetach(
ctx,
volume.ID,
&types.VolumeDetachOpts{
Force: store.GetBool("force"),
Opts: store,
})
if err != nil {
return nil, utils.NewBatchProcessErr(reply, err)
}
if err != nil {
return nil, err
}
if v == nil {
continue
}
if OnVolume != nil {
ok, err := OnVolume(ctx, req, store, v)
if err != nil {
return nil, err
}
if !ok {
return nil, utils.NewNotFoundError(v.ID)
}
}
if v.AttachmentState == 0 {
v.AttachmentState = types.VolumeAvailable
}
reply[v.ID] = v
}
return reply, nil
}
return httputils.WriteTask(
ctx,
r.config,
w,
store,
service.TaskExecute(ctx, run, schema.VolumeMapSchema),
http.StatusResetContent)
}
func (r *router) volumeInspect(
ctx types.Context,
w http.ResponseWriter,
req *http.Request,
store types.Store) error {
attachments := store.GetAttachments()
service := context.MustService(ctx)
iid, iidOK := context.InstanceID(ctx)
if !iidOK && attachments.RequiresInstanceID() {
return utils.NewMissingInstanceIDError(service.Name())
}
opts := &types.VolumeInspectOpts{
Attachments: attachments,
Opts: store,
}
var run types.StorageTaskRunFunc
if store.IsSet("byName") {
run = func(
ctx types.Context,
svc types.StorageService) (interface{}, error) {
vols, err := svc.Driver().Volumes(
ctx,
&types.VolumesOpts{
Attachments: attachments,
Opts: store,
})
if err != nil {
return nil, err
}
volID := store.GetString("volumeID")
for _, v := range vols {
if strings.EqualFold(v.Name, volID) {
if !handleVolAttachments(ctx, nil, iid, v, attachments) {
return nil, utils.NewNotFoundError(volID)
}
if OnVolume != nil {
ok, err := OnVolume(ctx, req, store, v)
if err != nil {
return nil, err
}
if !ok {
return nil, utils.NewNotFoundError(volID)
}
}
return v, nil
}
}
return nil, utils.NewNotFoundError(volID)
}
} else {
run = func(
ctx types.Context,
svc types.StorageService) (interface{}, error) {
v, err := svc.Driver().VolumeInspect(
ctx, store.GetString("volumeID"), opts)
if err != nil {
return nil, err
}
if !handleVolAttachments(ctx, nil, iid, v, attachments) {
return nil, utils.NewNotFoundError(v.ID)
}
if OnVolume != nil {
ok, err := OnVolume(ctx, req, store, v)
if err != nil {
return nil, err
}
if !ok {
return nil, utils.NewNotFoundError(v.ID)
}
}
return v, nil
}
}
return httputils.WriteTask(
ctx,
r.config,
w,
store,
service.TaskExecute(ctx, run, schema.VolumeSchema),
http.StatusOK)
}