// WriteTask writes a task to a ResponseWriter. func WriteTask( ctx types.Context, config gofig.Config, w http.ResponseWriter, store types.Store, task *types.Task, okStatus int) error { if store.GetBool("async") { WriteJSON(w, http.StatusAccepted, task) return nil } exeTimeoutDur, err := time.ParseDuration( config.GetString(types.ConfigServerTasksExeTimeout)) if err != nil { exeTimeoutDur = time.Duration(time.Second * 60) } exeTimeout := time.NewTimer(exeTimeoutDur) select { case <-services.TaskWaitC(ctx, task.ID): if task.Error != nil { return task.Error } WriteJSON(w, okStatus, task.Result) case <-exeTimeout.C: WriteJSON(w, http.StatusRequestTimeout, task) } return nil }
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 toServiceInfo( ctx types.Context, service types.StorageService, store types.Store) (*types.ServiceInfo, error) { d := service.Driver() var instance *types.Instance if store.GetBool("instance") { if _, ok := context.InstanceID(ctx); !ok { return nil, utils.NewMissingInstanceIDError(service.Name()) } var err error instance, err = d.InstanceInspect(ctx, store) if err != nil { return nil, err } } st, err := d.Type(ctx) if err != nil { return nil, err } nd, err := d.NextDeviceInfo(ctx) if err != nil { return nil, err } return &types.ServiceInfo{ Name: service.Name(), Instance: instance, Driver: &types.DriverInfo{ Name: d.Name(), Type: st, NextDevice: nd, }, }, nil }
// Unmount will unmount the specified volume by volumeName or volumeID. func (d *driver) Unmount( ctx types.Context, volumeID, volumeName string, opts types.Store) (*types.Volume, error) { ctx.WithFields(log.Fields{ "volumeName": volumeName, "volumeID": volumeID, "opts": opts}).Info("unmounting volume") if volumeName == "" && volumeID == "" { return nil, goof.New("missing volume name or ID") } vol, err := d.volumeInspectByIDOrName( ctx, volumeID, volumeName, types.VolAttReqWithDevMapOnlyVolsAttachedToInstance, opts) if err != nil { return nil, err } if len(vol.Attachments) == 0 { return nil, nil } client := context.MustClient(ctx) inst, err := client.Storage().InstanceInspect(ctx, utils.NewStore()) if err != nil { return nil, goof.New("problem getting instance ID") } var ma *types.VolumeAttachment for _, att := range vol.Attachments { if att.InstanceID.ID == inst.InstanceID.ID { ma = att break } } if ma == nil { return nil, goof.New("no attachment found for instance") } if ma.DeviceName == "" { return nil, goof.New("no device name found for attachment") } mounts, err := client.OS().Mounts( ctx, ma.DeviceName, "", opts) if err != nil { return nil, err } for _, mount := range mounts { ctx.WithField("mount", mount).Debug("retrieved mount") } if len(mounts) > 0 { for _, mount := range mounts { ctx.WithField("mount", mount).Debug("unmounting mount point") err = client.OS().Unmount(ctx, mount.MountPoint, opts) if err != nil { return nil, err } } } vol, err = client.Storage().VolumeDetach(ctx, vol.ID, &types.VolumeDetachOpts{ Force: opts.GetBool("force"), Opts: utils.NewStore(), }) if err != nil { return nil, err } ctx.WithFields(log.Fields{ "vol": vol}).Info("unmounted and detached volume") return vol, nil }
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) volumeDetachAll( ctx types.Context, w http.ResponseWriter, req *http.Request, store types.Store) error { var ( taskIDs []int tasks = map[string]*types.Task{} opts = &types.VolumesOpts{Opts: store} reply types.ServiceVolumeMap = map[string]types.VolumeMap{} replyRWL = &sync.Mutex{} ) for service := range services.StorageServices(ctx) { run := func( ctx types.Context, svc types.StorageService) (interface{}, error) { ctx = context.WithStorageService(ctx, svc) if _, ok := context.InstanceID(ctx); !ok { return nil, utils.NewMissingInstanceIDError(service.Name()) } var err error if ctx, err = context.WithStorageSession(ctx); err != nil { return nil, err } driver := svc.Driver() volumes, err := driver.Volumes(ctx, opts) if err != nil { return nil, err } // check here var volumeMap types.VolumeMap = map[string]*types.Volume{} defer func() { if len(volumeMap) > 0 { replyRWL.Lock() defer replyRWL.Unlock() reply[service.Name()] = volumeMap } }() for _, volume := range volumes { v, err := driver.VolumeDetach( ctx, volume.ID, &types.VolumeDetachOpts{ Force: store.GetBool("force"), Opts: store, }) if err != nil { return nil, 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 } volumeMap[v.ID] = v } return nil, nil } task := service.TaskExecute(ctx, run, nil) taskIDs = append(taskIDs, task.ID) tasks[service.Name()] = task } run := func(ctx types.Context) (interface{}, error) { services.TaskWaitAll(ctx, taskIDs...) for _, v := range tasks { if v.Error != nil { return nil, utils.NewBatchProcessErr(reply, v.Error) } } return reply, nil } return httputils.WriteTask( ctx, r.config, w, store, services.TaskExecute(ctx, run, schema.ServiceVolumeMapSchema), http.StatusResetContent) }