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
📄 README.md ## Performance Utility Downloads an Object from an S3 bucket in a loop for a set number of iterations or time limit. The utility outputs the connection and SDK timing metrics in CSV format.	192 B	2025-05-25 12:27
📄 client.go //go:build integration && perftest // +build integration,perftest package main import ( "net" "net/http" "time" ) func NewClient(cfg ClientConfig) http.Client { tr := &http.Transport{ Proxy: http.ProxyFromEnvironment, DialContext: (&net.Dialer{ Timeout: cfg.Timeouts.Connect, KeepAlive: 30 time.Second, DualStack: true, }).DialContext, MaxIdleConns: 100, IdleConnTimeout: 90 * time.Second, DisableKeepAlives: !cfg.KeepAlive, TLSHandshakeTimeout: cfg.Timeouts.TLSHandshake, ExpectContinueTimeout: cfg.Timeouts.ExpectContinue, ResponseHeaderTimeout: cfg.Timeouts.ResponseHeader, } return &http.Client{ Transport: tr, } }	674 B	2025-05-25 12:27
📄 config.go //go:build integration && perftest // +build integration,perftest package main import ( "flag" "fmt" "net/http" "strings" "time" ) type Config struct { RequestDuration time.Duration RequestCount int64 RequestDelay time.Duration Endpoint string Bucket, Key string SDK SDKConfig Client ClientConfig } func (c Config) SetupFlags(prefix string, flagset flag.FlagSet) { flagset.DurationVar(&c.RequestDuration, "duration", 0, "The duration to make requests for. Use instead of count for specific running duration.") flagset.Int64Var(&c.RequestCount, "count", 0, "The total `number` of requests to make. Use instead of duration for specific count.") flagset.DurationVar(&c.RequestDelay, "delay", 0, "The detail between sequential requests.") flagset.StringVar(&c.Endpoint, prefix+"endpoint", "", "Optional overridden endpoint S3 client will connect to.") flagset.StringVar(&c.Bucket, "bucket", "", "The S3 bucket `name` to request the object from.") flagset.StringVar(&c.Key, "key", "", "The S3 object key `name` to request the object from.") c.SDK.SetupFlags(prefix, flagset) c.Client.SetupFlags(prefix, flagset) } func (c Config) Validate() error { var errs Errors if c.RequestDuration != 0 && c.RequestCount != 0 { errs = append(errs, fmt.Errorf("duration and count canot be used together")) } if c.RequestDuration == 0 && c.RequestCount == 0 { errs = append(errs, fmt.Errorf("duration or count must be provided")) } if len(c.Bucket) == 0 \|\| len(c.Key) == 0 { errs = append(errs, fmt.Errorf("bucket and key are required")) } if err := c.SDK.Validate(); err != nil { errs = append(errs, err) } if err := c.Client.Validate(); err != nil { errs = append(errs, err) } if len(errs) != 0 { return errs } return nil } type SDKConfig struct { Anonymous bool ExpectContinue bool } func (c SDKConfig) SetupFlags(prefix string, flagset flag.FlagSet) { prefix += "sdk." flagset.BoolVar(&c.Anonymous, prefix+"anonymous", false, "Specifies if the SDK will make requests anonymously, and unsigned.") c.ExpectContinue = true // flagset.BoolVar(&c.ExpectContinue, prefix+"100-continue", true, // "Specifies if the SDK requests will wait for the 100 continue response before sending request payload.") } func (c SDKConfig) Validate() error { return nil } type ClientConfig struct { KeepAlive bool Timeouts Timeouts } func (c ClientConfig) SetupFlags(prefix string, flagset flag.FlagSet) { prefix += "client." flagset.BoolVar(&c.KeepAlive, prefix+"http-keep-alive", true, "Specifies if HTTP keep alive is enabled.") c.Timeouts.SetupFlags(prefix, flagset) } func (c ClientConfig) Validate() error { var errs Errors if err := c.Timeouts.Validate(); err != nil { errs = append(errs, err) } if len(errs) != 0 { return errs } return nil } type Timeouts struct { Connect time.Duration TLSHandshake time.Duration ExpectContinue time.Duration ResponseHeader time.Duration } func (c Timeouts) SetupFlags(prefix string, flagset flag.FlagSet) { prefix += "timeout." flagset.DurationVar(&c.Connect, prefix+"connect", 30time.Second, "The `timeout` connecting to the remote host.") defTR := http.DefaultTransport.(http.Transport) flagset.DurationVar(&c.TLSHandshake, prefix+"tls", defTR.TLSHandshakeTimeout, "The `timeout` waiting for the TLS handshake to complete.") c.ExpectContinue = defTR.ExpectContinueTimeout // flagset.DurationVar(&c.ExpectContinue, prefix+"expect-continue", defTR.ExpectContinueTimeout, // "The `timeout` waiting for the TLS handshake to complete.") flagset.DurationVar(&c.ResponseHeader, prefix+"response-header", defTR.ResponseHeaderTimeout, "The `timeout` waiting for the TLS handshake to complete.") } func (c Timeouts) Validate() error { return nil } type Errors []error func (es Errors) Error() string { var buf strings.Builder for _, e := range es { buf.WriteString(e.Error()) } return buf.String() }	3.89 KB	2025-05-25 12:27
📄 logger.go //go:build integration && perftest // +build integration,perftest package main import ( "encoding/csv" "fmt" "io" "os" "strconv" "strings" "time" ) type Logger struct { out csv.Writer } func NewLogger(writer io.Writer) Logger { l := &Logger{ out: csv.NewWriter(writer), } err := l.out.Write([]string{ "ID", "Attempt", "Latency", "DNSStart", "DNSDone", "DNSDur", "ConnectStart", "ConnectDone", "ConnectDur", "TLSStart", "TLSDone", "TLSDur", "WriteReq", "RespFirstByte", "WaitRespFirstByte", "Error", }) if err != nil { fmt.Fprintf(os.Stderr, "failed to write header trace, %v\n", err) } return l } func (l Logger) RecordTrace(trace RequestTrace) { req := RequestReport{ ID: trace.ID, TotalLatency: durToMSString(trace.TotalLatency()), Retries: trace.Retries(), } for i, a := range trace.Attempts() { attempt := AttemptReport{ Reused: a.Reused, SDKMarshal: durToMSString(a.SendStart.Sub(a.Start)), ReqWritten: durToMSString(a.RequestWritten.Sub(a.SendStart)), Latency: durToMSString(a.Finish.Sub(a.Start)), Err: a.Err, } if !a.FirstResponseByte.IsZero() { attempt.RespFirstByte = durToMSString(a.FirstResponseByte.Sub(a.SendStart)) attempt.WaitRespFirstByte = durToMSString(a.FirstResponseByte.Sub(a.RequestWritten)) } if !a.Reused { attempt.DNSStart = durToMSString(a.DNSStart.Sub(a.SendStart)) attempt.DNSDone = durToMSString(a.DNSDone.Sub(a.SendStart)) attempt.DNS = durToMSString(a.DNSDone.Sub(a.DNSStart)) attempt.ConnectStart = durToMSString(a.ConnectStart.Sub(a.SendStart)) attempt.ConnectDone = durToMSString(a.ConnectDone.Sub(a.SendStart)) attempt.Connect = durToMSString(a.ConnectDone.Sub(a.ConnectStart)) attempt.TLSHandshakeStart = durToMSString(a.TLSHandshakeStart.Sub(a.SendStart)) attempt.TLSHandshakeDone = durToMSString(a.TLSHandshakeDone.Sub(a.SendStart)) attempt.TLSHandshake = durToMSString(a.TLSHandshakeDone.Sub(a.TLSHandshakeStart)) } req.Attempts = append(req.Attempts, attempt) var reqErr string if attempt.Err != nil { reqErr = strings.Replace(attempt.Err.Error(), "\n", `\n`, -1) } err := l.out.Write([]string{ strconv.Itoa(int(req.ID)), strconv.Itoa(i + 1), attempt.Latency, attempt.DNSStart, attempt.DNSDone, attempt.DNS, attempt.ConnectStart, attempt.ConnectDone, attempt.Connect, attempt.TLSHandshakeStart, attempt.TLSHandshakeDone, attempt.TLSHandshake, attempt.ReqWritten, attempt.RespFirstByte, attempt.WaitRespFirstByte, reqErr, }) if err != nil { fmt.Fprintf(os.Stderr, "failed to write request trace, %v\n", err) } l.out.Flush() } } func durToMSString(v time.Duration) string { ms := float64(v) / float64(time.Millisecond) return fmt.Sprintf("%0.6f", ms) } type RequestReport struct { ID int64 TotalLatency string Retries int Attempts []AttemptReport } type AttemptReport struct { Reused bool Err error SDKMarshal string `json:",omitempty"` DNSStart string `json:",omitempty"` DNSDone string `json:",omitempty"` DNS string `json:",omitempty"` ConnectStart string `json:",omitempty"` ConnectDone string `json:",omitempty"` Connect string `json:",omitempty"` TLSHandshakeStart string `json:",omitempty"` TLSHandshakeDone string `json:",omitempty"` TLSHandshake string `json:",omitempty"` ReqWritten string `json:",omitempty"` RespFirstByte string `json:",omitempty"` WaitRespFirstByte string `json:",omitempty"` Latency string `json:",omitempty"` }	3.49 KB	2025-05-25 12:27
📄 main.go //go:build integration && perftest // +build integration,perftest package main import ( "context" "flag" "fmt" "io" "io/ioutil" "os" "os/signal" "time" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/credentials" "github.com/aws/aws-sdk-go/aws/request" "github.com/aws/aws-sdk-go/aws/session" "github.com/aws/aws-sdk-go/service/s3" ) var config Config func init() { config.SetupFlags("", flag.CommandLine) } func main() { if err := flag.CommandLine.Parse(os.Args[1:]); err != nil { flag.CommandLine.PrintDefaults() exitErrorf(err, "failed to parse CLI commands") } if err := config.Validate(); err != nil { flag.CommandLine.PrintDefaults() exitErrorf(err, "invalid arguments") } client := NewClient(config.Client) var creds credentials.Credentials if config.SDK.Anonymous { creds = credentials.AnonymousCredentials } var endpoint string if v := config.Endpoint; len(v) != 0 { endpoint = &v } sess, err := session.NewSession(&aws.Config{ HTTPClient: client, Endpoint: endpoint, Credentials: creds, S3Disable100Continue: aws.Bool(!config.SDK.ExpectContinue), }) if err != nil { exitErrorf(err, "failed to load config") } // Create context cancel for Ctrl+C/Interrupt ctx, cancelFn := context.WithCancel(context.Background()) defer cancelFn() sigCh := make(chan os.Signal, 1) signal.Notify(sigCh, os.Interrupt) go func() { <-sigCh cancelFn() }() // Use the request duration timeout if specified. if config.RequestDuration != 0 { var timeoutFn func() ctx, timeoutFn = context.WithTimeout(ctx, config.RequestDuration) defer timeoutFn() } logger := NewLogger(os.Stdout) // Start making the requests. svc := s3.New(sess) var reqCount int64 errCount := 0 for { trace := doRequest(ctx, reqCount, svc, config) select { case <-ctx.Done(): return default: } logger.RecordTrace(trace) if err := trace.Err(); err != nil { fmt.Fprintf(os.Stderr, err.Error()) errCount++ } else { errCount = 0 } if config.RequestCount > 0 && reqCount == config.RequestCount { return } reqCount++ // If the first several requests fail, exist, something is broken. if errCount == 5 && reqCount == 5 { exitErrorf(trace.Err(), "unable to make requests") } if config.RequestDelay > 0 { time.Sleep(config.RequestDelay) } } } func doRequest(ctx context.Context, id int64, svc s3.S3, config Config) RequestTrace { traceCtx := NewRequestTrace(ctx, id) defer traceCtx.RequestDone() resp, err := svc.GetObjectWithContext(traceCtx, &s3.GetObjectInput{ Bucket: &config.Bucket, Key: &config.Key, }, func(r *request.Request) { r.Handlers.Send.PushFront(traceCtx.OnSendAttempt) r.Handlers.Complete.PushBack(traceCtx.OnCompleteRequest) r.Handlers.CompleteAttempt.PushBack(traceCtx.OnCompleteAttempt) }) if err != nil { traceCtx.AppendError(fmt.Errorf("request failed, %v", err)) return traceCtx } defer resp.Body.Close() if n, err := io.Copy(ioutil.Discard, resp.Body); err != nil { traceCtx.AppendError(fmt.Errorf("read request body failed, read %v, %v", n, err)) return traceCtx } return traceCtx } func exitErrorf(err error, msg string, args ...interface{}) { fmt.Fprintf(os.Stderr, "FAILED: %v\n"+msg+"\n", append([]interface{}{err}, args...)...) os.Exit(1) }	3.28 KB	2025-05-25 12:27
📄 trace.go //go:build integration && perftest // +build integration,perftest package main import ( "context" "crypto/tls" "net/http/httptrace" "time" "github.com/aws/aws-sdk-go/aws/request" ) type RequestTrace struct { ID int64 context.Context start, finish time.Time errs Errors attempts []RequestAttempt curAttempt RequestAttempt } func NewRequestTrace(ctx context.Context, id int64) RequestTrace { rt := &RequestTrace{ ID: id, start: time.Now(), attempts: []RequestAttempt{}, } trace := &httptrace.ClientTrace{ GetConn: rt.getConn, GotConn: rt.gotConn, PutIdleConn: rt.putIdleConn, GotFirstResponseByte: rt.gotFirstResponseByte, Got100Continue: rt.got100Continue, DNSStart: rt.dnsStart, DNSDone: rt.dnsDone, ConnectStart: rt.connectStart, ConnectDone: rt.connectDone, TLSHandshakeStart: rt.tlsHandshakeStart, TLSHandshakeDone: rt.tlsHandshakeDone, WroteHeaders: rt.wroteHeaders, Wait100Continue: rt.wait100Continue, WroteRequest: rt.wroteRequest, } rt.Context = httptrace.WithClientTrace(ctx, trace) return rt } func (rt RequestTrace) AppendError(err error) { rt.errs = append(rt.errs, err) } func (rt RequestTrace) OnCompleteAttempt(r request.Request) { rt.curAttempt.Start = r.AttemptTime rt.curAttempt.Finish = time.Now() rt.curAttempt.Err = r.Error rt.attempts = append(rt.attempts, rt.curAttempt) rt.curAttempt = RequestAttempt{} } func (rt RequestTrace) OnSendAttempt(r request.Request) { rt.curAttempt.SendStart = time.Now() } func (rt RequestTrace) OnCompleteRequest(r request.Request) {} func (rt RequestTrace) RequestDone() { rt.finish = time.Now() // Last attempt includes reading the response body rt.attempts[len(rt.attempts)-1].Finish = rt.finish } func (rt RequestTrace) Err() error { return rt.errs } func (rt RequestTrace) TotalLatency() time.Duration { return rt.finish.Sub(rt.start) } func (rt RequestTrace) Attempts() []RequestAttempt { return rt.attempts } func (rt RequestTrace) Retries() int { return len(rt.attempts) - 1 } func (rt RequestTrace) getConn(hostPort string) {} func (rt RequestTrace) gotConn(info httptrace.GotConnInfo) { rt.curAttempt.Reused = info.Reused } func (rt RequestTrace) putIdleConn(err error) {} func (rt RequestTrace) gotFirstResponseByte() { rt.curAttempt.FirstResponseByte = time.Now() } func (rt RequestTrace) got100Continue() {} func (rt RequestTrace) dnsStart(info httptrace.DNSStartInfo) { rt.curAttempt.DNSStart = time.Now() } func (rt RequestTrace) dnsDone(info httptrace.DNSDoneInfo) { rt.curAttempt.DNSDone = time.Now() } func (rt RequestTrace) connectStart(network, addr string) { rt.curAttempt.ConnectStart = time.Now() } func (rt RequestTrace) connectDone(network, addr string, err error) { rt.curAttempt.ConnectDone = time.Now() } func (rt RequestTrace) tlsHandshakeStart() { rt.curAttempt.TLSHandshakeStart = time.Now() } func (rt RequestTrace) tlsHandshakeDone(state tls.ConnectionState, err error) { rt.curAttempt.TLSHandshakeDone = time.Now() } func (rt RequestTrace) wroteHeaders() {} func (rt RequestTrace) wait100Continue() {} func (rt *RequestTrace) wroteRequest(info httptrace.WroteRequestInfo) { rt.curAttempt.RequestWritten = time.Now() } type RequestAttempt struct { Start, Finish time.Time SendStart time.Time Err error Reused bool DNSStart, DNSDone time.Time ConnectStart, ConnectDone time.Time TLSHandshakeStart, TLSHandshakeDone time.Time RequestWritten time.Time FirstResponseByte time.Time }	3.61 KB	2025-05-25 12:27

Terminal