// Add the flags accepted by run to the supplied flag set, returning the // variables into which the flags will parse. func PopulateFlags(c *cli.Context) (flags *FlagStorage) { flags = &FlagStorage{ // File system MountOptions: make(map[string]string), DirMode: os.FileMode(c.Int("dir-mode")), FileMode: os.FileMode(c.Int("file-mode")), Uid: uint32(c.Int("uid")), Gid: uint32(c.Int("gid")), // Tuning, StatCacheTTL: c.Duration("stat-cache-ttl"), TypeCacheTTL: c.Duration("type-cache-ttl"), // OSS Endpoint: c.String("endpoint"), UsePathRequest: c.Bool("use-path-request"), Internal: c.Bool("internal"), // Debugging, DebugFuse: c.Bool("debug_fuse"), DebugOSS: c.Bool("debug_oss"), } // Handle the repeated "-o" flag. for _, o := range c.StringSlice("o") { parseOptions(flags.MountOptions, o) } // Get the region/AccessKeyId/AccessKeySecret flags.AccessKeyId = os.Getenv("ACCESS_KEY_ID") flags.AccessKeySecret = os.Getenv("ACCESS_KEY_SECRET") flags.Region = oss.Region(os.Getenv("OSS_REGION")) return }
// FromParameters constructs a new Driver with a given parameters map // Required parameters: // - accesskey // - secretkey // - region // - bucket // - encrypt func FromParameters(parameters map[string]interface{}) (*Driver, error) { // Providing no values for these is valid in case the user is authenticating accessKey, ok := parameters["accesskeyid"] if !ok { return nil, fmt.Errorf("No accesskeyid parameter provided") } secretKey, ok := parameters["accesskeysecret"] if !ok { return nil, fmt.Errorf("No accesskeysecret parameter provided") } regionName, ok := parameters["region"] if !ok || fmt.Sprint(regionName) == "" { return nil, fmt.Errorf("No region parameter provided") } bucket, ok := parameters["bucket"] if !ok || fmt.Sprint(bucket) == "" { return nil, fmt.Errorf("No bucket parameter provided") } internalBool := false internal, ok := parameters["internal"] if ok { internalBool, ok = internal.(bool) if !ok { return nil, fmt.Errorf("The internal parameter should be a boolean") } } encryptBool := false encrypt, ok := parameters["encrypt"] if ok { encryptBool, ok = encrypt.(bool) if !ok { return nil, fmt.Errorf("The encrypt parameter should be a boolean") } } secureBool := true secure, ok := parameters["secure"] if ok { secureBool, ok = secure.(bool) if !ok { return nil, fmt.Errorf("The secure parameter should be a boolean") } } chunkSize := int64(defaultChunkSize) chunkSizeParam, ok := parameters["chunksize"] if ok { switch v := chunkSizeParam.(type) { case string: vv, err := strconv.ParseInt(v, 0, 64) if err != nil { return nil, fmt.Errorf("chunksize parameter must be an integer, %v invalid", chunkSizeParam) } chunkSize = vv case int64: chunkSize = v case int, uint, int32, uint32, uint64: chunkSize = reflect.ValueOf(v).Convert(reflect.TypeOf(chunkSize)).Int() default: return nil, fmt.Errorf("invalid valud for chunksize: %#v", chunkSizeParam) } if chunkSize < minChunkSize { return nil, fmt.Errorf("The chunksize %#v parameter should be a number that is larger than or equal to %d", chunkSize, minChunkSize) } } rootDirectory, ok := parameters["rootdirectory"] if !ok { rootDirectory = "" } endpoint, ok := parameters["endpoint"] if !ok { endpoint = "" } params := DriverParameters{ AccessKeyID: fmt.Sprint(accessKey), AccessKeySecret: fmt.Sprint(secretKey), Bucket: fmt.Sprint(bucket), Region: oss.Region(fmt.Sprint(regionName)), ChunkSize: chunkSize, RootDirectory: fmt.Sprint(rootDirectory), Encrypt: encryptBool, Secure: secureBool, Internal: internalBool, Endpoint: fmt.Sprint(endpoint), } return New(params) }
func NewOssvfs(bucket string, flags *FlagStorage) *Ossvfs { // Set up the basic struct. fs := &Ossvfs{ bucketName: bucket, flags: flags, umask: 0122, } fs.client = oss.NewOSSClient(flags.Region, flags.Internal, flags.AccessKeyId, flags.AccessKeySecret, true) fs.bucket = fs.client.Bucket(bucket) if flags.DebugOSS { fs.client.SetDebug(flags.DebugOSS) ossLog.Level = logrus.DebugLevel } location, err := fs.bucket.Location() if err != nil { if mapOssError(err) == fuse.ENOENT { log.Errorf("bucket %v does not exist", bucket) return nil } } if oss.Region(location) != fs.flags.Region { log.Errorf("the location of bucket %v is wrong") return nil } now := time.Now() fs.rootAttrs = fuseops.InodeAttributes{ Size: 4096, Nlink: 2, Mode: flags.DirMode | os.ModeDir, Atime: now, Mtime: now, Ctime: now, Crtime: now, Uid: fs.flags.Uid, Gid: fs.flags.Gid, } fs.bufferPool = NewBufferPool(1000*1024*1024, 200*1024*1024) fs.nextInodeID = fuseops.RootInodeID + 1 fs.inodes = make(map[fuseops.InodeID]*Inode) root := NewInode(getStringPointer(""), getStringPointer(""), flags) root.Id = fuseops.RootInodeID root.Attributes = &fs.rootAttrs fs.inodes[fuseops.RootInodeID] = root fs.inodesCache = make(map[string]*Inode) fs.nextHandleID = 1 fs.dirHandles = make(map[fuseops.HandleID]*DirHandle) fs.fileHandles = make(map[fuseops.HandleID]*FileHandle) return fs }
func init() { accessKey := os.Getenv("ALIYUN_ACCESS_KEY_ID") secretKey := os.Getenv("ALIYUN_ACCESS_KEY_SECRET") bucket := os.Getenv("OSS_BUCKET") region := os.Getenv("OSS_REGION") internal := os.Getenv("OSS_INTERNAL") encrypt := os.Getenv("OSS_ENCRYPT") secure := os.Getenv("OSS_SECURE") endpoint := os.Getenv("OSS_ENDPOINT") root, err := ioutil.TempDir("", "driver-") if err != nil { panic(err) } defer os.Remove(root) ossDriverConstructor = func(rootDirectory string) (*Driver, error) { encryptBool := false if encrypt != "" { encryptBool, err = strconv.ParseBool(encrypt) if err != nil { return nil, err } } secureBool := false if secure != "" { secureBool, err = strconv.ParseBool(secure) if err != nil { return nil, err } } internalBool := false if internal != "" { internalBool, err = strconv.ParseBool(internal) if err != nil { return nil, err } } parameters := DriverParameters{ AccessKeyID: accessKey, AccessKeySecret: secretKey, Bucket: bucket, Region: alioss.Region(region), Internal: internalBool, ChunkSize: minChunkSize, RootDirectory: rootDirectory, Encrypt: encryptBool, Secure: secureBool, Endpoint: endpoint, } return New(parameters) } // Skip OSS storage driver tests if environment variable parameters are not provided skipCheck = func() string { if accessKey == "" || secretKey == "" || region == "" || bucket == "" || encrypt == "" { return "Must set ALIYUN_ACCESS_KEY_ID, ALIYUN_ACCESS_KEY_SECRET, OSS_REGION, OSS_BUCKET, and OSS_ENCRYPT to run OSS tests" } return "" } testsuites.RegisterSuite(func() (storagedriver.StorageDriver, error) { return ossDriverConstructor(root) }, skipCheck) }