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 list | docstring stringlengths 6 2.61k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 85 252 | partition stringclasses 1 value |
|---|---|---|---|---|---|---|---|---|---|---|---|
vulcand/oxy | forward/rewrite.go | Rewrite | func (rw *HeaderRewriter) Rewrite(req *http.Request) {
if !rw.TrustForwardHeader {
utils.RemoveHeaders(req.Header, XHeaders...)
}
if clientIP, _, err := net.SplitHostPort(req.RemoteAddr); err == nil {
clientIP = ipv6fix(clientIP)
// If not websocket, done in http.ReverseProxy
if IsWebsocketRequest(req) {
if prior, ok := req.Header[XForwardedFor]; ok {
req.Header.Set(XForwardedFor, strings.Join(prior, ", ")+", "+clientIP)
} else {
req.Header.Set(XForwardedFor, clientIP)
}
}
if req.Header.Get(XRealIp) == "" {
req.Header.Set(XRealIp, clientIP)
}
}
xfProto := req.Header.Get(XForwardedProto)
if xfProto == "" {
if req.TLS != nil {
req.Header.Set(XForwardedProto, "https")
} else {
req.Header.Set(XForwardedProto, "http")
}
}
if IsWebsocketRequest(req) {
if req.Header.Get(XForwardedProto) == "https" {
req.Header.Set(XForwardedProto, "wss")
} else {
req.Header.Set(XForwardedProto, "ws")
}
}
if xfPort := req.Header.Get(XForwardedPort); xfPort == "" {
req.Header.Set(XForwardedPort, forwardedPort(req))
}
if xfHost := req.Header.Get(XForwardedHost); xfHost == "" && req.Host != "" {
req.Header.Set(XForwardedHost, req.Host)
}
if rw.Hostname != "" {
req.Header.Set(XForwardedServer, rw.Hostname)
}
} | go | func (rw *HeaderRewriter) Rewrite(req *http.Request) {
if !rw.TrustForwardHeader {
utils.RemoveHeaders(req.Header, XHeaders...)
}
if clientIP, _, err := net.SplitHostPort(req.RemoteAddr); err == nil {
clientIP = ipv6fix(clientIP)
// If not websocket, done in http.ReverseProxy
if IsWebsocketRequest(req) {
if prior, ok := req.Header[XForwardedFor]; ok {
req.Header.Set(XForwardedFor, strings.Join(prior, ", ")+", "+clientIP)
} else {
req.Header.Set(XForwardedFor, clientIP)
}
}
if req.Header.Get(XRealIp) == "" {
req.Header.Set(XRealIp, clientIP)
}
}
xfProto := req.Header.Get(XForwardedProto)
if xfProto == "" {
if req.TLS != nil {
req.Header.Set(XForwardedProto, "https")
} else {
req.Header.Set(XForwardedProto, "http")
}
}
if IsWebsocketRequest(req) {
if req.Header.Get(XForwardedProto) == "https" {
req.Header.Set(XForwardedProto, "wss")
} else {
req.Header.Set(XForwardedProto, "ws")
}
}
if xfPort := req.Header.Get(XForwardedPort); xfPort == "" {
req.Header.Set(XForwardedPort, forwardedPort(req))
}
if xfHost := req.Header.Get(XForwardedHost); xfHost == "" && req.Host != "" {
req.Header.Set(XForwardedHost, req.Host)
}
if rw.Hostname != "" {
req.Header.Set(XForwardedServer, rw.Hostname)
}
} | [
"func",
"(",
"rw",
"*",
"HeaderRewriter",
")",
"Rewrite",
"(",
"req",
"*",
"http",
".",
"Request",
")",
"{",
"if",
"!",
"rw",
".",
"TrustForwardHeader",
"{",
"utils",
".",
"RemoveHeaders",
"(",
"req",
".",
"Header",
",",
"XHeaders",
"...",
")",
"\n",
... | // Rewrite rewrite request headers | [
"Rewrite",
"rewrite",
"request",
"headers"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/forward/rewrite.go#L23-L72 | train |
vulcand/oxy | ratelimit/bucketset.go | NewTokenBucketSet | func NewTokenBucketSet(rates *RateSet, clock timetools.TimeProvider) *TokenBucketSet {
tbs := new(TokenBucketSet)
tbs.clock = clock
// In the majority of cases we will have only one bucket.
tbs.buckets = make(map[time.Duration]*tokenBucket, len(rates.m))
for _, rate := range rates.m {
newBucket := newTokenBucket(rate, clock)
tbs.buckets[rate.period] = newBucket
tbs.maxPeriod = maxDuration(tbs.maxPeriod, rate.period)
}
return tbs
} | go | func NewTokenBucketSet(rates *RateSet, clock timetools.TimeProvider) *TokenBucketSet {
tbs := new(TokenBucketSet)
tbs.clock = clock
// In the majority of cases we will have only one bucket.
tbs.buckets = make(map[time.Duration]*tokenBucket, len(rates.m))
for _, rate := range rates.m {
newBucket := newTokenBucket(rate, clock)
tbs.buckets[rate.period] = newBucket
tbs.maxPeriod = maxDuration(tbs.maxPeriod, rate.period)
}
return tbs
} | [
"func",
"NewTokenBucketSet",
"(",
"rates",
"*",
"RateSet",
",",
"clock",
"timetools",
".",
"TimeProvider",
")",
"*",
"TokenBucketSet",
"{",
"tbs",
":=",
"new",
"(",
"TokenBucketSet",
")",
"\n",
"tbs",
".",
"clock",
"=",
"clock",
"\n",
"// In the majority of ca... | // NewTokenBucketSet creates a `TokenBucketSet` from the specified `rates`. | [
"NewTokenBucketSet",
"creates",
"a",
"TokenBucketSet",
"from",
"the",
"specified",
"rates",
"."
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/ratelimit/bucketset.go#L20-L31 | train |
vulcand/oxy | ratelimit/bucketset.go | Update | func (tbs *TokenBucketSet) Update(rates *RateSet) {
// Update existing buckets and delete those that have no corresponding spec.
for _, bucket := range tbs.buckets {
if rate, ok := rates.m[bucket.period]; ok {
bucket.update(rate)
} else {
delete(tbs.buckets, bucket.period)
}
}
// Add missing buckets.
for _, rate := range rates.m {
if _, ok := tbs.buckets[rate.period]; !ok {
newBucket := newTokenBucket(rate, tbs.clock)
tbs.buckets[rate.period] = newBucket
}
}
// Identify the maximum period in the set
tbs.maxPeriod = 0
for _, bucket := range tbs.buckets {
tbs.maxPeriod = maxDuration(tbs.maxPeriod, bucket.period)
}
} | go | func (tbs *TokenBucketSet) Update(rates *RateSet) {
// Update existing buckets and delete those that have no corresponding spec.
for _, bucket := range tbs.buckets {
if rate, ok := rates.m[bucket.period]; ok {
bucket.update(rate)
} else {
delete(tbs.buckets, bucket.period)
}
}
// Add missing buckets.
for _, rate := range rates.m {
if _, ok := tbs.buckets[rate.period]; !ok {
newBucket := newTokenBucket(rate, tbs.clock)
tbs.buckets[rate.period] = newBucket
}
}
// Identify the maximum period in the set
tbs.maxPeriod = 0
for _, bucket := range tbs.buckets {
tbs.maxPeriod = maxDuration(tbs.maxPeriod, bucket.period)
}
} | [
"func",
"(",
"tbs",
"*",
"TokenBucketSet",
")",
"Update",
"(",
"rates",
"*",
"RateSet",
")",
"{",
"// Update existing buckets and delete those that have no corresponding spec.",
"for",
"_",
",",
"bucket",
":=",
"range",
"tbs",
".",
"buckets",
"{",
"if",
"rate",
",... | // Update brings the buckets in the set in accordance with the provided `rates`. | [
"Update",
"brings",
"the",
"buckets",
"in",
"the",
"set",
"in",
"accordance",
"with",
"the",
"provided",
"rates",
"."
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/ratelimit/bucketset.go#L34-L55 | train |
vulcand/oxy | ratelimit/bucketset.go | Consume | func (tbs *TokenBucketSet) Consume(tokens int64) (time.Duration, error) {
var maxDelay time.Duration = UndefinedDelay
var firstErr error
for _, tokenBucket := range tbs.buckets {
// We keep calling `Consume` even after a error is returned for one of
// buckets because that allows us to simplify the rollback procedure,
// that is to just call `Rollback` for all buckets.
delay, err := tokenBucket.consume(tokens)
if firstErr == nil {
if err != nil {
firstErr = err
} else {
maxDelay = maxDuration(maxDelay, delay)
}
}
}
// If we could not make ALL buckets consume tokens for whatever reason,
// then rollback consumption for all of them.
if firstErr != nil || maxDelay > 0 {
for _, tokenBucket := range tbs.buckets {
tokenBucket.rollback()
}
}
return maxDelay, firstErr
} | go | func (tbs *TokenBucketSet) Consume(tokens int64) (time.Duration, error) {
var maxDelay time.Duration = UndefinedDelay
var firstErr error
for _, tokenBucket := range tbs.buckets {
// We keep calling `Consume` even after a error is returned for one of
// buckets because that allows us to simplify the rollback procedure,
// that is to just call `Rollback` for all buckets.
delay, err := tokenBucket.consume(tokens)
if firstErr == nil {
if err != nil {
firstErr = err
} else {
maxDelay = maxDuration(maxDelay, delay)
}
}
}
// If we could not make ALL buckets consume tokens for whatever reason,
// then rollback consumption for all of them.
if firstErr != nil || maxDelay > 0 {
for _, tokenBucket := range tbs.buckets {
tokenBucket.rollback()
}
}
return maxDelay, firstErr
} | [
"func",
"(",
"tbs",
"*",
"TokenBucketSet",
")",
"Consume",
"(",
"tokens",
"int64",
")",
"(",
"time",
".",
"Duration",
",",
"error",
")",
"{",
"var",
"maxDelay",
"time",
".",
"Duration",
"=",
"UndefinedDelay",
"\n",
"var",
"firstErr",
"error",
"\n",
"for"... | // Consume consume tokens | [
"Consume",
"consume",
"tokens"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/ratelimit/bucketset.go#L58-L82 | train |
vulcand/oxy | ratelimit/bucketset.go | debugState | func (tbs *TokenBucketSet) debugState() string {
periods := sort.IntSlice(make([]int, 0, len(tbs.buckets)))
for period := range tbs.buckets {
periods = append(periods, int(period))
}
sort.Sort(periods)
bucketRepr := make([]string, 0, len(tbs.buckets))
for _, period := range periods {
bucket := tbs.buckets[time.Duration(period)]
bucketRepr = append(bucketRepr, fmt.Sprintf("{%v: %v}", bucket.period, bucket.availableTokens))
}
return strings.Join(bucketRepr, ", ")
} | go | func (tbs *TokenBucketSet) debugState() string {
periods := sort.IntSlice(make([]int, 0, len(tbs.buckets)))
for period := range tbs.buckets {
periods = append(periods, int(period))
}
sort.Sort(periods)
bucketRepr := make([]string, 0, len(tbs.buckets))
for _, period := range periods {
bucket := tbs.buckets[time.Duration(period)]
bucketRepr = append(bucketRepr, fmt.Sprintf("{%v: %v}", bucket.period, bucket.availableTokens))
}
return strings.Join(bucketRepr, ", ")
} | [
"func",
"(",
"tbs",
"*",
"TokenBucketSet",
")",
"debugState",
"(",
")",
"string",
"{",
"periods",
":=",
"sort",
".",
"IntSlice",
"(",
"make",
"(",
"[",
"]",
"int",
",",
"0",
",",
"len",
"(",
"tbs",
".",
"buckets",
")",
")",
")",
"\n",
"for",
"per... | // debugState returns string that reflects the current state of all buckets in
// this set. It is intended to be used for debugging and testing only. | [
"debugState",
"returns",
"string",
"that",
"reflects",
"the",
"current",
"state",
"of",
"all",
"buckets",
"in",
"this",
"set",
".",
"It",
"is",
"intended",
"to",
"be",
"used",
"for",
"debugging",
"and",
"testing",
"only",
"."
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/ratelimit/bucketset.go#L91-L103 | train |
vulcand/oxy | cbreaker/predicates.go | parseExpression | func parseExpression(in string) (hpredicate, error) {
p, err := predicate.NewParser(predicate.Def{
Operators: predicate.Operators{
AND: and,
OR: or,
EQ: eq,
NEQ: neq,
LT: lt,
LE: le,
GT: gt,
GE: ge,
},
Functions: map[string]interface{}{
"LatencyAtQuantileMS": latencyAtQuantile,
"NetworkErrorRatio": networkErrorRatio,
"ResponseCodeRatio": responseCodeRatio,
},
})
if err != nil {
return nil, err
}
out, err := p.Parse(in)
if err != nil {
return nil, err
}
pr, ok := out.(hpredicate)
if !ok {
return nil, fmt.Errorf("expected predicate, got %T", out)
}
return pr, nil
} | go | func parseExpression(in string) (hpredicate, error) {
p, err := predicate.NewParser(predicate.Def{
Operators: predicate.Operators{
AND: and,
OR: or,
EQ: eq,
NEQ: neq,
LT: lt,
LE: le,
GT: gt,
GE: ge,
},
Functions: map[string]interface{}{
"LatencyAtQuantileMS": latencyAtQuantile,
"NetworkErrorRatio": networkErrorRatio,
"ResponseCodeRatio": responseCodeRatio,
},
})
if err != nil {
return nil, err
}
out, err := p.Parse(in)
if err != nil {
return nil, err
}
pr, ok := out.(hpredicate)
if !ok {
return nil, fmt.Errorf("expected predicate, got %T", out)
}
return pr, nil
} | [
"func",
"parseExpression",
"(",
"in",
"string",
")",
"(",
"hpredicate",
",",
"error",
")",
"{",
"p",
",",
"err",
":=",
"predicate",
".",
"NewParser",
"(",
"predicate",
".",
"Def",
"{",
"Operators",
":",
"predicate",
".",
"Operators",
"{",
"AND",
":",
"... | // parseExpression parses expression in the go language into predicates. | [
"parseExpression",
"parses",
"expression",
"in",
"the",
"go",
"language",
"into",
"predicates",
"."
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/cbreaker/predicates.go#L13-L43 | train |
vulcand/oxy | cbreaker/predicates.go | or | func or(fns ...hpredicate) hpredicate {
return func(c *CircuitBreaker) bool {
for _, fn := range fns {
if fn(c) {
return true
}
}
return false
}
} | go | func or(fns ...hpredicate) hpredicate {
return func(c *CircuitBreaker) bool {
for _, fn := range fns {
if fn(c) {
return true
}
}
return false
}
} | [
"func",
"or",
"(",
"fns",
"...",
"hpredicate",
")",
"hpredicate",
"{",
"return",
"func",
"(",
"c",
"*",
"CircuitBreaker",
")",
"bool",
"{",
"for",
"_",
",",
"fn",
":=",
"range",
"fns",
"{",
"if",
"fn",
"(",
"c",
")",
"{",
"return",
"true",
"\n",
... | // or returns predicate by joining the passed predicates with logical 'or' | [
"or",
"returns",
"predicate",
"by",
"joining",
"the",
"passed",
"predicates",
"with",
"logical",
"or"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/cbreaker/predicates.go#L72-L81 | train |
vulcand/oxy | cbreaker/predicates.go | neq | func neq(m interface{}, value interface{}) (hpredicate, error) {
p, err := eq(m, value)
if err != nil {
return nil, err
}
return not(p), nil
} | go | func neq(m interface{}, value interface{}) (hpredicate, error) {
p, err := eq(m, value)
if err != nil {
return nil, err
}
return not(p), nil
} | [
"func",
"neq",
"(",
"m",
"interface",
"{",
"}",
",",
"value",
"interface",
"{",
"}",
")",
"(",
"hpredicate",
",",
"error",
")",
"{",
"p",
",",
"err",
":=",
"eq",
"(",
"m",
",",
"value",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",... | // neq returns predicate that tests for inequality of the value of the mapper and the constant | [
"neq",
"returns",
"predicate",
"that",
"tests",
"for",
"inequality",
"of",
"the",
"value",
"of",
"the",
"mapper",
"and",
"the",
"constant"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/cbreaker/predicates.go#L114-L120 | train |
vulcand/oxy | cbreaker/predicates.go | le | func le(m interface{}, value interface{}) (hpredicate, error) {
l, err := lt(m, value)
if err != nil {
return nil, err
}
e, err := eq(m, value)
if err != nil {
return nil, err
}
return func(c *CircuitBreaker) bool {
return l(c) || e(c)
}, nil
} | go | func le(m interface{}, value interface{}) (hpredicate, error) {
l, err := lt(m, value)
if err != nil {
return nil, err
}
e, err := eq(m, value)
if err != nil {
return nil, err
}
return func(c *CircuitBreaker) bool {
return l(c) || e(c)
}, nil
} | [
"func",
"le",
"(",
"m",
"interface",
"{",
"}",
",",
"value",
"interface",
"{",
"}",
")",
"(",
"hpredicate",
",",
"error",
")",
"{",
"l",
",",
"err",
":=",
"lt",
"(",
"m",
",",
"value",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
... | // le returns predicate that tests that value of the mapper function is less or equal than the constant | [
"le",
"returns",
"predicate",
"that",
"tests",
"that",
"value",
"of",
"the",
"mapper",
"function",
"is",
"less",
"or",
"equal",
"than",
"the",
"constant"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/cbreaker/predicates.go#L134-L146 | train |
vulcand/oxy | cbreaker/predicates.go | gt | func gt(m interface{}, value interface{}) (hpredicate, error) {
switch mapper := m.(type) {
case toInt:
return intGT(mapper, value)
case toFloat64:
return float64GT(mapper, value)
}
return nil, fmt.Errorf("gt: unsupported argument: %T", m)
} | go | func gt(m interface{}, value interface{}) (hpredicate, error) {
switch mapper := m.(type) {
case toInt:
return intGT(mapper, value)
case toFloat64:
return float64GT(mapper, value)
}
return nil, fmt.Errorf("gt: unsupported argument: %T", m)
} | [
"func",
"gt",
"(",
"m",
"interface",
"{",
"}",
",",
"value",
"interface",
"{",
"}",
")",
"(",
"hpredicate",
",",
"error",
")",
"{",
"switch",
"mapper",
":=",
"m",
".",
"(",
"type",
")",
"{",
"case",
"toInt",
":",
"return",
"intGT",
"(",
"mapper",
... | // gt returns predicate that tests that value of the mapper function is greater than the constant | [
"gt",
"returns",
"predicate",
"that",
"tests",
"that",
"value",
"of",
"the",
"mapper",
"function",
"is",
"greater",
"than",
"the",
"constant"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/cbreaker/predicates.go#L149-L157 | train |
vulcand/oxy | cbreaker/predicates.go | ge | func ge(m interface{}, value interface{}) (hpredicate, error) {
g, err := gt(m, value)
if err != nil {
return nil, err
}
e, err := eq(m, value)
if err != nil {
return nil, err
}
return func(c *CircuitBreaker) bool {
return g(c) || e(c)
}, nil
} | go | func ge(m interface{}, value interface{}) (hpredicate, error) {
g, err := gt(m, value)
if err != nil {
return nil, err
}
e, err := eq(m, value)
if err != nil {
return nil, err
}
return func(c *CircuitBreaker) bool {
return g(c) || e(c)
}, nil
} | [
"func",
"ge",
"(",
"m",
"interface",
"{",
"}",
",",
"value",
"interface",
"{",
"}",
")",
"(",
"hpredicate",
",",
"error",
")",
"{",
"g",
",",
"err",
":=",
"gt",
"(",
"m",
",",
"value",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
... | // ge returns predicate that tests that value of the mapper function is less or equal than the constant | [
"ge",
"returns",
"predicate",
"that",
"tests",
"that",
"value",
"of",
"the",
"mapper",
"function",
"is",
"less",
"or",
"equal",
"than",
"the",
"constant"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/cbreaker/predicates.go#L160-L172 | train |
vulcand/oxy | cbreaker/cbreaker.go | activateFallback | func (c *CircuitBreaker) activateFallback(w http.ResponseWriter, req *http.Request) bool {
// Quick check with read locks optimized for normal operation use-case
if c.isStandby() {
return false
}
// Circuit breaker is in tripped or recovering state
c.m.Lock()
defer c.m.Unlock()
c.log.Warnf("%v is in error state", c)
switch c.state {
case stateStandby:
// someone else has set it to standby just now
return false
case stateTripped:
if c.clock.UtcNow().Before(c.until) {
return true
}
// We have been in active state enough, enter recovering state
c.setRecovering()
fallthrough
case stateRecovering:
// We have been in recovering state enough, enter standby and allow request
if c.clock.UtcNow().After(c.until) {
c.setState(stateStandby, c.clock.UtcNow())
return false
}
// ratio controller allows this request
if c.rc.allowRequest() {
return false
}
return true
}
return false
} | go | func (c *CircuitBreaker) activateFallback(w http.ResponseWriter, req *http.Request) bool {
// Quick check with read locks optimized for normal operation use-case
if c.isStandby() {
return false
}
// Circuit breaker is in tripped or recovering state
c.m.Lock()
defer c.m.Unlock()
c.log.Warnf("%v is in error state", c)
switch c.state {
case stateStandby:
// someone else has set it to standby just now
return false
case stateTripped:
if c.clock.UtcNow().Before(c.until) {
return true
}
// We have been in active state enough, enter recovering state
c.setRecovering()
fallthrough
case stateRecovering:
// We have been in recovering state enough, enter standby and allow request
if c.clock.UtcNow().After(c.until) {
c.setState(stateStandby, c.clock.UtcNow())
return false
}
// ratio controller allows this request
if c.rc.allowRequest() {
return false
}
return true
}
return false
} | [
"func",
"(",
"c",
"*",
"CircuitBreaker",
")",
"activateFallback",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
")",
"bool",
"{",
"// Quick check with read locks optimized for normal operation use-case",
"if",
"c",
".",
"isStandby... | // updateState updates internal state and returns true if fallback should be used and false otherwise | [
"updateState",
"updates",
"internal",
"state",
"and",
"returns",
"true",
"if",
"fallback",
"should",
"be",
"used",
"and",
"false",
"otherwise"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/cbreaker/cbreaker.go#L133-L168 | train |
vulcand/oxy | cbreaker/cbreaker.go | String | func (c *CircuitBreaker) String() string {
switch c.state {
case stateTripped, stateRecovering:
return fmt.Sprintf("CircuitBreaker(state=%v, until=%v)", c.state, c.until)
default:
return fmt.Sprintf("CircuitBreaker(state=%v)", c.state)
}
} | go | func (c *CircuitBreaker) String() string {
switch c.state {
case stateTripped, stateRecovering:
return fmt.Sprintf("CircuitBreaker(state=%v, until=%v)", c.state, c.until)
default:
return fmt.Sprintf("CircuitBreaker(state=%v)", c.state)
}
} | [
"func",
"(",
"c",
"*",
"CircuitBreaker",
")",
"String",
"(",
")",
"string",
"{",
"switch",
"c",
".",
"state",
"{",
"case",
"stateTripped",
",",
"stateRecovering",
":",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"c",
".",
"state",
",",
"c"... | // String returns log-friendly representation of the circuit breaker state | [
"String",
"returns",
"log",
"-",
"friendly",
"representation",
"of",
"the",
"circuit",
"breaker",
"state"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/cbreaker/cbreaker.go#L191-L198 | train |
vulcand/oxy | cbreaker/cbreaker.go | exec | func (c *CircuitBreaker) exec(s SideEffect) {
if s == nil {
return
}
go func() {
if err := s.Exec(); err != nil {
c.log.Errorf("%v side effect failure: %v", c, err)
}
}()
} | go | func (c *CircuitBreaker) exec(s SideEffect) {
if s == nil {
return
}
go func() {
if err := s.Exec(); err != nil {
c.log.Errorf("%v side effect failure: %v", c, err)
}
}()
} | [
"func",
"(",
"c",
"*",
"CircuitBreaker",
")",
"exec",
"(",
"s",
"SideEffect",
")",
"{",
"if",
"s",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"go",
"func",
"(",
")",
"{",
"if",
"err",
":=",
"s",
".",
"Exec",
"(",
")",
";",
"err",
"!=",
"nil... | // exec executes side effect | [
"exec",
"executes",
"side",
"effect"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/cbreaker/cbreaker.go#L201-L210 | train |
vulcand/oxy | cbreaker/cbreaker.go | checkAndSet | func (c *CircuitBreaker) checkAndSet() {
if !c.timeToCheck() {
return
}
c.m.Lock()
defer c.m.Unlock()
// Other goroutine could have updated the lastCheck variable before we grabbed mutex
if !c.clock.UtcNow().After(c.lastCheck) {
return
}
c.lastCheck = c.clock.UtcNow().Add(c.checkPeriod)
if c.state == stateTripped {
c.log.Debugf("%v skip set tripped", c)
return
}
if !c.condition(c) {
return
}
c.setState(stateTripped, c.clock.UtcNow().Add(c.fallbackDuration))
c.metrics.Reset()
} | go | func (c *CircuitBreaker) checkAndSet() {
if !c.timeToCheck() {
return
}
c.m.Lock()
defer c.m.Unlock()
// Other goroutine could have updated the lastCheck variable before we grabbed mutex
if !c.clock.UtcNow().After(c.lastCheck) {
return
}
c.lastCheck = c.clock.UtcNow().Add(c.checkPeriod)
if c.state == stateTripped {
c.log.Debugf("%v skip set tripped", c)
return
}
if !c.condition(c) {
return
}
c.setState(stateTripped, c.clock.UtcNow().Add(c.fallbackDuration))
c.metrics.Reset()
} | [
"func",
"(",
"c",
"*",
"CircuitBreaker",
")",
"checkAndSet",
"(",
")",
"{",
"if",
"!",
"c",
".",
"timeToCheck",
"(",
")",
"{",
"return",
"\n",
"}",
"\n\n",
"c",
".",
"m",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"m",
".",
"Unlock",
"(",
... | // Checks if tripping condition matches and sets circuit breaker to the tripped state | [
"Checks",
"if",
"tripping",
"condition",
"matches",
"and",
"sets",
"circuit",
"breaker",
"to",
"the",
"tripped",
"state"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/cbreaker/cbreaker.go#L231-L256 | train |
vulcand/oxy | cbreaker/cbreaker.go | Clock | func Clock(clock timetools.TimeProvider) CircuitBreakerOption {
return func(c *CircuitBreaker) error {
c.clock = clock
return nil
}
} | go | func Clock(clock timetools.TimeProvider) CircuitBreakerOption {
return func(c *CircuitBreaker) error {
c.clock = clock
return nil
}
} | [
"func",
"Clock",
"(",
"clock",
"timetools",
".",
"TimeProvider",
")",
"CircuitBreakerOption",
"{",
"return",
"func",
"(",
"c",
"*",
"CircuitBreaker",
")",
"error",
"{",
"c",
".",
"clock",
"=",
"clock",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // Clock allows you to fake che CircuitBreaker's view of the current time.
// Intended for unit tests. | [
"Clock",
"allows",
"you",
"to",
"fake",
"che",
"CircuitBreaker",
"s",
"view",
"of",
"the",
"current",
"time",
".",
"Intended",
"for",
"unit",
"tests",
"."
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/cbreaker/cbreaker.go#L269-L274 | train |
vulcand/oxy | cbreaker/cbreaker.go | FallbackDuration | func FallbackDuration(d time.Duration) CircuitBreakerOption {
return func(c *CircuitBreaker) error {
c.fallbackDuration = d
return nil
}
} | go | func FallbackDuration(d time.Duration) CircuitBreakerOption {
return func(c *CircuitBreaker) error {
c.fallbackDuration = d
return nil
}
} | [
"func",
"FallbackDuration",
"(",
"d",
"time",
".",
"Duration",
")",
"CircuitBreakerOption",
"{",
"return",
"func",
"(",
"c",
"*",
"CircuitBreaker",
")",
"error",
"{",
"c",
".",
"fallbackDuration",
"=",
"d",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // FallbackDuration is how long the CircuitBreaker will remain in the Tripped
// state before trying to recover. | [
"FallbackDuration",
"is",
"how",
"long",
"the",
"CircuitBreaker",
"will",
"remain",
"in",
"the",
"Tripped",
"state",
"before",
"trying",
"to",
"recover",
"."
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/cbreaker/cbreaker.go#L278-L283 | train |
vulcand/oxy | cbreaker/cbreaker.go | RecoveryDuration | func RecoveryDuration(d time.Duration) CircuitBreakerOption {
return func(c *CircuitBreaker) error {
c.recoveryDuration = d
return nil
}
} | go | func RecoveryDuration(d time.Duration) CircuitBreakerOption {
return func(c *CircuitBreaker) error {
c.recoveryDuration = d
return nil
}
} | [
"func",
"RecoveryDuration",
"(",
"d",
"time",
".",
"Duration",
")",
"CircuitBreakerOption",
"{",
"return",
"func",
"(",
"c",
"*",
"CircuitBreaker",
")",
"error",
"{",
"c",
".",
"recoveryDuration",
"=",
"d",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // RecoveryDuration is how long the CircuitBreaker will take to ramp up
// requests during the Recovering state. | [
"RecoveryDuration",
"is",
"how",
"long",
"the",
"CircuitBreaker",
"will",
"take",
"to",
"ramp",
"up",
"requests",
"during",
"the",
"Recovering",
"state",
"."
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/cbreaker/cbreaker.go#L287-L292 | train |
vulcand/oxy | cbreaker/cbreaker.go | CheckPeriod | func CheckPeriod(d time.Duration) CircuitBreakerOption {
return func(c *CircuitBreaker) error {
c.checkPeriod = d
return nil
}
} | go | func CheckPeriod(d time.Duration) CircuitBreakerOption {
return func(c *CircuitBreaker) error {
c.checkPeriod = d
return nil
}
} | [
"func",
"CheckPeriod",
"(",
"d",
"time",
".",
"Duration",
")",
"CircuitBreakerOption",
"{",
"return",
"func",
"(",
"c",
"*",
"CircuitBreaker",
")",
"error",
"{",
"c",
".",
"checkPeriod",
"=",
"d",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // CheckPeriod is how long the CircuitBreaker will wait between successive
// checks of the breaker condition. | [
"CheckPeriod",
"is",
"how",
"long",
"the",
"CircuitBreaker",
"will",
"wait",
"between",
"successive",
"checks",
"of",
"the",
"breaker",
"condition",
"."
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/cbreaker/cbreaker.go#L296-L301 | train |
vulcand/oxy | cbreaker/cbreaker.go | OnTripped | func OnTripped(s SideEffect) CircuitBreakerOption {
return func(c *CircuitBreaker) error {
c.onTripped = s
return nil
}
} | go | func OnTripped(s SideEffect) CircuitBreakerOption {
return func(c *CircuitBreaker) error {
c.onTripped = s
return nil
}
} | [
"func",
"OnTripped",
"(",
"s",
"SideEffect",
")",
"CircuitBreakerOption",
"{",
"return",
"func",
"(",
"c",
"*",
"CircuitBreaker",
")",
"error",
"{",
"c",
".",
"onTripped",
"=",
"s",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // OnTripped sets a SideEffect to run when entering the Tripped state.
// Only one SideEffect can be set for this hook. | [
"OnTripped",
"sets",
"a",
"SideEffect",
"to",
"run",
"when",
"entering",
"the",
"Tripped",
"state",
".",
"Only",
"one",
"SideEffect",
"can",
"be",
"set",
"for",
"this",
"hook",
"."
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/cbreaker/cbreaker.go#L305-L310 | train |
vulcand/oxy | cbreaker/cbreaker.go | OnStandby | func OnStandby(s SideEffect) CircuitBreakerOption {
return func(c *CircuitBreaker) error {
c.onStandby = s
return nil
}
} | go | func OnStandby(s SideEffect) CircuitBreakerOption {
return func(c *CircuitBreaker) error {
c.onStandby = s
return nil
}
} | [
"func",
"OnStandby",
"(",
"s",
"SideEffect",
")",
"CircuitBreakerOption",
"{",
"return",
"func",
"(",
"c",
"*",
"CircuitBreaker",
")",
"error",
"{",
"c",
".",
"onStandby",
"=",
"s",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // OnStandby sets a SideEffect to run when entering the Standby state.
// Only one SideEffect can be set for this hook. | [
"OnStandby",
"sets",
"a",
"SideEffect",
"to",
"run",
"when",
"entering",
"the",
"Standby",
"state",
".",
"Only",
"one",
"SideEffect",
"can",
"be",
"set",
"for",
"this",
"hook",
"."
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/cbreaker/cbreaker.go#L314-L319 | train |
vulcand/oxy | cbreaker/cbreaker.go | Fallback | func Fallback(h http.Handler) CircuitBreakerOption {
return func(c *CircuitBreaker) error {
c.fallback = h
return nil
}
} | go | func Fallback(h http.Handler) CircuitBreakerOption {
return func(c *CircuitBreaker) error {
c.fallback = h
return nil
}
} | [
"func",
"Fallback",
"(",
"h",
"http",
".",
"Handler",
")",
"CircuitBreakerOption",
"{",
"return",
"func",
"(",
"c",
"*",
"CircuitBreaker",
")",
"error",
"{",
"c",
".",
"fallback",
"=",
"h",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // Fallback defines the http.Handler that the CircuitBreaker should route
// requests to when it prevents a request from taking its normal path. | [
"Fallback",
"defines",
"the",
"http",
".",
"Handler",
"that",
"the",
"CircuitBreaker",
"should",
"route",
"requests",
"to",
"when",
"it",
"prevents",
"a",
"request",
"from",
"taking",
"its",
"normal",
"path",
"."
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/cbreaker/cbreaker.go#L323-L328 | train |
vulcand/oxy | memmetrics/ratio.go | RatioClock | func RatioClock(clock timetools.TimeProvider) ratioOptSetter {
return func(r *RatioCounter) error {
r.clock = clock
return nil
}
} | go | func RatioClock(clock timetools.TimeProvider) ratioOptSetter {
return func(r *RatioCounter) error {
r.clock = clock
return nil
}
} | [
"func",
"RatioClock",
"(",
"clock",
"timetools",
".",
"TimeProvider",
")",
"ratioOptSetter",
"{",
"return",
"func",
"(",
"r",
"*",
"RatioCounter",
")",
"error",
"{",
"r",
".",
"clock",
"=",
"clock",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // RatioClock sets a clock | [
"RatioClock",
"sets",
"a",
"clock"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/ratio.go#L12-L17 | train |
vulcand/oxy | memmetrics/ratio.go | NewRatioCounter | func NewRatioCounter(buckets int, resolution time.Duration, options ...ratioOptSetter) (*RatioCounter, error) {
rc := &RatioCounter{}
for _, o := range options {
if err := o(rc); err != nil {
return nil, err
}
}
if rc.clock == nil {
rc.clock = &timetools.RealTime{}
}
a, err := NewCounter(buckets, resolution, CounterClock(rc.clock))
if err != nil {
return nil, err
}
b, err := NewCounter(buckets, resolution, CounterClock(rc.clock))
if err != nil {
return nil, err
}
rc.a = a
rc.b = b
return rc, nil
} | go | func NewRatioCounter(buckets int, resolution time.Duration, options ...ratioOptSetter) (*RatioCounter, error) {
rc := &RatioCounter{}
for _, o := range options {
if err := o(rc); err != nil {
return nil, err
}
}
if rc.clock == nil {
rc.clock = &timetools.RealTime{}
}
a, err := NewCounter(buckets, resolution, CounterClock(rc.clock))
if err != nil {
return nil, err
}
b, err := NewCounter(buckets, resolution, CounterClock(rc.clock))
if err != nil {
return nil, err
}
rc.a = a
rc.b = b
return rc, nil
} | [
"func",
"NewRatioCounter",
"(",
"buckets",
"int",
",",
"resolution",
"time",
".",
"Duration",
",",
"options",
"...",
"ratioOptSetter",
")",
"(",
"*",
"RatioCounter",
",",
"error",
")",
"{",
"rc",
":=",
"&",
"RatioCounter",
"{",
"}",
"\n\n",
"for",
"_",
"... | // NewRatioCounter creates a new RatioCounter | [
"NewRatioCounter",
"creates",
"a",
"new",
"RatioCounter"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/ratio.go#L27-L53 | train |
vulcand/oxy | memmetrics/ratio.go | IsReady | func (r *RatioCounter) IsReady() bool {
return r.a.countedBuckets+r.b.countedBuckets >= len(r.a.values)
} | go | func (r *RatioCounter) IsReady() bool {
return r.a.countedBuckets+r.b.countedBuckets >= len(r.a.values)
} | [
"func",
"(",
"r",
"*",
"RatioCounter",
")",
"IsReady",
"(",
")",
"bool",
"{",
"return",
"r",
".",
"a",
".",
"countedBuckets",
"+",
"r",
".",
"b",
".",
"countedBuckets",
">=",
"len",
"(",
"r",
".",
"a",
".",
"values",
")",
"\n",
"}"
] | // IsReady returns true if the counter is ready | [
"IsReady",
"returns",
"true",
"if",
"the",
"counter",
"is",
"ready"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/ratio.go#L62-L64 | train |
vulcand/oxy | memmetrics/ratio.go | Ratio | func (r *RatioCounter) Ratio() float64 {
a := r.a.Count()
b := r.b.Count()
// No data, return ok
if a+b == 0 {
return 0
}
return float64(a) / float64(a+b)
} | go | func (r *RatioCounter) Ratio() float64 {
a := r.a.Count()
b := r.b.Count()
// No data, return ok
if a+b == 0 {
return 0
}
return float64(a) / float64(a+b)
} | [
"func",
"(",
"r",
"*",
"RatioCounter",
")",
"Ratio",
"(",
")",
"float64",
"{",
"a",
":=",
"r",
".",
"a",
".",
"Count",
"(",
")",
"\n",
"b",
":=",
"r",
".",
"b",
".",
"Count",
"(",
")",
"\n",
"// No data, return ok",
"if",
"a",
"+",
"b",
"==",
... | // Ratio gets ratio | [
"Ratio",
"gets",
"ratio"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/ratio.go#L97-L105 | train |
vulcand/oxy | connlimit/connlimit.go | New | func New(next http.Handler, extract utils.SourceExtractor, maxConnections int64, options ...ConnLimitOption) (*ConnLimiter, error) {
if extract == nil {
return nil, fmt.Errorf("Extract function can not be nil")
}
cl := &ConnLimiter{
mutex: &sync.Mutex{},
extract: extract,
maxConnections: maxConnections,
connections: make(map[string]int64),
next: next,
log: log.StandardLogger(),
}
for _, o := range options {
if err := o(cl); err != nil {
return nil, err
}
}
if cl.errHandler == nil {
cl.errHandler = &ConnErrHandler{
log: cl.log,
}
}
return cl, nil
} | go | func New(next http.Handler, extract utils.SourceExtractor, maxConnections int64, options ...ConnLimitOption) (*ConnLimiter, error) {
if extract == nil {
return nil, fmt.Errorf("Extract function can not be nil")
}
cl := &ConnLimiter{
mutex: &sync.Mutex{},
extract: extract,
maxConnections: maxConnections,
connections: make(map[string]int64),
next: next,
log: log.StandardLogger(),
}
for _, o := range options {
if err := o(cl); err != nil {
return nil, err
}
}
if cl.errHandler == nil {
cl.errHandler = &ConnErrHandler{
log: cl.log,
}
}
return cl, nil
} | [
"func",
"New",
"(",
"next",
"http",
".",
"Handler",
",",
"extract",
"utils",
".",
"SourceExtractor",
",",
"maxConnections",
"int64",
",",
"options",
"...",
"ConnLimitOption",
")",
"(",
"*",
"ConnLimiter",
",",
"error",
")",
"{",
"if",
"extract",
"==",
"nil... | // New creates a new ConnLimiter | [
"New",
"creates",
"a",
"new",
"ConnLimiter"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/connlimit/connlimit.go#L28-L52 | train |
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",
"("... | // NewResponseFallbackWithLogger creates a new ResponseFallback | [
"NewResponseFallbackWithLogger",
"creates",
"a",
"new",
"ResponseFallback"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/cbreaker/fallback.go#L28-L33 | train |
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",
... | // NewRedirectFallbackWithLogger creates a new RedirectFallback | [
"NewRedirectFallbackWithLogger",
"creates",
"a",
"new",
"RedirectFallback"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/cbreaker/fallback.go#L74-L80 | train |
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",
"(... | // 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 | train |
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",
"... | // 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",
"consu... | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/ratelimit/bucket.go#L63-L75 | train |
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"... | // 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 | train |
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",
")"... | // 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 | train |
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... | // 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",
"t... | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/ratelimit/bucket.go#L111-L126 | train |
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",... | // 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 | train |
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",
"retur... | // 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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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",
"}",
"\... | // RebalancerStickySession sets a sticky session | [
"RebalancerStickySession",
"sets",
"a",
"sticky",
"session"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/roundrobin/rebalancer.go#L93-L98 | train |
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",
"}",
"\... | // 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 | train |
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",
"... | // NewRebalancer creates a new Rebalancer | [
"NewRebalancer",
"creates",
"a",
"new",
"Rebalancer"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/roundrobin/rebalancer.go#L109-L145 | train |
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 gets all servers | [
"Servers",
"gets",
"all",
"servers"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/roundrobin/rebalancer.go#L158-L163 | train |
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",
... | // 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 | train |
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",
"(",
"... | // UpsertServer upsert a server | [
"UpsertServer",
"upsert",
"a",
"server"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/roundrobin/rebalancer.go#L249-L263 | train |
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",... | // 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 | train |
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",
"}"... | // 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",
"... | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/roundrobin/rebalancer.go#L392-L408 | train |
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",
")",
... | // Record records a meter | [
"Record",
"records",
"a",
"meter"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/roundrobin/rebalancer.go#L492-L498 | train |
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",
... | // NewHDRHistogram creates a new HDRHistogram | [
"NewHDRHistogram",
"creates",
"a",
"new",
"HDRHistogram"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/histogram.go#L24-L36 | train |
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",
"(",
")",
... | // Export export a HDRHistogram | [
"Export",
"export",
"a",
"HDRHistogram"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/histogram.go#L39-L46 | train |
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 | train |
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",
")",
... | // 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 | train |
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 | train |
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 | train |
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",
"(",
... | // Merge merge a HDRHistogram | [
"Merge",
"merge",
"a",
"HDRHistogram"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/histogram.go#L74-L80 | train |
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 | train |
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",
")",
"{",
... | // NewRollingHDRHistogram created a new RollingHDRHistogram | [
"NewRollingHDRHistogram",
"created",
"a",
"new",
"RollingHDRHistogram"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/histogram.go#L107-L136 | train |
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",
"... | // Export export a RollingHDRHistogram | [
"Export",
"export",
"a",
"RollingHDRHistogram"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/histogram.go#L139-L157 | train |
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",
".",
"l... | // Append append a RollingHDRHistogram | [
"Append",
"append",
"a",
"RollingHDRHistogram"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/histogram.go#L160-L171 | train |
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",
... | // Reset reset a RollingHDRHistogram | [
"Reset",
"reset",
"a",
"RollingHDRHistogram"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/histogram.go#L174-L180 | train |
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",
"... | // Merged gets merged histogram | [
"Merged",
"gets",
"merged",
"histogram"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/memmetrics/histogram.go#L188-L199 | train |
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 | train |
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 | train |
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 | train |
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",
... | // 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 | train |
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",
"... | // 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 | train |
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",
",",
... | // 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 | train |
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 | train |
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 | train |
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 | train |
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",
... | // 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 | train |
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 | train |
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 | train |
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 | train |
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 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 | train |
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",
"=",
"re... | // 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 | train |
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... | // 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 | train |
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",... | // RoundTrip executes the round trip | [
"RoundTrip",
"executes",
"the",
"round",
"trip"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/forward/fwd.go#L163-L173 | train |
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",
".",... | // 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 | train |
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",
":=... | // 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 | train |
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",
"=",... | // 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 | train |
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",
... | // 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 | train |
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... | // 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 | train |
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",
... | // 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 | train |
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",
"=",
... | // Clone clone a request | [
"Clone",
"clone",
"a",
"request"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/utils/dumpreq.go#L33-L50 | train |
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",
".",
"... | // ToJson serializes to JSON | [
"ToJson",
"serializes",
"to",
"JSON"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/utils/dumpreq.go#L53-L59 | train |
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 | train |
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",
"==",
... | // NewExtractor creates a new SourceExtractor | [
"NewExtractor",
"creates",
"a",
"new",
"SourceExtractor"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/utils/source.go#L28-L43 | train |
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",
"=",... | // 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 | train |
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 | train |
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 | train |
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",
":",
"&",... | // New created a new RoundRobin | [
"New",
"created",
"a",
"new",
"RoundRobin"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/roundrobin/rr.go#L65-L84 | train |
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",
... | // NextServer gets the next server | [
"NextServer",
"gets",
"the",
"next",
"server"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/roundrobin/rr.go#L151-L157 | train |
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",
"(",
"[",
... | // Servers gets servers URL | [
"Servers",
"gets",
"servers",
"URL"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/roundrobin/rr.go#L209-L218 | train |
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",
"... | // ServerWeight gets the server weight | [
"ServerWeight",
"gets",
"the",
"server",
"weight"
] | c34b0c501e43223bc816ac9b40b0ac29c44c8952 | https://github.com/vulcand/oxy/blob/c34b0c501e43223bc816ac9b40b0ac29c44c8952/roundrobin/rr.go#L221-L229 | train |
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",
"(",
... | // 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 | train |
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 | train |
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 | train |
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"... | // 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 | train |
Subsets and Splits
SQL Console for semeru/code-text-go
Retrieves a limited set of code samples with their languages, with a specific case adjustment for 'Go' language.