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
📄 cache.go package crr import ( "sync/atomic" ) // EndpointCache is an LRU cache that holds a series of endpoints // based on some key. The datastructure makes use of a read write // mutex to enable asynchronous use. type EndpointCache struct { // size is used to count the number elements in the cache. // The atomic package is used to ensure this size is accurate when // using multiple goroutines. size int64 endpoints syncMap endpointLimit int64 } // NewEndpointCache will return a newly initialized cache with a limit // of endpointLimit entries. func NewEndpointCache(endpointLimit int64) EndpointCache { return &EndpointCache{ endpointLimit: endpointLimit, endpoints: newSyncMap(), } } // get is a concurrent safe get operation that will retrieve an endpoint // based on endpointKey. A boolean will also be returned to illustrate whether // or not the endpoint had been found. func (c EndpointCache) get(endpointKey string) (Endpoint, bool) { endpoint, ok := c.endpoints.Load(endpointKey) if !ok { return Endpoint{}, false } ev := endpoint.(Endpoint) ev.Prune() c.endpoints.Store(endpointKey, ev) return endpoint.(Endpoint), true } // Has returns if the enpoint cache contains a valid entry for the endpoint key // provided. func (c EndpointCache) Has(endpointKey string) bool { endpoint, ok := c.get(endpointKey) _, found := endpoint.GetValidAddress() return ok && found } // Get will retrieve a weighted address based off of the endpoint key. If an endpoint // should be retrieved, due to not existing or the current endpoint has expired // the Discoverer object that was passed in will attempt to discover a new endpoint // and add that to the cache. func (c EndpointCache) Get(d Discoverer, endpointKey string, required bool) (WeightedAddress, error) { var err error endpoint, ok := c.get(endpointKey) weighted, found := endpoint.GetValidAddress() shouldGet := !ok \|\| !found if required && shouldGet { if endpoint, err = c.discover(d, endpointKey); err != nil { return WeightedAddress{}, err } weighted, _ = endpoint.GetValidAddress() } else if shouldGet { go c.discover(d, endpointKey) } return weighted, nil } // Add is a concurrent safe operation that will allow new endpoints to be added // to the cache. If the cache is full, the number of endpoints equal endpointLimit, // then this will remove the oldest entry before adding the new endpoint. func (c EndpointCache) Add(endpoint Endpoint) { // de-dups multiple adds of an endpoint with a pre-existing key if iface, ok := c.endpoints.Load(endpoint.Key); ok { e := iface.(Endpoint) if e.Len() > 0 { return } } c.endpoints.Store(endpoint.Key, endpoint) size := atomic.AddInt64(&c.size, 1) if size > 0 && size > c.endpointLimit { c.deleteRandomKey() } } // deleteRandomKey will delete a random key from the cache. If // no key was deleted false will be returned. func (c EndpointCache) deleteRandomKey() bool { atomic.AddInt64(&c.size, -1) found := false c.endpoints.Range(func(key, value interface{}) bool { found = true c.endpoints.Delete(key) return false }) return found } // discover will get and store and endpoint using the Discoverer. func (c *EndpointCache) discover(d Discoverer, endpointKey string) (Endpoint, error) { endpoint, err := d.Discover() if err != nil { return Endpoint{}, err } endpoint.Key = endpointKey c.Add(endpoint) return endpoint, nil }	3.37 KB	2025-05-25 12:27
📄 cache_test.go package crr import ( "net/url" "reflect" "testing" "time" ) func urlParse(uri string) url.URL { u, _ := url.Parse(uri) return u } func TestCacheAdd(t testing.T) { cases := []struct { limit int64 endpoints []Endpoint validKeys map[string]Endpoint expectedSize int }{ { limit: 5, endpoints: []Endpoint{ { Key: "foo", Addresses: []WeightedAddress{ { URL: urlParse("http://0"), }, }, }, { Key: "bar", Addresses: []WeightedAddress{ { URL: urlParse("http://1"), }, }, }, { Key: "baz", Addresses: []WeightedAddress{ { URL: urlParse("http://2"), }, }, }, { Key: "qux", Addresses: []WeightedAddress{ { URL: urlParse("http://3"), }, }, }, { Key: "moo", Addresses: []WeightedAddress{ { URL: urlParse("http://4"), }, }, }, }, validKeys: map[string]Endpoint{ "foo": { Key: "foo", Addresses: []WeightedAddress{ { URL: urlParse("http://0"), }, }, }, "bar": { Key: "bar", Addresses: []WeightedAddress{ { URL: urlParse("http://1"), }, }, }, "baz": { Key: "baz", Addresses: []WeightedAddress{ { URL: urlParse("http://2"), }, }, }, "qux": { Key: "qux", Addresses: []WeightedAddress{ { URL: urlParse("http://3"), }, }, }, "moo": { Key: "moo", Addresses: []WeightedAddress{ { URL: urlParse("http://4"), }, }, }, }, expectedSize: 5, }, { limit: 2, endpoints: []Endpoint{ { Key: "bar", Addresses: []WeightedAddress{ { URL: urlParse("http://1"), }, }, }, { Key: "foo", Addresses: []WeightedAddress{ { URL: urlParse("http://0"), }, }, }, { Key: "baz", Addresses: []WeightedAddress{ { URL: urlParse("http://2"), }, }, }, { Key: "qux", Addresses: []WeightedAddress{ { URL: urlParse("http://3"), }, }, }, { Key: "moo", Addresses: []WeightedAddress{ { URL: urlParse("http://4"), }, }, }, }, validKeys: map[string]Endpoint{ "foo": { Key: "foo", Addresses: []WeightedAddress{ { URL: urlParse("http://0"), }, }, }, "bar": { Key: "bar", Addresses: []WeightedAddress{ { URL: urlParse("http://1"), }, }, }, "baz": { Key: "baz", Addresses: []WeightedAddress{ { URL: urlParse("http://2"), }, }, }, "qux": { Key: "qux", Addresses: []WeightedAddress{ { URL: urlParse("http://3"), }, }, }, "moo": { Key: "moo", Addresses: []WeightedAddress{ { URL: urlParse("http://4"), }, }, }, }, expectedSize: 2, }, } for _, c := range cases { cache := NewEndpointCache(c.limit) for _, endpoint := range c.endpoints { cache.Add(endpoint) } count := 0 endpoints := map[string]Endpoint{} cache.endpoints.Range(func(key, value interface{}) bool { count++ endpoints[key.(string)] = value.(Endpoint) return true }) if e, a := c.expectedSize, cache.size; int64(e) != a { t.Errorf("expected %v, but received %v", e, a) } if e, a := c.expectedSize, count; e != a { t.Errorf("expected %v, but received %v", e, a) } for k, ep := range endpoints { endpoint, ok := c.validKeys[k] if !ok { t.Errorf("unrecognized key %q in cache", k) } if e, a := endpoint, ep; !reflect.DeepEqual(e, a) { t.Errorf("expected %v, but received %v", e, a) } } } } func TestCacheGet(t testing.T) { cases := []struct { addEndpoints []Endpoint validKeys map[string]Endpoint limit int64 }{ { limit: 5, addEndpoints: []Endpoint{ { Key: "foo", Addresses: []WeightedAddress{ { URL: urlParse("http://0"), }, }, }, { Key: "bar", Addresses: []WeightedAddress{ { URL: urlParse("http://1"), }, }, }, { Key: "baz", Addresses: []WeightedAddress{ { URL: urlParse("http://2"), }, }, }, { Key: "qux", Addresses: []WeightedAddress{ { URL: urlParse("http://3"), }, }, }, { Key: "moo", Addresses: []WeightedAddress{ { URL: urlParse("http://4"), }, }, }, }, validKeys: map[string]Endpoint{ "foo": { Key: "foo", Addresses: []WeightedAddress{ { URL: urlParse("http://0"), }, }, }, "bar": { Key: "bar", Addresses: []WeightedAddress{ { URL: urlParse("http://1"), }, }, }, "baz": { Key: "baz", Addresses: []WeightedAddress{ { URL: urlParse("http://2"), }, }, }, "qux": { Key: "qux", Addresses: []WeightedAddress{ { URL: urlParse("http://3"), }, }, }, "moo": { Key: "moo", Addresses: []WeightedAddress{ { URL: urlParse("http://4"), }, }, }, }, }, { limit: 2, addEndpoints: []Endpoint{ { Key: "bar", Addresses: []WeightedAddress{ { URL: urlParse("http://1"), }, }, }, { Key: "foo", Addresses: []WeightedAddress{ { URL: urlParse("http://0"), }, }, }, { Key: "baz", Addresses: []WeightedAddress{ { URL: urlParse("http://2"), }, }, }, { Key: "qux", Addresses: []WeightedAddress{ { URL: urlParse("http://3"), }, }, }, { Key: "moo", Addresses: []WeightedAddress{ { URL: urlParse("http://4"), }, }, }, }, validKeys: map[string]Endpoint{ "foo": { Key: "foo", Addresses: []WeightedAddress{ { URL: urlParse("http://0"), }, }, }, "bar": { Key: "bar", Addresses: []WeightedAddress{ { URL: urlParse("http://1"), }, }, }, "baz": { Key: "baz", Addresses: []WeightedAddress{ { URL: urlParse("http://2"), }, }, }, "qux": { Key: "qux", Addresses: []WeightedAddress{ { URL: urlParse("http://3"), }, }, }, "moo": { Key: "moo", Addresses: []WeightedAddress{ { URL: urlParse("http://4"), }, }, }, }, }, } for _, c := range cases { cache := NewEndpointCache(c.limit) for _, endpoint := range c.addEndpoints { cache.Add(endpoint) } keys := []string{} cache.endpoints.Range(func(key, value interface{}) bool { a := value.(Endpoint) e, ok := c.validKeys[key.(string)] if !ok { t.Errorf("unrecognized key %q in cache", key.(string)) } if !reflect.DeepEqual(e, a) { t.Errorf("expected %v, but received %v", e, a) } keys = append(keys, key.(string)) return true }) for _, key := range keys { a, ok := cache.get(key) if !ok { t.Errorf("expected key to be present: %q", key) } e := c.validKeys[key] if !reflect.DeepEqual(e, a) { t.Errorf("expected %v, but received %v", e, a) } } } } func TestEndpointCache_Get_prune(t testing.T) { c := NewEndpointCache(2) c.Add(Endpoint{ Key: "foo", Addresses: []WeightedAddress{ { URL: &url.URL{ Host: "foo.amazonaws.com", }, Expired: time.Now().Add(5 * time.Minute), }, { URL: &url.URL{ Host: "bar.amazonaws.com", }, Expired: time.Now().Add(5 * -time.Minute), }, }, }) load, _ := c.endpoints.Load("foo") if ev := load.(Endpoint); len(ev.Addresses) != 2 { t.Errorf("expected two weighted addresses") } weightedAddress, err := c.Get(nil, "foo", false) if err != nil { t.Errorf("expect no error, got %v", err) } if e, a := "foo.amazonaws.com", weightedAddress.URL.Host; e != a { t.Errorf("expect %v, got %v", e, a) } load, _ = c.endpoints.Load("foo") if ev := load.(Endpoint); len(ev.Addresses) != 1 { t.Errorf("expected one weighted address") } }	8.2 KB	2025-05-25 12:27
📄 endpoint.go package crr import ( "net/url" "sort" "strings" "time" "github.com/aws/aws-sdk-go/aws" ) // Endpoint represents an endpoint used in endpoint discovery. type Endpoint struct { Key string Addresses WeightedAddresses } // WeightedAddresses represents a list of WeightedAddress. type WeightedAddresses []WeightedAddress // WeightedAddress represents an address with a given weight. type WeightedAddress struct { URL url.URL Expired time.Time } // HasExpired will return whether or not the endpoint has expired with // the exception of a zero expiry meaning does not expire. func (e WeightedAddress) HasExpired() bool { return e.Expired.Before(time.Now()) } // Add will add a given WeightedAddress to the address list of Endpoint. func (e Endpoint) Add(addr WeightedAddress) { e.Addresses = append(e.Addresses, addr) } // Len returns the number of valid endpoints where valid means the endpoint // has not expired. func (e Endpoint) Len() int { validEndpoints := 0 for _, endpoint := range e.Addresses { if endpoint.HasExpired() { continue } validEndpoints++ } return validEndpoints } // GetValidAddress will return a non-expired weight endpoint func (e Endpoint) GetValidAddress() (WeightedAddress, bool) { for i := 0; i < len(e.Addresses); i++ { we := e.Addresses[i] if we.HasExpired() { e.Addresses = append(e.Addresses[:i], e.Addresses[i+1:]...) i-- continue } we.URL = cloneURL(we.URL) return we, true } return WeightedAddress{}, false } // Prune will prune the expired addresses from the endpoint by allocating a new []WeightAddress. // This is not concurrent safe, and should be called from a single owning thread. func (e Endpoint) Prune() bool { validLen := e.Len() if validLen == len(e.Addresses) { return false } wa := make([]WeightedAddress, 0, validLen) for i := range e.Addresses { if e.Addresses[i].HasExpired() { continue } wa = append(wa, e.Addresses[i]) } e.Addresses = wa return true } // Discoverer is an interface used to discovery which endpoint hit. This // allows for specifics about what parameters need to be used to be contained // in the Discoverer implementor. type Discoverer interface { Discover() (Endpoint, error) } // BuildEndpointKey will sort the keys in alphabetical order and then retrieve // the values in that order. Those values are then concatenated together to form // the endpoint key. func BuildEndpointKey(params map[string]string) string { keys := make([]string, len(params)) i := 0 for k := range params { keys[i] = k i++ } sort.Strings(keys) values := make([]string, len(params)) for i, k := range keys { if params[k] == nil { continue } values[i] = aws.StringValue(params[k]) } return strings.Join(values, ".") } func cloneURL(u url.URL) (clone url.URL) { clone = &url.URL{} clone = u if u.User != nil { user := *u.User clone.User = &user } return clone }	2.87 KB	2025-05-25 12:27
📄 endpoint_test.go //go:build go1.16 // +build go1.16 package crr import ( "net/url" "reflect" "strconv" "testing" "time" ) func Test_cloneURL(t testing.T) { tests := []struct { value url.URL wantClone url.URL }{ { value: &url.URL{ Scheme: "https", Opaque: "foo", User: nil, Host: "amazonaws.com", Path: "/", RawPath: "/", ForceQuery: true, RawQuery: "thing=value", Fragment: "1234", RawFragment: "1234", }, wantClone: &url.URL{ Scheme: "https", Opaque: "foo", User: nil, Host: "amazonaws.com", Path: "/", RawPath: "/", ForceQuery: true, RawQuery: "thing=value", Fragment: "1234", RawFragment: "1234", }, }, { value: &url.URL{ Scheme: "https", Opaque: "foo", User: url.UserPassword("NOT", "VALID"), Host: "amazonaws.com", Path: "/", RawPath: "/", ForceQuery: true, RawQuery: "thing=value", Fragment: "1234", RawFragment: "1234", }, wantClone: &url.URL{ Scheme: "https", Opaque: "foo", User: url.UserPassword("NOT", "VALID"), Host: "amazonaws.com", Path: "/", RawPath: "/", ForceQuery: true, RawQuery: "thing=value", Fragment: "1234", RawFragment: "1234", }, }, } for i, tt := range tests { t.Run(strconv.Itoa(i), func(t testing.T) { gotClone := cloneURL(tt.value) if gotClone == tt.value { t.Errorf("expct clone URL to not be same pointer address") } if tt.value.User != nil { if tt.value.User == gotClone.User { t.Errorf("expct cloned Userinfo to not be same pointer address") } } if !reflect.DeepEqual(gotClone, tt.wantClone) { t.Errorf("cloneURL() = %v, want %v", gotClone, tt.wantClone) } }) } } func TestEndpoint_Prune(t testing.T) { endpoint := Endpoint{} endpoint.Add(WeightedAddress{ URL: &url.URL{}, Expired: time.Now().Add(5 time.Minute), }) initial := endpoint.Addresses if e, a := false, endpoint.Prune(); e != a { t.Errorf("expect prune %v, got %v", e, a) } if e, a := &initial[0], &endpoint.Addresses[0]; e != a { t.Errorf("expect slice address to be same") } endpoint.Add(WeightedAddress{ URL: &url.URL{}, Expired: time.Now().Add(5 * -time.Minute), }) initial = endpoint.Addresses if e, a := true, endpoint.Prune(); e != a { t.Errorf("expect prune %v, got %v", e, a) } if e, a := &initial[0], &endpoint.Addresses[0]; e == a { t.Errorf("expect slice address to be different") } if e, a := 1, endpoint.Len(); e != a { t.Errorf("expect slice length %v, got %v", e, a) } }	2.69 KB	2025-05-25 12:27
📄 sync_map.go //go:build go1.9 // +build go1.9 package crr import ( "sync" ) type syncMap sync.Map func newSyncMap() syncMap { return syncMap{} } func (m syncMap) Load(key interface{}) (interface{}, bool) { return (sync.Map)(m).Load(key) } func (m syncMap) Store(key interface{}, value interface{}) { (sync.Map)(m).Store(key, value) } func (m syncMap) Delete(key interface{}) { (sync.Map)(m).Delete(key) } func (m syncMap) Range(f func(interface{}, interface{}) bool) { (sync.Map)(m).Range(f) }	503 B	2025-05-25 12:27
📄 sync_map_1_8.go //go:build !go1.9 // +build !go1.9 package crr import ( "sync" ) type syncMap struct { container map[interface{}]interface{} lock sync.RWMutex } func newSyncMap() syncMap { return syncMap{ container: map[interface{}]interface{}{}, } } func (m syncMap) Load(key interface{}) (interface{}, bool) { m.lock.RLock() defer m.lock.RUnlock() v, ok := m.container[key] return v, ok } func (m syncMap) Store(key interface{}, value interface{}) { m.lock.Lock() defer m.lock.Unlock() m.container[key] = value } func (m syncMap) Delete(key interface{}) { m.lock.Lock() defer m.lock.Unlock() delete(m.container, key) } func (m syncMap) Range(f func(interface{}, interface{}) bool) { for k, v := range m.container { if !f(k, v) { return } } }	774 B	2025-05-25 12:27
📄 sync_map_test.go package crr import ( "reflect" "testing" ) func TestRangeDelete(t testing.T) { m := newSyncMap() for i := 0; i < 10; i++ { m.Store(i, i10) } m.Range(func(key, value interface{}) bool { m.Delete(key) return true }) expectedMap := map[interface{}]interface{}{} actualMap := map[interface{}]interface{}{} m.Range(func(key, value interface{}) bool { actualMap[key] = value return true }) if e, a := len(expectedMap), len(actualMap); e != a { t.Errorf("expected map size %d, but received %d", e, a) } if e, a := expectedMap, actualMap; !reflect.DeepEqual(e, a) { t.Errorf("expected %v, but received %v", e, a) } } func TestRangeStore(t testing.T) { m := newSyncMap() for i := 0; i < 10; i++ { m.Store(i, i10) } m.Range(func(key, value interface{}) bool { v := value.(int) m.Store(key, v+1) return true }) expectedMap := map[interface{}]interface{}{ 0: 1, 1: 11, 2: 21, 3: 31, 4: 41, 5: 51, 6: 61, 7: 71, 8: 81, 9: 91, } actualMap := map[interface{}]interface{}{} m.Range(func(key, value interface{}) bool { actualMap[key] = value return true }) if e, a := len(expectedMap), len(actualMap); e != a { t.Errorf("expected map size %d, but received %d", e, a) } if e, a := expectedMap, actualMap; !reflect.DeepEqual(e, a) { t.Errorf("expected %v, but received %v", e, a) } } func TestRangeGet(t testing.T) { m := newSyncMap() for i := 0; i < 10; i++ { m.Store(i, i10) } m.Range(func(key, value interface{}) bool { m.Load(key) return true }) expectedMap := map[interface{}]interface{}{ 0: 0, 1: 10, 2: 20, 3: 30, 4: 40, 5: 50, 6: 60, 7: 70, 8: 80, 9: 90, } actualMap := map[interface{}]interface{}{} m.Range(func(key, value interface{}) bool { actualMap[key] = value return true }) if e, a := len(expectedMap), len(actualMap); e != a { t.Errorf("expected map size %d, but received %d", e, a) } if e, a := expectedMap, actualMap; !reflect.DeepEqual(e, a) { t.Errorf("expected %v, but received %v", e, a) } }	2 KB	2025-05-25 12:27

Terminal