func (d *driver) createGetSnapshot( volumeOpts core.VolumeOpts) (*core.Snapshot, error) { var optSnapshotName string var optSnapshotID string optSnapshotName, _ = volumeOpts["snapshotname"] optSnapshotID, _ = volumeOpts["snapshotid"] if optSnapshotName == "" && optSnapshotID == "" { return nil, nil } var err error var snapshots []*core.Snapshot if snapshots, err = d.r.Storage.GetSnapshot( "", optSnapshotID, optSnapshotName); err != nil { return nil, err } switch { case len(snapshots) == 0: return nil, errors.WithField( "optSnapshotName", optSnapshotName, "No snapshots returned") case len(snapshots) > 1: return nil, errors.WithField( "optSnapshotName", optSnapshotName, "Too many snapshots returned") } return snapshots[0], nil }
func (d *driver) createInitVolume( volumeName string, volumeOpts core.VolumeOpts) (*core.Volume, error) { var optVolumeName string var optVolumeID string optVolumeName, _ = volumeOpts["volumename"] optVolumeID, _ = volumeOpts["volumeid"] if optVolumeName == "" && optVolumeID == "" { return nil, nil } var err error var volumes []*core.Volume if volumes, err = d.r.Storage.GetVolume(optVolumeID, optVolumeName); err != nil { return nil, err } switch { case len(volumes) == 0: return nil, errors.WithField( "optVolumeName", optVolumeName, "No volumes returned") case len(volumes) > 1: return nil, errors.WithField( "optVolumeName", optVolumeName, "Too many volumes returned") } return volumes[0], nil }
// ParseAddress parses a standard golang network address and returns the // protocol and path. func ParseAddress(addr string) (proto string, path string, err error) { m := netAddrRx.FindStringSubmatch(addr) if m == nil { return "", "", errors.WithField("address", addr, "invalid address") } return m[1], m[2], nil }
// GetModuleInstance gets the module instance with the provided instance ID. func GetModuleInstance(modInstID int32) (*Instance, error) { modInstancesRwl.RLock() defer modInstancesRwl.RUnlock() mod, modExists := modInstances[modInstID] if !modExists { return nil, errors.WithField("id", modInstID, "unknown module instance") } return mod, nil }
func (d *driver) createGetVolumes( volumeName string, volumeOpts core.VolumeOpts) ([]*core.Volume, bool, error) { var err error var volumes []*core.Volume if volumes, err = d.r.Storage.GetVolume("", volumeName); err != nil { return nil, false, err } overwriteFs, _ := strconv.ParseBool(volumeOpts["overwritefs"]) switch { case len(volumes) == 1 && !overwriteFs: return volumes, overwriteFs, nil case len(volumes) > 1: return nil, overwriteFs, errors.WithField( "volumeName", volumeName, "Too many volumes returned") } return volumes, overwriteFs, nil }
func (m *mod) Start() error { proto, addr, parseAddrErr := util.ParseAddress(m.Address()) if parseAddrErr != nil { return parseAddrErr } const validProtoPatt = "(?i)^unix|tcp$" isProtoValid, matchProtoErr := regexp.MatchString(validProtoPatt, proto) if matchProtoErr != nil { return errors.WithFieldsE(errors.Fields{ "protocol": proto, "validProtoPatt": validProtoPatt, }, "error matching protocol", matchProtoErr) } if !isProtoValid { return errors.WithField("protocol", proto, "invalid protocol") } if err := m.r.InitDrivers(); err != nil { return errors.WithFieldsE(errors.Fields{ "m": m, "m.r": m.r, }, "error initializing drivers", err) } if err := os.MkdirAll("/etc/docker/plugins", 0755); err != nil { return err } var specPath string var startFunc func() error mux := m.buildMux() if proto == "unix" { sockFile := addr sockFileDir := filepath.Dir(sockFile) mkSockFileDirErr := os.MkdirAll(sockFileDir, 0755) if mkSockFileDirErr != nil { return mkSockFileDirErr } _ = os.RemoveAll(sockFile) specPath = m.Address() startFunc = func() error { l, lErr := net.Listen("unix", sockFile) if lErr != nil { return lErr } defer l.Close() defer os.Remove(sockFile) return http.Serve(l, mux) } } else { specPath = addr startFunc = func() error { s := &http.Server{ Addr: addr, Handler: mux, ReadTimeout: 10 * time.Second, WriteTimeout: 10 * time.Second, MaxHeaderBytes: 1 << 20, } return s.ListenAndServe() } } go func() { sErr := startFunc() if sErr != nil { panic(sErr) } }() writeSpecErr := ioutil.WriteFile( "/etc/docker/plugins/rexray.spec", []byte(specPath), 0644) if writeSpecErr != nil { return writeSpecErr } return nil }