Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:27
📄 chain_provider.go // Copyright (C) MongoDB, Inc. 2023-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 // // Based on github.com/aws/aws-sdk-go by Amazon.com, Inc. with code from: // - github.com/aws/aws-sdk-go/blob/v1.44.225/aws/credentials/chain_provider.go // See THIRD-PARTY-NOTICES for original license terms package credentials import ( "go.mongodb.org/mongo-driver/internal/aws/awserr" ) // A ChainProvider will search for a provider which returns credentials // and cache that provider until Retrieve is called again. // // The ChainProvider provides a way of chaining multiple providers together // which will pick the first available using priority order of the Providers // in the list. // // If none of the Providers retrieve valid credentials Value, ChainProvider's // Retrieve() will return the error ErrNoValidProvidersFoundInChain. // // If a Provider is found which returns valid credentials Value ChainProvider // will cache that Provider for all calls to IsExpired(), until Retrieve is // called again. type ChainProvider struct { Providers []Provider curr Provider } // NewChainCredentials returns a pointer to a new Credentials object // wrapping a chain of providers. func NewChainCredentials(providers []Provider) Credentials { return NewCredentials(&ChainProvider{ Providers: append([]Provider{}, providers...), }) } // Retrieve returns the credentials value or error if no provider returned // without error. // // If a provider is found it will be cached and any calls to IsExpired() // will return the expired state of the cached provider. func (c ChainProvider) Retrieve() (Value, error) { var errs = make([]error, 0, len(c.Providers)) for _, p := range c.Providers { creds, err := p.Retrieve() if err == nil { c.curr = p return creds, nil } errs = append(errs, err) } c.curr = nil var err = awserr.NewBatchError("NoCredentialProviders", "no valid providers in chain", errs) return Value{}, err } // IsExpired will returned the expired state of the currently cached provider // if there is one. If there is no current provider, true will be returned. func (c *ChainProvider) IsExpired() bool { if c.curr != nil { return c.curr.IsExpired() } return true }	2.34 KB	2025-05-25 12:27
📄 chain_provider_test.go // Copyright (C) MongoDB, Inc. 2023-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 // // Based on github.com/aws/aws-sdk-go by Amazon.com, Inc. with code from: // - github.com/aws/aws-sdk-go/blob/v1.44.225/aws/credentials/chain_provider_test.go // See THIRD-PARTY-NOTICES for original license terms package credentials import ( "reflect" "testing" "go.mongodb.org/mongo-driver/internal/aws/awserr" ) type secondStubProvider struct { creds Value expired bool err error } func (s secondStubProvider) Retrieve() (Value, error) { s.expired = false s.creds.ProviderName = "secondStubProvider" return s.creds, s.err } func (s secondStubProvider) IsExpired() bool { return s.expired } func TestChainProviderWithNames(t testing.T) { p := &ChainProvider{ Providers: []Provider{ &stubProvider{err: awserr.New("FirstError", "first provider error", nil)}, &stubProvider{err: awserr.New("SecondError", "second provider error", nil)}, &secondStubProvider{ creds: Value{ AccessKeyID: "AKIF", SecretAccessKey: "NOSECRET", SessionToken: "", }, }, &stubProvider{ creds: Value{ AccessKeyID: "AKID", SecretAccessKey: "SECRET", SessionToken: "", }, }, }, } creds, err := p.Retrieve() if err != nil { t.Errorf("Expect no error, got %v", err) } if e, a := "secondStubProvider", creds.ProviderName; e != a { t.Errorf("Expect provider name to match, %v got, %v", e, a) } // Also check credentials if e, a := "AKIF", creds.AccessKeyID; e != a { t.Errorf("Expect access key ID to match, %v got %v", e, a) } if e, a := "NOSECRET", creds.SecretAccessKey; e != a { t.Errorf("Expect secret access key to match, %v got %v", e, a) } if v := creds.SessionToken; len(v) != 0 { t.Errorf("Expect session token to be empty, %v", v) } } func TestChainProviderGet(t testing.T) { p := &ChainProvider{ Providers: []Provider{ &stubProvider{err: awserr.New("FirstError", "first provider error", nil)}, &stubProvider{err: awserr.New("SecondError", "second provider error", nil)}, &stubProvider{ creds: Value{ AccessKeyID: "AKID", SecretAccessKey: "SECRET", SessionToken: "", }, }, }, } creds, err := p.Retrieve() if err != nil { t.Errorf("Expect no error, got %v", err) } if e, a := "AKID", creds.AccessKeyID; e != a { t.Errorf("Expect access key ID to match, %v got %v", e, a) } if e, a := "SECRET", creds.SecretAccessKey; e != a { t.Errorf("Expect secret access key to match, %v got %v", e, a) } if v := creds.SessionToken; len(v) != 0 { t.Errorf("Expect session token to be empty, %v", v) } } func TestChainProviderIsExpired(t testing.T) { stubProvider := &stubProvider{expired: true} p := &ChainProvider{ Providers: []Provider{ stubProvider, }, } if !p.IsExpired() { t.Errorf("Expect expired to be true before any Retrieve") } _, err := p.Retrieve() if err != nil { t.Errorf("Expect no error, got %v", err) } if p.IsExpired() { t.Errorf("Expect not expired after retrieve") } stubProvider.expired = true if !p.IsExpired() { t.Errorf("Expect return of expired provider") } _, err = p.Retrieve() if err != nil { t.Errorf("Expect no error, got %v", err) } if p.IsExpired() { t.Errorf("Expect not expired after retrieve") } } func TestChainProviderWithNoProvider(t testing.T) { p := &ChainProvider{ Providers: []Provider{}, } if !p.IsExpired() { t.Errorf("Expect expired with no providers") } _, err := p.Retrieve() if err.Error() != "NoCredentialProviders: no valid providers in chain" { t.Errorf("Expect no providers error returned, got %v", err) } } func TestChainProviderWithNoValidProvider(t *testing.T) { errs := []error{ awserr.New("FirstError", "first provider error", nil), awserr.New("SecondError", "second provider error", nil), } p := &ChainProvider{ Providers: []Provider{ &stubProvider{err: errs[0]}, &stubProvider{err: errs[1]}, }, } if !p.IsExpired() { t.Errorf("Expect expired with no providers") } _, err := p.Retrieve() expectErr := awserr.NewBatchError("NoCredentialProviders", "no valid providers in chain", errs) if e, a := expectErr, err; !reflect.DeepEqual(e, a) { t.Errorf("Expect no providers error returned, %v, got %v", e, a) } }	4.38 KB	2025-05-25 12:27
📄 credentials.go // Copyright (C) MongoDB, Inc. 2023-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 // // Based on github.com/aws/aws-sdk-go by Amazon.com, Inc. with code from: // - github.com/aws/aws-sdk-go/blob/v1.44.225/aws/credentials/credentials.go // See THIRD-PARTY-NOTICES for original license terms package credentials import ( "context" "sync" "time" "go.mongodb.org/mongo-driver/internal/aws/awserr" "golang.org/x/sync/singleflight" ) // A Value is the AWS credentials value for individual credential fields. // // A Value is also used to represent Azure credentials. // Azure credentials only consist of an access token, which is stored in the `SessionToken` field. type Value struct { // AWS Access key ID AccessKeyID string // AWS Secret Access Key SecretAccessKey string // AWS Session Token SessionToken string // Provider used to get credentials ProviderName string } // HasKeys returns if the credentials Value has both AccessKeyID and // SecretAccessKey value set. func (v Value) HasKeys() bool { return len(v.AccessKeyID) != 0 && len(v.SecretAccessKey) != 0 } // A Provider is the interface for any component which will provide credentials // Value. A provider is required to manage its own Expired state, and what to // be expired means. // // The Provider should not need to implement its own mutexes, because // that will be managed by Credentials. type Provider interface { // Retrieve returns nil if it successfully retrieved the value. // Error is returned if the value were not obtainable, or empty. Retrieve() (Value, error) // IsExpired returns if the credentials are no longer valid, and need // to be retrieved. IsExpired() bool } // ProviderWithContext is a Provider that can retrieve credentials with a Context type ProviderWithContext interface { Provider RetrieveWithContext(context.Context) (Value, error) } // A Credentials provides concurrency safe retrieval of AWS credentials Value. // // A Credentials is also used to fetch Azure credentials Value. // // Credentials will cache the credentials value until they expire. Once the value // expires the next Get will attempt to retrieve valid credentials. // // Credentials is safe to use across multiple goroutines and will manage the // synchronous state so the Providers do not need to implement their own // synchronization. // // The first Credentials.Get() will always call Provider.Retrieve() to get the // first instance of the credentials Value. All calls to Get() after that // will return the cached credentials Value until IsExpired() returns true. type Credentials struct { sf singleflight.Group m sync.RWMutex creds Value provider Provider } // NewCredentials returns a pointer to a new Credentials with the provider set. func NewCredentials(provider Provider) Credentials { c := &Credentials{ provider: provider, } return c } // GetWithContext returns the credentials value, or error if the credentials // Value failed to be retrieved. Will return early if the passed in context is // canceled. // // Will return the cached credentials Value if it has not expired. If the // credentials Value has expired the Provider's Retrieve() will be called // to refresh the credentials. // // If Credentials.Expire() was called the credentials Value will be force // expired, and the next call to Get() will cause them to be refreshed. func (c Credentials) GetWithContext(ctx context.Context) (Value, error) { // Check if credentials are cached, and not expired. select { case curCreds, ok := <-c.asyncIsExpired(): // ok will only be true, of the credentials were not expired. ok will // be false and have no value if the credentials are expired. if ok { return curCreds, nil } case <-ctx.Done(): return Value{}, awserr.New("RequestCanceled", "request context canceled", ctx.Err()) } // Cannot pass context down to the actual retrieve, because the first // context would cancel the whole group when there is not direct // association of items in the group. resCh := c.sf.DoChan("", func() (interface{}, error) { return c.singleRetrieve(&suppressedContext{ctx}) }) select { case res := <-resCh: return res.Val.(Value), res.Err case <-ctx.Done(): return Value{}, awserr.New("RequestCanceled", "request context canceled", ctx.Err()) } } func (c Credentials) singleRetrieve(ctx context.Context) (interface{}, error) { c.m.Lock() defer c.m.Unlock() if curCreds := c.creds; !c.isExpiredLocked(curCreds) { return curCreds, nil } var creds Value var err error if p, ok := c.provider.(ProviderWithContext); ok { creds, err = p.RetrieveWithContext(ctx) } else { creds, err = c.provider.Retrieve() } if err == nil { c.creds = creds } return creds, err } // asyncIsExpired returns a channel of credentials Value. If the channel is // closed the credentials are expired and credentials value are not empty. func (c Credentials) asyncIsExpired() <-chan Value { ch := make(chan Value, 1) go func() { c.m.RLock() defer c.m.RUnlock() if curCreds := c.creds; !c.isExpiredLocked(curCreds) { ch <- curCreds } close(ch) }() return ch } // isExpiredLocked helper method wrapping the definition of expired credentials. func (c Credentials) isExpiredLocked(creds interface{}) bool { return creds == nil \|\| creds.(Value) == Value{} \|\| c.provider.IsExpired() } type suppressedContext struct { context.Context } func (s suppressedContext) Deadline() (deadline time.Time, ok bool) { return time.Time{}, false } func (s suppressedContext) Done() <-chan struct{} { return nil } func (s suppressedContext) Err() error { return nil }	5.69 KB	2025-05-25 12:27
📄 credentials_test.go // Copyright (C) MongoDB, Inc. 2023-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 // // Based on github.com/aws/aws-sdk-go by Amazon.com, Inc. with code from: // - github.com/aws/aws-sdk-go/blob/v1.44.225/aws/credentials/credentials_test.go // See THIRD-PARTY-NOTICES for original license terms package credentials import ( "context" "sync" "testing" "time" "go.mongodb.org/mongo-driver/internal/aws/awserr" ) func isExpired(c Credentials) bool { c.m.RLock() defer c.m.RUnlock() return c.isExpiredLocked(c.creds) } type stubProvider struct { creds Value retrievedCount int expired bool err error } func (s stubProvider) Retrieve() (Value, error) { s.retrievedCount++ s.expired = false s.creds.ProviderName = "stubProvider" return s.creds, s.err } func (s stubProvider) IsExpired() bool { return s.expired } func TestCredentialsGet(t testing.T) { c := NewCredentials(&stubProvider{ creds: Value{ AccessKeyID: "AKID", SecretAccessKey: "SECRET", SessionToken: "", }, expired: true, }) creds, err := c.GetWithContext(context.Background()) if err != nil { t.Errorf("Expected no error, got %v", err) } if e, a := "AKID", creds.AccessKeyID; e != a { t.Errorf("Expect access key ID to match, %v got %v", e, a) } if e, a := "SECRET", creds.SecretAccessKey; e != a { t.Errorf("Expect secret access key to match, %v got %v", e, a) } if v := creds.SessionToken; len(v) != 0 { t.Errorf("Expect session token to be empty, %v", v) } } func TestCredentialsGetWithError(t testing.T) { c := NewCredentials(&stubProvider{err: awserr.New("provider error", "", nil), expired: true}) _, err := c.GetWithContext(context.Background()) if e, a := "provider error", err.(awserr.Error).Code(); e != a { t.Errorf("Expected provider error, %v got %v", e, a) } } func TestCredentialsExpire(t testing.T) { stub := &stubProvider{} c := NewCredentials(stub) stub.expired = false if !isExpired(c) { t.Errorf("Expected to start out expired") } _, err := c.GetWithContext(context.Background()) if err != nil { t.Errorf("Expected no err, got %v", err) } if isExpired(c) { t.Errorf("Expected not to be expired") } stub.expired = true if !isExpired(c) { t.Errorf("Expected to be expired") } } func TestCredentialsGetWithProviderName(t testing.T) { stub := &stubProvider{} c := NewCredentials(stub) creds, err := c.GetWithContext(context.Background()) if err != nil { t.Errorf("Expected no error, got %v", err) } if e, a := creds.ProviderName, "stubProvider"; e != a { t.Errorf("Expected provider name to match, %v got %v", e, a) } } type MockProvider struct { // The date/time when to expire on expiration time.Time // If set will be used by IsExpired to determine the current time. // Defaults to time.Now if CurrentTime is not set. Available for testing // to be able to mock out the current time. CurrentTime func() time.Time } // IsExpired returns if the credentials are expired. func (e MockProvider) IsExpired() bool { curTime := e.CurrentTime if curTime == nil { curTime = time.Now } return e.expiration.Before(curTime()) } func (MockProvider) Retrieve() (Value, error) { return Value{}, nil } func TestCredentialsIsExpired_Race(_ testing.T) { creds := NewChainCredentials([]Provider{&MockProvider{}}) starter := make(chan struct{}) var wg sync.WaitGroup wg.Add(10) for i := 0; i < 10; i++ { go func() { defer wg.Done() <-starter for i := 0; i < 100; i++ { isExpired(creds) } }() } close(starter) wg.Wait() } type stubProviderConcurrent struct { stubProvider done chan struct{} } func (s stubProviderConcurrent) Retrieve() (Value, error) { <-s.done return s.stubProvider.Retrieve() } func TestCredentialsGetConcurrent(t testing.T) { stub := &stubProviderConcurrent{ done: make(chan struct{}), } c := NewCredentials(stub) done := make(chan struct{}) for i := 0; i < 2; i++ { go func() { _, err := c.GetWithContext(context.Background()) if err != nil { t.Errorf("Expected no err, got %v", err) } done <- struct{}{} }() } // Validates that a single call to Retrieve is shared between two calls to Get stub.done <- struct{}{} <-done <-done }	4.33 KB	2025-05-25 12:27

Terminal