func init() { bucket := os.Getenv("REGISTRY_STORAGE_GCS_BUCKET") keyfile := os.Getenv("REGISTRY_STORAGE_GCS_KEYFILE") credentials := os.Getenv("GOOGLE_APPLICATION_CREDENTIALS") root, err := ioutil.TempDir("", "driver-") if err != nil { panic(err) } defer os.Remove(root) gcsDriverConstructor = func(rootDirectory string) (storagedriver.StorageDriver, error) { parameters := driverParameters{ bucket, keyfile, rootDirectory, } return New(parameters) } // Skip GCS storage driver tests if environment variable parameters are not provided skipGCS = func() string { if bucket == "" || (credentials == "" && keyfile == "") { return "Must set REGISTRY_STORAGE_GCS_BUCKET and (GOOGLE_APPLICATION_CREDENTIALS or REGISTRY_STORAGE_GCS_KEYFILE) to run GCS tests" } return "" } testsuites.RegisterSuite(func() (storagedriver.StorageDriver, error) { return gcsDriverConstructor(root) }, skipGCS) }
func init() { bucket := os.Getenv("REGISTRY_STORAGE_GCS_BUCKET") credentials := os.Getenv("GOOGLE_APPLICATION_CREDENTIALS") // Skip GCS storage driver tests if environment variable parameters are not provided skipGCS = func() string { if bucket == "" || credentials == "" { return "The following environment variables must be set to enable these tests: REGISTRY_STORAGE_GCS_BUCKET, GOOGLE_APPLICATION_CREDENTIALS" } return "" } if skipGCS() != "" { return } root, err := ioutil.TempDir("", "driver-") if err != nil { panic(err) } defer os.Remove(root) var ts oauth2.TokenSource var email string var privateKey []byte ts, err = google.DefaultTokenSource(ctx.Background(), storage.ScopeFullControl) if err != nil { // Assume that the file contents are within the environment variable since it exists // but does not contain a valid file path jwtConfig, err := google.JWTConfigFromJSON([]byte(credentials), storage.ScopeFullControl) if err != nil { panic(fmt.Sprintf("Error reading JWT config : %s", err)) } email = jwtConfig.Email privateKey = []byte(jwtConfig.PrivateKey) if len(privateKey) == 0 { panic("Error reading JWT config : missing private_key property") } if email == "" { panic("Error reading JWT config : missing client_email property") } ts = jwtConfig.TokenSource(ctx.Background()) } gcsDriverConstructor = func(rootDirectory string) (storagedriver.StorageDriver, error) { parameters := driverParameters{ bucket: bucket, rootDirectory: root, email: email, privateKey: privateKey, client: oauth2.NewClient(ctx.Background(), ts), } return New(parameters) } testsuites.RegisterSuite(func() (storagedriver.StorageDriver, error) { return gcsDriverConstructor(root) }, skipGCS) }
func init() { storageURLs := os.Getenv("SPEEDY_STORAGE_URL") chunkSizeStr := os.Getenv("SPEEDY_CHUNKSIZE") heartBeatIntervalStr := os.Getenv("SPEEDY_HEART_BEAT") var chunkSize int //MB var heartBeatInterval int //seconds if chunkSizeStr != "" { chunkSize, _ = strconv.Atoi(chunkSizeStr) } if heartBeatIntervalStr != "" { heartBeatInterval, _ = strconv.Atoi(heartBeatIntervalStr) } driverConstructor := func() (storagedriver.StorageDriver, error) { parameters := DriverParameters{ storageURLs: storageURLs, chunkSize: uint64(chunkSize), heartBeatInterval: heartBeatInterval, } return New(parameters) } skipCheck := func() string { if storageURLs == "" || chunkSize == 0 || heartBeatInterval == 0 { return "Must set SPEEDY_STORAGE_URL, SPEEDY_CHUNKSIZE and SPEEDY_HEART_BEAT to run speedy test" } return "" } testsuites.RegisterSuite(driverConstructor, skipCheck) }
func init() { accessKeyId := os.Getenv("ACCESS_KEY_ID") secretAccessKey := os.Getenv("SECRET_ACCESS_KEY") bucketName := os.Getenv("BUCKET_NAME") endpoint := os.Getenv("ENDPOINT") driverConstructor := func() (storagedriver.StorageDriver, error) { parameters := DriverParameters{ accessKeyId, secretAccessKey, bucketName, endpoint, } return New(parameters) } skipCheck := func() string { return "" if accessKeyId == "" { return "RADOS_POOL must be set to run Rado tests" } return "" } testsuites.RegisterSuite(driverConstructor, skipCheck) }
func init() { accessKey := os.Getenv("AWS_ACCESS_KEY") secretKey := os.Getenv("AWS_SECRET_KEY") bucket := os.Getenv("S3_BUCKET") encrypt := os.Getenv("S3_ENCRYPT") secure := os.Getenv("S3_SECURE") region := os.Getenv("AWS_REGION") root, err := ioutil.TempDir("", "driver-") if err != nil { panic(err) } defer os.Remove(root) s3DriverConstructor = func(rootDirectory, storageClass string) (*Driver, error) { encryptBool := false if encrypt != "" { encryptBool, err = strconv.ParseBool(encrypt) if err != nil { return nil, err } } secureBool := true if secure != "" { secureBool, err = strconv.ParseBool(secure) if err != nil { return nil, err } } parameters := DriverParameters{ accessKey, secretKey, bucket, region, encryptBool, secureBool, minChunkSize, rootDirectory, storageClass, driverName + "-test", } return New(parameters) } // Skip S3 storage driver tests if environment variable parameters are not provided skipS3 = func() string { if accessKey == "" || secretKey == "" || region == "" || bucket == "" || encrypt == "" { return "Must set AWS_ACCESS_KEY, AWS_SECRET_KEY, AWS_REGION, S3_BUCKET, and S3_ENCRYPT to run S3 tests" } return "" } testsuites.RegisterSuite(func() (storagedriver.StorageDriver, error) { return s3DriverConstructor(root, s3.StorageClassStandard) }, skipS3) }
func init() { root, err := ioutil.TempDir("", "driver-") if err != nil { panic(err) } defer os.Remove(root) testsuites.RegisterSuite(func() (storagedriver.StorageDriver, error) { return New(root), nil }, testsuites.NeverSkip) }
func init() { zone := os.Getenv("KODO_ZONE") accessKey := os.Getenv("KODO_ACCESS_KEY") secretKey := os.Getenv("KODO_SECRET_KEY") bucket := os.Getenv("KODO_BUCKET") baseURL := os.Getenv("KODO_BASE_URL") root, err := ioutil.TempDir("", "driver-") if err != nil { panic(err) } defer os.Remove(root) kodoDriverConstructor = func(rootDirectory string) (*Driver, error) { var zoneValue int64 if zone != "" { zoneValue, err = strconv.ParseInt(zone, 10, 64) if err != nil { return nil, err } } parameters := DriverParameters{ int(zoneValue), bucket, baseURL, rootDirectory, kodo.Config{ AccessKey: accessKey, SecretKey: secretKey, }, } return New(parameters) } skipkodo = func() string { if accessKey == "" || secretKey == "" || bucket == "" || baseURL == "" { return "Must set KODO_ACCESS_KEY, KODO_SECRET_KEY, KODO_BUCKET, KODO_BASE_URL to run kodo tests" } return "" } testsuites.RegisterSuite(func() (storagedriver.StorageDriver, error) { return kodoDriverConstructor(root) }, skipkodo) }
func init() { root, err := ioutil.TempDir("", "driver-") if err != nil { panic(err) } defer os.Remove(root) driver, err := FromParameters(map[string]interface{}{ "rootdirectory": root, }) if err != nil { panic(err) } testsuites.RegisterSuite(func() (storagedriver.StorageDriver, error) { return driver, nil }, testsuites.NeverSkip) }
func init() { testAddr = os.Getenv("IPFS_ADDR") testRoot = os.Getenv("IPFS_ROOT") ipfsDriverConstructor := func() (storagedriver.StorageDriver, error) { return New(testAddr, testRoot), nil } // Skip ipfs storage driver tests if environment variable parameters are not provided skipCheck = func() string { if testAddr == "" || testRoot == "" { return fmt.Sprintf("Must set IPFS_ADDR and IPFS_ROOT environment variables to run IPFS tests") } return "" } // BUG(stevvooe): IPC is broken so we're disabling for now. Will revisit later. // testsuites.RegisterIPCSuite(driverName, map[string]string{"rootdirectory": root}, skipCheck) testsuites.RegisterSuite(ipfsDriverConstructor, skipCheck) }
func init() { var ( accountName string accountKey string container string realm string ) config := []struct { env string value *string }{ {envAccountName, &accountName}, {envAccountKey, &accountKey}, {envContainer, &container}, {envRealm, &realm}, } missing := []string{} for _, v := range config { *v.value = os.Getenv(v.env) if *v.value == "" { missing = append(missing, v.env) } } azureDriverConstructor := func() (storagedriver.StorageDriver, error) { return New(accountName, accountKey, container, realm) } // Skip Azure storage driver tests if environment variable parameters are not provided skipCheck := func() string { if len(missing) > 0 { return fmt.Sprintf("Must set %s environment variables to run Azure tests", strings.Join(missing, ", ")) } return "" } testsuites.RegisterSuite(azureDriverConstructor, skipCheck) }
func init() { poolname := os.Getenv("RADOS_POOL") username := os.Getenv("RADOS_USER") driverConstructor := func() (storagedriver.StorageDriver, error) { parameters := DriverParameters{ poolname, username, defaultChunkSize, } return New(parameters) } skipCheck := func() string { if poolname == "" { return "RADOS_POOL must be set to run Rado tests" } return "" } testsuites.RegisterSuite(driverConstructor, skipCheck) }
func init() { var ( username string password string authURL string tenant string tenantID string domain string domainID string trustID string container string region string AuthVersion int insecureSkipVerify bool secretKey string accessKey string containerKey bool tempURLMethods []string swiftServer *swifttest.SwiftServer err error ) username = os.Getenv("SWIFT_USERNAME") password = os.Getenv("SWIFT_PASSWORD") authURL = os.Getenv("SWIFT_AUTH_URL") tenant = os.Getenv("SWIFT_TENANT_NAME") tenantID = os.Getenv("SWIFT_TENANT_ID") domain = os.Getenv("SWIFT_DOMAIN_NAME") domainID = os.Getenv("SWIFT_DOMAIN_ID") trustID = os.Getenv("SWIFT_TRUST_ID") container = os.Getenv("SWIFT_CONTAINER_NAME") region = os.Getenv("SWIFT_REGION_NAME") AuthVersion, _ = strconv.Atoi(os.Getenv("SWIFT_AUTH_VERSION")) insecureSkipVerify, _ = strconv.ParseBool(os.Getenv("SWIFT_INSECURESKIPVERIFY")) secretKey = os.Getenv("SWIFT_SECRET_KEY") accessKey = os.Getenv("SWIFT_ACCESS_KEY") containerKey, _ = strconv.ParseBool(os.Getenv("SWIFT_TEMPURL_CONTAINERKEY")) tempURLMethods = strings.Split(os.Getenv("SWIFT_TEMPURL_METHODS"), ",") if username == "" || password == "" || authURL == "" || container == "" { if swiftServer, err = swifttest.NewSwiftServer("localhost"); err != nil { panic(err) } username = "******" password = "******" authURL = swiftServer.AuthURL container = "test" } prefix, err := ioutil.TempDir("", "driver-") if err != nil { panic(err) } defer os.Remove(prefix) swiftDriverConstructor = func(root string) (*Driver, error) { parameters := Parameters{ username, password, authURL, tenant, tenantID, domain, domainID, trustID, region, AuthVersion, container, root, insecureSkipVerify, defaultChunkSize, secretKey, accessKey, containerKey, tempURLMethods, } return New(parameters) } driverConstructor := func() (storagedriver.StorageDriver, error) { return swiftDriverConstructor(prefix) } testsuites.RegisterSuite(driverConstructor, testsuites.NeverSkip) }
func init() { accessKey := os.Getenv("AWS_ACCESS_KEY") secretKey := os.Getenv("AWS_SECRET_KEY") bucket := os.Getenv("S3_BUCKET") encrypt := os.Getenv("S3_ENCRYPT") secure := os.Getenv("S3_SECURE") v4auth := os.Getenv("S3_USE_V4_AUTH") region := os.Getenv("AWS_REGION") endpoint := os.Getenv("BUCKET_ENDPOINT") root, err := ioutil.TempDir("", "driver-") if err != nil { panic(err) } defer os.Remove(root) s3DriverConstructor = func(rootDirectory string) (*Driver, error) { encryptBool := false if encrypt != "" { encryptBool, err = strconv.ParseBool(encrypt) if err != nil { return nil, err } } secureBool := true if secure != "" { secureBool, err = strconv.ParseBool(secure) if err != nil { return nil, err } } v4AuthBool := false if v4auth != "" { v4AuthBool, err = strconv.ParseBool(v4auth) if err != nil { return nil, err } } endpointStr := "" if endpoint != "" { endpointStr = endpoint } parameters := DriverParameters{ accessKey, secretKey, bucket, aws.GetRegion(region), encryptBool, secureBool, v4AuthBool, minChunkSize, rootDirectory, endpointStr, } return New(parameters) } // Skip S3 storage driver tests if environment variable parameters are not provided skipS3 = func() string { if accessKey == "" || secretKey == "" || region == "" || bucket == "" || encrypt == "" { return "Must set AWS_ACCESS_KEY, AWS_SECRET_KEY, AWS_REGION, S3_BUCKET, and S3_ENCRYPT to run S3 tests" } return "" } testsuites.RegisterSuite(func() (storagedriver.StorageDriver, error) { return s3DriverConstructor(root) }, skipS3) }
func init() { inmemoryDriverConstructor := func() (storagedriver.StorageDriver, error) { return New(), nil } testsuites.RegisterSuite(inmemoryDriverConstructor, testsuites.NeverSkip) }
func init() { accessKey := os.Getenv("AWS_ACCESS_KEY") secretKey := os.Getenv("AWS_SECRET_KEY") bucket := os.Getenv("S3_BUCKET") encrypt := os.Getenv("S3_ENCRYPT") keyID := os.Getenv("S3_KEY_ID") secure := os.Getenv("S3_SECURE") v4Auth := os.Getenv("S3_V4_AUTH") region := os.Getenv("AWS_REGION") objectAcl := os.Getenv("S3_OBJECT_ACL") root, err := ioutil.TempDir("", "driver-") regionEndpoint := os.Getenv("REGION_ENDPOINT") if err != nil { panic(err) } defer os.Remove(root) s3DriverConstructor = func(rootDirectory, storageClass string) (*Driver, error) { encryptBool := false if encrypt != "" { encryptBool, err = strconv.ParseBool(encrypt) if err != nil { return nil, err } } secureBool := true if secure != "" { secureBool, err = strconv.ParseBool(secure) if err != nil { return nil, err } } v4Bool := true if v4Auth != "" { v4Bool, err = strconv.ParseBool(v4Auth) if err != nil { return nil, err } } parameters := DriverParameters{ accessKey, secretKey, bucket, region, regionEndpoint, encryptBool, keyID, secureBool, v4Bool, minChunkSize, defaultMultipartCopyChunkSize, defaultMultipartCopyMaxConcurrency, defaultMultipartCopyThresholdSize, rootDirectory, storageClass, driverName + "-test", objectAcl, } return New(parameters) } // Skip S3 storage driver tests if environment variable parameters are not provided skipS3 = func() string { if accessKey == "" || secretKey == "" || region == "" || bucket == "" || encrypt == "" { return "Must set AWS_ACCESS_KEY, AWS_SECRET_KEY, AWS_REGION, S3_BUCKET, and S3_ENCRYPT to run S3 tests" } return "" } testsuites.RegisterSuite(func() (storagedriver.StorageDriver, error) { return s3DriverConstructor(root, s3.StorageClassStandard) }, skipS3) }
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) }