id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequencelengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
sequencelengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
149,300 | vulcand/oxy | cbreaker/fallback.go | NewResponseFallbackWithLogger | func NewResponseFallbackWithLogger(r Response, l *log.Logger) (*ResponseFallback, error) {
if r.StatusCode == 0 {
return nil, fmt.Errorf("response code should not be 0")
}
return &ResponseFallback{r: r, log: l}, nil
} | go | func NewResponseFallbackWithLogger(r Response, l *log.Logger) (*ResponseFallback, error) {
if r.StatusCode == 0 {
return nil, fmt.Errorf("response code should not be 0")
}
return &ResponseFallback{r: r, log: l}, nil
} | [
"func",
"NewResponseFallbackWithLogger",
"(",
"r",
"Response",
",",
"l",
"*",
"log",
".",
"Logger",
")",
"(",
"*",
"ResponseFallback",
",",
"error",
")",
"{",
"if",
"r",
".",
"StatusCode",
"==",
"0",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"&",
"ResponseFallback",
"{",
"r",
":",
"r",
",",
"log",
":",
"l",
"}",
",",
"nil",
"\n",
"}"
] | // NewResponseFallbackWithLogger creates a new ResponseFallback | [
"NewResponseFallbackWithLogger",
"creates",
"a",
"new",
"ResponseFallback"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/cbreaker/fallback.go#L28-L33 |
149,301 | vulcand/oxy | cbreaker/fallback.go | NewRedirectFallbackWithLogger | func NewRedirectFallbackWithLogger(r Redirect, l *log.Logger) (*RedirectFallback, error) {
u, err := url.ParseRequestURI(r.URL)
if err != nil {
return nil, err
}
return &RedirectFallback{r: r, u: u, log: l}, nil
} | go | func NewRedirectFallbackWithLogger(r Redirect, l *log.Logger) (*RedirectFallback, error) {
u, err := url.ParseRequestURI(r.URL)
if err != nil {
return nil, err
}
return &RedirectFallback{r: r, u: u, log: l}, nil
} | [
"func",
"NewRedirectFallbackWithLogger",
"(",
"r",
"Redirect",
",",
"l",
"*",
"log",
".",
"Logger",
")",
"(",
"*",
"RedirectFallback",
",",
"error",
")",
"{",
"u",
",",
"err",
":=",
"url",
".",
"ParseRequestURI",
"(",
"r",
".",
"URL",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"RedirectFallback",
"{",
"r",
":",
"r",
",",
"u",
":",
"u",
",",
"log",
":",
"l",
"}",
",",
"nil",
"\n",
"}"
] | // NewRedirectFallbackWithLogger creates a new RedirectFallback | [
"NewRedirectFallbackWithLogger",
"creates",
"a",
"new",
"RedirectFallback"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/cbreaker/fallback.go#L74-L80 |
149,302 | vulcand/oxy | ratelimit/bucket.go | newTokenBucket | func newTokenBucket(rate *rate, clock timetools.TimeProvider) *tokenBucket {
return &tokenBucket{
period: rate.period,
timePerToken: time.Duration(int64(rate.period) / rate.average),
burst: rate.burst,
clock: clock,
lastRefresh: clock.UtcNow(),
availableTokens: rate.burst,
}
} | go | func newTokenBucket(rate *rate, clock timetools.TimeProvider) *tokenBucket {
return &tokenBucket{
period: rate.period,
timePerToken: time.Duration(int64(rate.period) / rate.average),
burst: rate.burst,
clock: clock,
lastRefresh: clock.UtcNow(),
availableTokens: rate.burst,
}
} | [
"func",
"newTokenBucket",
"(",
"rate",
"*",
"rate",
",",
"clock",
"timetools",
".",
"TimeProvider",
")",
"*",
"tokenBucket",
"{",
"return",
"&",
"tokenBucket",
"{",
"period",
":",
"rate",
".",
"period",
",",
"timePerToken",
":",
"time",
".",
"Duration",
"(",
"int64",
"(",
"rate",
".",
"period",
")",
"/",
"rate",
".",
"average",
")",
",",
"burst",
":",
"rate",
".",
"burst",
",",
"clock",
":",
"clock",
",",
"lastRefresh",
":",
"clock",
".",
"UtcNow",
"(",
")",
",",
"availableTokens",
":",
"rate",
".",
"burst",
",",
"}",
"\n",
"}"
] | // newTokenBucket crates a `tokenBucket` instance for the specified `Rate`. | [
"newTokenBucket",
"crates",
"a",
"tokenBucket",
"instance",
"for",
"the",
"specified",
"Rate",
"."
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/ratelimit/bucket.go#L46-L55 |
149,303 | vulcand/oxy | ratelimit/bucket.go | consume | func (tb *tokenBucket) consume(tokens int64) (time.Duration, error) {
tb.updateAvailableTokens()
tb.lastConsumed = 0
if tokens > tb.burst {
return UndefinedDelay, fmt.Errorf("requested tokens larger than max tokens")
}
if tb.availableTokens < tokens {
return tb.timeTillAvailable(tokens), nil
}
tb.availableTokens -= tokens
tb.lastConsumed = tokens
return 0, nil
} | go | func (tb *tokenBucket) consume(tokens int64) (time.Duration, error) {
tb.updateAvailableTokens()
tb.lastConsumed = 0
if tokens > tb.burst {
return UndefinedDelay, fmt.Errorf("requested tokens larger than max tokens")
}
if tb.availableTokens < tokens {
return tb.timeTillAvailable(tokens), nil
}
tb.availableTokens -= tokens
tb.lastConsumed = tokens
return 0, nil
} | [
"func",
"(",
"tb",
"*",
"tokenBucket",
")",
"consume",
"(",
"tokens",
"int64",
")",
"(",
"time",
".",
"Duration",
",",
"error",
")",
"{",
"tb",
".",
"updateAvailableTokens",
"(",
")",
"\n",
"tb",
".",
"lastConsumed",
"=",
"0",
"\n",
"if",
"tokens",
">",
"tb",
".",
"burst",
"{",
"return",
"UndefinedDelay",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"tb",
".",
"availableTokens",
"<",
"tokens",
"{",
"return",
"tb",
".",
"timeTillAvailable",
"(",
"tokens",
")",
",",
"nil",
"\n",
"}",
"\n",
"tb",
".",
"availableTokens",
"-=",
"tokens",
"\n",
"tb",
".",
"lastConsumed",
"=",
"tokens",
"\n",
"return",
"0",
",",
"nil",
"\n",
"}"
] | // consume makes an attempt to consume the specified number of tokens from the
// bucket. If there are enough tokens available then `0, nil` is returned; if
// tokens to consume is larger than the burst size, then an error is returned
// and the delay is not defined; otherwise returned a none zero delay that tells
// how much time the caller needs to wait until the desired number of tokens
// will become available for consumption. | [
"consume",
"makes",
"an",
"attempt",
"to",
"consume",
"the",
"specified",
"number",
"of",
"tokens",
"from",
"the",
"bucket",
".",
"If",
"there",
"are",
"enough",
"tokens",
"available",
"then",
"0",
"nil",
"is",
"returned",
";",
"if",
"tokens",
"to",
"consume",
"is",
"larger",
"than",
"the",
"burst",
"size",
"then",
"an",
"error",
"is",
"returned",
"and",
"the",
"delay",
"is",
"not",
"defined",
";",
"otherwise",
"returned",
"a",
"none",
"zero",
"delay",
"that",
"tells",
"how",
"much",
"time",
"the",
"caller",
"needs",
"to",
"wait",
"until",
"the",
"desired",
"number",
"of",
"tokens",
"will",
"become",
"available",
"for",
"consumption",
"."
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/ratelimit/bucket.go#L63-L75 |
149,304 | vulcand/oxy | ratelimit/bucket.go | update | func (tb *tokenBucket) update(rate *rate) error {
if rate.period != tb.period {
return fmt.Errorf("period mismatch: %v != %v", tb.period, rate.period)
}
tb.timePerToken = time.Duration(int64(tb.period) / rate.average)
tb.burst = rate.burst
if tb.availableTokens > rate.burst {
tb.availableTokens = rate.burst
}
return nil
} | go | func (tb *tokenBucket) update(rate *rate) error {
if rate.period != tb.period {
return fmt.Errorf("period mismatch: %v != %v", tb.period, rate.period)
}
tb.timePerToken = time.Duration(int64(tb.period) / rate.average)
tb.burst = rate.burst
if tb.availableTokens > rate.burst {
tb.availableTokens = rate.burst
}
return nil
} | [
"func",
"(",
"tb",
"*",
"tokenBucket",
")",
"update",
"(",
"rate",
"*",
"rate",
")",
"error",
"{",
"if",
"rate",
".",
"period",
"!=",
"tb",
".",
"period",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tb",
".",
"period",
",",
"rate",
".",
"period",
")",
"\n",
"}",
"\n",
"tb",
".",
"timePerToken",
"=",
"time",
".",
"Duration",
"(",
"int64",
"(",
"tb",
".",
"period",
")",
"/",
"rate",
".",
"average",
")",
"\n",
"tb",
".",
"burst",
"=",
"rate",
".",
"burst",
"\n",
"if",
"tb",
".",
"availableTokens",
">",
"rate",
".",
"burst",
"{",
"tb",
".",
"availableTokens",
"=",
"rate",
".",
"burst",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // update modifies `average` and `burst` fields of the token bucket according
// to the provided `Rate` | [
"update",
"modifies",
"average",
"and",
"burst",
"fields",
"of",
"the",
"token",
"bucket",
"according",
"to",
"the",
"provided",
"Rate"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/ratelimit/bucket.go#L89-L99 |
149,305 | vulcand/oxy | ratelimit/bucket.go | timeTillAvailable | func (tb *tokenBucket) timeTillAvailable(tokens int64) time.Duration {
missingTokens := tokens - tb.availableTokens
return time.Duration(missingTokens) * tb.timePerToken
} | go | func (tb *tokenBucket) timeTillAvailable(tokens int64) time.Duration {
missingTokens := tokens - tb.availableTokens
return time.Duration(missingTokens) * tb.timePerToken
} | [
"func",
"(",
"tb",
"*",
"tokenBucket",
")",
"timeTillAvailable",
"(",
"tokens",
"int64",
")",
"time",
".",
"Duration",
"{",
"missingTokens",
":=",
"tokens",
"-",
"tb",
".",
"availableTokens",
"\n",
"return",
"time",
".",
"Duration",
"(",
"missingTokens",
")",
"*",
"tb",
".",
"timePerToken",
"\n",
"}"
] | // timeTillAvailable returns the number of nanoseconds that we need to
// wait until the specified number of tokens becomes available for consumption. | [
"timeTillAvailable",
"returns",
"the",
"number",
"of",
"nanoseconds",
"that",
"we",
"need",
"to",
"wait",
"until",
"the",
"specified",
"number",
"of",
"tokens",
"becomes",
"available",
"for",
"consumption",
"."
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/ratelimit/bucket.go#L103-L106 |
149,306 | vulcand/oxy | ratelimit/bucket.go | updateAvailableTokens | func (tb *tokenBucket) updateAvailableTokens() {
now := tb.clock.UtcNow()
timePassed := now.Sub(tb.lastRefresh)
tokens := tb.availableTokens + int64(timePassed/tb.timePerToken)
// If we haven't added any tokens that means that not enough time has passed,
// in this case do not adjust last refill checkpoint, otherwise it will be
// always moving in time in case of frequent requests that exceed the rate
if tokens != tb.availableTokens {
tb.lastRefresh = now
tb.availableTokens = tokens
}
if tb.availableTokens > tb.burst {
tb.availableTokens = tb.burst
}
} | go | func (tb *tokenBucket) updateAvailableTokens() {
now := tb.clock.UtcNow()
timePassed := now.Sub(tb.lastRefresh)
tokens := tb.availableTokens + int64(timePassed/tb.timePerToken)
// If we haven't added any tokens that means that not enough time has passed,
// in this case do not adjust last refill checkpoint, otherwise it will be
// always moving in time in case of frequent requests that exceed the rate
if tokens != tb.availableTokens {
tb.lastRefresh = now
tb.availableTokens = tokens
}
if tb.availableTokens > tb.burst {
tb.availableTokens = tb.burst
}
} | [
"func",
"(",
"tb",
"*",
"tokenBucket",
")",
"updateAvailableTokens",
"(",
")",
"{",
"now",
":=",
"tb",
".",
"clock",
".",
"UtcNow",
"(",
")",
"\n",
"timePassed",
":=",
"now",
".",
"Sub",
"(",
"tb",
".",
"lastRefresh",
")",
"\n\n",
"tokens",
":=",
"tb",
".",
"availableTokens",
"+",
"int64",
"(",
"timePassed",
"/",
"tb",
".",
"timePerToken",
")",
"\n",
"// If we haven't added any tokens that means that not enough time has passed,",
"// in this case do not adjust last refill checkpoint, otherwise it will be",
"// always moving in time in case of frequent requests that exceed the rate",
"if",
"tokens",
"!=",
"tb",
".",
"availableTokens",
"{",
"tb",
".",
"lastRefresh",
"=",
"now",
"\n",
"tb",
".",
"availableTokens",
"=",
"tokens",
"\n",
"}",
"\n",
"if",
"tb",
".",
"availableTokens",
">",
"tb",
".",
"burst",
"{",
"tb",
".",
"availableTokens",
"=",
"tb",
".",
"burst",
"\n",
"}",
"\n",
"}"
] | // updateAvailableTokens updates the number of tokens available for consumption.
// It is calculated based on the refill rate, the time passed since last refresh,
// and is limited by the bucket capacity. | [
"updateAvailableTokens",
"updates",
"the",
"number",
"of",
"tokens",
"available",
"for",
"consumption",
".",
"It",
"is",
"calculated",
"based",
"on",
"the",
"refill",
"rate",
"the",
"time",
"passed",
"since",
"last",
"refresh",
"and",
"is",
"limited",
"by",
"the",
"bucket",
"capacity",
"."
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/ratelimit/bucket.go#L111-L126 |
149,307 | vulcand/oxy | trace/trace.go | RequestHeaders | func RequestHeaders(headers ...string) Option {
return func(t *Tracer) error {
t.reqHeaders = append(t.reqHeaders, headers...)
return nil
}
} | go | func RequestHeaders(headers ...string) Option {
return func(t *Tracer) error {
t.reqHeaders = append(t.reqHeaders, headers...)
return nil
}
} | [
"func",
"RequestHeaders",
"(",
"headers",
"...",
"string",
")",
"Option",
"{",
"return",
"func",
"(",
"t",
"*",
"Tracer",
")",
"error",
"{",
"t",
".",
"reqHeaders",
"=",
"append",
"(",
"t",
".",
"reqHeaders",
",",
"headers",
"...",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // RequestHeaders adds request headers to capture | [
"RequestHeaders",
"adds",
"request",
"headers",
"to",
"capture"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/trace/trace.go#L29-L34 |
149,308 | vulcand/oxy | trace/trace.go | ResponseHeaders | func ResponseHeaders(headers ...string) Option {
return func(t *Tracer) error {
t.respHeaders = append(t.respHeaders, headers...)
return nil
}
} | go | func ResponseHeaders(headers ...string) Option {
return func(t *Tracer) error {
t.respHeaders = append(t.respHeaders, headers...)
return nil
}
} | [
"func",
"ResponseHeaders",
"(",
"headers",
"...",
"string",
")",
"Option",
"{",
"return",
"func",
"(",
"t",
"*",
"Tracer",
")",
"error",
"{",
"t",
".",
"respHeaders",
"=",
"append",
"(",
"t",
".",
"respHeaders",
",",
"headers",
"...",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // ResponseHeaders adds response headers to capture | [
"ResponseHeaders",
"adds",
"response",
"headers",
"to",
"capture"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/trace/trace.go#L37-L42 |
149,309 | vulcand/oxy | roundrobin/rebalancer.go | RebalancerClock | func RebalancerClock(clock timetools.TimeProvider) RebalancerOption {
return func(r *Rebalancer) error {
r.clock = clock
return nil
}
} | go | func RebalancerClock(clock timetools.TimeProvider) RebalancerOption {
return func(r *Rebalancer) error {
r.clock = clock
return nil
}
} | [
"func",
"RebalancerClock",
"(",
"clock",
"timetools",
".",
"TimeProvider",
")",
"RebalancerOption",
"{",
"return",
"func",
"(",
"r",
"*",
"Rebalancer",
")",
"error",
"{",
"r",
".",
"clock",
"=",
"clock",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // RebalancerClock sets a clock | [
"RebalancerClock",
"sets",
"a",
"clock"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/roundrobin/rebalancer.go#L61-L66 |
149,310 | vulcand/oxy | roundrobin/rebalancer.go | RebalancerBackoff | func RebalancerBackoff(d time.Duration) RebalancerOption {
return func(r *Rebalancer) error {
r.backoffDuration = d
return nil
}
} | go | func RebalancerBackoff(d time.Duration) RebalancerOption {
return func(r *Rebalancer) error {
r.backoffDuration = d
return nil
}
} | [
"func",
"RebalancerBackoff",
"(",
"d",
"time",
".",
"Duration",
")",
"RebalancerOption",
"{",
"return",
"func",
"(",
"r",
"*",
"Rebalancer",
")",
"error",
"{",
"r",
".",
"backoffDuration",
"=",
"d",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // RebalancerBackoff sets a beck off duration | [
"RebalancerBackoff",
"sets",
"a",
"beck",
"off",
"duration"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/roundrobin/rebalancer.go#L69-L74 |
149,311 | vulcand/oxy | roundrobin/rebalancer.go | RebalancerMeter | func RebalancerMeter(newMeter NewMeterFn) RebalancerOption {
return func(r *Rebalancer) error {
r.newMeter = newMeter
return nil
}
} | go | func RebalancerMeter(newMeter NewMeterFn) RebalancerOption {
return func(r *Rebalancer) error {
r.newMeter = newMeter
return nil
}
} | [
"func",
"RebalancerMeter",
"(",
"newMeter",
"NewMeterFn",
")",
"RebalancerOption",
"{",
"return",
"func",
"(",
"r",
"*",
"Rebalancer",
")",
"error",
"{",
"r",
".",
"newMeter",
"=",
"newMeter",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // RebalancerMeter sets a Meter builder function | [
"RebalancerMeter",
"sets",
"a",
"Meter",
"builder",
"function"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/roundrobin/rebalancer.go#L77-L82 |
149,312 | vulcand/oxy | roundrobin/rebalancer.go | RebalancerErrorHandler | func RebalancerErrorHandler(h utils.ErrorHandler) RebalancerOption {
return func(r *Rebalancer) error {
r.errHandler = h
return nil
}
} | go | func RebalancerErrorHandler(h utils.ErrorHandler) RebalancerOption {
return func(r *Rebalancer) error {
r.errHandler = h
return nil
}
} | [
"func",
"RebalancerErrorHandler",
"(",
"h",
"utils",
".",
"ErrorHandler",
")",
"RebalancerOption",
"{",
"return",
"func",
"(",
"r",
"*",
"Rebalancer",
")",
"error",
"{",
"r",
".",
"errHandler",
"=",
"h",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // RebalancerErrorHandler is a functional argument that sets error handler of the server | [
"RebalancerErrorHandler",
"is",
"a",
"functional",
"argument",
"that",
"sets",
"error",
"handler",
"of",
"the",
"server"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/roundrobin/rebalancer.go#L85-L90 |
149,313 | vulcand/oxy | roundrobin/rebalancer.go | RebalancerStickySession | func RebalancerStickySession(stickySession *StickySession) RebalancerOption {
return func(r *Rebalancer) error {
r.stickySession = stickySession
return nil
}
} | go | func RebalancerStickySession(stickySession *StickySession) RebalancerOption {
return func(r *Rebalancer) error {
r.stickySession = stickySession
return nil
}
} | [
"func",
"RebalancerStickySession",
"(",
"stickySession",
"*",
"StickySession",
")",
"RebalancerOption",
"{",
"return",
"func",
"(",
"r",
"*",
"Rebalancer",
")",
"error",
"{",
"r",
".",
"stickySession",
"=",
"stickySession",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // RebalancerStickySession sets a sticky session | [
"RebalancerStickySession",
"sets",
"a",
"sticky",
"session"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/roundrobin/rebalancer.go#L93-L98 |
149,314 | vulcand/oxy | roundrobin/rebalancer.go | RebalancerRequestRewriteListener | func RebalancerRequestRewriteListener(rrl RequestRewriteListener) RebalancerOption {
return func(r *Rebalancer) error {
r.requestRewriteListener = rrl
return nil
}
} | go | func RebalancerRequestRewriteListener(rrl RequestRewriteListener) RebalancerOption {
return func(r *Rebalancer) error {
r.requestRewriteListener = rrl
return nil
}
} | [
"func",
"RebalancerRequestRewriteListener",
"(",
"rrl",
"RequestRewriteListener",
")",
"RebalancerOption",
"{",
"return",
"func",
"(",
"r",
"*",
"Rebalancer",
")",
"error",
"{",
"r",
".",
"requestRewriteListener",
"=",
"rrl",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // RebalancerRequestRewriteListener is a functional argument that sets error handler of the server | [
"RebalancerRequestRewriteListener",
"is",
"a",
"functional",
"argument",
"that",
"sets",
"error",
"handler",
"of",
"the",
"server"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/roundrobin/rebalancer.go#L101-L106 |
149,315 | vulcand/oxy | roundrobin/rebalancer.go | NewRebalancer | func NewRebalancer(handler balancerHandler, opts ...RebalancerOption) (*Rebalancer, error) {
rb := &Rebalancer{
mtx: &sync.Mutex{},
next: handler,
stickySession: nil,
log: log.StandardLogger(),
}
for _, o := range opts {
if err := o(rb); err != nil {
return nil, err
}
}
if rb.clock == nil {
rb.clock = &timetools.RealTime{}
}
if rb.backoffDuration == 0 {
rb.backoffDuration = 10 * time.Second
}
if rb.newMeter == nil {
rb.newMeter = func() (Meter, error) {
rc, err := memmetrics.NewRatioCounter(10, time.Second, memmetrics.RatioClock(rb.clock))
if err != nil {
return nil, err
}
return &codeMeter{
r: rc,
codeS: http.StatusInternalServerError,
codeE: http.StatusGatewayTimeout + 1,
}, nil
}
}
if rb.errHandler == nil {
rb.errHandler = utils.DefaultHandler
}
return rb, nil
} | go | func NewRebalancer(handler balancerHandler, opts ...RebalancerOption) (*Rebalancer, error) {
rb := &Rebalancer{
mtx: &sync.Mutex{},
next: handler,
stickySession: nil,
log: log.StandardLogger(),
}
for _, o := range opts {
if err := o(rb); err != nil {
return nil, err
}
}
if rb.clock == nil {
rb.clock = &timetools.RealTime{}
}
if rb.backoffDuration == 0 {
rb.backoffDuration = 10 * time.Second
}
if rb.newMeter == nil {
rb.newMeter = func() (Meter, error) {
rc, err := memmetrics.NewRatioCounter(10, time.Second, memmetrics.RatioClock(rb.clock))
if err != nil {
return nil, err
}
return &codeMeter{
r: rc,
codeS: http.StatusInternalServerError,
codeE: http.StatusGatewayTimeout + 1,
}, nil
}
}
if rb.errHandler == nil {
rb.errHandler = utils.DefaultHandler
}
return rb, nil
} | [
"func",
"NewRebalancer",
"(",
"handler",
"balancerHandler",
",",
"opts",
"...",
"RebalancerOption",
")",
"(",
"*",
"Rebalancer",
",",
"error",
")",
"{",
"rb",
":=",
"&",
"Rebalancer",
"{",
"mtx",
":",
"&",
"sync",
".",
"Mutex",
"{",
"}",
",",
"next",
":",
"handler",
",",
"stickySession",
":",
"nil",
",",
"log",
":",
"log",
".",
"StandardLogger",
"(",
")",
",",
"}",
"\n",
"for",
"_",
",",
"o",
":=",
"range",
"opts",
"{",
"if",
"err",
":=",
"o",
"(",
"rb",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"rb",
".",
"clock",
"==",
"nil",
"{",
"rb",
".",
"clock",
"=",
"&",
"timetools",
".",
"RealTime",
"{",
"}",
"\n",
"}",
"\n",
"if",
"rb",
".",
"backoffDuration",
"==",
"0",
"{",
"rb",
".",
"backoffDuration",
"=",
"10",
"*",
"time",
".",
"Second",
"\n",
"}",
"\n",
"if",
"rb",
".",
"newMeter",
"==",
"nil",
"{",
"rb",
".",
"newMeter",
"=",
"func",
"(",
")",
"(",
"Meter",
",",
"error",
")",
"{",
"rc",
",",
"err",
":=",
"memmetrics",
".",
"NewRatioCounter",
"(",
"10",
",",
"time",
".",
"Second",
",",
"memmetrics",
".",
"RatioClock",
"(",
"rb",
".",
"clock",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"codeMeter",
"{",
"r",
":",
"rc",
",",
"codeS",
":",
"http",
".",
"StatusInternalServerError",
",",
"codeE",
":",
"http",
".",
"StatusGatewayTimeout",
"+",
"1",
",",
"}",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"rb",
".",
"errHandler",
"==",
"nil",
"{",
"rb",
".",
"errHandler",
"=",
"utils",
".",
"DefaultHandler",
"\n",
"}",
"\n",
"return",
"rb",
",",
"nil",
"\n",
"}"
] | // NewRebalancer creates a new Rebalancer | [
"NewRebalancer",
"creates",
"a",
"new",
"Rebalancer"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/roundrobin/rebalancer.go#L109-L145 |
149,316 | vulcand/oxy | roundrobin/rebalancer.go | Servers | func (rb *Rebalancer) Servers() []*url.URL {
rb.mtx.Lock()
defer rb.mtx.Unlock()
return rb.next.Servers()
} | go | func (rb *Rebalancer) Servers() []*url.URL {
rb.mtx.Lock()
defer rb.mtx.Unlock()
return rb.next.Servers()
} | [
"func",
"(",
"rb",
"*",
"Rebalancer",
")",
"Servers",
"(",
")",
"[",
"]",
"*",
"url",
".",
"URL",
"{",
"rb",
".",
"mtx",
".",
"Lock",
"(",
")",
"\n",
"defer",
"rb",
".",
"mtx",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"rb",
".",
"next",
".",
"Servers",
"(",
")",
"\n",
"}"
] | // Servers gets all servers | [
"Servers",
"gets",
"all",
"servers"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/roundrobin/rebalancer.go#L158-L163 |
149,317 | vulcand/oxy | roundrobin/rebalancer.go | Wrap | func (rb *Rebalancer) Wrap(next balancerHandler) error {
if rb.next != nil {
return fmt.Errorf("already bound to %T", rb.next)
}
rb.next = next
return nil
} | go | func (rb *Rebalancer) Wrap(next balancerHandler) error {
if rb.next != nil {
return fmt.Errorf("already bound to %T", rb.next)
}
rb.next = next
return nil
} | [
"func",
"(",
"rb",
"*",
"Rebalancer",
")",
"Wrap",
"(",
"next",
"balancerHandler",
")",
"error",
"{",
"if",
"rb",
".",
"next",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"rb",
".",
"next",
")",
"\n",
"}",
"\n",
"rb",
".",
"next",
"=",
"next",
"\n",
"return",
"nil",
"\n",
"}"
] | // Wrap sets the next handler to be called by rebalancer handler. | [
"Wrap",
"sets",
"the",
"next",
"handler",
"to",
"be",
"called",
"by",
"rebalancer",
"handler",
"."
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/roundrobin/rebalancer.go#L240-L246 |
149,318 | vulcand/oxy | roundrobin/rebalancer.go | UpsertServer | func (rb *Rebalancer) UpsertServer(u *url.URL, options ...ServerOption) error {
rb.mtx.Lock()
defer rb.mtx.Unlock()
if err := rb.next.UpsertServer(u, options...); err != nil {
return err
}
weight, _ := rb.next.ServerWeight(u)
if err := rb.upsertServer(u, weight); err != nil {
rb.next.RemoveServer(u)
return err
}
rb.reset()
return nil
} | go | func (rb *Rebalancer) UpsertServer(u *url.URL, options ...ServerOption) error {
rb.mtx.Lock()
defer rb.mtx.Unlock()
if err := rb.next.UpsertServer(u, options...); err != nil {
return err
}
weight, _ := rb.next.ServerWeight(u)
if err := rb.upsertServer(u, weight); err != nil {
rb.next.RemoveServer(u)
return err
}
rb.reset()
return nil
} | [
"func",
"(",
"rb",
"*",
"Rebalancer",
")",
"UpsertServer",
"(",
"u",
"*",
"url",
".",
"URL",
",",
"options",
"...",
"ServerOption",
")",
"error",
"{",
"rb",
".",
"mtx",
".",
"Lock",
"(",
")",
"\n",
"defer",
"rb",
".",
"mtx",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"err",
":=",
"rb",
".",
"next",
".",
"UpsertServer",
"(",
"u",
",",
"options",
"...",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"weight",
",",
"_",
":=",
"rb",
".",
"next",
".",
"ServerWeight",
"(",
"u",
")",
"\n",
"if",
"err",
":=",
"rb",
".",
"upsertServer",
"(",
"u",
",",
"weight",
")",
";",
"err",
"!=",
"nil",
"{",
"rb",
".",
"next",
".",
"RemoveServer",
"(",
"u",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"rb",
".",
"reset",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // UpsertServer upsert a server | [
"UpsertServer",
"upsert",
"a",
"server"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/roundrobin/rebalancer.go#L249-L263 |
149,319 | vulcand/oxy | roundrobin/rebalancer.go | adjustWeights | func (rb *Rebalancer) adjustWeights() {
rb.mtx.Lock()
defer rb.mtx.Unlock()
// In this case adjusting weights would have no effect, so do nothing
if len(rb.servers) < 2 {
return
}
// Metrics are not ready
if !rb.metricsReady() {
return
}
if !rb.timerExpired() {
return
}
if rb.markServers() {
if rb.setMarkedWeights() {
rb.setTimer()
}
} else { // No servers that are different by their quality, so converge weights
if rb.convergeWeights() {
rb.setTimer()
}
}
} | go | func (rb *Rebalancer) adjustWeights() {
rb.mtx.Lock()
defer rb.mtx.Unlock()
// In this case adjusting weights would have no effect, so do nothing
if len(rb.servers) < 2 {
return
}
// Metrics are not ready
if !rb.metricsReady() {
return
}
if !rb.timerExpired() {
return
}
if rb.markServers() {
if rb.setMarkedWeights() {
rb.setTimer()
}
} else { // No servers that are different by their quality, so converge weights
if rb.convergeWeights() {
rb.setTimer()
}
}
} | [
"func",
"(",
"rb",
"*",
"Rebalancer",
")",
"adjustWeights",
"(",
")",
"{",
"rb",
".",
"mtx",
".",
"Lock",
"(",
")",
"\n",
"defer",
"rb",
".",
"mtx",
".",
"Unlock",
"(",
")",
"\n\n",
"// In this case adjusting weights would have no effect, so do nothing",
"if",
"len",
"(",
"rb",
".",
"servers",
")",
"<",
"2",
"{",
"return",
"\n",
"}",
"\n",
"// Metrics are not ready",
"if",
"!",
"rb",
".",
"metricsReady",
"(",
")",
"{",
"return",
"\n",
"}",
"\n",
"if",
"!",
"rb",
".",
"timerExpired",
"(",
")",
"{",
"return",
"\n",
"}",
"\n",
"if",
"rb",
".",
"markServers",
"(",
")",
"{",
"if",
"rb",
".",
"setMarkedWeights",
"(",
")",
"{",
"rb",
".",
"setTimer",
"(",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"// No servers that are different by their quality, so converge weights",
"if",
"rb",
".",
"convergeWeights",
"(",
")",
"{",
"rb",
".",
"setTimer",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // adjustWeights Called on every load balancer ServeHTTP call, returns the suggested weights
// on every call, can adjust weights if needed. | [
"adjustWeights",
"Called",
"on",
"every",
"load",
"balancer",
"ServeHTTP",
"call",
"returns",
"the",
"suggested",
"weights",
"on",
"every",
"call",
"can",
"adjust",
"weights",
"if",
"needed",
"."
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/roundrobin/rebalancer.go#L318-L342 |
149,320 | vulcand/oxy | roundrobin/rebalancer.go | markServers | func (rb *Rebalancer) markServers() bool {
for i, srv := range rb.servers {
rb.ratings[i] = srv.meter.Rating()
}
g, b := memmetrics.SplitFloat64(splitThreshold, 0, rb.ratings)
for i, srv := range rb.servers {
if g[rb.ratings[i]] {
srv.good = true
} else {
srv.good = false
}
}
if len(g) != 0 && len(b) != 0 {
rb.log.Debugf("bad: %v good: %v, ratings: %v", b, g, rb.ratings)
}
return len(g) != 0 && len(b) != 0
} | go | func (rb *Rebalancer) markServers() bool {
for i, srv := range rb.servers {
rb.ratings[i] = srv.meter.Rating()
}
g, b := memmetrics.SplitFloat64(splitThreshold, 0, rb.ratings)
for i, srv := range rb.servers {
if g[rb.ratings[i]] {
srv.good = true
} else {
srv.good = false
}
}
if len(g) != 0 && len(b) != 0 {
rb.log.Debugf("bad: %v good: %v, ratings: %v", b, g, rb.ratings)
}
return len(g) != 0 && len(b) != 0
} | [
"func",
"(",
"rb",
"*",
"Rebalancer",
")",
"markServers",
"(",
")",
"bool",
"{",
"for",
"i",
",",
"srv",
":=",
"range",
"rb",
".",
"servers",
"{",
"rb",
".",
"ratings",
"[",
"i",
"]",
"=",
"srv",
".",
"meter",
".",
"Rating",
"(",
")",
"\n",
"}",
"\n",
"g",
",",
"b",
":=",
"memmetrics",
".",
"SplitFloat64",
"(",
"splitThreshold",
",",
"0",
",",
"rb",
".",
"ratings",
")",
"\n",
"for",
"i",
",",
"srv",
":=",
"range",
"rb",
".",
"servers",
"{",
"if",
"g",
"[",
"rb",
".",
"ratings",
"[",
"i",
"]",
"]",
"{",
"srv",
".",
"good",
"=",
"true",
"\n",
"}",
"else",
"{",
"srv",
".",
"good",
"=",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"g",
")",
"!=",
"0",
"&&",
"len",
"(",
"b",
")",
"!=",
"0",
"{",
"rb",
".",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"b",
",",
"g",
",",
"rb",
".",
"ratings",
")",
"\n",
"}",
"\n",
"return",
"len",
"(",
"g",
")",
"!=",
"0",
"&&",
"len",
"(",
"b",
")",
"!=",
"0",
"\n",
"}"
] | // markServers splits servers into two groups of servers with bad and good failure rate.
// It does compare relative performances of the servers though, so if all servers have approximately the same error rate
// this function returns the result as if all servers are equally good. | [
"markServers",
"splits",
"servers",
"into",
"two",
"groups",
"of",
"servers",
"with",
"bad",
"and",
"good",
"failure",
"rate",
".",
"It",
"does",
"compare",
"relative",
"performances",
"of",
"the",
"servers",
"though",
"so",
"if",
"all",
"servers",
"have",
"approximately",
"the",
"same",
"error",
"rate",
"this",
"function",
"returns",
"the",
"result",
"as",
"if",
"all",
"servers",
"are",
"equally",
"good",
"."
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/roundrobin/rebalancer.go#L392-L408 |
149,321 | vulcand/oxy | roundrobin/rebalancer.go | Record | func (n *codeMeter) Record(code int, d time.Duration) {
if code >= n.codeS && code < n.codeE {
n.r.IncA(1)
} else {
n.r.IncB(1)
}
} | go | func (n *codeMeter) Record(code int, d time.Duration) {
if code >= n.codeS && code < n.codeE {
n.r.IncA(1)
} else {
n.r.IncB(1)
}
} | [
"func",
"(",
"n",
"*",
"codeMeter",
")",
"Record",
"(",
"code",
"int",
",",
"d",
"time",
".",
"Duration",
")",
"{",
"if",
"code",
">=",
"n",
".",
"codeS",
"&&",
"code",
"<",
"n",
".",
"codeE",
"{",
"n",
".",
"r",
".",
"IncA",
"(",
"1",
")",
"\n",
"}",
"else",
"{",
"n",
".",
"r",
".",
"IncB",
"(",
"1",
")",
"\n",
"}",
"\n",
"}"
] | // Record records a meter | [
"Record",
"records",
"a",
"meter"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/roundrobin/rebalancer.go#L492-L498 |
149,322 | vulcand/oxy | memmetrics/histogram.go | NewHDRHistogram | func NewHDRHistogram(low, high int64, sigfigs int) (h *HDRHistogram, err error) {
defer func() {
if msg := recover(); msg != nil {
err = fmt.Errorf("%s", msg)
}
}()
return &HDRHistogram{
low: low,
high: high,
sigfigs: sigfigs,
h: hdrhistogram.New(low, high, sigfigs),
}, nil
} | go | func NewHDRHistogram(low, high int64, sigfigs int) (h *HDRHistogram, err error) {
defer func() {
if msg := recover(); msg != nil {
err = fmt.Errorf("%s", msg)
}
}()
return &HDRHistogram{
low: low,
high: high,
sigfigs: sigfigs,
h: hdrhistogram.New(low, high, sigfigs),
}, nil
} | [
"func",
"NewHDRHistogram",
"(",
"low",
",",
"high",
"int64",
",",
"sigfigs",
"int",
")",
"(",
"h",
"*",
"HDRHistogram",
",",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"msg",
":=",
"recover",
"(",
")",
";",
"msg",
"!=",
"nil",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"msg",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"return",
"&",
"HDRHistogram",
"{",
"low",
":",
"low",
",",
"high",
":",
"high",
",",
"sigfigs",
":",
"sigfigs",
",",
"h",
":",
"hdrhistogram",
".",
"New",
"(",
"low",
",",
"high",
",",
"sigfigs",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewHDRHistogram creates a new HDRHistogram | [
"NewHDRHistogram",
"creates",
"a",
"new",
"HDRHistogram"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/histogram.go#L24-L36 |
149,323 | vulcand/oxy | memmetrics/histogram.go | Export | func (h *HDRHistogram) Export() *HDRHistogram {
var hist *hdrhistogram.Histogram
if h.h != nil {
snapshot := h.h.Export()
hist = hdrhistogram.Import(snapshot)
}
return &HDRHistogram{low: h.low, high: h.high, sigfigs: h.sigfigs, h: hist}
} | go | func (h *HDRHistogram) Export() *HDRHistogram {
var hist *hdrhistogram.Histogram
if h.h != nil {
snapshot := h.h.Export()
hist = hdrhistogram.Import(snapshot)
}
return &HDRHistogram{low: h.low, high: h.high, sigfigs: h.sigfigs, h: hist}
} | [
"func",
"(",
"h",
"*",
"HDRHistogram",
")",
"Export",
"(",
")",
"*",
"HDRHistogram",
"{",
"var",
"hist",
"*",
"hdrhistogram",
".",
"Histogram",
"\n",
"if",
"h",
".",
"h",
"!=",
"nil",
"{",
"snapshot",
":=",
"h",
".",
"h",
".",
"Export",
"(",
")",
"\n",
"hist",
"=",
"hdrhistogram",
".",
"Import",
"(",
"snapshot",
")",
"\n",
"}",
"\n",
"return",
"&",
"HDRHistogram",
"{",
"low",
":",
"h",
".",
"low",
",",
"high",
":",
"h",
".",
"high",
",",
"sigfigs",
":",
"h",
".",
"sigfigs",
",",
"h",
":",
"hist",
"}",
"\n",
"}"
] | // Export export a HDRHistogram | [
"Export",
"export",
"a",
"HDRHistogram"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/histogram.go#L39-L46 |
149,324 | vulcand/oxy | memmetrics/histogram.go | LatencyAtQuantile | func (h *HDRHistogram) LatencyAtQuantile(q float64) time.Duration {
return time.Duration(h.ValueAtQuantile(q)) * time.Microsecond
} | go | func (h *HDRHistogram) LatencyAtQuantile(q float64) time.Duration {
return time.Duration(h.ValueAtQuantile(q)) * time.Microsecond
} | [
"func",
"(",
"h",
"*",
"HDRHistogram",
")",
"LatencyAtQuantile",
"(",
"q",
"float64",
")",
"time",
".",
"Duration",
"{",
"return",
"time",
".",
"Duration",
"(",
"h",
".",
"ValueAtQuantile",
"(",
"q",
")",
")",
"*",
"time",
".",
"Microsecond",
"\n",
"}"
] | // LatencyAtQuantile sets latency at quantile with microsecond precision | [
"LatencyAtQuantile",
"sets",
"latency",
"at",
"quantile",
"with",
"microsecond",
"precision"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/histogram.go#L49-L51 |
149,325 | vulcand/oxy | memmetrics/histogram.go | RecordLatencies | func (h *HDRHistogram) RecordLatencies(d time.Duration, n int64) error {
return h.RecordValues(int64(d/time.Microsecond), n)
} | go | func (h *HDRHistogram) RecordLatencies(d time.Duration, n int64) error {
return h.RecordValues(int64(d/time.Microsecond), n)
} | [
"func",
"(",
"h",
"*",
"HDRHistogram",
")",
"RecordLatencies",
"(",
"d",
"time",
".",
"Duration",
",",
"n",
"int64",
")",
"error",
"{",
"return",
"h",
".",
"RecordValues",
"(",
"int64",
"(",
"d",
"/",
"time",
".",
"Microsecond",
")",
",",
"n",
")",
"\n",
"}"
] | // RecordLatencies Records latencies with microsecond precision | [
"RecordLatencies",
"Records",
"latencies",
"with",
"microsecond",
"precision"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/histogram.go#L54-L56 |
149,326 | vulcand/oxy | memmetrics/histogram.go | ValueAtQuantile | func (h *HDRHistogram) ValueAtQuantile(q float64) int64 {
return h.h.ValueAtQuantile(q)
} | go | func (h *HDRHistogram) ValueAtQuantile(q float64) int64 {
return h.h.ValueAtQuantile(q)
} | [
"func",
"(",
"h",
"*",
"HDRHistogram",
")",
"ValueAtQuantile",
"(",
"q",
"float64",
")",
"int64",
"{",
"return",
"h",
".",
"h",
".",
"ValueAtQuantile",
"(",
"q",
")",
"\n",
"}"
] | // ValueAtQuantile sets value at quantile | [
"ValueAtQuantile",
"sets",
"value",
"at",
"quantile"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/histogram.go#L64-L66 |
149,327 | vulcand/oxy | memmetrics/histogram.go | RecordValues | func (h *HDRHistogram) RecordValues(v, n int64) error {
return h.h.RecordValues(v, n)
} | go | func (h *HDRHistogram) RecordValues(v, n int64) error {
return h.h.RecordValues(v, n)
} | [
"func",
"(",
"h",
"*",
"HDRHistogram",
")",
"RecordValues",
"(",
"v",
",",
"n",
"int64",
")",
"error",
"{",
"return",
"h",
".",
"h",
".",
"RecordValues",
"(",
"v",
",",
"n",
")",
"\n",
"}"
] | // RecordValues sets record values | [
"RecordValues",
"sets",
"record",
"values"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/histogram.go#L69-L71 |
149,328 | vulcand/oxy | memmetrics/histogram.go | Merge | func (h *HDRHistogram) Merge(other *HDRHistogram) error {
if other == nil {
return fmt.Errorf("other is nil")
}
h.h.Merge(other.h)
return nil
} | go | func (h *HDRHistogram) Merge(other *HDRHistogram) error {
if other == nil {
return fmt.Errorf("other is nil")
}
h.h.Merge(other.h)
return nil
} | [
"func",
"(",
"h",
"*",
"HDRHistogram",
")",
"Merge",
"(",
"other",
"*",
"HDRHistogram",
")",
"error",
"{",
"if",
"other",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"h",
".",
"h",
".",
"Merge",
"(",
"other",
".",
"h",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // Merge merge a HDRHistogram | [
"Merge",
"merge",
"a",
"HDRHistogram"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/histogram.go#L74-L80 |
149,329 | vulcand/oxy | memmetrics/histogram.go | RollingClock | func RollingClock(clock timetools.TimeProvider) rhOptSetter {
return func(r *RollingHDRHistogram) error {
r.clock = clock
return nil
}
} | go | func RollingClock(clock timetools.TimeProvider) rhOptSetter {
return func(r *RollingHDRHistogram) error {
r.clock = clock
return nil
}
} | [
"func",
"RollingClock",
"(",
"clock",
"timetools",
".",
"TimeProvider",
")",
"rhOptSetter",
"{",
"return",
"func",
"(",
"r",
"*",
"RollingHDRHistogram",
")",
"error",
"{",
"r",
".",
"clock",
"=",
"clock",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // RollingClock sets a clock | [
"RollingClock",
"sets",
"a",
"clock"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/histogram.go#L85-L90 |
149,330 | vulcand/oxy | memmetrics/histogram.go | NewRollingHDRHistogram | func NewRollingHDRHistogram(low, high int64, sigfigs int, period time.Duration, bucketCount int, options ...rhOptSetter) (*RollingHDRHistogram, error) {
rh := &RollingHDRHistogram{
bucketCount: bucketCount,
period: period,
low: low,
high: high,
sigfigs: sigfigs,
}
for _, o := range options {
if err := o(rh); err != nil {
return nil, err
}
}
if rh.clock == nil {
rh.clock = &timetools.RealTime{}
}
buckets := make([]*HDRHistogram, rh.bucketCount)
for i := range buckets {
h, err := NewHDRHistogram(low, high, sigfigs)
if err != nil {
return nil, err
}
buckets[i] = h
}
rh.buckets = buckets
return rh, nil
} | go | func NewRollingHDRHistogram(low, high int64, sigfigs int, period time.Duration, bucketCount int, options ...rhOptSetter) (*RollingHDRHistogram, error) {
rh := &RollingHDRHistogram{
bucketCount: bucketCount,
period: period,
low: low,
high: high,
sigfigs: sigfigs,
}
for _, o := range options {
if err := o(rh); err != nil {
return nil, err
}
}
if rh.clock == nil {
rh.clock = &timetools.RealTime{}
}
buckets := make([]*HDRHistogram, rh.bucketCount)
for i := range buckets {
h, err := NewHDRHistogram(low, high, sigfigs)
if err != nil {
return nil, err
}
buckets[i] = h
}
rh.buckets = buckets
return rh, nil
} | [
"func",
"NewRollingHDRHistogram",
"(",
"low",
",",
"high",
"int64",
",",
"sigfigs",
"int",
",",
"period",
"time",
".",
"Duration",
",",
"bucketCount",
"int",
",",
"options",
"...",
"rhOptSetter",
")",
"(",
"*",
"RollingHDRHistogram",
",",
"error",
")",
"{",
"rh",
":=",
"&",
"RollingHDRHistogram",
"{",
"bucketCount",
":",
"bucketCount",
",",
"period",
":",
"period",
",",
"low",
":",
"low",
",",
"high",
":",
"high",
",",
"sigfigs",
":",
"sigfigs",
",",
"}",
"\n\n",
"for",
"_",
",",
"o",
":=",
"range",
"options",
"{",
"if",
"err",
":=",
"o",
"(",
"rh",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"rh",
".",
"clock",
"==",
"nil",
"{",
"rh",
".",
"clock",
"=",
"&",
"timetools",
".",
"RealTime",
"{",
"}",
"\n",
"}",
"\n\n",
"buckets",
":=",
"make",
"(",
"[",
"]",
"*",
"HDRHistogram",
",",
"rh",
".",
"bucketCount",
")",
"\n",
"for",
"i",
":=",
"range",
"buckets",
"{",
"h",
",",
"err",
":=",
"NewHDRHistogram",
"(",
"low",
",",
"high",
",",
"sigfigs",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"buckets",
"[",
"i",
"]",
"=",
"h",
"\n",
"}",
"\n",
"rh",
".",
"buckets",
"=",
"buckets",
"\n",
"return",
"rh",
",",
"nil",
"\n",
"}"
] | // NewRollingHDRHistogram created a new RollingHDRHistogram | [
"NewRollingHDRHistogram",
"created",
"a",
"new",
"RollingHDRHistogram"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/histogram.go#L107-L136 |
149,331 | vulcand/oxy | memmetrics/histogram.go | Export | func (r *RollingHDRHistogram) Export() *RollingHDRHistogram {
export := &RollingHDRHistogram{}
export.idx = r.idx
export.lastRoll = r.lastRoll
export.period = r.period
export.bucketCount = r.bucketCount
export.low = r.low
export.high = r.high
export.sigfigs = r.sigfigs
export.clock = r.clock
exportBuckets := make([]*HDRHistogram, len(r.buckets))
for i, hist := range r.buckets {
exportBuckets[i] = hist.Export()
}
export.buckets = exportBuckets
return export
} | go | func (r *RollingHDRHistogram) Export() *RollingHDRHistogram {
export := &RollingHDRHistogram{}
export.idx = r.idx
export.lastRoll = r.lastRoll
export.period = r.period
export.bucketCount = r.bucketCount
export.low = r.low
export.high = r.high
export.sigfigs = r.sigfigs
export.clock = r.clock
exportBuckets := make([]*HDRHistogram, len(r.buckets))
for i, hist := range r.buckets {
exportBuckets[i] = hist.Export()
}
export.buckets = exportBuckets
return export
} | [
"func",
"(",
"r",
"*",
"RollingHDRHistogram",
")",
"Export",
"(",
")",
"*",
"RollingHDRHistogram",
"{",
"export",
":=",
"&",
"RollingHDRHistogram",
"{",
"}",
"\n",
"export",
".",
"idx",
"=",
"r",
".",
"idx",
"\n",
"export",
".",
"lastRoll",
"=",
"r",
".",
"lastRoll",
"\n",
"export",
".",
"period",
"=",
"r",
".",
"period",
"\n",
"export",
".",
"bucketCount",
"=",
"r",
".",
"bucketCount",
"\n",
"export",
".",
"low",
"=",
"r",
".",
"low",
"\n",
"export",
".",
"high",
"=",
"r",
".",
"high",
"\n",
"export",
".",
"sigfigs",
"=",
"r",
".",
"sigfigs",
"\n",
"export",
".",
"clock",
"=",
"r",
".",
"clock",
"\n\n",
"exportBuckets",
":=",
"make",
"(",
"[",
"]",
"*",
"HDRHistogram",
",",
"len",
"(",
"r",
".",
"buckets",
")",
")",
"\n",
"for",
"i",
",",
"hist",
":=",
"range",
"r",
".",
"buckets",
"{",
"exportBuckets",
"[",
"i",
"]",
"=",
"hist",
".",
"Export",
"(",
")",
"\n",
"}",
"\n",
"export",
".",
"buckets",
"=",
"exportBuckets",
"\n\n",
"return",
"export",
"\n",
"}"
] | // Export export a RollingHDRHistogram | [
"Export",
"export",
"a",
"RollingHDRHistogram"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/histogram.go#L139-L157 |
149,332 | vulcand/oxy | memmetrics/histogram.go | Append | func (r *RollingHDRHistogram) Append(o *RollingHDRHistogram) error {
if r.bucketCount != o.bucketCount || r.period != o.period || r.low != o.low || r.high != o.high || r.sigfigs != o.sigfigs {
return fmt.Errorf("can't merge")
}
for i := range r.buckets {
if err := r.buckets[i].Merge(o.buckets[i]); err != nil {
return err
}
}
return nil
} | go | func (r *RollingHDRHistogram) Append(o *RollingHDRHistogram) error {
if r.bucketCount != o.bucketCount || r.period != o.period || r.low != o.low || r.high != o.high || r.sigfigs != o.sigfigs {
return fmt.Errorf("can't merge")
}
for i := range r.buckets {
if err := r.buckets[i].Merge(o.buckets[i]); err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"r",
"*",
"RollingHDRHistogram",
")",
"Append",
"(",
"o",
"*",
"RollingHDRHistogram",
")",
"error",
"{",
"if",
"r",
".",
"bucketCount",
"!=",
"o",
".",
"bucketCount",
"||",
"r",
".",
"period",
"!=",
"o",
".",
"period",
"||",
"r",
".",
"low",
"!=",
"o",
".",
"low",
"||",
"r",
".",
"high",
"!=",
"o",
".",
"high",
"||",
"r",
".",
"sigfigs",
"!=",
"o",
".",
"sigfigs",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"for",
"i",
":=",
"range",
"r",
".",
"buckets",
"{",
"if",
"err",
":=",
"r",
".",
"buckets",
"[",
"i",
"]",
".",
"Merge",
"(",
"o",
".",
"buckets",
"[",
"i",
"]",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Append append a RollingHDRHistogram | [
"Append",
"append",
"a",
"RollingHDRHistogram"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/histogram.go#L160-L171 |
149,333 | vulcand/oxy | memmetrics/histogram.go | Reset | func (r *RollingHDRHistogram) Reset() {
r.idx = 0
r.lastRoll = r.clock.UtcNow()
for _, b := range r.buckets {
b.Reset()
}
} | go | func (r *RollingHDRHistogram) Reset() {
r.idx = 0
r.lastRoll = r.clock.UtcNow()
for _, b := range r.buckets {
b.Reset()
}
} | [
"func",
"(",
"r",
"*",
"RollingHDRHistogram",
")",
"Reset",
"(",
")",
"{",
"r",
".",
"idx",
"=",
"0",
"\n",
"r",
".",
"lastRoll",
"=",
"r",
".",
"clock",
".",
"UtcNow",
"(",
")",
"\n",
"for",
"_",
",",
"b",
":=",
"range",
"r",
".",
"buckets",
"{",
"b",
".",
"Reset",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // Reset reset a RollingHDRHistogram | [
"Reset",
"reset",
"a",
"RollingHDRHistogram"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/histogram.go#L174-L180 |
149,334 | vulcand/oxy | memmetrics/histogram.go | Merged | func (r *RollingHDRHistogram) Merged() (*HDRHistogram, error) {
m, err := NewHDRHistogram(r.low, r.high, r.sigfigs)
if err != nil {
return m, err
}
for _, h := range r.buckets {
if errMerge := m.Merge(h); errMerge != nil {
return nil, errMerge
}
}
return m, nil
} | go | func (r *RollingHDRHistogram) Merged() (*HDRHistogram, error) {
m, err := NewHDRHistogram(r.low, r.high, r.sigfigs)
if err != nil {
return m, err
}
for _, h := range r.buckets {
if errMerge := m.Merge(h); errMerge != nil {
return nil, errMerge
}
}
return m, nil
} | [
"func",
"(",
"r",
"*",
"RollingHDRHistogram",
")",
"Merged",
"(",
")",
"(",
"*",
"HDRHistogram",
",",
"error",
")",
"{",
"m",
",",
"err",
":=",
"NewHDRHistogram",
"(",
"r",
".",
"low",
",",
"r",
".",
"high",
",",
"r",
".",
"sigfigs",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"m",
",",
"err",
"\n",
"}",
"\n",
"for",
"_",
",",
"h",
":=",
"range",
"r",
".",
"buckets",
"{",
"if",
"errMerge",
":=",
"m",
".",
"Merge",
"(",
"h",
")",
";",
"errMerge",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errMerge",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"m",
",",
"nil",
"\n",
"}"
] | // Merged gets merged histogram | [
"Merged",
"gets",
"merged",
"histogram"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/histogram.go#L188-L199 |
149,335 | vulcand/oxy | memmetrics/histogram.go | RecordLatencies | func (r *RollingHDRHistogram) RecordLatencies(v time.Duration, n int64) error {
return r.getHist().RecordLatencies(v, n)
} | go | func (r *RollingHDRHistogram) RecordLatencies(v time.Duration, n int64) error {
return r.getHist().RecordLatencies(v, n)
} | [
"func",
"(",
"r",
"*",
"RollingHDRHistogram",
")",
"RecordLatencies",
"(",
"v",
"time",
".",
"Duration",
",",
"n",
"int64",
")",
"error",
"{",
"return",
"r",
".",
"getHist",
"(",
")",
".",
"RecordLatencies",
"(",
"v",
",",
"n",
")",
"\n",
"}"
] | // RecordLatencies sets records latencies | [
"RecordLatencies",
"sets",
"records",
"latencies"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/histogram.go#L210-L212 |
149,336 | vulcand/oxy | memmetrics/histogram.go | RecordValues | func (r *RollingHDRHistogram) RecordValues(v, n int64) error {
return r.getHist().RecordValues(v, n)
} | go | func (r *RollingHDRHistogram) RecordValues(v, n int64) error {
return r.getHist().RecordValues(v, n)
} | [
"func",
"(",
"r",
"*",
"RollingHDRHistogram",
")",
"RecordValues",
"(",
"v",
",",
"n",
"int64",
")",
"error",
"{",
"return",
"r",
".",
"getHist",
"(",
")",
".",
"RecordValues",
"(",
"v",
",",
"n",
")",
"\n",
"}"
] | // RecordValues set record values | [
"RecordValues",
"set",
"record",
"values"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/histogram.go#L215-L217 |
149,337 | vulcand/oxy | stream/threshold.go | IsValidExpression | func IsValidExpression(expr string) bool {
_, err := parseExpression(expr)
return err == nil
} | go | func IsValidExpression(expr string) bool {
_, err := parseExpression(expr)
return err == nil
} | [
"func",
"IsValidExpression",
"(",
"expr",
"string",
")",
"bool",
"{",
"_",
",",
"err",
":=",
"parseExpression",
"(",
"expr",
")",
"\n",
"return",
"err",
"==",
"nil",
"\n",
"}"
] | // IsValidExpression check if it's a valid expression | [
"IsValidExpression",
"check",
"if",
"it",
"s",
"a",
"valid",
"expression"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/stream/threshold.go#L11-L14 |
149,338 | vulcand/oxy | stream/threshold.go | lt | func lt(m interface{}, value interface{}) (hpredicate, error) {
switch mapper := m.(type) {
case toInt:
return intLT(mapper, value)
}
return nil, fmt.Errorf("unsupported argument: %T", m)
} | go | func lt(m interface{}, value interface{}) (hpredicate, error) {
switch mapper := m.(type) {
case toInt:
return intLT(mapper, value)
}
return nil, fmt.Errorf("unsupported argument: %T", m)
} | [
"func",
"lt",
"(",
"m",
"interface",
"{",
"}",
",",
"value",
"interface",
"{",
"}",
")",
"(",
"hpredicate",
",",
"error",
")",
"{",
"switch",
"mapper",
":=",
"m",
".",
"(",
"type",
")",
"{",
"case",
"toInt",
":",
"return",
"intLT",
"(",
"mapper",
",",
"value",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"m",
")",
"\n",
"}"
] | // lt returns predicate that tests that value of the mapper function is less than the constant | [
"lt",
"returns",
"predicate",
"that",
"tests",
"that",
"value",
"of",
"the",
"mapper",
"function",
"is",
"less",
"than",
"the",
"constant"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/stream/threshold.go#L141-L147 |
149,339 | vulcand/oxy | roundrobin/stickysessions.go | GetBackend | func (s *StickySession) GetBackend(req *http.Request, servers []*url.URL) (*url.URL, bool, error) {
cookie, err := req.Cookie(s.cookieName)
switch err {
case nil:
case http.ErrNoCookie:
return nil, false, nil
default:
return nil, false, err
}
serverURL, err := url.Parse(cookie.Value)
if err != nil {
return nil, false, err
}
if s.isBackendAlive(serverURL, servers) {
return serverURL, true, nil
}
return nil, false, nil
} | go | func (s *StickySession) GetBackend(req *http.Request, servers []*url.URL) (*url.URL, bool, error) {
cookie, err := req.Cookie(s.cookieName)
switch err {
case nil:
case http.ErrNoCookie:
return nil, false, nil
default:
return nil, false, err
}
serverURL, err := url.Parse(cookie.Value)
if err != nil {
return nil, false, err
}
if s.isBackendAlive(serverURL, servers) {
return serverURL, true, nil
}
return nil, false, nil
} | [
"func",
"(",
"s",
"*",
"StickySession",
")",
"GetBackend",
"(",
"req",
"*",
"http",
".",
"Request",
",",
"servers",
"[",
"]",
"*",
"url",
".",
"URL",
")",
"(",
"*",
"url",
".",
"URL",
",",
"bool",
",",
"error",
")",
"{",
"cookie",
",",
"err",
":=",
"req",
".",
"Cookie",
"(",
"s",
".",
"cookieName",
")",
"\n",
"switch",
"err",
"{",
"case",
"nil",
":",
"case",
"http",
".",
"ErrNoCookie",
":",
"return",
"nil",
",",
"false",
",",
"nil",
"\n",
"default",
":",
"return",
"nil",
",",
"false",
",",
"err",
"\n",
"}",
"\n\n",
"serverURL",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"cookie",
".",
"Value",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"false",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"s",
".",
"isBackendAlive",
"(",
"serverURL",
",",
"servers",
")",
"{",
"return",
"serverURL",
",",
"true",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"false",
",",
"nil",
"\n",
"}"
] | // GetBackend returns the backend URL stored in the sticky cookie, iff the backend is still in the valid list of servers. | [
"GetBackend",
"returns",
"the",
"backend",
"URL",
"stored",
"in",
"the",
"sticky",
"cookie",
"iff",
"the",
"backend",
"is",
"still",
"in",
"the",
"valid",
"list",
"of",
"servers",
"."
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/roundrobin/stickysessions.go#L19-L38 |
149,340 | vulcand/oxy | roundrobin/stickysessions.go | StickBackend | func (s *StickySession) StickBackend(backend *url.URL, w *http.ResponseWriter) {
cookie := &http.Cookie{Name: s.cookieName, Value: backend.String(), Path: "/"}
http.SetCookie(*w, cookie)
} | go | func (s *StickySession) StickBackend(backend *url.URL, w *http.ResponseWriter) {
cookie := &http.Cookie{Name: s.cookieName, Value: backend.String(), Path: "/"}
http.SetCookie(*w, cookie)
} | [
"func",
"(",
"s",
"*",
"StickySession",
")",
"StickBackend",
"(",
"backend",
"*",
"url",
".",
"URL",
",",
"w",
"*",
"http",
".",
"ResponseWriter",
")",
"{",
"cookie",
":=",
"&",
"http",
".",
"Cookie",
"{",
"Name",
":",
"s",
".",
"cookieName",
",",
"Value",
":",
"backend",
".",
"String",
"(",
")",
",",
"Path",
":",
"\"",
"\"",
"}",
"\n",
"http",
".",
"SetCookie",
"(",
"*",
"w",
",",
"cookie",
")",
"\n",
"}"
] | // StickBackend creates and sets the cookie | [
"StickBackend",
"creates",
"and",
"sets",
"the",
"cookie"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/roundrobin/stickysessions.go#L41-L44 |
149,341 | vulcand/oxy | forward/fwd.go | PassHostHeader | func PassHostHeader(b bool) optSetter {
return func(f *Forwarder) error {
f.httpForwarder.passHost = b
return nil
}
} | go | func PassHostHeader(b bool) optSetter {
return func(f *Forwarder) error {
f.httpForwarder.passHost = b
return nil
}
} | [
"func",
"PassHostHeader",
"(",
"b",
"bool",
")",
"optSetter",
"{",
"return",
"func",
"(",
"f",
"*",
"Forwarder",
")",
"error",
"{",
"f",
".",
"httpForwarder",
".",
"passHost",
"=",
"b",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // PassHostHeader specifies if a client's Host header field should be delegated | [
"PassHostHeader",
"specifies",
"if",
"a",
"client",
"s",
"Host",
"header",
"field",
"should",
"be",
"delegated"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/forward/fwd.go#L49-L54 |
149,342 | vulcand/oxy | forward/fwd.go | RoundTripper | func RoundTripper(r http.RoundTripper) optSetter {
return func(f *Forwarder) error {
f.httpForwarder.roundTripper = r
return nil
}
} | go | func RoundTripper(r http.RoundTripper) optSetter {
return func(f *Forwarder) error {
f.httpForwarder.roundTripper = r
return nil
}
} | [
"func",
"RoundTripper",
"(",
"r",
"http",
".",
"RoundTripper",
")",
"optSetter",
"{",
"return",
"func",
"(",
"f",
"*",
"Forwarder",
")",
"error",
"{",
"f",
".",
"httpForwarder",
".",
"roundTripper",
"=",
"r",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // RoundTripper sets a new http.RoundTripper
// Forwarder will use http.DefaultTransport as a default round tripper | [
"RoundTripper",
"sets",
"a",
"new",
"http",
".",
"RoundTripper",
"Forwarder",
"will",
"use",
"http",
".",
"DefaultTransport",
"as",
"a",
"default",
"round",
"tripper"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/forward/fwd.go#L58-L63 |
149,343 | vulcand/oxy | forward/fwd.go | Rewriter | func Rewriter(r ReqRewriter) optSetter {
return func(f *Forwarder) error {
f.httpForwarder.rewriter = r
return nil
}
} | go | func Rewriter(r ReqRewriter) optSetter {
return func(f *Forwarder) error {
f.httpForwarder.rewriter = r
return nil
}
} | [
"func",
"Rewriter",
"(",
"r",
"ReqRewriter",
")",
"optSetter",
"{",
"return",
"func",
"(",
"f",
"*",
"Forwarder",
")",
"error",
"{",
"f",
".",
"httpForwarder",
".",
"rewriter",
"=",
"r",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // Rewriter defines a request rewriter for the HTTP forwarder | [
"Rewriter",
"defines",
"a",
"request",
"rewriter",
"for",
"the",
"HTTP",
"forwarder"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/forward/fwd.go#L66-L71 |
149,344 | vulcand/oxy | forward/fwd.go | WebsocketTLSClientConfig | func WebsocketTLSClientConfig(tcc *tls.Config) optSetter {
return func(f *Forwarder) error {
f.httpForwarder.tlsClientConfig = tcc
return nil
}
} | go | func WebsocketTLSClientConfig(tcc *tls.Config) optSetter {
return func(f *Forwarder) error {
f.httpForwarder.tlsClientConfig = tcc
return nil
}
} | [
"func",
"WebsocketTLSClientConfig",
"(",
"tcc",
"*",
"tls",
".",
"Config",
")",
"optSetter",
"{",
"return",
"func",
"(",
"f",
"*",
"Forwarder",
")",
"error",
"{",
"f",
".",
"httpForwarder",
".",
"tlsClientConfig",
"=",
"tcc",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // WebsocketTLSClientConfig define the websocker client TLS configuration | [
"WebsocketTLSClientConfig",
"define",
"the",
"websocker",
"client",
"TLS",
"configuration"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/forward/fwd.go#L74-L79 |
149,345 | vulcand/oxy | forward/fwd.go | BufferPool | func BufferPool(pool httputil.BufferPool) optSetter {
return func(f *Forwarder) error {
f.bufferPool = pool
return nil
}
} | go | func BufferPool(pool httputil.BufferPool) optSetter {
return func(f *Forwarder) error {
f.bufferPool = pool
return nil
}
} | [
"func",
"BufferPool",
"(",
"pool",
"httputil",
".",
"BufferPool",
")",
"optSetter",
"{",
"return",
"func",
"(",
"f",
"*",
"Forwarder",
")",
"error",
"{",
"f",
".",
"bufferPool",
"=",
"pool",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // BufferPool specifies a buffer pool for httputil.ReverseProxy. | [
"BufferPool",
"specifies",
"a",
"buffer",
"pool",
"for",
"httputil",
".",
"ReverseProxy",
"."
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/forward/fwd.go#L90-L95 |
149,346 | vulcand/oxy | forward/fwd.go | Stream | func Stream(stream bool) optSetter {
return func(f *Forwarder) error {
f.stream = stream
return nil
}
} | go | func Stream(stream bool) optSetter {
return func(f *Forwarder) error {
f.stream = stream
return nil
}
} | [
"func",
"Stream",
"(",
"stream",
"bool",
")",
"optSetter",
"{",
"return",
"func",
"(",
"f",
"*",
"Forwarder",
")",
"error",
"{",
"f",
".",
"stream",
"=",
"stream",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // Stream specifies if HTTP responses should be streamed. | [
"Stream",
"specifies",
"if",
"HTTP",
"responses",
"should",
"be",
"streamed",
"."
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/forward/fwd.go#L98-L103 |
149,347 | vulcand/oxy | forward/fwd.go | StateListener | func StateListener(stateListener UrlForwardingStateListener) optSetter {
return func(f *Forwarder) error {
f.stateListener = stateListener
return nil
}
} | go | func StateListener(stateListener UrlForwardingStateListener) optSetter {
return func(f *Forwarder) error {
f.stateListener = stateListener
return nil
}
} | [
"func",
"StateListener",
"(",
"stateListener",
"UrlForwardingStateListener",
")",
"optSetter",
"{",
"return",
"func",
"(",
"f",
"*",
"Forwarder",
")",
"error",
"{",
"f",
".",
"stateListener",
"=",
"stateListener",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // StateListener defines a state listener for the HTTP forwarder | [
"StateListener",
"defines",
"a",
"state",
"listener",
"for",
"the",
"HTTP",
"forwarder"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/forward/fwd.go#L125-L130 |
149,348 | vulcand/oxy | forward/fwd.go | WebsocketConnectionClosedHook | func WebsocketConnectionClosedHook(hook func(req *http.Request, conn net.Conn)) optSetter {
return func(f *Forwarder) error {
f.httpForwarder.websocketConnectionClosedHook = hook
return nil
}
} | go | func WebsocketConnectionClosedHook(hook func(req *http.Request, conn net.Conn)) optSetter {
return func(f *Forwarder) error {
f.httpForwarder.websocketConnectionClosedHook = hook
return nil
}
} | [
"func",
"WebsocketConnectionClosedHook",
"(",
"hook",
"func",
"(",
"req",
"*",
"http",
".",
"Request",
",",
"conn",
"net",
".",
"Conn",
")",
")",
"optSetter",
"{",
"return",
"func",
"(",
"f",
"*",
"Forwarder",
")",
"error",
"{",
"f",
".",
"httpForwarder",
".",
"websocketConnectionClosedHook",
"=",
"hook",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // WebsocketConnectionClosedHook defines a hook called when websocket connection is closed | [
"WebsocketConnectionClosedHook",
"defines",
"a",
"hook",
"called",
"when",
"websocket",
"connection",
"is",
"closed"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/forward/fwd.go#L133-L138 |
149,349 | vulcand/oxy | forward/fwd.go | ResponseModifier | func ResponseModifier(responseModifier func(*http.Response) error) optSetter {
return func(f *Forwarder) error {
f.httpForwarder.modifyResponse = responseModifier
return nil
}
} | go | func ResponseModifier(responseModifier func(*http.Response) error) optSetter {
return func(f *Forwarder) error {
f.httpForwarder.modifyResponse = responseModifier
return nil
}
} | [
"func",
"ResponseModifier",
"(",
"responseModifier",
"func",
"(",
"*",
"http",
".",
"Response",
")",
"error",
")",
"optSetter",
"{",
"return",
"func",
"(",
"f",
"*",
"Forwarder",
")",
"error",
"{",
"f",
".",
"httpForwarder",
".",
"modifyResponse",
"=",
"responseModifier",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // ResponseModifier defines a response modifier for the HTTP forwarder | [
"ResponseModifier",
"defines",
"a",
"response",
"modifier",
"for",
"the",
"HTTP",
"forwarder"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/forward/fwd.go#L141-L146 |
149,350 | vulcand/oxy | forward/fwd.go | StreamingFlushInterval | func StreamingFlushInterval(flushInterval time.Duration) optSetter {
return func(f *Forwarder) error {
f.httpForwarder.flushInterval = flushInterval
return nil
}
} | go | func StreamingFlushInterval(flushInterval time.Duration) optSetter {
return func(f *Forwarder) error {
f.httpForwarder.flushInterval = flushInterval
return nil
}
} | [
"func",
"StreamingFlushInterval",
"(",
"flushInterval",
"time",
".",
"Duration",
")",
"optSetter",
"{",
"return",
"func",
"(",
"f",
"*",
"Forwarder",
")",
"error",
"{",
"f",
".",
"httpForwarder",
".",
"flushInterval",
"=",
"flushInterval",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // StreamingFlushInterval defines a streaming flush interval for the HTTP forwarder | [
"StreamingFlushInterval",
"defines",
"a",
"streaming",
"flush",
"interval",
"for",
"the",
"HTTP",
"forwarder"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/forward/fwd.go#L149-L154 |
149,351 | vulcand/oxy | forward/fwd.go | RoundTrip | func (rt ErrorHandlingRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
res, err := rt.RoundTripper.RoundTrip(req)
if err != nil {
// We use the recorder from httptest because there isn't another `public` implementation of a recorder.
recorder := httptest.NewRecorder()
rt.errorHandler.ServeHTTP(recorder, req, err)
res = recorder.Result()
err = nil
}
return res, err
} | go | func (rt ErrorHandlingRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
res, err := rt.RoundTripper.RoundTrip(req)
if err != nil {
// We use the recorder from httptest because there isn't another `public` implementation of a recorder.
recorder := httptest.NewRecorder()
rt.errorHandler.ServeHTTP(recorder, req, err)
res = recorder.Result()
err = nil
}
return res, err
} | [
"func",
"(",
"rt",
"ErrorHandlingRoundTripper",
")",
"RoundTrip",
"(",
"req",
"*",
"http",
".",
"Request",
")",
"(",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"res",
",",
"err",
":=",
"rt",
".",
"RoundTripper",
".",
"RoundTrip",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// We use the recorder from httptest because there isn't another `public` implementation of a recorder.",
"recorder",
":=",
"httptest",
".",
"NewRecorder",
"(",
")",
"\n",
"rt",
".",
"errorHandler",
".",
"ServeHTTP",
"(",
"recorder",
",",
"req",
",",
"err",
")",
"\n",
"res",
"=",
"recorder",
".",
"Result",
"(",
")",
"\n",
"err",
"=",
"nil",
"\n",
"}",
"\n",
"return",
"res",
",",
"err",
"\n",
"}"
] | // RoundTrip executes the round trip | [
"RoundTrip",
"executes",
"the",
"round",
"trip"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/forward/fwd.go#L163-L173 |
149,352 | vulcand/oxy | forward/fwd.go | New | func New(setters ...optSetter) (*Forwarder, error) {
f := &Forwarder{
httpForwarder: &httpForwarder{log: &internalLogger{Logger: log.StandardLogger()}},
handlerContext: &handlerContext{},
}
for _, s := range setters {
if err := s(f); err != nil {
return nil, err
}
}
if !f.stream {
f.flushInterval = 0
} else if f.flushInterval == 0 {
f.flushInterval = defaultFlushInterval
}
if f.httpForwarder.rewriter == nil {
h, err := os.Hostname()
if err != nil {
h = "localhost"
}
f.httpForwarder.rewriter = &HeaderRewriter{TrustForwardHeader: true, Hostname: h}
}
if f.httpForwarder.roundTripper == nil {
f.httpForwarder.roundTripper = http.DefaultTransport
}
if f.errHandler == nil {
f.errHandler = utils.DefaultHandler
}
if f.tlsClientConfig == nil {
if ht, ok := f.httpForwarder.roundTripper.(*http.Transport); ok {
f.tlsClientConfig = ht.TLSClientConfig
}
}
f.httpForwarder.roundTripper = ErrorHandlingRoundTripper{
RoundTripper: f.httpForwarder.roundTripper,
errorHandler: f.errHandler,
}
f.postConfig()
return f, nil
} | go | func New(setters ...optSetter) (*Forwarder, error) {
f := &Forwarder{
httpForwarder: &httpForwarder{log: &internalLogger{Logger: log.StandardLogger()}},
handlerContext: &handlerContext{},
}
for _, s := range setters {
if err := s(f); err != nil {
return nil, err
}
}
if !f.stream {
f.flushInterval = 0
} else if f.flushInterval == 0 {
f.flushInterval = defaultFlushInterval
}
if f.httpForwarder.rewriter == nil {
h, err := os.Hostname()
if err != nil {
h = "localhost"
}
f.httpForwarder.rewriter = &HeaderRewriter{TrustForwardHeader: true, Hostname: h}
}
if f.httpForwarder.roundTripper == nil {
f.httpForwarder.roundTripper = http.DefaultTransport
}
if f.errHandler == nil {
f.errHandler = utils.DefaultHandler
}
if f.tlsClientConfig == nil {
if ht, ok := f.httpForwarder.roundTripper.(*http.Transport); ok {
f.tlsClientConfig = ht.TLSClientConfig
}
}
f.httpForwarder.roundTripper = ErrorHandlingRoundTripper{
RoundTripper: f.httpForwarder.roundTripper,
errorHandler: f.errHandler,
}
f.postConfig()
return f, nil
} | [
"func",
"New",
"(",
"setters",
"...",
"optSetter",
")",
"(",
"*",
"Forwarder",
",",
"error",
")",
"{",
"f",
":=",
"&",
"Forwarder",
"{",
"httpForwarder",
":",
"&",
"httpForwarder",
"{",
"log",
":",
"&",
"internalLogger",
"{",
"Logger",
":",
"log",
".",
"StandardLogger",
"(",
")",
"}",
"}",
",",
"handlerContext",
":",
"&",
"handlerContext",
"{",
"}",
",",
"}",
"\n",
"for",
"_",
",",
"s",
":=",
"range",
"setters",
"{",
"if",
"err",
":=",
"s",
"(",
"f",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"!",
"f",
".",
"stream",
"{",
"f",
".",
"flushInterval",
"=",
"0",
"\n",
"}",
"else",
"if",
"f",
".",
"flushInterval",
"==",
"0",
"{",
"f",
".",
"flushInterval",
"=",
"defaultFlushInterval",
"\n",
"}",
"\n\n",
"if",
"f",
".",
"httpForwarder",
".",
"rewriter",
"==",
"nil",
"{",
"h",
",",
"err",
":=",
"os",
".",
"Hostname",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"h",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"f",
".",
"httpForwarder",
".",
"rewriter",
"=",
"&",
"HeaderRewriter",
"{",
"TrustForwardHeader",
":",
"true",
",",
"Hostname",
":",
"h",
"}",
"\n",
"}",
"\n\n",
"if",
"f",
".",
"httpForwarder",
".",
"roundTripper",
"==",
"nil",
"{",
"f",
".",
"httpForwarder",
".",
"roundTripper",
"=",
"http",
".",
"DefaultTransport",
"\n",
"}",
"\n\n",
"if",
"f",
".",
"errHandler",
"==",
"nil",
"{",
"f",
".",
"errHandler",
"=",
"utils",
".",
"DefaultHandler",
"\n",
"}",
"\n\n",
"if",
"f",
".",
"tlsClientConfig",
"==",
"nil",
"{",
"if",
"ht",
",",
"ok",
":=",
"f",
".",
"httpForwarder",
".",
"roundTripper",
".",
"(",
"*",
"http",
".",
"Transport",
")",
";",
"ok",
"{",
"f",
".",
"tlsClientConfig",
"=",
"ht",
".",
"TLSClientConfig",
"\n",
"}",
"\n",
"}",
"\n\n",
"f",
".",
"httpForwarder",
".",
"roundTripper",
"=",
"ErrorHandlingRoundTripper",
"{",
"RoundTripper",
":",
"f",
".",
"httpForwarder",
".",
"roundTripper",
",",
"errorHandler",
":",
"f",
".",
"errHandler",
",",
"}",
"\n\n",
"f",
".",
"postConfig",
"(",
")",
"\n\n",
"return",
"f",
",",
"nil",
"\n",
"}"
] | // New creates an instance of Forwarder based on the provided list of configuration options | [
"New",
"creates",
"an",
"instance",
"of",
"Forwarder",
"based",
"on",
"the",
"provided",
"list",
"of",
"configuration",
"options"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/forward/fwd.go#L218-L265 |
149,353 | vulcand/oxy | forward/fwd.go | ServeHTTP | func (f *Forwarder) ServeHTTP(w http.ResponseWriter, req *http.Request) {
if f.log.GetLevel() >= log.DebugLevel {
logEntry := f.log.WithField("Request", utils.DumpHttpRequest(req))
logEntry.Debug("vulcand/oxy/forward: begin ServeHttp on request")
defer logEntry.Debug("vulcand/oxy/forward: completed ServeHttp on request")
}
if f.stateListener != nil {
f.stateListener(req.URL, StateConnected)
defer f.stateListener(req.URL, StateDisconnected)
}
if IsWebsocketRequest(req) {
f.httpForwarder.serveWebSocket(w, req, f.handlerContext)
} else {
f.httpForwarder.serveHTTP(w, req, f.handlerContext)
}
} | go | func (f *Forwarder) ServeHTTP(w http.ResponseWriter, req *http.Request) {
if f.log.GetLevel() >= log.DebugLevel {
logEntry := f.log.WithField("Request", utils.DumpHttpRequest(req))
logEntry.Debug("vulcand/oxy/forward: begin ServeHttp on request")
defer logEntry.Debug("vulcand/oxy/forward: completed ServeHttp on request")
}
if f.stateListener != nil {
f.stateListener(req.URL, StateConnected)
defer f.stateListener(req.URL, StateDisconnected)
}
if IsWebsocketRequest(req) {
f.httpForwarder.serveWebSocket(w, req, f.handlerContext)
} else {
f.httpForwarder.serveHTTP(w, req, f.handlerContext)
}
} | [
"func",
"(",
"f",
"*",
"Forwarder",
")",
"ServeHTTP",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
")",
"{",
"if",
"f",
".",
"log",
".",
"GetLevel",
"(",
")",
">=",
"log",
".",
"DebugLevel",
"{",
"logEntry",
":=",
"f",
".",
"log",
".",
"WithField",
"(",
"\"",
"\"",
",",
"utils",
".",
"DumpHttpRequest",
"(",
"req",
")",
")",
"\n",
"logEntry",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"defer",
"logEntry",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"f",
".",
"stateListener",
"!=",
"nil",
"{",
"f",
".",
"stateListener",
"(",
"req",
".",
"URL",
",",
"StateConnected",
")",
"\n",
"defer",
"f",
".",
"stateListener",
"(",
"req",
".",
"URL",
",",
"StateDisconnected",
")",
"\n",
"}",
"\n",
"if",
"IsWebsocketRequest",
"(",
"req",
")",
"{",
"f",
".",
"httpForwarder",
".",
"serveWebSocket",
"(",
"w",
",",
"req",
",",
"f",
".",
"handlerContext",
")",
"\n",
"}",
"else",
"{",
"f",
".",
"httpForwarder",
".",
"serveHTTP",
"(",
"w",
",",
"req",
",",
"f",
".",
"handlerContext",
")",
"\n",
"}",
"\n",
"}"
] | // ServeHTTP decides which forwarder to use based on the specified
// request and delegates to the proper implementation | [
"ServeHTTP",
"decides",
"which",
"forwarder",
"to",
"use",
"based",
"on",
"the",
"specified",
"request",
"and",
"delegates",
"to",
"the",
"proper",
"implementation"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/forward/fwd.go#L269-L285 |
149,354 | vulcand/oxy | forward/fwd.go | copyWebSocketRequest | func (f *httpForwarder) copyWebSocketRequest(req *http.Request) (outReq *http.Request) {
outReq = new(http.Request)
*outReq = *req // includes shallow copies of maps, but we handle this below
outReq.URL = utils.CopyURL(req.URL)
outReq.URL.Scheme = req.URL.Scheme
// sometimes backends might be registered as HTTP/HTTPS servers so translate URLs to websocket URLs.
switch req.URL.Scheme {
case "https":
outReq.URL.Scheme = "wss"
case "http":
outReq.URL.Scheme = "ws"
}
u := f.getUrlFromRequest(outReq)
outReq.URL.Path = u.Path
outReq.URL.RawPath = u.RawPath
outReq.URL.RawQuery = u.RawQuery
outReq.RequestURI = "" // Outgoing request should not have RequestURI
outReq.URL.Host = req.URL.Host
if !f.passHost {
outReq.Host = req.URL.Host
}
outReq.Header = make(http.Header)
// gorilla websocket use this header to set the request.Host tested in checkSameOrigin
outReq.Header.Set("Host", outReq.Host)
utils.CopyHeaders(outReq.Header, req.Header)
utils.RemoveHeaders(outReq.Header, WebsocketDialHeaders...)
if f.rewriter != nil {
f.rewriter.Rewrite(outReq)
}
return outReq
} | go | func (f *httpForwarder) copyWebSocketRequest(req *http.Request) (outReq *http.Request) {
outReq = new(http.Request)
*outReq = *req // includes shallow copies of maps, but we handle this below
outReq.URL = utils.CopyURL(req.URL)
outReq.URL.Scheme = req.URL.Scheme
// sometimes backends might be registered as HTTP/HTTPS servers so translate URLs to websocket URLs.
switch req.URL.Scheme {
case "https":
outReq.URL.Scheme = "wss"
case "http":
outReq.URL.Scheme = "ws"
}
u := f.getUrlFromRequest(outReq)
outReq.URL.Path = u.Path
outReq.URL.RawPath = u.RawPath
outReq.URL.RawQuery = u.RawQuery
outReq.RequestURI = "" // Outgoing request should not have RequestURI
outReq.URL.Host = req.URL.Host
if !f.passHost {
outReq.Host = req.URL.Host
}
outReq.Header = make(http.Header)
// gorilla websocket use this header to set the request.Host tested in checkSameOrigin
outReq.Header.Set("Host", outReq.Host)
utils.CopyHeaders(outReq.Header, req.Header)
utils.RemoveHeaders(outReq.Header, WebsocketDialHeaders...)
if f.rewriter != nil {
f.rewriter.Rewrite(outReq)
}
return outReq
} | [
"func",
"(",
"f",
"*",
"httpForwarder",
")",
"copyWebSocketRequest",
"(",
"req",
"*",
"http",
".",
"Request",
")",
"(",
"outReq",
"*",
"http",
".",
"Request",
")",
"{",
"outReq",
"=",
"new",
"(",
"http",
".",
"Request",
")",
"\n",
"*",
"outReq",
"=",
"*",
"req",
"// includes shallow copies of maps, but we handle this below",
"\n\n",
"outReq",
".",
"URL",
"=",
"utils",
".",
"CopyURL",
"(",
"req",
".",
"URL",
")",
"\n",
"outReq",
".",
"URL",
".",
"Scheme",
"=",
"req",
".",
"URL",
".",
"Scheme",
"\n\n",
"// sometimes backends might be registered as HTTP/HTTPS servers so translate URLs to websocket URLs.",
"switch",
"req",
".",
"URL",
".",
"Scheme",
"{",
"case",
"\"",
"\"",
":",
"outReq",
".",
"URL",
".",
"Scheme",
"=",
"\"",
"\"",
"\n",
"case",
"\"",
"\"",
":",
"outReq",
".",
"URL",
".",
"Scheme",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"u",
":=",
"f",
".",
"getUrlFromRequest",
"(",
"outReq",
")",
"\n\n",
"outReq",
".",
"URL",
".",
"Path",
"=",
"u",
".",
"Path",
"\n",
"outReq",
".",
"URL",
".",
"RawPath",
"=",
"u",
".",
"RawPath",
"\n",
"outReq",
".",
"URL",
".",
"RawQuery",
"=",
"u",
".",
"RawQuery",
"\n",
"outReq",
".",
"RequestURI",
"=",
"\"",
"\"",
"// Outgoing request should not have RequestURI",
"\n\n",
"outReq",
".",
"URL",
".",
"Host",
"=",
"req",
".",
"URL",
".",
"Host",
"\n",
"if",
"!",
"f",
".",
"passHost",
"{",
"outReq",
".",
"Host",
"=",
"req",
".",
"URL",
".",
"Host",
"\n",
"}",
"\n\n",
"outReq",
".",
"Header",
"=",
"make",
"(",
"http",
".",
"Header",
")",
"\n",
"// gorilla websocket use this header to set the request.Host tested in checkSameOrigin",
"outReq",
".",
"Header",
".",
"Set",
"(",
"\"",
"\"",
",",
"outReq",
".",
"Host",
")",
"\n",
"utils",
".",
"CopyHeaders",
"(",
"outReq",
".",
"Header",
",",
"req",
".",
"Header",
")",
"\n",
"utils",
".",
"RemoveHeaders",
"(",
"outReq",
".",
"Header",
",",
"WebsocketDialHeaders",
"...",
")",
"\n\n",
"if",
"f",
".",
"rewriter",
"!=",
"nil",
"{",
"f",
".",
"rewriter",
".",
"Rewrite",
"(",
"outReq",
")",
"\n",
"}",
"\n",
"return",
"outReq",
"\n",
"}"
] | // copyWebsocketRequest makes a copy of the specified request. | [
"copyWebsocketRequest",
"makes",
"a",
"copy",
"of",
"the",
"specified",
"request",
"."
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/forward/fwd.go#L471-L508 |
149,355 | vulcand/oxy | forward/fwd.go | serveHTTP | func (f *httpForwarder) serveHTTP(w http.ResponseWriter, inReq *http.Request, ctx *handlerContext) {
if f.log.GetLevel() >= log.DebugLevel {
logEntry := f.log.WithField("Request", utils.DumpHttpRequest(inReq))
logEntry.Debug("vulcand/oxy/forward/http: begin ServeHttp on request")
defer logEntry.Debug("vulcand/oxy/forward/http: completed ServeHttp on request")
}
start := time.Now().UTC()
outReq := new(http.Request)
*outReq = *inReq // includes shallow copies of maps, but we handle this in Director
revproxy := httputil.ReverseProxy{
Director: func(req *http.Request) {
f.modifyRequest(req, inReq.URL)
},
Transport: f.roundTripper,
FlushInterval: f.flushInterval,
ModifyResponse: f.modifyResponse,
BufferPool: f.bufferPool,
}
if f.log.GetLevel() >= log.DebugLevel {
pw := utils.NewProxyWriter(w)
revproxy.ServeHTTP(pw, outReq)
if inReq.TLS != nil {
f.log.Debugf("vulcand/oxy/forward/http: Round trip: %v, code: %v, Length: %v, duration: %v tls:version: %x, tls:resume:%t, tls:csuite:%x, tls:server:%v",
inReq.URL, pw.StatusCode(), pw.GetLength(), time.Now().UTC().Sub(start),
inReq.TLS.Version,
inReq.TLS.DidResume,
inReq.TLS.CipherSuite,
inReq.TLS.ServerName)
} else {
f.log.Debugf("vulcand/oxy/forward/http: Round trip: %v, code: %v, Length: %v, duration: %v",
inReq.URL, pw.StatusCode(), pw.GetLength(), time.Now().UTC().Sub(start))
}
} else {
revproxy.ServeHTTP(w, outReq)
}
for key := range w.Header() {
if strings.HasPrefix(key, http.TrailerPrefix) {
if fl, ok := w.(http.Flusher); ok {
fl.Flush()
}
break
}
}
} | go | func (f *httpForwarder) serveHTTP(w http.ResponseWriter, inReq *http.Request, ctx *handlerContext) {
if f.log.GetLevel() >= log.DebugLevel {
logEntry := f.log.WithField("Request", utils.DumpHttpRequest(inReq))
logEntry.Debug("vulcand/oxy/forward/http: begin ServeHttp on request")
defer logEntry.Debug("vulcand/oxy/forward/http: completed ServeHttp on request")
}
start := time.Now().UTC()
outReq := new(http.Request)
*outReq = *inReq // includes shallow copies of maps, but we handle this in Director
revproxy := httputil.ReverseProxy{
Director: func(req *http.Request) {
f.modifyRequest(req, inReq.URL)
},
Transport: f.roundTripper,
FlushInterval: f.flushInterval,
ModifyResponse: f.modifyResponse,
BufferPool: f.bufferPool,
}
if f.log.GetLevel() >= log.DebugLevel {
pw := utils.NewProxyWriter(w)
revproxy.ServeHTTP(pw, outReq)
if inReq.TLS != nil {
f.log.Debugf("vulcand/oxy/forward/http: Round trip: %v, code: %v, Length: %v, duration: %v tls:version: %x, tls:resume:%t, tls:csuite:%x, tls:server:%v",
inReq.URL, pw.StatusCode(), pw.GetLength(), time.Now().UTC().Sub(start),
inReq.TLS.Version,
inReq.TLS.DidResume,
inReq.TLS.CipherSuite,
inReq.TLS.ServerName)
} else {
f.log.Debugf("vulcand/oxy/forward/http: Round trip: %v, code: %v, Length: %v, duration: %v",
inReq.URL, pw.StatusCode(), pw.GetLength(), time.Now().UTC().Sub(start))
}
} else {
revproxy.ServeHTTP(w, outReq)
}
for key := range w.Header() {
if strings.HasPrefix(key, http.TrailerPrefix) {
if fl, ok := w.(http.Flusher); ok {
fl.Flush()
}
break
}
}
} | [
"func",
"(",
"f",
"*",
"httpForwarder",
")",
"serveHTTP",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"inReq",
"*",
"http",
".",
"Request",
",",
"ctx",
"*",
"handlerContext",
")",
"{",
"if",
"f",
".",
"log",
".",
"GetLevel",
"(",
")",
">=",
"log",
".",
"DebugLevel",
"{",
"logEntry",
":=",
"f",
".",
"log",
".",
"WithField",
"(",
"\"",
"\"",
",",
"utils",
".",
"DumpHttpRequest",
"(",
"inReq",
")",
")",
"\n",
"logEntry",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"defer",
"logEntry",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"start",
":=",
"time",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
"\n\n",
"outReq",
":=",
"new",
"(",
"http",
".",
"Request",
")",
"\n",
"*",
"outReq",
"=",
"*",
"inReq",
"// includes shallow copies of maps, but we handle this in Director",
"\n\n",
"revproxy",
":=",
"httputil",
".",
"ReverseProxy",
"{",
"Director",
":",
"func",
"(",
"req",
"*",
"http",
".",
"Request",
")",
"{",
"f",
".",
"modifyRequest",
"(",
"req",
",",
"inReq",
".",
"URL",
")",
"\n",
"}",
",",
"Transport",
":",
"f",
".",
"roundTripper",
",",
"FlushInterval",
":",
"f",
".",
"flushInterval",
",",
"ModifyResponse",
":",
"f",
".",
"modifyResponse",
",",
"BufferPool",
":",
"f",
".",
"bufferPool",
",",
"}",
"\n\n",
"if",
"f",
".",
"log",
".",
"GetLevel",
"(",
")",
">=",
"log",
".",
"DebugLevel",
"{",
"pw",
":=",
"utils",
".",
"NewProxyWriter",
"(",
"w",
")",
"\n",
"revproxy",
".",
"ServeHTTP",
"(",
"pw",
",",
"outReq",
")",
"\n\n",
"if",
"inReq",
".",
"TLS",
"!=",
"nil",
"{",
"f",
".",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"inReq",
".",
"URL",
",",
"pw",
".",
"StatusCode",
"(",
")",
",",
"pw",
".",
"GetLength",
"(",
")",
",",
"time",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"Sub",
"(",
"start",
")",
",",
"inReq",
".",
"TLS",
".",
"Version",
",",
"inReq",
".",
"TLS",
".",
"DidResume",
",",
"inReq",
".",
"TLS",
".",
"CipherSuite",
",",
"inReq",
".",
"TLS",
".",
"ServerName",
")",
"\n",
"}",
"else",
"{",
"f",
".",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"inReq",
".",
"URL",
",",
"pw",
".",
"StatusCode",
"(",
")",
",",
"pw",
".",
"GetLength",
"(",
")",
",",
"time",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"Sub",
"(",
"start",
")",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"revproxy",
".",
"ServeHTTP",
"(",
"w",
",",
"outReq",
")",
"\n",
"}",
"\n\n",
"for",
"key",
":=",
"range",
"w",
".",
"Header",
"(",
")",
"{",
"if",
"strings",
".",
"HasPrefix",
"(",
"key",
",",
"http",
".",
"TrailerPrefix",
")",
"{",
"if",
"fl",
",",
"ok",
":=",
"w",
".",
"(",
"http",
".",
"Flusher",
")",
";",
"ok",
"{",
"fl",
".",
"Flush",
"(",
")",
"\n",
"}",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n\n",
"}"
] | // serveHTTP forwards HTTP traffic using the configured transport | [
"serveHTTP",
"forwards",
"HTTP",
"traffic",
"using",
"the",
"configured",
"transport"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/forward/fwd.go#L511-L561 |
149,356 | vulcand/oxy | forward/fwd.go | IsWebsocketRequest | func IsWebsocketRequest(req *http.Request) bool {
containsHeader := func(name, value string) bool {
items := strings.Split(req.Header.Get(name), ",")
for _, item := range items {
if value == strings.ToLower(strings.TrimSpace(item)) {
return true
}
}
return false
}
return containsHeader(Connection, "upgrade") && containsHeader(Upgrade, "websocket")
} | go | func IsWebsocketRequest(req *http.Request) bool {
containsHeader := func(name, value string) bool {
items := strings.Split(req.Header.Get(name), ",")
for _, item := range items {
if value == strings.ToLower(strings.TrimSpace(item)) {
return true
}
}
return false
}
return containsHeader(Connection, "upgrade") && containsHeader(Upgrade, "websocket")
} | [
"func",
"IsWebsocketRequest",
"(",
"req",
"*",
"http",
".",
"Request",
")",
"bool",
"{",
"containsHeader",
":=",
"func",
"(",
"name",
",",
"value",
"string",
")",
"bool",
"{",
"items",
":=",
"strings",
".",
"Split",
"(",
"req",
".",
"Header",
".",
"Get",
"(",
"name",
")",
",",
"\"",
"\"",
")",
"\n",
"for",
"_",
",",
"item",
":=",
"range",
"items",
"{",
"if",
"value",
"==",
"strings",
".",
"ToLower",
"(",
"strings",
".",
"TrimSpace",
"(",
"item",
")",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}",
"\n",
"return",
"containsHeader",
"(",
"Connection",
",",
"\"",
"\"",
")",
"&&",
"containsHeader",
"(",
"Upgrade",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // IsWebsocketRequest determines if the specified HTTP request is a
// websocket handshake request | [
"IsWebsocketRequest",
"determines",
"if",
"the",
"specified",
"HTTP",
"request",
"is",
"a",
"websocket",
"handshake",
"request"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/forward/fwd.go#L565-L576 |
149,357 | vulcand/oxy | utils/auth.go | ParseAuthHeader | func ParseAuthHeader(header string) (*BasicAuth, error) {
values := strings.Fields(header)
if len(values) != 2 {
return nil, fmt.Errorf(fmt.Sprintf("Failed to parse header '%s'", header))
}
authType := strings.ToLower(values[0])
if authType != "basic" {
return nil, fmt.Errorf("Expected basic auth type, got '%s'", authType)
}
encodedString := values[1]
decodedString, err := base64.StdEncoding.DecodeString(encodedString)
if err != nil {
return nil, fmt.Errorf("Failed to parse header '%s', base64 failed: %s", header, err)
}
values = strings.SplitN(string(decodedString), ":", 2)
if len(values) != 2 {
return nil, fmt.Errorf("Failed to parse header '%s', expected separator ':'", header)
}
return &BasicAuth{Username: values[0], Password: values[1]}, nil
} | go | func ParseAuthHeader(header string) (*BasicAuth, error) {
values := strings.Fields(header)
if len(values) != 2 {
return nil, fmt.Errorf(fmt.Sprintf("Failed to parse header '%s'", header))
}
authType := strings.ToLower(values[0])
if authType != "basic" {
return nil, fmt.Errorf("Expected basic auth type, got '%s'", authType)
}
encodedString := values[1]
decodedString, err := base64.StdEncoding.DecodeString(encodedString)
if err != nil {
return nil, fmt.Errorf("Failed to parse header '%s', base64 failed: %s", header, err)
}
values = strings.SplitN(string(decodedString), ":", 2)
if len(values) != 2 {
return nil, fmt.Errorf("Failed to parse header '%s', expected separator ':'", header)
}
return &BasicAuth{Username: values[0], Password: values[1]}, nil
} | [
"func",
"ParseAuthHeader",
"(",
"header",
"string",
")",
"(",
"*",
"BasicAuth",
",",
"error",
")",
"{",
"values",
":=",
"strings",
".",
"Fields",
"(",
"header",
")",
"\n",
"if",
"len",
"(",
"values",
")",
"!=",
"2",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"header",
")",
")",
"\n",
"}",
"\n\n",
"authType",
":=",
"strings",
".",
"ToLower",
"(",
"values",
"[",
"0",
"]",
")",
"\n",
"if",
"authType",
"!=",
"\"",
"\"",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"authType",
")",
"\n",
"}",
"\n\n",
"encodedString",
":=",
"values",
"[",
"1",
"]",
"\n",
"decodedString",
",",
"err",
":=",
"base64",
".",
"StdEncoding",
".",
"DecodeString",
"(",
"encodedString",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"header",
",",
"err",
")",
"\n",
"}",
"\n\n",
"values",
"=",
"strings",
".",
"SplitN",
"(",
"string",
"(",
"decodedString",
")",
",",
"\"",
"\"",
",",
"2",
")",
"\n",
"if",
"len",
"(",
"values",
")",
"!=",
"2",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"header",
")",
"\n",
"}",
"\n",
"return",
"&",
"BasicAuth",
"{",
"Username",
":",
"values",
"[",
"0",
"]",
",",
"Password",
":",
"values",
"[",
"1",
"]",
"}",
",",
"nil",
"\n",
"}"
] | // ParseAuthHeader creates a new BasicAuth from header values | [
"ParseAuthHeader",
"creates",
"a",
"new",
"BasicAuth",
"from",
"header",
"values"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/utils/auth.go#L21-L43 |
149,358 | vulcand/oxy | utils/dumpreq.go | Clone | func Clone(r *http.Request) *SerializableHttpRequest {
if r == nil {
return nil
}
rc := new(SerializableHttpRequest)
rc.Method = r.Method
rc.URL = r.URL
rc.Proto = r.Proto
rc.ProtoMajor = r.ProtoMajor
rc.ProtoMinor = r.ProtoMinor
rc.Header = r.Header
rc.ContentLength = r.ContentLength
rc.Host = r.Host
rc.RemoteAddr = r.RemoteAddr
rc.RequestURI = r.RequestURI
return rc
} | go | func Clone(r *http.Request) *SerializableHttpRequest {
if r == nil {
return nil
}
rc := new(SerializableHttpRequest)
rc.Method = r.Method
rc.URL = r.URL
rc.Proto = r.Proto
rc.ProtoMajor = r.ProtoMajor
rc.ProtoMinor = r.ProtoMinor
rc.Header = r.Header
rc.ContentLength = r.ContentLength
rc.Host = r.Host
rc.RemoteAddr = r.RemoteAddr
rc.RequestURI = r.RequestURI
return rc
} | [
"func",
"Clone",
"(",
"r",
"*",
"http",
".",
"Request",
")",
"*",
"SerializableHttpRequest",
"{",
"if",
"r",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"rc",
":=",
"new",
"(",
"SerializableHttpRequest",
")",
"\n",
"rc",
".",
"Method",
"=",
"r",
".",
"Method",
"\n",
"rc",
".",
"URL",
"=",
"r",
".",
"URL",
"\n",
"rc",
".",
"Proto",
"=",
"r",
".",
"Proto",
"\n",
"rc",
".",
"ProtoMajor",
"=",
"r",
".",
"ProtoMajor",
"\n",
"rc",
".",
"ProtoMinor",
"=",
"r",
".",
"ProtoMinor",
"\n",
"rc",
".",
"Header",
"=",
"r",
".",
"Header",
"\n",
"rc",
".",
"ContentLength",
"=",
"r",
".",
"ContentLength",
"\n",
"rc",
".",
"Host",
"=",
"r",
".",
"Host",
"\n",
"rc",
".",
"RemoteAddr",
"=",
"r",
".",
"RemoteAddr",
"\n",
"rc",
".",
"RequestURI",
"=",
"r",
".",
"RequestURI",
"\n",
"return",
"rc",
"\n",
"}"
] | // Clone clone a request | [
"Clone",
"clone",
"a",
"request"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/utils/dumpreq.go#L33-L50 |
149,359 | vulcand/oxy | utils/dumpreq.go | ToJson | func (s *SerializableHttpRequest) ToJson() string {
jsonVal, err := json.Marshal(s)
if err != nil || jsonVal == nil {
return fmt.Sprintf("Error marshalling SerializableHttpRequest to json: %s", err)
}
return string(jsonVal)
} | go | func (s *SerializableHttpRequest) ToJson() string {
jsonVal, err := json.Marshal(s)
if err != nil || jsonVal == nil {
return fmt.Sprintf("Error marshalling SerializableHttpRequest to json: %s", err)
}
return string(jsonVal)
} | [
"func",
"(",
"s",
"*",
"SerializableHttpRequest",
")",
"ToJson",
"(",
")",
"string",
"{",
"jsonVal",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"s",
")",
"\n",
"if",
"err",
"!=",
"nil",
"||",
"jsonVal",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"string",
"(",
"jsonVal",
")",
"\n",
"}"
] | // ToJson serializes to JSON | [
"ToJson",
"serializes",
"to",
"JSON"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/utils/dumpreq.go#L53-L59 |
149,360 | vulcand/oxy | stream/stream.go | Wrap | func (s *Stream) Wrap(next http.Handler) error {
s.next = next
return nil
} | go | func (s *Stream) Wrap(next http.Handler) error {
s.next = next
return nil
} | [
"func",
"(",
"s",
"*",
"Stream",
")",
"Wrap",
"(",
"next",
"http",
".",
"Handler",
")",
"error",
"{",
"s",
".",
"next",
"=",
"next",
"\n",
"return",
"nil",
"\n",
"}"
] | // Wrap sets the next handler to be called by stream handler. | [
"Wrap",
"sets",
"the",
"next",
"handler",
"to",
"be",
"called",
"by",
"stream",
"handler",
"."
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/stream/stream.go#L93-L96 |
149,361 | vulcand/oxy | utils/source.go | NewExtractor | func NewExtractor(variable string) (SourceExtractor, error) {
if variable == "client.ip" {
return ExtractorFunc(extractClientIP), nil
}
if variable == "request.host" {
return ExtractorFunc(extractHost), nil
}
if strings.HasPrefix(variable, "request.header.") {
header := strings.TrimPrefix(variable, "request.header.")
if len(header) == 0 {
return nil, fmt.Errorf("wrong header: %s", header)
}
return makeHeaderExtractor(header), nil
}
return nil, fmt.Errorf("unsupported limiting variable: '%s'", variable)
} | go | func NewExtractor(variable string) (SourceExtractor, error) {
if variable == "client.ip" {
return ExtractorFunc(extractClientIP), nil
}
if variable == "request.host" {
return ExtractorFunc(extractHost), nil
}
if strings.HasPrefix(variable, "request.header.") {
header := strings.TrimPrefix(variable, "request.header.")
if len(header) == 0 {
return nil, fmt.Errorf("wrong header: %s", header)
}
return makeHeaderExtractor(header), nil
}
return nil, fmt.Errorf("unsupported limiting variable: '%s'", variable)
} | [
"func",
"NewExtractor",
"(",
"variable",
"string",
")",
"(",
"SourceExtractor",
",",
"error",
")",
"{",
"if",
"variable",
"==",
"\"",
"\"",
"{",
"return",
"ExtractorFunc",
"(",
"extractClientIP",
")",
",",
"nil",
"\n",
"}",
"\n",
"if",
"variable",
"==",
"\"",
"\"",
"{",
"return",
"ExtractorFunc",
"(",
"extractHost",
")",
",",
"nil",
"\n",
"}",
"\n",
"if",
"strings",
".",
"HasPrefix",
"(",
"variable",
",",
"\"",
"\"",
")",
"{",
"header",
":=",
"strings",
".",
"TrimPrefix",
"(",
"variable",
",",
"\"",
"\"",
")",
"\n",
"if",
"len",
"(",
"header",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"header",
")",
"\n",
"}",
"\n",
"return",
"makeHeaderExtractor",
"(",
"header",
")",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"variable",
")",
"\n",
"}"
] | // NewExtractor creates a new SourceExtractor | [
"NewExtractor",
"creates",
"a",
"new",
"SourceExtractor"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/utils/source.go#L28-L43 |
149,362 | vulcand/oxy | roundrobin/rr.go | Weight | func Weight(w int) ServerOption {
return func(s *server) error {
if w < 0 {
return fmt.Errorf("Weight should be >= 0")
}
s.weight = w
return nil
}
} | go | func Weight(w int) ServerOption {
return func(s *server) error {
if w < 0 {
return fmt.Errorf("Weight should be >= 0")
}
s.weight = w
return nil
}
} | [
"func",
"Weight",
"(",
"w",
"int",
")",
"ServerOption",
"{",
"return",
"func",
"(",
"s",
"*",
"server",
")",
"error",
"{",
"if",
"w",
"<",
"0",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"s",
".",
"weight",
"=",
"w",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // Weight is an optional functional argument that sets weight of the server | [
"Weight",
"is",
"an",
"optional",
"functional",
"argument",
"that",
"sets",
"weight",
"of",
"the",
"server"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/roundrobin/rr.go#L15-L23 |
149,363 | vulcand/oxy | roundrobin/rr.go | EnableStickySession | func EnableStickySession(stickySession *StickySession) LBOption {
return func(s *RoundRobin) error {
s.stickySession = stickySession
return nil
}
} | go | func EnableStickySession(stickySession *StickySession) LBOption {
return func(s *RoundRobin) error {
s.stickySession = stickySession
return nil
}
} | [
"func",
"EnableStickySession",
"(",
"stickySession",
"*",
"StickySession",
")",
"LBOption",
"{",
"return",
"func",
"(",
"s",
"*",
"RoundRobin",
")",
"error",
"{",
"s",
".",
"stickySession",
"=",
"stickySession",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // EnableStickySession enable sticky session | [
"EnableStickySession",
"enable",
"sticky",
"session"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/roundrobin/rr.go#L34-L39 |
149,364 | vulcand/oxy | roundrobin/rr.go | RoundRobinRequestRewriteListener | func RoundRobinRequestRewriteListener(rrl RequestRewriteListener) LBOption {
return func(s *RoundRobin) error {
s.requestRewriteListener = rrl
return nil
}
} | go | func RoundRobinRequestRewriteListener(rrl RequestRewriteListener) LBOption {
return func(s *RoundRobin) error {
s.requestRewriteListener = rrl
return nil
}
} | [
"func",
"RoundRobinRequestRewriteListener",
"(",
"rrl",
"RequestRewriteListener",
")",
"LBOption",
"{",
"return",
"func",
"(",
"s",
"*",
"RoundRobin",
")",
"error",
"{",
"s",
".",
"requestRewriteListener",
"=",
"rrl",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // RoundRobinRequestRewriteListener is a functional argument that sets error handler of the server | [
"RoundRobinRequestRewriteListener",
"is",
"a",
"functional",
"argument",
"that",
"sets",
"error",
"handler",
"of",
"the",
"server"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/roundrobin/rr.go#L42-L47 |
149,365 | vulcand/oxy | roundrobin/rr.go | New | func New(next http.Handler, opts ...LBOption) (*RoundRobin, error) {
rr := &RoundRobin{
next: next,
index: -1,
mutex: &sync.Mutex{},
servers: []*server{},
stickySession: nil,
log: log.StandardLogger(),
}
for _, o := range opts {
if err := o(rr); err != nil {
return nil, err
}
}
if rr.errHandler == nil {
rr.errHandler = utils.DefaultHandler
}
return rr, nil
} | go | func New(next http.Handler, opts ...LBOption) (*RoundRobin, error) {
rr := &RoundRobin{
next: next,
index: -1,
mutex: &sync.Mutex{},
servers: []*server{},
stickySession: nil,
log: log.StandardLogger(),
}
for _, o := range opts {
if err := o(rr); err != nil {
return nil, err
}
}
if rr.errHandler == nil {
rr.errHandler = utils.DefaultHandler
}
return rr, nil
} | [
"func",
"New",
"(",
"next",
"http",
".",
"Handler",
",",
"opts",
"...",
"LBOption",
")",
"(",
"*",
"RoundRobin",
",",
"error",
")",
"{",
"rr",
":=",
"&",
"RoundRobin",
"{",
"next",
":",
"next",
",",
"index",
":",
"-",
"1",
",",
"mutex",
":",
"&",
"sync",
".",
"Mutex",
"{",
"}",
",",
"servers",
":",
"[",
"]",
"*",
"server",
"{",
"}",
",",
"stickySession",
":",
"nil",
",",
"log",
":",
"log",
".",
"StandardLogger",
"(",
")",
",",
"}",
"\n",
"for",
"_",
",",
"o",
":=",
"range",
"opts",
"{",
"if",
"err",
":=",
"o",
"(",
"rr",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"rr",
".",
"errHandler",
"==",
"nil",
"{",
"rr",
".",
"errHandler",
"=",
"utils",
".",
"DefaultHandler",
"\n",
"}",
"\n",
"return",
"rr",
",",
"nil",
"\n",
"}"
] | // New created a new RoundRobin | [
"New",
"created",
"a",
"new",
"RoundRobin"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/roundrobin/rr.go#L65-L84 |
149,366 | vulcand/oxy | roundrobin/rr.go | NextServer | func (r *RoundRobin) NextServer() (*url.URL, error) {
srv, err := r.nextServer()
if err != nil {
return nil, err
}
return utils.CopyURL(srv.url), nil
} | go | func (r *RoundRobin) NextServer() (*url.URL, error) {
srv, err := r.nextServer()
if err != nil {
return nil, err
}
return utils.CopyURL(srv.url), nil
} | [
"func",
"(",
"r",
"*",
"RoundRobin",
")",
"NextServer",
"(",
")",
"(",
"*",
"url",
".",
"URL",
",",
"error",
")",
"{",
"srv",
",",
"err",
":=",
"r",
".",
"nextServer",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"utils",
".",
"CopyURL",
"(",
"srv",
".",
"url",
")",
",",
"nil",
"\n",
"}"
] | // NextServer gets the next server | [
"NextServer",
"gets",
"the",
"next",
"server"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/roundrobin/rr.go#L151-L157 |
149,367 | vulcand/oxy | roundrobin/rr.go | Servers | func (r *RoundRobin) Servers() []*url.URL {
r.mutex.Lock()
defer r.mutex.Unlock()
out := make([]*url.URL, len(r.servers))
for i, srv := range r.servers {
out[i] = srv.url
}
return out
} | go | func (r *RoundRobin) Servers() []*url.URL {
r.mutex.Lock()
defer r.mutex.Unlock()
out := make([]*url.URL, len(r.servers))
for i, srv := range r.servers {
out[i] = srv.url
}
return out
} | [
"func",
"(",
"r",
"*",
"RoundRobin",
")",
"Servers",
"(",
")",
"[",
"]",
"*",
"url",
".",
"URL",
"{",
"r",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"out",
":=",
"make",
"(",
"[",
"]",
"*",
"url",
".",
"URL",
",",
"len",
"(",
"r",
".",
"servers",
")",
")",
"\n",
"for",
"i",
",",
"srv",
":=",
"range",
"r",
".",
"servers",
"{",
"out",
"[",
"i",
"]",
"=",
"srv",
".",
"url",
"\n",
"}",
"\n",
"return",
"out",
"\n",
"}"
] | // Servers gets servers URL | [
"Servers",
"gets",
"servers",
"URL"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/roundrobin/rr.go#L209-L218 |
149,368 | vulcand/oxy | roundrobin/rr.go | ServerWeight | func (r *RoundRobin) ServerWeight(u *url.URL) (int, bool) {
r.mutex.Lock()
defer r.mutex.Unlock()
if s, _ := r.findServerByURL(u); s != nil {
return s.weight, true
}
return -1, false
} | go | func (r *RoundRobin) ServerWeight(u *url.URL) (int, bool) {
r.mutex.Lock()
defer r.mutex.Unlock()
if s, _ := r.findServerByURL(u); s != nil {
return s.weight, true
}
return -1, false
} | [
"func",
"(",
"r",
"*",
"RoundRobin",
")",
"ServerWeight",
"(",
"u",
"*",
"url",
".",
"URL",
")",
"(",
"int",
",",
"bool",
")",
"{",
"r",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"s",
",",
"_",
":=",
"r",
".",
"findServerByURL",
"(",
"u",
")",
";",
"s",
"!=",
"nil",
"{",
"return",
"s",
".",
"weight",
",",
"true",
"\n",
"}",
"\n",
"return",
"-",
"1",
",",
"false",
"\n",
"}"
] | // ServerWeight gets the server weight | [
"ServerWeight",
"gets",
"the",
"server",
"weight"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/roundrobin/rr.go#L221-L229 |
149,369 | vulcand/oxy | roundrobin/rr.go | UpsertServer | func (r *RoundRobin) UpsertServer(u *url.URL, options ...ServerOption) error {
r.mutex.Lock()
defer r.mutex.Unlock()
if u == nil {
return fmt.Errorf("server URL can't be nil")
}
if s, _ := r.findServerByURL(u); s != nil {
for _, o := range options {
if err := o(s); err != nil {
return err
}
}
r.resetState()
return nil
}
srv := &server{url: utils.CopyURL(u)}
for _, o := range options {
if err := o(srv); err != nil {
return err
}
}
if srv.weight == 0 {
srv.weight = defaultWeight
}
r.servers = append(r.servers, srv)
r.resetState()
return nil
} | go | func (r *RoundRobin) UpsertServer(u *url.URL, options ...ServerOption) error {
r.mutex.Lock()
defer r.mutex.Unlock()
if u == nil {
return fmt.Errorf("server URL can't be nil")
}
if s, _ := r.findServerByURL(u); s != nil {
for _, o := range options {
if err := o(s); err != nil {
return err
}
}
r.resetState()
return nil
}
srv := &server{url: utils.CopyURL(u)}
for _, o := range options {
if err := o(srv); err != nil {
return err
}
}
if srv.weight == 0 {
srv.weight = defaultWeight
}
r.servers = append(r.servers, srv)
r.resetState()
return nil
} | [
"func",
"(",
"r",
"*",
"RoundRobin",
")",
"UpsertServer",
"(",
"u",
"*",
"url",
".",
"URL",
",",
"options",
"...",
"ServerOption",
")",
"error",
"{",
"r",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"u",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"s",
",",
"_",
":=",
"r",
".",
"findServerByURL",
"(",
"u",
")",
";",
"s",
"!=",
"nil",
"{",
"for",
"_",
",",
"o",
":=",
"range",
"options",
"{",
"if",
"err",
":=",
"o",
"(",
"s",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"r",
".",
"resetState",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"srv",
":=",
"&",
"server",
"{",
"url",
":",
"utils",
".",
"CopyURL",
"(",
"u",
")",
"}",
"\n",
"for",
"_",
",",
"o",
":=",
"range",
"options",
"{",
"if",
"err",
":=",
"o",
"(",
"srv",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"srv",
".",
"weight",
"==",
"0",
"{",
"srv",
".",
"weight",
"=",
"defaultWeight",
"\n",
"}",
"\n\n",
"r",
".",
"servers",
"=",
"append",
"(",
"r",
".",
"servers",
",",
"srv",
")",
"\n",
"r",
".",
"resetState",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // UpsertServer In case if server is already present in the load balancer, returns error | [
"UpsertServer",
"In",
"case",
"if",
"server",
"is",
"already",
"present",
"in",
"the",
"load",
"balancer",
"returns",
"error"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/roundrobin/rr.go#L232-L264 |
149,370 | vulcand/oxy | roundrobin/rr.go | SetDefaultWeight | func SetDefaultWeight(weight int) error {
if weight < 0 {
return fmt.Errorf("default weight should be >= 0")
}
defaultWeight = weight
return nil
} | go | func SetDefaultWeight(weight int) error {
if weight < 0 {
return fmt.Errorf("default weight should be >= 0")
}
defaultWeight = weight
return nil
} | [
"func",
"SetDefaultWeight",
"(",
"weight",
"int",
")",
"error",
"{",
"if",
"weight",
"<",
"0",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"defaultWeight",
"=",
"weight",
"\n",
"return",
"nil",
"\n",
"}"
] | // SetDefaultWeight sets the default server weight | [
"SetDefaultWeight",
"sets",
"the",
"default",
"server",
"weight"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/roundrobin/rr.go#L332-L338 |
149,371 | vulcand/oxy | ratelimit/tokenlimiter.go | NewRateSet | func NewRateSet() *RateSet {
rs := new(RateSet)
rs.m = make(map[time.Duration]*rate)
return rs
} | go | func NewRateSet() *RateSet {
rs := new(RateSet)
rs.m = make(map[time.Duration]*rate)
return rs
} | [
"func",
"NewRateSet",
"(",
")",
"*",
"RateSet",
"{",
"rs",
":=",
"new",
"(",
"RateSet",
")",
"\n",
"rs",
".",
"m",
"=",
"make",
"(",
"map",
"[",
"time",
".",
"Duration",
"]",
"*",
"rate",
")",
"\n",
"return",
"rs",
"\n",
"}"
] | // NewRateSet crates an empty `RateSet` instance. | [
"NewRateSet",
"crates",
"an",
"empty",
"RateSet",
"instance",
"."
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/ratelimit/tokenlimiter.go#L25-L29 |
149,372 | vulcand/oxy | ratelimit/tokenlimiter.go | Add | func (rs *RateSet) Add(period time.Duration, average int64, burst int64) error {
if period <= 0 {
return fmt.Errorf("invalid period: %v", period)
}
if average <= 0 {
return fmt.Errorf("invalid average: %v", average)
}
if burst <= 0 {
return fmt.Errorf("invalid burst: %v", burst)
}
rs.m[period] = &rate{period: period, average: average, burst: burst}
return nil
} | go | func (rs *RateSet) Add(period time.Duration, average int64, burst int64) error {
if period <= 0 {
return fmt.Errorf("invalid period: %v", period)
}
if average <= 0 {
return fmt.Errorf("invalid average: %v", average)
}
if burst <= 0 {
return fmt.Errorf("invalid burst: %v", burst)
}
rs.m[period] = &rate{period: period, average: average, burst: burst}
return nil
} | [
"func",
"(",
"rs",
"*",
"RateSet",
")",
"Add",
"(",
"period",
"time",
".",
"Duration",
",",
"average",
"int64",
",",
"burst",
"int64",
")",
"error",
"{",
"if",
"period",
"<=",
"0",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"period",
")",
"\n",
"}",
"\n",
"if",
"average",
"<=",
"0",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"average",
")",
"\n",
"}",
"\n",
"if",
"burst",
"<=",
"0",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"burst",
")",
"\n",
"}",
"\n",
"rs",
".",
"m",
"[",
"period",
"]",
"=",
"&",
"rate",
"{",
"period",
":",
"period",
",",
"average",
":",
"average",
",",
"burst",
":",
"burst",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Add adds a rate to the set. If there is a rate with the same period in the
// set then the new rate overrides the old one. | [
"Add",
"adds",
"a",
"rate",
"to",
"the",
"set",
".",
"If",
"there",
"is",
"a",
"rate",
"with",
"the",
"same",
"period",
"in",
"the",
"set",
"then",
"the",
"new",
"rate",
"overrides",
"the",
"old",
"one",
"."
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/ratelimit/tokenlimiter.go#L33-L45 |
149,373 | vulcand/oxy | ratelimit/tokenlimiter.go | New | func New(next http.Handler, extract utils.SourceExtractor, defaultRates *RateSet, opts ...TokenLimiterOption) (*TokenLimiter, error) {
if defaultRates == nil || len(defaultRates.m) == 0 {
return nil, fmt.Errorf("provide default rates")
}
if extract == nil {
return nil, fmt.Errorf("provide extract function")
}
tl := &TokenLimiter{
next: next,
defaultRates: defaultRates,
extract: extract,
log: log.StandardLogger(),
}
for _, o := range opts {
if err := o(tl); err != nil {
return nil, err
}
}
setDefaults(tl)
bucketSets, err := ttlmap.NewMapWithProvider(tl.capacity, tl.clock)
if err != nil {
return nil, err
}
tl.bucketSets = bucketSets
return tl, nil
} | go | func New(next http.Handler, extract utils.SourceExtractor, defaultRates *RateSet, opts ...TokenLimiterOption) (*TokenLimiter, error) {
if defaultRates == nil || len(defaultRates.m) == 0 {
return nil, fmt.Errorf("provide default rates")
}
if extract == nil {
return nil, fmt.Errorf("provide extract function")
}
tl := &TokenLimiter{
next: next,
defaultRates: defaultRates,
extract: extract,
log: log.StandardLogger(),
}
for _, o := range opts {
if err := o(tl); err != nil {
return nil, err
}
}
setDefaults(tl)
bucketSets, err := ttlmap.NewMapWithProvider(tl.capacity, tl.clock)
if err != nil {
return nil, err
}
tl.bucketSets = bucketSets
return tl, nil
} | [
"func",
"New",
"(",
"next",
"http",
".",
"Handler",
",",
"extract",
"utils",
".",
"SourceExtractor",
",",
"defaultRates",
"*",
"RateSet",
",",
"opts",
"...",
"TokenLimiterOption",
")",
"(",
"*",
"TokenLimiter",
",",
"error",
")",
"{",
"if",
"defaultRates",
"==",
"nil",
"||",
"len",
"(",
"defaultRates",
".",
"m",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"extract",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"tl",
":=",
"&",
"TokenLimiter",
"{",
"next",
":",
"next",
",",
"defaultRates",
":",
"defaultRates",
",",
"extract",
":",
"extract",
",",
"log",
":",
"log",
".",
"StandardLogger",
"(",
")",
",",
"}",
"\n\n",
"for",
"_",
",",
"o",
":=",
"range",
"opts",
"{",
"if",
"err",
":=",
"o",
"(",
"tl",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"setDefaults",
"(",
"tl",
")",
"\n",
"bucketSets",
",",
"err",
":=",
"ttlmap",
".",
"NewMapWithProvider",
"(",
"tl",
".",
"capacity",
",",
"tl",
".",
"clock",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"tl",
".",
"bucketSets",
"=",
"bucketSets",
"\n",
"return",
"tl",
",",
"nil",
"\n",
"}"
] | // New constructs a `TokenLimiter` middleware instance. | [
"New",
"constructs",
"a",
"TokenLimiter",
"middleware",
"instance",
"."
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/ratelimit/tokenlimiter.go#L80-L107 |
149,374 | vulcand/oxy | ratelimit/tokenlimiter.go | ExtractRates | func ExtractRates(e RateExtractor) TokenLimiterOption {
return func(cl *TokenLimiter) error {
cl.extractRates = e
return nil
}
} | go | func ExtractRates(e RateExtractor) TokenLimiterOption {
return func(cl *TokenLimiter) error {
cl.extractRates = e
return nil
}
} | [
"func",
"ExtractRates",
"(",
"e",
"RateExtractor",
")",
"TokenLimiterOption",
"{",
"return",
"func",
"(",
"cl",
"*",
"TokenLimiter",
")",
"error",
"{",
"cl",
".",
"extractRates",
"=",
"e",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // ExtractRates sets the rate extractor | [
"ExtractRates",
"sets",
"the",
"rate",
"extractor"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/ratelimit/tokenlimiter.go#L224-L229 |
149,375 | vulcand/oxy | ratelimit/tokenlimiter.go | Clock | func Clock(clock timetools.TimeProvider) TokenLimiterOption {
return func(cl *TokenLimiter) error {
cl.clock = clock
return nil
}
} | go | func Clock(clock timetools.TimeProvider) TokenLimiterOption {
return func(cl *TokenLimiter) error {
cl.clock = clock
return nil
}
} | [
"func",
"Clock",
"(",
"clock",
"timetools",
".",
"TimeProvider",
")",
"TokenLimiterOption",
"{",
"return",
"func",
"(",
"cl",
"*",
"TokenLimiter",
")",
"error",
"{",
"cl",
".",
"clock",
"=",
"clock",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // Clock sets the clock | [
"Clock",
"sets",
"the",
"clock"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/ratelimit/tokenlimiter.go#L232-L237 |
149,376 | vulcand/oxy | ratelimit/tokenlimiter.go | Capacity | func Capacity(cap int) TokenLimiterOption {
return func(cl *TokenLimiter) error {
if cap <= 0 {
return fmt.Errorf("bad capacity: %v", cap)
}
cl.capacity = cap
return nil
}
} | go | func Capacity(cap int) TokenLimiterOption {
return func(cl *TokenLimiter) error {
if cap <= 0 {
return fmt.Errorf("bad capacity: %v", cap)
}
cl.capacity = cap
return nil
}
} | [
"func",
"Capacity",
"(",
"cap",
"int",
")",
"TokenLimiterOption",
"{",
"return",
"func",
"(",
"cl",
"*",
"TokenLimiter",
")",
"error",
"{",
"if",
"cap",
"<=",
"0",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"cap",
")",
"\n",
"}",
"\n",
"cl",
".",
"capacity",
"=",
"cap",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // Capacity sets the capacity | [
"Capacity",
"sets",
"the",
"capacity"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/ratelimit/tokenlimiter.go#L240-L248 |
149,377 | vulcand/oxy | buffer/buffer.go | MaxRequestBodyBytes | func MaxRequestBodyBytes(m int64) optSetter {
return func(b *Buffer) error {
if m < 0 {
return fmt.Errorf("max bytes should be >= 0 got %d", m)
}
b.maxRequestBodyBytes = m
return nil
}
} | go | func MaxRequestBodyBytes(m int64) optSetter {
return func(b *Buffer) error {
if m < 0 {
return fmt.Errorf("max bytes should be >= 0 got %d", m)
}
b.maxRequestBodyBytes = m
return nil
}
} | [
"func",
"MaxRequestBodyBytes",
"(",
"m",
"int64",
")",
"optSetter",
"{",
"return",
"func",
"(",
"b",
"*",
"Buffer",
")",
"error",
"{",
"if",
"m",
"<",
"0",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"m",
")",
"\n",
"}",
"\n",
"b",
".",
"maxRequestBodyBytes",
"=",
"m",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // MaxRequestBodyBytes sets the maximum request body size in bytes | [
"MaxRequestBodyBytes",
"sets",
"the",
"maximum",
"request",
"body",
"size",
"in",
"bytes"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/buffer/buffer.go#L160-L168 |
149,378 | vulcand/oxy | buffer/buffer.go | MemRequestBodyBytes | func MemRequestBodyBytes(m int64) optSetter {
return func(b *Buffer) error {
if m < 0 {
return fmt.Errorf("mem bytes should be >= 0 got %d", m)
}
b.memRequestBodyBytes = m
return nil
}
} | go | func MemRequestBodyBytes(m int64) optSetter {
return func(b *Buffer) error {
if m < 0 {
return fmt.Errorf("mem bytes should be >= 0 got %d", m)
}
b.memRequestBodyBytes = m
return nil
}
} | [
"func",
"MemRequestBodyBytes",
"(",
"m",
"int64",
")",
"optSetter",
"{",
"return",
"func",
"(",
"b",
"*",
"Buffer",
")",
"error",
"{",
"if",
"m",
"<",
"0",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"m",
")",
"\n",
"}",
"\n",
"b",
".",
"memRequestBodyBytes",
"=",
"m",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // MemRequestBodyBytes bytes sets the maximum request body to be stored in memory
// buffer middleware will serialize the excess to disk. | [
"MemRequestBodyBytes",
"bytes",
"sets",
"the",
"maximum",
"request",
"body",
"to",
"be",
"stored",
"in",
"memory",
"buffer",
"middleware",
"will",
"serialize",
"the",
"excess",
"to",
"disk",
"."
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/buffer/buffer.go#L172-L180 |
149,379 | vulcand/oxy | buffer/buffer.go | MaxResponseBodyBytes | func MaxResponseBodyBytes(m int64) optSetter {
return func(b *Buffer) error {
if m < 0 {
return fmt.Errorf("max bytes should be >= 0 got %d", m)
}
b.maxResponseBodyBytes = m
return nil
}
} | go | func MaxResponseBodyBytes(m int64) optSetter {
return func(b *Buffer) error {
if m < 0 {
return fmt.Errorf("max bytes should be >= 0 got %d", m)
}
b.maxResponseBodyBytes = m
return nil
}
} | [
"func",
"MaxResponseBodyBytes",
"(",
"m",
"int64",
")",
"optSetter",
"{",
"return",
"func",
"(",
"b",
"*",
"Buffer",
")",
"error",
"{",
"if",
"m",
"<",
"0",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"m",
")",
"\n",
"}",
"\n",
"b",
".",
"maxResponseBodyBytes",
"=",
"m",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // MaxResponseBodyBytes sets the maximum request body size in bytes | [
"MaxResponseBodyBytes",
"sets",
"the",
"maximum",
"request",
"body",
"size",
"in",
"bytes"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/buffer/buffer.go#L183-L191 |
149,380 | vulcand/oxy | buffer/buffer.go | MemResponseBodyBytes | func MemResponseBodyBytes(m int64) optSetter {
return func(b *Buffer) error {
if m < 0 {
return fmt.Errorf("mem bytes should be >= 0 got %d", m)
}
b.memResponseBodyBytes = m
return nil
}
} | go | func MemResponseBodyBytes(m int64) optSetter {
return func(b *Buffer) error {
if m < 0 {
return fmt.Errorf("mem bytes should be >= 0 got %d", m)
}
b.memResponseBodyBytes = m
return nil
}
} | [
"func",
"MemResponseBodyBytes",
"(",
"m",
"int64",
")",
"optSetter",
"{",
"return",
"func",
"(",
"b",
"*",
"Buffer",
")",
"error",
"{",
"if",
"m",
"<",
"0",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"m",
")",
"\n",
"}",
"\n",
"b",
".",
"memResponseBodyBytes",
"=",
"m",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // MemResponseBodyBytes sets the maximum request body to be stored in memory
// buffer middleware will serialize the excess to disk. | [
"MemResponseBodyBytes",
"sets",
"the",
"maximum",
"request",
"body",
"to",
"be",
"stored",
"in",
"memory",
"buffer",
"middleware",
"will",
"serialize",
"the",
"excess",
"to",
"disk",
"."
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/buffer/buffer.go#L195-L203 |
149,381 | vulcand/oxy | buffer/buffer.go | Wrap | func (b *Buffer) Wrap(next http.Handler) error {
b.next = next
return nil
} | go | func (b *Buffer) Wrap(next http.Handler) error {
b.next = next
return nil
} | [
"func",
"(",
"b",
"*",
"Buffer",
")",
"Wrap",
"(",
"next",
"http",
".",
"Handler",
")",
"error",
"{",
"b",
".",
"next",
"=",
"next",
"\n",
"return",
"nil",
"\n",
"}"
] | // Wrap sets the next handler to be called by buffer handler. | [
"Wrap",
"sets",
"the",
"next",
"handler",
"to",
"be",
"called",
"by",
"buffer",
"handler",
"."
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/buffer/buffer.go#L206-L209 |
149,382 | vulcand/oxy | buffer/buffer.go | CloseNotify | func (b *bufferWriter) CloseNotify() <-chan bool {
if cn, ok := b.responseWriter.(http.CloseNotifier); ok {
return cn.CloseNotify()
}
b.log.Warningf("Upstream ResponseWriter of type %v does not implement http.CloseNotifier. Returning dummy channel.", reflect.TypeOf(b.responseWriter))
return make(<-chan bool)
} | go | func (b *bufferWriter) CloseNotify() <-chan bool {
if cn, ok := b.responseWriter.(http.CloseNotifier); ok {
return cn.CloseNotify()
}
b.log.Warningf("Upstream ResponseWriter of type %v does not implement http.CloseNotifier. Returning dummy channel.", reflect.TypeOf(b.responseWriter))
return make(<-chan bool)
} | [
"func",
"(",
"b",
"*",
"bufferWriter",
")",
"CloseNotify",
"(",
")",
"<-",
"chan",
"bool",
"{",
"if",
"cn",
",",
"ok",
":=",
"b",
".",
"responseWriter",
".",
"(",
"http",
".",
"CloseNotifier",
")",
";",
"ok",
"{",
"return",
"cn",
".",
"CloseNotify",
"(",
")",
"\n",
"}",
"\n",
"b",
".",
"log",
".",
"Warningf",
"(",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"b",
".",
"responseWriter",
")",
")",
"\n",
"return",
"make",
"(",
"<-",
"chan",
"bool",
")",
"\n",
"}"
] | // CloseNotifier interface - this allows downstream connections to be terminated when the client terminates. | [
"CloseNotifier",
"interface",
"-",
"this",
"allows",
"downstream",
"connections",
"to",
"be",
"terminated",
"when",
"the",
"client",
"terminates",
"."
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/buffer/buffer.go#L402-L408 |
149,383 | vulcand/oxy | buffer/buffer.go | Hijack | func (b *bufferWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
if hi, ok := b.responseWriter.(http.Hijacker); ok {
conn, rw, err := hi.Hijack()
if err != nil {
b.hijacked = true
}
return conn, rw, err
}
b.log.Warningf("Upstream ResponseWriter of type %v does not implement http.Hijacker. Returning dummy channel.", reflect.TypeOf(b.responseWriter))
return nil, nil, fmt.Errorf("the response writer wrapped in this proxy does not implement http.Hijacker. Its type is: %v", reflect.TypeOf(b.responseWriter))
} | go | func (b *bufferWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
if hi, ok := b.responseWriter.(http.Hijacker); ok {
conn, rw, err := hi.Hijack()
if err != nil {
b.hijacked = true
}
return conn, rw, err
}
b.log.Warningf("Upstream ResponseWriter of type %v does not implement http.Hijacker. Returning dummy channel.", reflect.TypeOf(b.responseWriter))
return nil, nil, fmt.Errorf("the response writer wrapped in this proxy does not implement http.Hijacker. Its type is: %v", reflect.TypeOf(b.responseWriter))
} | [
"func",
"(",
"b",
"*",
"bufferWriter",
")",
"Hijack",
"(",
")",
"(",
"net",
".",
"Conn",
",",
"*",
"bufio",
".",
"ReadWriter",
",",
"error",
")",
"{",
"if",
"hi",
",",
"ok",
":=",
"b",
".",
"responseWriter",
".",
"(",
"http",
".",
"Hijacker",
")",
";",
"ok",
"{",
"conn",
",",
"rw",
",",
"err",
":=",
"hi",
".",
"Hijack",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"b",
".",
"hijacked",
"=",
"true",
"\n",
"}",
"\n",
"return",
"conn",
",",
"rw",
",",
"err",
"\n",
"}",
"\n",
"b",
".",
"log",
".",
"Warningf",
"(",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"b",
".",
"responseWriter",
")",
")",
"\n",
"return",
"nil",
",",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"b",
".",
"responseWriter",
")",
")",
"\n",
"}"
] | // Hijack This allows connections to be hijacked for websockets for instance. | [
"Hijack",
"This",
"allows",
"connections",
"to",
"be",
"hijacked",
"for",
"websockets",
"for",
"instance",
"."
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/buffer/buffer.go#L411-L421 |
149,384 | vulcand/oxy | memmetrics/roundtrip.go | RTCounter | func RTCounter(new NewCounterFn) rrOptSetter {
return func(r *RTMetrics) error {
r.newCounter = new
return nil
}
} | go | func RTCounter(new NewCounterFn) rrOptSetter {
return func(r *RTMetrics) error {
r.newCounter = new
return nil
}
} | [
"func",
"RTCounter",
"(",
"new",
"NewCounterFn",
")",
"rrOptSetter",
"{",
"return",
"func",
"(",
"r",
"*",
"RTMetrics",
")",
"error",
"{",
"r",
".",
"newCounter",
"=",
"new",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // RTCounter set a builder function for Counter | [
"RTCounter",
"set",
"a",
"builder",
"function",
"for",
"Counter"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/roundtrip.go#L42-L47 |
149,385 | vulcand/oxy | memmetrics/roundtrip.go | RTHistogram | func RTHistogram(fn NewRollingHistogramFn) rrOptSetter {
return func(r *RTMetrics) error {
r.newHist = fn
return nil
}
} | go | func RTHistogram(fn NewRollingHistogramFn) rrOptSetter {
return func(r *RTMetrics) error {
r.newHist = fn
return nil
}
} | [
"func",
"RTHistogram",
"(",
"fn",
"NewRollingHistogramFn",
")",
"rrOptSetter",
"{",
"return",
"func",
"(",
"r",
"*",
"RTMetrics",
")",
"error",
"{",
"r",
".",
"newHist",
"=",
"fn",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // RTHistogram set a builder function for RollingHistogram | [
"RTHistogram",
"set",
"a",
"builder",
"function",
"for",
"RollingHistogram"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/roundtrip.go#L50-L55 |
149,386 | vulcand/oxy | memmetrics/roundtrip.go | RTClock | func RTClock(clock timetools.TimeProvider) rrOptSetter {
return func(r *RTMetrics) error {
r.clock = clock
return nil
}
} | go | func RTClock(clock timetools.TimeProvider) rrOptSetter {
return func(r *RTMetrics) error {
r.clock = clock
return nil
}
} | [
"func",
"RTClock",
"(",
"clock",
"timetools",
".",
"TimeProvider",
")",
"rrOptSetter",
"{",
"return",
"func",
"(",
"r",
"*",
"RTMetrics",
")",
"error",
"{",
"r",
".",
"clock",
"=",
"clock",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // RTClock sets a clock | [
"RTClock",
"sets",
"a",
"clock"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/roundtrip.go#L58-L63 |
149,387 | vulcand/oxy | memmetrics/roundtrip.go | NewRTMetrics | func NewRTMetrics(settings ...rrOptSetter) (*RTMetrics, error) {
m := &RTMetrics{
statusCodes: make(map[int]*RollingCounter),
statusCodesLock: sync.RWMutex{},
}
for _, s := range settings {
if err := s(m); err != nil {
return nil, err
}
}
if m.clock == nil {
m.clock = &timetools.RealTime{}
}
if m.newCounter == nil {
m.newCounter = func() (*RollingCounter, error) {
return NewCounter(counterBuckets, counterResolution, CounterClock(m.clock))
}
}
if m.newHist == nil {
m.newHist = func() (*RollingHDRHistogram, error) {
return NewRollingHDRHistogram(histMin, histMax, histSignificantFigures, histPeriod, histBuckets, RollingClock(m.clock))
}
}
h, err := m.newHist()
if err != nil {
return nil, err
}
netErrors, err := m.newCounter()
if err != nil {
return nil, err
}
total, err := m.newCounter()
if err != nil {
return nil, err
}
m.histogram = h
m.netErrors = netErrors
m.total = total
return m, nil
} | go | func NewRTMetrics(settings ...rrOptSetter) (*RTMetrics, error) {
m := &RTMetrics{
statusCodes: make(map[int]*RollingCounter),
statusCodesLock: sync.RWMutex{},
}
for _, s := range settings {
if err := s(m); err != nil {
return nil, err
}
}
if m.clock == nil {
m.clock = &timetools.RealTime{}
}
if m.newCounter == nil {
m.newCounter = func() (*RollingCounter, error) {
return NewCounter(counterBuckets, counterResolution, CounterClock(m.clock))
}
}
if m.newHist == nil {
m.newHist = func() (*RollingHDRHistogram, error) {
return NewRollingHDRHistogram(histMin, histMax, histSignificantFigures, histPeriod, histBuckets, RollingClock(m.clock))
}
}
h, err := m.newHist()
if err != nil {
return nil, err
}
netErrors, err := m.newCounter()
if err != nil {
return nil, err
}
total, err := m.newCounter()
if err != nil {
return nil, err
}
m.histogram = h
m.netErrors = netErrors
m.total = total
return m, nil
} | [
"func",
"NewRTMetrics",
"(",
"settings",
"...",
"rrOptSetter",
")",
"(",
"*",
"RTMetrics",
",",
"error",
")",
"{",
"m",
":=",
"&",
"RTMetrics",
"{",
"statusCodes",
":",
"make",
"(",
"map",
"[",
"int",
"]",
"*",
"RollingCounter",
")",
",",
"statusCodesLock",
":",
"sync",
".",
"RWMutex",
"{",
"}",
",",
"}",
"\n",
"for",
"_",
",",
"s",
":=",
"range",
"settings",
"{",
"if",
"err",
":=",
"s",
"(",
"m",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"m",
".",
"clock",
"==",
"nil",
"{",
"m",
".",
"clock",
"=",
"&",
"timetools",
".",
"RealTime",
"{",
"}",
"\n",
"}",
"\n\n",
"if",
"m",
".",
"newCounter",
"==",
"nil",
"{",
"m",
".",
"newCounter",
"=",
"func",
"(",
")",
"(",
"*",
"RollingCounter",
",",
"error",
")",
"{",
"return",
"NewCounter",
"(",
"counterBuckets",
",",
"counterResolution",
",",
"CounterClock",
"(",
"m",
".",
"clock",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"m",
".",
"newHist",
"==",
"nil",
"{",
"m",
".",
"newHist",
"=",
"func",
"(",
")",
"(",
"*",
"RollingHDRHistogram",
",",
"error",
")",
"{",
"return",
"NewRollingHDRHistogram",
"(",
"histMin",
",",
"histMax",
",",
"histSignificantFigures",
",",
"histPeriod",
",",
"histBuckets",
",",
"RollingClock",
"(",
"m",
".",
"clock",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"h",
",",
"err",
":=",
"m",
".",
"newHist",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"netErrors",
",",
"err",
":=",
"m",
".",
"newCounter",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"total",
",",
"err",
":=",
"m",
".",
"newCounter",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"m",
".",
"histogram",
"=",
"h",
"\n",
"m",
".",
"netErrors",
"=",
"netErrors",
"\n",
"m",
".",
"total",
"=",
"total",
"\n",
"return",
"m",
",",
"nil",
"\n",
"}"
] | // NewRTMetrics returns new instance of metrics collector. | [
"NewRTMetrics",
"returns",
"new",
"instance",
"of",
"metrics",
"collector",
"."
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/roundtrip.go#L66-L112 |
149,388 | vulcand/oxy | memmetrics/roundtrip.go | Export | func (m *RTMetrics) Export() *RTMetrics {
m.statusCodesLock.RLock()
defer m.statusCodesLock.RUnlock()
m.histogramLock.RLock()
defer m.histogramLock.RUnlock()
export := &RTMetrics{}
export.statusCodesLock = sync.RWMutex{}
export.histogramLock = sync.RWMutex{}
export.total = m.total.Clone()
export.netErrors = m.netErrors.Clone()
exportStatusCodes := map[int]*RollingCounter{}
for code, rollingCounter := range m.statusCodes {
exportStatusCodes[code] = rollingCounter.Clone()
}
export.statusCodes = exportStatusCodes
if m.histogram != nil {
export.histogram = m.histogram.Export()
}
export.newCounter = m.newCounter
export.newHist = m.newHist
export.clock = m.clock
return export
} | go | func (m *RTMetrics) Export() *RTMetrics {
m.statusCodesLock.RLock()
defer m.statusCodesLock.RUnlock()
m.histogramLock.RLock()
defer m.histogramLock.RUnlock()
export := &RTMetrics{}
export.statusCodesLock = sync.RWMutex{}
export.histogramLock = sync.RWMutex{}
export.total = m.total.Clone()
export.netErrors = m.netErrors.Clone()
exportStatusCodes := map[int]*RollingCounter{}
for code, rollingCounter := range m.statusCodes {
exportStatusCodes[code] = rollingCounter.Clone()
}
export.statusCodes = exportStatusCodes
if m.histogram != nil {
export.histogram = m.histogram.Export()
}
export.newCounter = m.newCounter
export.newHist = m.newHist
export.clock = m.clock
return export
} | [
"func",
"(",
"m",
"*",
"RTMetrics",
")",
"Export",
"(",
")",
"*",
"RTMetrics",
"{",
"m",
".",
"statusCodesLock",
".",
"RLock",
"(",
")",
"\n",
"defer",
"m",
".",
"statusCodesLock",
".",
"RUnlock",
"(",
")",
"\n",
"m",
".",
"histogramLock",
".",
"RLock",
"(",
")",
"\n",
"defer",
"m",
".",
"histogramLock",
".",
"RUnlock",
"(",
")",
"\n\n",
"export",
":=",
"&",
"RTMetrics",
"{",
"}",
"\n",
"export",
".",
"statusCodesLock",
"=",
"sync",
".",
"RWMutex",
"{",
"}",
"\n",
"export",
".",
"histogramLock",
"=",
"sync",
".",
"RWMutex",
"{",
"}",
"\n",
"export",
".",
"total",
"=",
"m",
".",
"total",
".",
"Clone",
"(",
")",
"\n",
"export",
".",
"netErrors",
"=",
"m",
".",
"netErrors",
".",
"Clone",
"(",
")",
"\n",
"exportStatusCodes",
":=",
"map",
"[",
"int",
"]",
"*",
"RollingCounter",
"{",
"}",
"\n",
"for",
"code",
",",
"rollingCounter",
":=",
"range",
"m",
".",
"statusCodes",
"{",
"exportStatusCodes",
"[",
"code",
"]",
"=",
"rollingCounter",
".",
"Clone",
"(",
")",
"\n",
"}",
"\n",
"export",
".",
"statusCodes",
"=",
"exportStatusCodes",
"\n",
"if",
"m",
".",
"histogram",
"!=",
"nil",
"{",
"export",
".",
"histogram",
"=",
"m",
".",
"histogram",
".",
"Export",
"(",
")",
"\n",
"}",
"\n",
"export",
".",
"newCounter",
"=",
"m",
".",
"newCounter",
"\n",
"export",
".",
"newHist",
"=",
"m",
".",
"newHist",
"\n",
"export",
".",
"clock",
"=",
"m",
".",
"clock",
"\n\n",
"return",
"export",
"\n",
"}"
] | // Export Returns a new RTMetrics which is a copy of the current one | [
"Export",
"Returns",
"a",
"new",
"RTMetrics",
"which",
"is",
"a",
"copy",
"of",
"the",
"current",
"one"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/roundtrip.go#L115-L139 |
149,389 | vulcand/oxy | memmetrics/roundtrip.go | NetworkErrorRatio | func (m *RTMetrics) NetworkErrorRatio() float64 {
if m.total.Count() == 0 {
return 0
}
return float64(m.netErrors.Count()) / float64(m.total.Count())
} | go | func (m *RTMetrics) NetworkErrorRatio() float64 {
if m.total.Count() == 0 {
return 0
}
return float64(m.netErrors.Count()) / float64(m.total.Count())
} | [
"func",
"(",
"m",
"*",
"RTMetrics",
")",
"NetworkErrorRatio",
"(",
")",
"float64",
"{",
"if",
"m",
".",
"total",
".",
"Count",
"(",
")",
"==",
"0",
"{",
"return",
"0",
"\n",
"}",
"\n",
"return",
"float64",
"(",
"m",
".",
"netErrors",
".",
"Count",
"(",
")",
")",
"/",
"float64",
"(",
"m",
".",
"total",
".",
"Count",
"(",
")",
")",
"\n",
"}"
] | // NetworkErrorRatio calculates the amont of network errors such as time outs and dropped connection
// that occurred in the given time window compared to the total requests count. | [
"NetworkErrorRatio",
"calculates",
"the",
"amont",
"of",
"network",
"errors",
"such",
"as",
"time",
"outs",
"and",
"dropped",
"connection",
"that",
"occurred",
"in",
"the",
"given",
"time",
"window",
"compared",
"to",
"the",
"total",
"requests",
"count",
"."
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/roundtrip.go#L148-L153 |
149,390 | vulcand/oxy | memmetrics/roundtrip.go | Append | func (m *RTMetrics) Append(other *RTMetrics) error {
if m == other {
return errors.New("RTMetrics cannot append to self")
}
if err := m.total.Append(other.total); err != nil {
return err
}
if err := m.netErrors.Append(other.netErrors); err != nil {
return err
}
copied := other.Export()
m.statusCodesLock.Lock()
defer m.statusCodesLock.Unlock()
m.histogramLock.Lock()
defer m.histogramLock.Unlock()
for code, c := range copied.statusCodes {
o, ok := m.statusCodes[code]
if ok {
if err := o.Append(c); err != nil {
return err
}
} else {
m.statusCodes[code] = c.Clone()
}
}
return m.histogram.Append(copied.histogram)
} | go | func (m *RTMetrics) Append(other *RTMetrics) error {
if m == other {
return errors.New("RTMetrics cannot append to self")
}
if err := m.total.Append(other.total); err != nil {
return err
}
if err := m.netErrors.Append(other.netErrors); err != nil {
return err
}
copied := other.Export()
m.statusCodesLock.Lock()
defer m.statusCodesLock.Unlock()
m.histogramLock.Lock()
defer m.histogramLock.Unlock()
for code, c := range copied.statusCodes {
o, ok := m.statusCodes[code]
if ok {
if err := o.Append(c); err != nil {
return err
}
} else {
m.statusCodes[code] = c.Clone()
}
}
return m.histogram.Append(copied.histogram)
} | [
"func",
"(",
"m",
"*",
"RTMetrics",
")",
"Append",
"(",
"other",
"*",
"RTMetrics",
")",
"error",
"{",
"if",
"m",
"==",
"other",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"m",
".",
"total",
".",
"Append",
"(",
"other",
".",
"total",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"m",
".",
"netErrors",
".",
"Append",
"(",
"other",
".",
"netErrors",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"copied",
":=",
"other",
".",
"Export",
"(",
")",
"\n\n",
"m",
".",
"statusCodesLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"statusCodesLock",
".",
"Unlock",
"(",
")",
"\n",
"m",
".",
"histogramLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"histogramLock",
".",
"Unlock",
"(",
")",
"\n",
"for",
"code",
",",
"c",
":=",
"range",
"copied",
".",
"statusCodes",
"{",
"o",
",",
"ok",
":=",
"m",
".",
"statusCodes",
"[",
"code",
"]",
"\n",
"if",
"ok",
"{",
"if",
"err",
":=",
"o",
".",
"Append",
"(",
"c",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"m",
".",
"statusCodes",
"[",
"code",
"]",
"=",
"c",
".",
"Clone",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"m",
".",
"histogram",
".",
"Append",
"(",
"copied",
".",
"histogram",
")",
"\n",
"}"
] | // Append append a metric | [
"Append",
"append",
"a",
"metric"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/roundtrip.go#L176-L207 |
149,391 | vulcand/oxy | memmetrics/roundtrip.go | Record | func (m *RTMetrics) Record(code int, duration time.Duration) {
m.total.Inc(1)
if code == http.StatusGatewayTimeout || code == http.StatusBadGateway {
m.netErrors.Inc(1)
}
m.recordStatusCode(code)
m.recordLatency(duration)
} | go | func (m *RTMetrics) Record(code int, duration time.Duration) {
m.total.Inc(1)
if code == http.StatusGatewayTimeout || code == http.StatusBadGateway {
m.netErrors.Inc(1)
}
m.recordStatusCode(code)
m.recordLatency(duration)
} | [
"func",
"(",
"m",
"*",
"RTMetrics",
")",
"Record",
"(",
"code",
"int",
",",
"duration",
"time",
".",
"Duration",
")",
"{",
"m",
".",
"total",
".",
"Inc",
"(",
"1",
")",
"\n",
"if",
"code",
"==",
"http",
".",
"StatusGatewayTimeout",
"||",
"code",
"==",
"http",
".",
"StatusBadGateway",
"{",
"m",
".",
"netErrors",
".",
"Inc",
"(",
"1",
")",
"\n",
"}",
"\n",
"m",
".",
"recordStatusCode",
"(",
"code",
")",
"\n",
"m",
".",
"recordLatency",
"(",
"duration",
")",
"\n",
"}"
] | // Record records a metric | [
"Record",
"records",
"a",
"metric"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/roundtrip.go#L210-L217 |
149,392 | vulcand/oxy | memmetrics/roundtrip.go | StatusCodesCounts | func (m *RTMetrics) StatusCodesCounts() map[int]int64 {
sc := make(map[int]int64)
m.statusCodesLock.RLock()
defer m.statusCodesLock.RUnlock()
for k, v := range m.statusCodes {
if v.Count() != 0 {
sc[k] = v.Count()
}
}
return sc
} | go | func (m *RTMetrics) StatusCodesCounts() map[int]int64 {
sc := make(map[int]int64)
m.statusCodesLock.RLock()
defer m.statusCodesLock.RUnlock()
for k, v := range m.statusCodes {
if v.Count() != 0 {
sc[k] = v.Count()
}
}
return sc
} | [
"func",
"(",
"m",
"*",
"RTMetrics",
")",
"StatusCodesCounts",
"(",
")",
"map",
"[",
"int",
"]",
"int64",
"{",
"sc",
":=",
"make",
"(",
"map",
"[",
"int",
"]",
"int64",
")",
"\n",
"m",
".",
"statusCodesLock",
".",
"RLock",
"(",
")",
"\n",
"defer",
"m",
".",
"statusCodesLock",
".",
"RUnlock",
"(",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"m",
".",
"statusCodes",
"{",
"if",
"v",
".",
"Count",
"(",
")",
"!=",
"0",
"{",
"sc",
"[",
"k",
"]",
"=",
"v",
".",
"Count",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"sc",
"\n",
"}"
] | // StatusCodesCounts returns map with counts of the response codes | [
"StatusCodesCounts",
"returns",
"map",
"with",
"counts",
"of",
"the",
"response",
"codes"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/roundtrip.go#L230-L240 |
149,393 | vulcand/oxy | memmetrics/roundtrip.go | LatencyHistogram | func (m *RTMetrics) LatencyHistogram() (*HDRHistogram, error) {
m.histogramLock.Lock()
defer m.histogramLock.Unlock()
return m.histogram.Merged()
} | go | func (m *RTMetrics) LatencyHistogram() (*HDRHistogram, error) {
m.histogramLock.Lock()
defer m.histogramLock.Unlock()
return m.histogram.Merged()
} | [
"func",
"(",
"m",
"*",
"RTMetrics",
")",
"LatencyHistogram",
"(",
")",
"(",
"*",
"HDRHistogram",
",",
"error",
")",
"{",
"m",
".",
"histogramLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"histogramLock",
".",
"Unlock",
"(",
")",
"\n",
"return",
"m",
".",
"histogram",
".",
"Merged",
"(",
")",
"\n",
"}"
] | // LatencyHistogram computes and returns resulting histogram with latencies observed. | [
"LatencyHistogram",
"computes",
"and",
"returns",
"resulting",
"histogram",
"with",
"latencies",
"observed",
"."
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/roundtrip.go#L243-L247 |
149,394 | vulcand/oxy | memmetrics/roundtrip.go | Reset | func (m *RTMetrics) Reset() {
m.statusCodesLock.Lock()
defer m.statusCodesLock.Unlock()
m.histogramLock.Lock()
defer m.histogramLock.Unlock()
m.histogram.Reset()
m.total.Reset()
m.netErrors.Reset()
m.statusCodes = make(map[int]*RollingCounter)
} | go | func (m *RTMetrics) Reset() {
m.statusCodesLock.Lock()
defer m.statusCodesLock.Unlock()
m.histogramLock.Lock()
defer m.histogramLock.Unlock()
m.histogram.Reset()
m.total.Reset()
m.netErrors.Reset()
m.statusCodes = make(map[int]*RollingCounter)
} | [
"func",
"(",
"m",
"*",
"RTMetrics",
")",
"Reset",
"(",
")",
"{",
"m",
".",
"statusCodesLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"statusCodesLock",
".",
"Unlock",
"(",
")",
"\n",
"m",
".",
"histogramLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"histogramLock",
".",
"Unlock",
"(",
")",
"\n",
"m",
".",
"histogram",
".",
"Reset",
"(",
")",
"\n",
"m",
".",
"total",
".",
"Reset",
"(",
")",
"\n",
"m",
".",
"netErrors",
".",
"Reset",
"(",
")",
"\n",
"m",
".",
"statusCodes",
"=",
"make",
"(",
"map",
"[",
"int",
"]",
"*",
"RollingCounter",
")",
"\n",
"}"
] | // Reset reset metrics | [
"Reset",
"reset",
"metrics"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/roundtrip.go#L250-L259 |
149,395 | vulcand/oxy | utils/netutils.go | NewProxyWriterWithLogger | func NewProxyWriterWithLogger(w http.ResponseWriter, l *log.Logger) *ProxyWriter {
return &ProxyWriter{
w: w,
log: l,
}
} | go | func NewProxyWriterWithLogger(w http.ResponseWriter, l *log.Logger) *ProxyWriter {
return &ProxyWriter{
w: w,
log: l,
}
} | [
"func",
"NewProxyWriterWithLogger",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"l",
"*",
"log",
".",
"Logger",
")",
"*",
"ProxyWriter",
"{",
"return",
"&",
"ProxyWriter",
"{",
"w",
":",
"w",
",",
"log",
":",
"l",
",",
"}",
"\n",
"}"
] | // NewProxyWriterWithLogger creates a new ProxyWriter | [
"NewProxyWriterWithLogger",
"creates",
"a",
"new",
"ProxyWriter"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/utils/netutils.go#L30-L35 |
149,396 | vulcand/oxy | utils/netutils.go | StatusCode | func (p *ProxyWriter) StatusCode() int {
if p.code == 0 {
// per contract standard lib will set this to http.StatusOK if not set
// by user, here we avoid the confusion by mirroring this logic
return http.StatusOK
}
return p.code
} | go | func (p *ProxyWriter) StatusCode() int {
if p.code == 0 {
// per contract standard lib will set this to http.StatusOK if not set
// by user, here we avoid the confusion by mirroring this logic
return http.StatusOK
}
return p.code
} | [
"func",
"(",
"p",
"*",
"ProxyWriter",
")",
"StatusCode",
"(",
")",
"int",
"{",
"if",
"p",
".",
"code",
"==",
"0",
"{",
"// per contract standard lib will set this to http.StatusOK if not set",
"// by user, here we avoid the confusion by mirroring this logic",
"return",
"http",
".",
"StatusOK",
"\n",
"}",
"\n",
"return",
"p",
".",
"code",
"\n",
"}"
] | // StatusCode gets status code | [
"StatusCode",
"gets",
"status",
"code"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/utils/netutils.go#L38-L45 |
149,397 | vulcand/oxy | utils/netutils.go | WriteHeader | func (p *ProxyWriter) WriteHeader(code int) {
p.code = code
p.w.WriteHeader(code)
} | go | func (p *ProxyWriter) WriteHeader(code int) {
p.code = code
p.w.WriteHeader(code)
} | [
"func",
"(",
"p",
"*",
"ProxyWriter",
")",
"WriteHeader",
"(",
"code",
"int",
")",
"{",
"p",
".",
"code",
"=",
"code",
"\n",
"p",
".",
"w",
".",
"WriteHeader",
"(",
"code",
")",
"\n",
"}"
] | // WriteHeader writes status code | [
"WriteHeader",
"writes",
"status",
"code"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/utils/netutils.go#L63-L66 |
149,398 | vulcand/oxy | utils/netutils.go | Flush | func (p *ProxyWriter) Flush() {
if f, ok := p.w.(http.Flusher); ok {
f.Flush()
}
} | go | func (p *ProxyWriter) Flush() {
if f, ok := p.w.(http.Flusher); ok {
f.Flush()
}
} | [
"func",
"(",
"p",
"*",
"ProxyWriter",
")",
"Flush",
"(",
")",
"{",
"if",
"f",
",",
"ok",
":=",
"p",
".",
"w",
".",
"(",
"http",
".",
"Flusher",
")",
";",
"ok",
"{",
"f",
".",
"Flush",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // Flush flush the writer | [
"Flush",
"flush",
"the",
"writer"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/utils/netutils.go#L69-L73 |
149,399 | vulcand/oxy | utils/netutils.go | NewBufferWriter | func NewBufferWriter(w io.WriteCloser) *BufferWriter {
return &BufferWriter{
W: w,
H: make(http.Header),
}
} | go | func NewBufferWriter(w io.WriteCloser) *BufferWriter {
return &BufferWriter{
W: w,
H: make(http.Header),
}
} | [
"func",
"NewBufferWriter",
"(",
"w",
"io",
".",
"WriteCloser",
")",
"*",
"BufferWriter",
"{",
"return",
"&",
"BufferWriter",
"{",
"W",
":",
"w",
",",
"H",
":",
"make",
"(",
"http",
".",
"Header",
")",
",",
"}",
"\n",
"}"
] | // NewBufferWriter creates a new BufferWriter | [
"NewBufferWriter",
"creates",
"a",
"new",
"BufferWriter"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/utils/netutils.go#L95-L100 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.