func (d *Driver) ListVolume(id, snapshotID string) ([]byte, error) { volumes := api.DeviceMapperVolumes{ Volumes: make(map[string]api.DeviceMapperVolume), } if id != "" { volume := d.loadVolume(id) if volume == nil { return nil, generateError(logrus.Fields{ LOG_FIELD_VOLUME: id, }, "volume doesn't exists") } if snapshotID != "" { volumes.Volumes[id] = *getVolumeSnapshotInfo(id, volume, snapshotID) } else { volumes.Volumes[id] = *getVolumeInfo(id, volume) } } else { volumeIDs := d.listVolumeIDs() for _, uuid := range volumeIDs { volume := d.loadVolume(uuid) if volume == nil { return nil, generateError(logrus.Fields{ LOG_FIELD_VOLUME: uuid, }, "Volume list changed for volume") } volumes.Volumes[uuid] = *getVolumeInfo(uuid, volume) } } return api.ResponseOutput(volumes) }
func listVolume(volumeID, snapshotID string, driver ObjectStoreDriver) ([]byte, error) { log.WithFields(logrus.Fields{ LOG_FIELD_VOLUME: volumeID, LOG_FIELD_SNAPSHOT: snapshotID, }).Debug("Listing objectstore for volume and snapshot") resp := api.VolumesResponse{ Volumes: make(map[string]api.VolumeResponse), } v, err := loadVolumeConfig(volumeID, driver) if err != nil { // Volume doesn't exist return api.ResponseOutput(resp) } snapshots, err := getSnapshots(volumeID, driver) if err != nil { return nil, err } volumeResp := api.VolumeResponse{ UUID: volumeID, Name: v.Name, Base: v.Base, Size: v.Size, Snapshots: make(map[string]api.SnapshotResponse), } if snapshotID != "" { if _, exists := snapshots[snapshotID]; exists { volumeResp.Snapshots[snapshotID] = api.SnapshotResponse{ UUID: snapshotID, VolumeUUID: volumeID, } } } else { for s := range snapshots { volumeResp.Snapshots[s] = api.SnapshotResponse{ UUID: s, VolumeUUID: volumeID, } } } resp.Volumes[volumeID] = volumeResp return api.ResponseOutput(resp) }
func writeResponseOutput(w http.ResponseWriter, v interface{}) error { output, err := api.ResponseOutput(v) if err != nil { return err } log.Debugln("Response: ", string(output)) _, err = w.Write(output) return err }
func (d *Driver) Info() ([]byte, error) { // from sector count to byte blockSize := d.ThinpoolBlockSize * 512 dmInfo := api.DeviceMapperInfo{ Driver: d.Name(), Root: d.Root, DataDevice: d.DataDevice, MetadataDevice: d.MetadataDevice, ThinpoolDevice: d.ThinpoolDevice, ThinpoolSize: d.ThinpoolSize, ThinpoolBlockSize: blockSize, } data, err := api.ResponseOutput(dmInfo) if err != nil { return nil, err } return data, nil }
func (s *Server) ListVolume(volumeUUID, snapshotUUID string) ([]byte, error) { resp := api.VolumesResponse{ Volumes: make(map[string]api.VolumeResponse), } var volumeUUIDs []string if volumeUUID != "" { volumeUUIDs = append(volumeUUIDs, volumeUUID) } else { volumeUUIDs = util.ListConfigIDs(s.Root, VOLUME_CFG_PREFIX, CFG_POSTFIX) } for _, uuid := range volumeUUIDs { volume := s.loadVolume(uuid) if volume == nil { return nil, fmt.Errorf("Volume list changed for volume %v", uuid) } resp.Volumes[uuid] = *getVolumeInfo(volume, snapshotUUID) } return api.ResponseOutput(resp) }
func (s *Server) doInfo(version string, w http.ResponseWriter, r *http.Request, objs map[string]string) error { s.GlobalLock.RLock() defer s.GlobalLock.RUnlock() var err error _, err = w.Write([]byte(fmt.Sprint("{\n\"General\" : "))) if err != nil { return err } data, err := api.ResponseOutput(&s.Config) if err != nil { return err } _, err = w.Write(data) if err != nil { return err } if _, err := w.Write([]byte(fmt.Sprint(",\n\"Driver\" : "))); err != nil { return err } driver := s.StorageDriver data, err = driver.Info() if err != nil { return err } _, err = w.Write(data) if err != nil { return err } if _, err := w.Write([]byte(fmt.Sprint("\n}"))); err != nil { return err } return nil }
func AddImage(root, imageDir, imageUUID, imageName, imageFilePath, objectstoreUUID string) ([]byte, error) { imageStat, err := os.Stat(imageFilePath) if os.IsNotExist(err) || imageStat.IsDir() { return nil, fmt.Errorf("Invalid image file") } imageLocalStorePath := GetImageLocalStorePath(imageDir, imageUUID) if _, err := os.Stat(imageLocalStorePath); err == nil { return nil, generateError(logrus.Fields{ LOG_FIELD_IMAGE: imageUUID, }, "UUID is already used by another image") } _, bsDriver, err := getObjectStoreCfgAndDriver(root, objectstoreUUID) if err != nil { return nil, err } imageObjectStorePath := getImageObjectStorePath(imageUUID) imageCfgObjectStorePath := getImageCfgObjectStorePath(imageUUID) imageExists := bsDriver.FileExists(imageObjectStorePath) imageCfgExists := bsDriver.FileExists(imageCfgObjectStorePath) if imageExists && imageCfgExists { return nil, generateError(logrus.Fields{ LOG_FIELD_IMAGE: imageUUID, }, "The image already existed in objectstore") } else if imageExists != imageCfgExists { return nil, generateError(logrus.Fields{ LOG_FIELD_IMAGE: imageUUID, }, "The image state is inconsistent in objectstore") } if imageStat.Size()%DEFAULT_BLOCK_SIZE != 0 { return nil, fmt.Errorf("The image size must be multiplier of %v", DEFAULT_BLOCK_SIZE) } image := &Image{} image.UUID = imageUUID image.Name = imageName image.Size = imageStat.Size() log.Debugf("Copying image %v to local store %v", imageFilePath, imageLocalStorePath) if err := util.Copy(imageFilePath, imageLocalStorePath); err != nil { log.Debugf("Copying image failed") return nil, err } log.Debug("Copied image to local store") log.WithFields(logrus.Fields{ LOG_FIELD_REASON: LOG_REASON_START, LOG_FIELD_EVENT: LOG_EVENT_UPLOAD, LOG_FIELD_OBJECT: LOG_OBJECT_IMAGE, LOG_FIELD_IMAGE: imageUUID, LOG_FIELD_IMAGE_FILE: imageLocalStorePath, LOG_FIELD_OBJECTSTORE: objectstoreUUID, }).Debug("Uploading image to objectstore") if err := uploadImage(imageLocalStorePath, bsDriver, image); err != nil { log.Debugf("Uploading image failed") return nil, err } if err := saveImageConfig(imageUUID, bsDriver, image); err != nil { return nil, err } imageResp := api.ImageResponse{ UUID: image.UUID, Name: image.Name, Size: image.Size, Checksum: image.Checksum, RawChecksum: image.RawChecksum, } return api.ResponseOutput(imageResp) }