func Init(params volume.DriverParams) (volume.VolumeDriver, error) { inst := &driver{ IoNotSupported: &volume.IoNotSupported{}, DefaultEnumerator: volume.NewDefaultEnumerator(Name, kvdb.Instance()), } inst.buseDevices = make(map[string]*buseDev) if err := os.MkdirAll(BuseMountPath, 0744); err != nil { return nil, err } volumeInfo, err := inst.DefaultEnumerator.Enumerate( &api.VolumeLocator{}, nil, ) if err == nil { for _, info := range volumeInfo { if info.Status == api.VolumeStatus_VOLUME_STATUS_NONE { info.Status = api.VolumeStatus_VOLUME_STATUS_UP inst.UpdateVol(info) } } } else { dlog.Println("Could not enumerate Volumes, ", err) } c, err := cluster.Inst() if err != nil { dlog.Println("BUSE initializing in single node mode") } else { dlog.Println("BUSE initializing in clustered mode") c.AddEventListener(inst) } dlog.Println("BUSE initialized and driver mounted at: ", BuseMountPath) return inst, nil }
func Init(params volume.DriverParams) (volume.VolumeDriver, error) { restUrl, ok := params["restUrl"] if !ok { return nil, fmt.Errorf("rest api 'url' configuration parameter must be set") } user, ok := params["user"] if !ok { return nil, fmt.Errorf("rest auth 'user' must be set") } pass, ok := params["password"] if !ok { return nil, fmt.Errorf("rest auth 'password' must be set") } consistency_group, ok := params["consistency_group"] if !ok { return nil, fmt.Errorf("'consistency_group' configuration parameter must be set") } project, ok := params["project"] if !ok { return nil, fmt.Errorf("'project' configuration parameter must be set") } varray, ok := params["varray"] if !ok { return nil, fmt.Errorf("'varray' configuration parameter must be set") } vpool, ok := params["vpool"] if !ok { return nil, fmt.Errorf("'vpool' configuration parameter must be set") } d := &driver{ DefaultEnumerator: volume.NewDefaultEnumerator(Name, kvdb.Instance()), consistency_group: consistency_group, project: project, varray: varray, vpool: vpool, url: restUrl, creds: url.UserPassword(user, pass), httpClient: &http.Client{ Transport: &http.Transport{ TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, }, }, } return d, nil }
func Init(params volume.DriverParams) (volume.VolumeDriver, error) { root, ok := params[RootParam] if !ok { return nil, fmt.Errorf("Root directory should be specified with key %q", RootParam) } home := path.Join(root, Volumes) d, err := btrfs.Init(home, nil) if err != nil { return nil, err } s := volume.NewDefaultEnumerator(Name, kvdb.Instance()) return &driver{btrfs: d, root: root, DefaultEnumerator: s}, nil }
// Init aws volume driver metadata. func Init(params volume.DriverParams) (volume.VolumeDriver, error) { zone, err := metadata("placement/availability-zone") if err != nil { return nil, err } instance, err := metadata("instance-id") if err != nil { return nil, err } logrus.Infof("AWS instance %v zone %v", instance, zone) accessKey, ok := params["AWS_ACCESS_KEY_ID"] if !ok { if accessKey = os.Getenv("AWS_ACCESS_KEY_ID"); accessKey == "" { return nil, fmt.Errorf("AWS_ACCESS_KEY_ID environment variable must be set") } } secretKey, ok := params["AWS_SECRET_ACCESS_KEY"] if !ok { if secretKey = os.Getenv("AWS_SECRET_ACCESS_KEY"); secretKey == "" { return nil, fmt.Errorf("AWS_SECRET_ACCESS_KEY environment variable must be set") } } creds := credentials.NewStaticCredentials(accessKey, secretKey, "") region := zone[:len(zone)-1] d := &Driver{ ec2: ec2.New( session.New( &aws.Config{ Region: ®ion, Credentials: creds, }, ), ), md: &Metadata{ zone: zone, instance: instance, }, IoNotSupported: &volume.IoNotSupported{}, DefaultEnumerator: volume.NewDefaultEnumerator(Name, kvdb.Instance()), } devPrefix, letters, err := d.freeDevices() if err != nil { return nil, err } d.SingleLetter, err = device.NewSingleLetter(devPrefix, letters) if err != nil { return nil, err } return d, nil }
func newVolumeDriver( name string, baseDirPath string, provider Provider, ) *volumeDriver { return &volumeDriver{ name, baseDirPath, provider, &volume.DefaultBlockDriver{}, volume.NewDefaultEnumerator( name, kvdb.Instance(), ), &volume.SnapshotNotSupported{}, } }
// Init aws volume driver metadata. func Init(params volume.DriverParams) (volume.VolumeDriver, error) { zone, err := metadata("placement/availability-zone") if err != nil { return nil, err } instance, err := metadata("instance-id") if err != nil { return nil, err } log.Infof("AWS instance %v zone %v", instance, zone) if accessKey, ok := params["AWS_ACCESS_KEY_ID"]; ok { os.Setenv("AWS_ACCESS_KEY_ID", accessKey) } if secretKey, ok := params["AWS_SECRET_ACCESS_KEY"]; ok { os.Setenv("AWS_SECRET_ACCESS_KEY", secretKey) } if accessKey := os.Getenv("AWS_ACCESS_KEY_ID"); accessKey == "" { return nil, fmt.Errorf("AWS_ACCESS_KEY_ID environment variable must be set") } if secretKey := os.Getenv("AWS_SECRET_ACCESS_KEY"); secretKey == "" { return nil, fmt.Errorf("AWS_SECRET_ACCESS_KEY environment variable must be set") } creds := credentials.NewEnvCredentials() region := zone[:len(zone)-1] inst := &Driver{ ec2: ec2.New(&aws.Config{ Region: ®ion, Credentials: creds, }), md: &Metadata{ zone: zone, instance: instance, }, devices: "abcdefghijklmnopqrstuvwxyz", DefaultEnumerator: volume.NewDefaultEnumerator(Name, kvdb.Instance()), } return inst, nil }
func Init(params volume.DriverParams) (volume.VolumeDriver, error) { path, ok := params["path"] if !ok { return nil, errors.New("No NFS path provided") } server, ok := params["server"] if !ok { log.Printf("No NFS server provided, will attempt to bind mount %s", path) } else { log.Printf("NFS driver initializing with %s:%s ", server, path) } inst := &driver{ DefaultEnumerator: volume.NewDefaultEnumerator(Name, kvdb.Instance()), nfsServer: server, nfsPath: path} err := os.MkdirAll(nfsMountPath, 0744) if err != nil { return nil, err } // Mount the nfs server locally on a unique path. syscall.Unmount(nfsMountPath, 0) if server != "" { err = syscall.Mount(":"+inst.nfsPath, nfsMountPath, "nfs", 0, "nolock,addr="+inst.nfsServer) } else { err = syscall.Mount(inst.nfsPath, nfsMountPath, "", syscall.MS_BIND, "") } if err != nil { log.Printf("Unable to mount %s:%s at %s (%+v)", inst.nfsServer, inst.nfsPath, nfsMountPath, err) return nil, err } log.Println("NFS initialized and driver mounted at: ", nfsMountPath) return inst, nil }
func Init(params volume.DriverParams) (volume.VolumeDriver, error) { path, ok := params["path"] if !ok { return nil, errors.New("No NFS path provided") } server, ok := params["server"] if !ok { dlog.Printf("No NFS server provided, will attempt to bind mount %s", path) } else { dlog.Printf("NFS driver initializing with %s:%s ", server, path) } // Create a mount manager for this NFS server. Blank sever is OK. mounter, err := mount.New(mount.NFSMount, server) if err != nil { dlog.Warnf("Failed to create mount manager for server: %v (%v)", server, err) return nil, err } inst := &driver{ IoNotSupported: &volume.IoNotSupported{}, DefaultEnumerator: volume.NewDefaultEnumerator(Name, kvdb.Instance()), nfsServer: server, nfsPath: path, mounter: mounter, } if err := os.MkdirAll(nfsMountPath, 0744); err != nil { return nil, err } src := inst.nfsPath if server != "" { src = ":" + inst.nfsPath } // If src is already mounted at dest, leave it be. mountExists, err := mounter.Exists(src, nfsMountPath) if !mountExists { // Mount the nfs server locally on a unique path. syscall.Unmount(nfsMountPath, 0) if server != "" { err = syscall.Mount(src, nfsMountPath, "nfs", 0, "nolock,addr="+inst.nfsServer) } else { err = syscall.Mount(src, nfsMountPath, "", syscall.MS_BIND, "") } if err != nil { dlog.Printf("Unable to mount %s:%s at %s (%+v)", inst.nfsServer, inst.nfsPath, nfsMountPath, err) return nil, err } } volumeInfo, err := inst.DefaultEnumerator.Enumerate(&api.VolumeLocator{}, nil) if err == nil { for _, info := range volumeInfo { if info.Status == api.VolumeStatus_VOLUME_STATUS_NONE { info.Status = api.VolumeStatus_VOLUME_STATUS_UP inst.UpdateVol(info) } } } else { dlog.Println("Could not enumerate Volumes, ", err) } dlog.Println("NFS initialized and driver mounted at: ", nfsMountPath) return inst, nil }
// Init Driver intialization. func Init(params volume.DriverParams) (volume.VolumeDriver, error) { return &driver{ IoNotSupported: &volume.IoNotSupported{}, DefaultEnumerator: volume.NewDefaultEnumerator(Name, kvdb.Instance()), }, nil }
func Init(params map[string]string) (volume.VolumeDriver, error) { host, ok := params["url"] if !ok { return nil, ErrApiUrlRequired } token, ok := params["token"] if !ok { return nil, ErrApiAuthTokenRequired } // create a coprhd api client instance client := coprhd.NewClient(host, token) d := &driver{ DefaultEnumerator: volume.NewDefaultEnumerator(Name, kvdb.Instance()), client: client, } if projectName, ok := params["project"]; ok { if project, err := client.Project().Name(projectName).Query(); err != nil { return nil, err } else { d.project = project } } else { dlog.Warnln("Default coprhd 'project' not set") } if varrayName, ok := params["varray"]; ok { if varray, err := client.VArray().Name(varrayName).Query(); err != nil { return nil, err } else { d.varray = varray } } else { dlog.Warnf("Default coprhd 'varray' not set") } if vpoolName, ok := params["vpool"]; ok { if vpool, err := client.VPool().Name(vpoolName).Query(); err != nil { return nil, err } else { d.vpool = vpool } } else { dlog.Warnf("Default coprhd 'vpool' not set") } if port, ok := params["port"]; ok { if initiator, err := client.Initiator().Port(port).Query(); err != nil { return nil, err } else { d.initiator = initiator } } else { return nil, ErrPortRequired } return d, nil }
// Init Driver intialization. func Init(params volume.DriverParams) (volume.VolumeDriver, error) { return &driver{ DefaultEnumerator: volume.NewDefaultEnumerator(Name, kvdb.Instance())}, nil }