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
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 85
252
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
kelseyhightower/confd | log/log.go | Error | func Error(format string, v ...interface{}) {
log.Error(fmt.Sprintf(format, v...))
} | go | func Error(format string, v ...interface{}) {
log.Error(fmt.Sprintf(format, v...))
} | [
"func",
"Error",
"(",
"format",
"string",
",",
"v",
"...",
"interface",
"{",
"}",
")",
"{",
"log",
".",
"Error",
"(",
"fmt",
".",
"Sprintf",
"(",
"format",
",",
"v",
"...",
")",
")",
"\n",
"}"
] | // Error logs a message with severity ERROR. | [
"Error",
"logs",
"a",
"message",
"with",
"severity",
"ERROR",
"."
] | cccd334562329858feac719ad94b75aa87968a99 | https://github.com/kelseyhightower/confd/blob/cccd334562329858feac719ad94b75aa87968a99/log/log.go#L57-L59 | train |
kelseyhightower/confd | log/log.go | Info | func Info(format string, v ...interface{}) {
log.Info(fmt.Sprintf(format, v...))
} | go | func Info(format string, v ...interface{}) {
log.Info(fmt.Sprintf(format, v...))
} | [
"func",
"Info",
"(",
"format",
"string",
",",
"v",
"...",
"interface",
"{",
"}",
")",
"{",
"log",
".",
"Info",
"(",
"fmt",
".",
"Sprintf",
"(",
"format",
",",
"v",
"...",
")",
")",
"\n",
"}"
] | // Info logs a message with severity INFO. | [
"Info",
"logs",
"a",
"message",
"with",
"severity",
"INFO",
"."
] | cccd334562329858feac719ad94b75aa87968a99 | https://github.com/kelseyhightower/confd/blob/cccd334562329858feac719ad94b75aa87968a99/log/log.go#L67-L69 | train |
kelseyhightower/confd | log/log.go | Warning | func Warning(format string, v ...interface{}) {
log.Warning(fmt.Sprintf(format, v...))
} | go | func Warning(format string, v ...interface{}) {
log.Warning(fmt.Sprintf(format, v...))
} | [
"func",
"Warning",
"(",
"format",
"string",
",",
"v",
"...",
"interface",
"{",
"}",
")",
"{",
"log",
".",
"Warning",
"(",
"fmt",
".",
"Sprintf",
"(",
"format",
",",
"v",
"...",
")",
")",
"\n",
"}"
] | // Warning logs a message with severity WARNING. | [
"Warning",
"logs",
"a",
"message",
"with",
"severity",
"WARNING",
"."
] | cccd334562329858feac719ad94b75aa87968a99 | https://github.com/kelseyhightower/confd/blob/cccd334562329858feac719ad94b75aa87968a99/log/log.go#L72-L74 | train |
kelseyhightower/confd | backends/env/client.go | GetValues | func (c *Client) GetValues(keys []string) (map[string]string, error) {
allEnvVars := os.Environ()
envMap := make(map[string]string)
for _, e := range allEnvVars {
index := strings.Index(e, "=")
envMap[e[:index]] = e[index+1:]
}
vars := make(map[string]string)
for _, key := range keys {
k := transform(key)
for envKey, envValue := range envMap {
if strings.HasPrefix(envKey, k) {
vars[clean(envKey)] = envValue
}
}
}
log.Debug(fmt.Sprintf("Key Map: %#v", vars))
return vars, nil
} | go | func (c *Client) GetValues(keys []string) (map[string]string, error) {
allEnvVars := os.Environ()
envMap := make(map[string]string)
for _, e := range allEnvVars {
index := strings.Index(e, "=")
envMap[e[:index]] = e[index+1:]
}
vars := make(map[string]string)
for _, key := range keys {
k := transform(key)
for envKey, envValue := range envMap {
if strings.HasPrefix(envKey, k) {
vars[clean(envKey)] = envValue
}
}
}
log.Debug(fmt.Sprintf("Key Map: %#v", vars))
return vars, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetValues",
"(",
"keys",
"[",
"]",
"string",
")",
"(",
"map",
"[",
"string",
"]",
"string",
",",
"error",
")",
"{",
"allEnvVars",
":=",
"os",
".",
"Environ",
"(",
")",
"\n",
"envMap",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
"\n",
"for",
"_",
",",
"e",
":=",
"range",
"allEnvVars",
"{",
"index",
":=",
"strings",
".",
"Index",
"(",
"e",
",",
"\"",
"\"",
")",
"\n",
"envMap",
"[",
"e",
"[",
":",
"index",
"]",
"]",
"=",
"e",
"[",
"index",
"+",
"1",
":",
"]",
"\n",
"}",
"\n",
"vars",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
"\n",
"for",
"_",
",",
"key",
":=",
"range",
"keys",
"{",
"k",
":=",
"transform",
"(",
"key",
")",
"\n",
"for",
"envKey",
",",
"envValue",
":=",
"range",
"envMap",
"{",
"if",
"strings",
".",
"HasPrefix",
"(",
"envKey",
",",
"k",
")",
"{",
"vars",
"[",
"clean",
"(",
"envKey",
")",
"]",
"=",
"envValue",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"log",
".",
"Debug",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"vars",
")",
")",
"\n\n",
"return",
"vars",
",",
"nil",
"\n",
"}"
] | // GetValues queries the environment for keys | [
"GetValues",
"queries",
"the",
"environment",
"for",
"keys"
] | cccd334562329858feac719ad94b75aa87968a99 | https://github.com/kelseyhightower/confd/blob/cccd334562329858feac719ad94b75aa87968a99/backends/env/client.go#L22-L42 | train |
kelseyhightower/confd | backends/consul/client.go | New | func New(nodes []string, scheme, cert, key, caCert string, basicAuth bool, username string, password string) (*ConsulClient, error) {
conf := api.DefaultConfig()
conf.Scheme = scheme
if len(nodes) > 0 {
conf.Address = nodes[0]
}
if basicAuth {
conf.HttpAuth = &api.HttpBasicAuth{
Username: username,
Password: password,
}
}
if cert != "" && key != "" {
conf.TLSConfig.CertFile = cert
conf.TLSConfig.KeyFile = key
}
if caCert != "" {
conf.TLSConfig.CAFile = caCert
}
client, err := api.NewClient(conf)
if err != nil {
return nil, err
}
return &ConsulClient{client.KV()}, nil
} | go | func New(nodes []string, scheme, cert, key, caCert string, basicAuth bool, username string, password string) (*ConsulClient, error) {
conf := api.DefaultConfig()
conf.Scheme = scheme
if len(nodes) > 0 {
conf.Address = nodes[0]
}
if basicAuth {
conf.HttpAuth = &api.HttpBasicAuth{
Username: username,
Password: password,
}
}
if cert != "" && key != "" {
conf.TLSConfig.CertFile = cert
conf.TLSConfig.KeyFile = key
}
if caCert != "" {
conf.TLSConfig.CAFile = caCert
}
client, err := api.NewClient(conf)
if err != nil {
return nil, err
}
return &ConsulClient{client.KV()}, nil
} | [
"func",
"New",
"(",
"nodes",
"[",
"]",
"string",
",",
"scheme",
",",
"cert",
",",
"key",
",",
"caCert",
"string",
",",
"basicAuth",
"bool",
",",
"username",
"string",
",",
"password",
"string",
")",
"(",
"*",
"ConsulClient",
",",
"error",
")",
"{",
"conf",
":=",
"api",
".",
"DefaultConfig",
"(",
")",
"\n\n",
"conf",
".",
"Scheme",
"=",
"scheme",
"\n\n",
"if",
"len",
"(",
"nodes",
")",
">",
"0",
"{",
"conf",
".",
"Address",
"=",
"nodes",
"[",
"0",
"]",
"\n",
"}",
"\n\n",
"if",
"basicAuth",
"{",
"conf",
".",
"HttpAuth",
"=",
"&",
"api",
".",
"HttpBasicAuth",
"{",
"Username",
":",
"username",
",",
"Password",
":",
"password",
",",
"}",
"\n",
"}",
"\n\n",
"if",
"cert",
"!=",
"\"",
"\"",
"&&",
"key",
"!=",
"\"",
"\"",
"{",
"conf",
".",
"TLSConfig",
".",
"CertFile",
"=",
"cert",
"\n",
"conf",
".",
"TLSConfig",
".",
"KeyFile",
"=",
"key",
"\n",
"}",
"\n",
"if",
"caCert",
"!=",
"\"",
"\"",
"{",
"conf",
".",
"TLSConfig",
".",
"CAFile",
"=",
"caCert",
"\n",
"}",
"\n\n",
"client",
",",
"err",
":=",
"api",
".",
"NewClient",
"(",
"conf",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"ConsulClient",
"{",
"client",
".",
"KV",
"(",
")",
"}",
",",
"nil",
"\n",
"}"
] | // NewConsulClient returns a new client to Consul for the given address | [
"NewConsulClient",
"returns",
"a",
"new",
"client",
"to",
"Consul",
"for",
"the",
"given",
"address"
] | cccd334562329858feac719ad94b75aa87968a99 | https://github.com/kelseyhightower/confd/blob/cccd334562329858feac719ad94b75aa87968a99/backends/consul/client.go#L16-L45 | train |
kelseyhightower/confd | backends/consul/client.go | GetValues | func (c *ConsulClient) GetValues(keys []string) (map[string]string, error) {
vars := make(map[string]string)
for _, key := range keys {
key := strings.TrimPrefix(key, "/")
pairs, _, err := c.client.List(key, nil)
if err != nil {
return vars, err
}
for _, p := range pairs {
vars[path.Join("/", p.Key)] = string(p.Value)
}
}
return vars, nil
} | go | func (c *ConsulClient) GetValues(keys []string) (map[string]string, error) {
vars := make(map[string]string)
for _, key := range keys {
key := strings.TrimPrefix(key, "/")
pairs, _, err := c.client.List(key, nil)
if err != nil {
return vars, err
}
for _, p := range pairs {
vars[path.Join("/", p.Key)] = string(p.Value)
}
}
return vars, nil
} | [
"func",
"(",
"c",
"*",
"ConsulClient",
")",
"GetValues",
"(",
"keys",
"[",
"]",
"string",
")",
"(",
"map",
"[",
"string",
"]",
"string",
",",
"error",
")",
"{",
"vars",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
"\n",
"for",
"_",
",",
"key",
":=",
"range",
"keys",
"{",
"key",
":=",
"strings",
".",
"TrimPrefix",
"(",
"key",
",",
"\"",
"\"",
")",
"\n",
"pairs",
",",
"_",
",",
"err",
":=",
"c",
".",
"client",
".",
"List",
"(",
"key",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"vars",
",",
"err",
"\n",
"}",
"\n",
"for",
"_",
",",
"p",
":=",
"range",
"pairs",
"{",
"vars",
"[",
"path",
".",
"Join",
"(",
"\"",
"\"",
",",
"p",
".",
"Key",
")",
"]",
"=",
"string",
"(",
"p",
".",
"Value",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"vars",
",",
"nil",
"\n",
"}"
] | // GetValues queries Consul for keys | [
"GetValues",
"queries",
"Consul",
"for",
"keys"
] | cccd334562329858feac719ad94b75aa87968a99 | https://github.com/kelseyhightower/confd/blob/cccd334562329858feac719ad94b75aa87968a99/backends/consul/client.go#L48-L61 | train |
kelseyhightower/confd | backends/vault/client.go | panicToError | func panicToError(err *error) {
if r := recover(); r != nil {
switch t := r.(type) {
case string:
*err = errors.New(t)
case error:
*err = t
default: // panic again if we don't know how to handle
panic(r)
}
}
} | go | func panicToError(err *error) {
if r := recover(); r != nil {
switch t := r.(type) {
case string:
*err = errors.New(t)
case error:
*err = t
default: // panic again if we don't know how to handle
panic(r)
}
}
} | [
"func",
"panicToError",
"(",
"err",
"*",
"error",
")",
"{",
"if",
"r",
":=",
"recover",
"(",
")",
";",
"r",
"!=",
"nil",
"{",
"switch",
"t",
":=",
"r",
".",
"(",
"type",
")",
"{",
"case",
"string",
":",
"*",
"err",
"=",
"errors",
".",
"New",
"(",
"t",
")",
"\n",
"case",
"error",
":",
"*",
"err",
"=",
"t",
"\n",
"default",
":",
"// panic again if we don't know how to handle",
"panic",
"(",
"r",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // panicToError converts a panic to an error | [
"panicToError",
"converts",
"a",
"panic",
"to",
"an",
"error"
] | cccd334562329858feac719ad94b75aa87968a99 | https://github.com/kelseyhightower/confd/blob/cccd334562329858feac719ad94b75aa87968a99/backends/vault/client.go#L33-L44 | train |
kelseyhightower/confd | backends/vault/client.go | authenticate | func authenticate(c *vaultapi.Client, authType string, params map[string]string) (err error) {
var secret *vaultapi.Secret
// handle panics gracefully by creating an error
// this would happen when we get a parameter that is missing
defer panicToError(&err)
path := params["path"]
if path == "" {
path = authType
if authType == "app-role" {
path = "approle"
}
}
url := fmt.Sprintf("/auth/%s/login", path)
switch authType {
case "app-role":
secret, err = c.Logical().Write(url, map[string]interface{}{
"role_id": getParameter("role-id", params),
"secret_id": getParameter("secret-id", params),
})
case "app-id":
secret, err = c.Logical().Write(url, map[string]interface{}{
"app_id": getParameter("app-id", params),
"user_id": getParameter("user-id", params),
})
case "github":
secret, err = c.Logical().Write(url, map[string]interface{}{
"token": getParameter("token", params),
})
case "token":
c.SetToken(getParameter("token", params))
secret, err = c.Logical().Read("/auth/token/lookup-self")
case "userpass":
username, password := getParameter("username", params), getParameter("password", params)
secret, err = c.Logical().Write(fmt.Sprintf("%s/%s", url, username), map[string]interface{}{
"password": password,
})
case "kubernetes":
jwt, err := ioutil.ReadFile("/var/run/secrets/kubernetes.io/serviceaccount/token")
if err != nil {
return err
}
secret, err = c.Logical().Write(url, map[string]interface{}{
"jwt": string(jwt[:]),
"role": getParameter("role-id", params),
})
case "cert":
secret, err = c.Logical().Write(url, map[string]interface{}{})
}
if err != nil {
return err
}
// if the token has already been set
if c.Token() != "" {
return nil
}
if secret == nil || secret.Auth == nil {
return errors.New("Unable to authenticate")
}
log.Debug("client authenticated with auth backend: %s", authType)
// the default place for a token is in the auth section
// otherwise, the backend will set the token itself
c.SetToken(secret.Auth.ClientToken)
return nil
} | go | func authenticate(c *vaultapi.Client, authType string, params map[string]string) (err error) {
var secret *vaultapi.Secret
// handle panics gracefully by creating an error
// this would happen when we get a parameter that is missing
defer panicToError(&err)
path := params["path"]
if path == "" {
path = authType
if authType == "app-role" {
path = "approle"
}
}
url := fmt.Sprintf("/auth/%s/login", path)
switch authType {
case "app-role":
secret, err = c.Logical().Write(url, map[string]interface{}{
"role_id": getParameter("role-id", params),
"secret_id": getParameter("secret-id", params),
})
case "app-id":
secret, err = c.Logical().Write(url, map[string]interface{}{
"app_id": getParameter("app-id", params),
"user_id": getParameter("user-id", params),
})
case "github":
secret, err = c.Logical().Write(url, map[string]interface{}{
"token": getParameter("token", params),
})
case "token":
c.SetToken(getParameter("token", params))
secret, err = c.Logical().Read("/auth/token/lookup-self")
case "userpass":
username, password := getParameter("username", params), getParameter("password", params)
secret, err = c.Logical().Write(fmt.Sprintf("%s/%s", url, username), map[string]interface{}{
"password": password,
})
case "kubernetes":
jwt, err := ioutil.ReadFile("/var/run/secrets/kubernetes.io/serviceaccount/token")
if err != nil {
return err
}
secret, err = c.Logical().Write(url, map[string]interface{}{
"jwt": string(jwt[:]),
"role": getParameter("role-id", params),
})
case "cert":
secret, err = c.Logical().Write(url, map[string]interface{}{})
}
if err != nil {
return err
}
// if the token has already been set
if c.Token() != "" {
return nil
}
if secret == nil || secret.Auth == nil {
return errors.New("Unable to authenticate")
}
log.Debug("client authenticated with auth backend: %s", authType)
// the default place for a token is in the auth section
// otherwise, the backend will set the token itself
c.SetToken(secret.Auth.ClientToken)
return nil
} | [
"func",
"authenticate",
"(",
"c",
"*",
"vaultapi",
".",
"Client",
",",
"authType",
"string",
",",
"params",
"map",
"[",
"string",
"]",
"string",
")",
"(",
"err",
"error",
")",
"{",
"var",
"secret",
"*",
"vaultapi",
".",
"Secret",
"\n\n",
"// handle panics gracefully by creating an error",
"// this would happen when we get a parameter that is missing",
"defer",
"panicToError",
"(",
"&",
"err",
")",
"\n\n",
"path",
":=",
"params",
"[",
"\"",
"\"",
"]",
"\n",
"if",
"path",
"==",
"\"",
"\"",
"{",
"path",
"=",
"authType",
"\n",
"if",
"authType",
"==",
"\"",
"\"",
"{",
"path",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"}",
"\n",
"url",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"path",
")",
"\n\n",
"switch",
"authType",
"{",
"case",
"\"",
"\"",
":",
"secret",
",",
"err",
"=",
"c",
".",
"Logical",
"(",
")",
".",
"Write",
"(",
"url",
",",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"getParameter",
"(",
"\"",
"\"",
",",
"params",
")",
",",
"\"",
"\"",
":",
"getParameter",
"(",
"\"",
"\"",
",",
"params",
")",
",",
"}",
")",
"\n",
"case",
"\"",
"\"",
":",
"secret",
",",
"err",
"=",
"c",
".",
"Logical",
"(",
")",
".",
"Write",
"(",
"url",
",",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"getParameter",
"(",
"\"",
"\"",
",",
"params",
")",
",",
"\"",
"\"",
":",
"getParameter",
"(",
"\"",
"\"",
",",
"params",
")",
",",
"}",
")",
"\n",
"case",
"\"",
"\"",
":",
"secret",
",",
"err",
"=",
"c",
".",
"Logical",
"(",
")",
".",
"Write",
"(",
"url",
",",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"getParameter",
"(",
"\"",
"\"",
",",
"params",
")",
",",
"}",
")",
"\n",
"case",
"\"",
"\"",
":",
"c",
".",
"SetToken",
"(",
"getParameter",
"(",
"\"",
"\"",
",",
"params",
")",
")",
"\n",
"secret",
",",
"err",
"=",
"c",
".",
"Logical",
"(",
")",
".",
"Read",
"(",
"\"",
"\"",
")",
"\n",
"case",
"\"",
"\"",
":",
"username",
",",
"password",
":=",
"getParameter",
"(",
"\"",
"\"",
",",
"params",
")",
",",
"getParameter",
"(",
"\"",
"\"",
",",
"params",
")",
"\n",
"secret",
",",
"err",
"=",
"c",
".",
"Logical",
"(",
")",
".",
"Write",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"url",
",",
"username",
")",
",",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"password",
",",
"}",
")",
"\n",
"case",
"\"",
"\"",
":",
"jwt",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"secret",
",",
"err",
"=",
"c",
".",
"Logical",
"(",
")",
".",
"Write",
"(",
"url",
",",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"string",
"(",
"jwt",
"[",
":",
"]",
")",
",",
"\"",
"\"",
":",
"getParameter",
"(",
"\"",
"\"",
",",
"params",
")",
",",
"}",
")",
"\n",
"case",
"\"",
"\"",
":",
"secret",
",",
"err",
"=",
"c",
".",
"Logical",
"(",
")",
".",
"Write",
"(",
"url",
",",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"}",
")",
"\n",
"}",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// if the token has already been set",
"if",
"c",
".",
"Token",
"(",
")",
"!=",
"\"",
"\"",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"secret",
"==",
"nil",
"||",
"secret",
".",
"Auth",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"log",
".",
"Debug",
"(",
"\"",
"\"",
",",
"authType",
")",
"\n",
"// the default place for a token is in the auth section",
"// otherwise, the backend will set the token itself",
"c",
".",
"SetToken",
"(",
"secret",
".",
"Auth",
".",
"ClientToken",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // authenticate with the remote client | [
"authenticate",
"with",
"the",
"remote",
"client"
] | cccd334562329858feac719ad94b75aa87968a99 | https://github.com/kelseyhightower/confd/blob/cccd334562329858feac719ad94b75aa87968a99/backends/vault/client.go#L47-L117 | train |
kelseyhightower/confd | backends/vault/client.go | isKV | func isKV(data map[string]interface{}) (string, bool) {
if len(data) == 1 {
if value, ok := data["value"]; ok {
if text, ok := value.(string); ok {
return text, true
}
}
}
return "", false
} | go | func isKV(data map[string]interface{}) (string, bool) {
if len(data) == 1 {
if value, ok := data["value"]; ok {
if text, ok := value.(string); ok {
return text, true
}
}
}
return "", false
} | [
"func",
"isKV",
"(",
"data",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"(",
"string",
",",
"bool",
")",
"{",
"if",
"len",
"(",
"data",
")",
"==",
"1",
"{",
"if",
"value",
",",
"ok",
":=",
"data",
"[",
"\"",
"\"",
"]",
";",
"ok",
"{",
"if",
"text",
",",
"ok",
":=",
"value",
".",
"(",
"string",
")",
";",
"ok",
"{",
"return",
"text",
",",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
",",
"false",
"\n",
"}"
] | // isKV checks if a given map has only one key of type string
// if so, returns the value of that key | [
"isKV",
"checks",
"if",
"a",
"given",
"map",
"has",
"only",
"one",
"key",
"of",
"type",
"string",
"if",
"so",
"returns",
"the",
"value",
"of",
"that",
"key"
] | cccd334562329858feac719ad94b75aa87968a99 | https://github.com/kelseyhightower/confd/blob/cccd334562329858feac719ad94b75aa87968a99/backends/vault/client.go#L210-L219 | train |
kelseyhightower/confd | backends/vault/client.go | flatten | func flatten(key string, value interface{}, vars map[string]string) {
switch value.(type) {
case string:
log.Debug("setting key %s to: %s", key, value)
vars[key] = value.(string)
case map[string]interface{}:
inner := value.(map[string]interface{})
for innerKey, innerValue := range inner {
innerKey = path.Join(key, "/", innerKey)
flatten(innerKey, innerValue, vars)
}
default: // we don't know how to handle non string or maps of strings
log.Warning("type of '%s' is not supported (%T)", key, value)
}
} | go | func flatten(key string, value interface{}, vars map[string]string) {
switch value.(type) {
case string:
log.Debug("setting key %s to: %s", key, value)
vars[key] = value.(string)
case map[string]interface{}:
inner := value.(map[string]interface{})
for innerKey, innerValue := range inner {
innerKey = path.Join(key, "/", innerKey)
flatten(innerKey, innerValue, vars)
}
default: // we don't know how to handle non string or maps of strings
log.Warning("type of '%s' is not supported (%T)", key, value)
}
} | [
"func",
"flatten",
"(",
"key",
"string",
",",
"value",
"interface",
"{",
"}",
",",
"vars",
"map",
"[",
"string",
"]",
"string",
")",
"{",
"switch",
"value",
".",
"(",
"type",
")",
"{",
"case",
"string",
":",
"log",
".",
"Debug",
"(",
"\"",
"\"",
",",
"key",
",",
"value",
")",
"\n",
"vars",
"[",
"key",
"]",
"=",
"value",
".",
"(",
"string",
")",
"\n",
"case",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
":",
"inner",
":=",
"value",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"for",
"innerKey",
",",
"innerValue",
":=",
"range",
"inner",
"{",
"innerKey",
"=",
"path",
".",
"Join",
"(",
"key",
",",
"\"",
"\"",
",",
"innerKey",
")",
"\n",
"flatten",
"(",
"innerKey",
",",
"innerValue",
",",
"vars",
")",
"\n",
"}",
"\n",
"default",
":",
"// we don't know how to handle non string or maps of strings",
"log",
".",
"Warning",
"(",
"\"",
"\"",
",",
"key",
",",
"value",
")",
"\n",
"}",
"\n",
"}"
] | // recursively walks on all the values of a specific key and set them in the variables map | [
"recursively",
"walks",
"on",
"all",
"the",
"values",
"of",
"a",
"specific",
"key",
"and",
"set",
"them",
"in",
"the",
"variables",
"map"
] | cccd334562329858feac719ad94b75aa87968a99 | https://github.com/kelseyhightower/confd/blob/cccd334562329858feac719ad94b75aa87968a99/backends/vault/client.go#L222-L236 | train |
kelseyhightower/confd | backends/vault/client.go | walkTree | func walkTree(c *Client, key string, branches map[string]bool) error {
log.Debug("listing %s from vault", key)
// strip trailing slash as long as it's not the only character
if last := len(key) - 1; last > 0 && key[last] == '/' {
key = key[:last]
}
if branches[key] {
// already processed this branch
return nil
}
branches[key] = true
resp, err := c.client.Logical().List(key)
if err != nil {
log.Debug("there was an error extracting %s", key)
return err
}
if resp == nil || resp.Data == nil || resp.Data["keys"] == nil {
return nil
}
switch resp.Data["keys"].(type) {
case []interface{}:
// expected
default:
log.Warning("key list type of '%s' is not supported (%T)", key, resp.Data["keys"])
return nil
}
keyList := resp.Data["keys"].([]interface{})
for _, innerKey := range keyList {
switch innerKey.(type) {
case string:
innerKey = path.Join(key, "/", innerKey.(string))
walkTree(c, innerKey.(string), branches)
default: // we don't know how to handle other data types
log.Warning("type of '%s' is not supported (%T)", key, keyList)
}
}
return nil
} | go | func walkTree(c *Client, key string, branches map[string]bool) error {
log.Debug("listing %s from vault", key)
// strip trailing slash as long as it's not the only character
if last := len(key) - 1; last > 0 && key[last] == '/' {
key = key[:last]
}
if branches[key] {
// already processed this branch
return nil
}
branches[key] = true
resp, err := c.client.Logical().List(key)
if err != nil {
log.Debug("there was an error extracting %s", key)
return err
}
if resp == nil || resp.Data == nil || resp.Data["keys"] == nil {
return nil
}
switch resp.Data["keys"].(type) {
case []interface{}:
// expected
default:
log.Warning("key list type of '%s' is not supported (%T)", key, resp.Data["keys"])
return nil
}
keyList := resp.Data["keys"].([]interface{})
for _, innerKey := range keyList {
switch innerKey.(type) {
case string:
innerKey = path.Join(key, "/", innerKey.(string))
walkTree(c, innerKey.(string), branches)
default: // we don't know how to handle other data types
log.Warning("type of '%s' is not supported (%T)", key, keyList)
}
}
return nil
} | [
"func",
"walkTree",
"(",
"c",
"*",
"Client",
",",
"key",
"string",
",",
"branches",
"map",
"[",
"string",
"]",
"bool",
")",
"error",
"{",
"log",
".",
"Debug",
"(",
"\"",
"\"",
",",
"key",
")",
"\n\n",
"// strip trailing slash as long as it's not the only character",
"if",
"last",
":=",
"len",
"(",
"key",
")",
"-",
"1",
";",
"last",
">",
"0",
"&&",
"key",
"[",
"last",
"]",
"==",
"'/'",
"{",
"key",
"=",
"key",
"[",
":",
"last",
"]",
"\n",
"}",
"\n",
"if",
"branches",
"[",
"key",
"]",
"{",
"// already processed this branch",
"return",
"nil",
"\n",
"}",
"\n",
"branches",
"[",
"key",
"]",
"=",
"true",
"\n\n",
"resp",
",",
"err",
":=",
"c",
".",
"client",
".",
"Logical",
"(",
")",
".",
"List",
"(",
"key",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Debug",
"(",
"\"",
"\"",
",",
"key",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"if",
"resp",
"==",
"nil",
"||",
"resp",
".",
"Data",
"==",
"nil",
"||",
"resp",
".",
"Data",
"[",
"\"",
"\"",
"]",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"switch",
"resp",
".",
"Data",
"[",
"\"",
"\"",
"]",
".",
"(",
"type",
")",
"{",
"case",
"[",
"]",
"interface",
"{",
"}",
":",
"// expected",
"default",
":",
"log",
".",
"Warning",
"(",
"\"",
"\"",
",",
"key",
",",
"resp",
".",
"Data",
"[",
"\"",
"\"",
"]",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"keyList",
":=",
"resp",
".",
"Data",
"[",
"\"",
"\"",
"]",
".",
"(",
"[",
"]",
"interface",
"{",
"}",
")",
"\n",
"for",
"_",
",",
"innerKey",
":=",
"range",
"keyList",
"{",
"switch",
"innerKey",
".",
"(",
"type",
")",
"{",
"case",
"string",
":",
"innerKey",
"=",
"path",
".",
"Join",
"(",
"key",
",",
"\"",
"\"",
",",
"innerKey",
".",
"(",
"string",
")",
")",
"\n",
"walkTree",
"(",
"c",
",",
"innerKey",
".",
"(",
"string",
")",
",",
"branches",
")",
"\n\n",
"default",
":",
"// we don't know how to handle other data types",
"log",
".",
"Warning",
"(",
"\"",
"\"",
",",
"key",
",",
"keyList",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // recursively walk the branches in the Vault, adding to branches map | [
"recursively",
"walk",
"the",
"branches",
"in",
"the",
"Vault",
"adding",
"to",
"branches",
"map"
] | cccd334562329858feac719ad94b75aa87968a99 | https://github.com/kelseyhightower/confd/blob/cccd334562329858feac719ad94b75aa87968a99/backends/vault/client.go#L239-L283 | train |
kelseyhightower/confd | util/filestat_posix.go | FileStat | func FileStat(name string) (fi FileInfo, err error) {
if IsFileExist(name) {
f, err := os.Open(name)
if err != nil {
return fi, err
}
defer f.Close()
stats, _ := f.Stat()
fi.Uid = stats.Sys().(*syscall.Stat_t).Uid
fi.Gid = stats.Sys().(*syscall.Stat_t).Gid
fi.Mode = stats.Mode()
h := md5.New()
io.Copy(h, f)
fi.Md5 = fmt.Sprintf("%x", h.Sum(nil))
return fi, nil
}
return fi, errors.New("File not found")
} | go | func FileStat(name string) (fi FileInfo, err error) {
if IsFileExist(name) {
f, err := os.Open(name)
if err != nil {
return fi, err
}
defer f.Close()
stats, _ := f.Stat()
fi.Uid = stats.Sys().(*syscall.Stat_t).Uid
fi.Gid = stats.Sys().(*syscall.Stat_t).Gid
fi.Mode = stats.Mode()
h := md5.New()
io.Copy(h, f)
fi.Md5 = fmt.Sprintf("%x", h.Sum(nil))
return fi, nil
}
return fi, errors.New("File not found")
} | [
"func",
"FileStat",
"(",
"name",
"string",
")",
"(",
"fi",
"FileInfo",
",",
"err",
"error",
")",
"{",
"if",
"IsFileExist",
"(",
"name",
")",
"{",
"f",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fi",
",",
"err",
"\n",
"}",
"\n",
"defer",
"f",
".",
"Close",
"(",
")",
"\n",
"stats",
",",
"_",
":=",
"f",
".",
"Stat",
"(",
")",
"\n",
"fi",
".",
"Uid",
"=",
"stats",
".",
"Sys",
"(",
")",
".",
"(",
"*",
"syscall",
".",
"Stat_t",
")",
".",
"Uid",
"\n",
"fi",
".",
"Gid",
"=",
"stats",
".",
"Sys",
"(",
")",
".",
"(",
"*",
"syscall",
".",
"Stat_t",
")",
".",
"Gid",
"\n",
"fi",
".",
"Mode",
"=",
"stats",
".",
"Mode",
"(",
")",
"\n",
"h",
":=",
"md5",
".",
"New",
"(",
")",
"\n",
"io",
".",
"Copy",
"(",
"h",
",",
"f",
")",
"\n",
"fi",
".",
"Md5",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"h",
".",
"Sum",
"(",
"nil",
")",
")",
"\n",
"return",
"fi",
",",
"nil",
"\n",
"}",
"\n",
"return",
"fi",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}"
] | // filestat return a FileInfo describing the named file. | [
"filestat",
"return",
"a",
"FileInfo",
"describing",
"the",
"named",
"file",
"."
] | cccd334562329858feac719ad94b75aa87968a99 | https://github.com/kelseyhightower/confd/blob/cccd334562329858feac719ad94b75aa87968a99/util/filestat_posix.go#L15-L32 | train |
lucas-clemente/quic-go | internal/flowcontrol/connection_flow_controller.go | NewConnectionFlowController | func NewConnectionFlowController(
receiveWindow protocol.ByteCount,
maxReceiveWindow protocol.ByteCount,
queueWindowUpdate func(),
rttStats *congestion.RTTStats,
logger utils.Logger,
) ConnectionFlowController {
return &connectionFlowController{
baseFlowController: baseFlowController{
rttStats: rttStats,
receiveWindow: receiveWindow,
receiveWindowSize: receiveWindow,
maxReceiveWindowSize: maxReceiveWindow,
logger: logger,
},
queueWindowUpdate: queueWindowUpdate,
}
} | go | func NewConnectionFlowController(
receiveWindow protocol.ByteCount,
maxReceiveWindow protocol.ByteCount,
queueWindowUpdate func(),
rttStats *congestion.RTTStats,
logger utils.Logger,
) ConnectionFlowController {
return &connectionFlowController{
baseFlowController: baseFlowController{
rttStats: rttStats,
receiveWindow: receiveWindow,
receiveWindowSize: receiveWindow,
maxReceiveWindowSize: maxReceiveWindow,
logger: logger,
},
queueWindowUpdate: queueWindowUpdate,
}
} | [
"func",
"NewConnectionFlowController",
"(",
"receiveWindow",
"protocol",
".",
"ByteCount",
",",
"maxReceiveWindow",
"protocol",
".",
"ByteCount",
",",
"queueWindowUpdate",
"func",
"(",
")",
",",
"rttStats",
"*",
"congestion",
".",
"RTTStats",
",",
"logger",
"utils",
".",
"Logger",
",",
")",
"ConnectionFlowController",
"{",
"return",
"&",
"connectionFlowController",
"{",
"baseFlowController",
":",
"baseFlowController",
"{",
"rttStats",
":",
"rttStats",
",",
"receiveWindow",
":",
"receiveWindow",
",",
"receiveWindowSize",
":",
"receiveWindow",
",",
"maxReceiveWindowSize",
":",
"maxReceiveWindow",
",",
"logger",
":",
"logger",
",",
"}",
",",
"queueWindowUpdate",
":",
"queueWindowUpdate",
",",
"}",
"\n",
"}"
] | // NewConnectionFlowController gets a new flow controller for the connection
// It is created before we receive the peer's transport paramenters, thus it starts with a sendWindow of 0. | [
"NewConnectionFlowController",
"gets",
"a",
"new",
"flow",
"controller",
"for",
"the",
"connection",
"It",
"is",
"created",
"before",
"we",
"receive",
"the",
"peer",
"s",
"transport",
"paramenters",
"thus",
"it",
"starts",
"with",
"a",
"sendWindow",
"of",
"0",
"."
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/flowcontrol/connection_flow_controller.go#L22-L39 | train |
lucas-clemente/quic-go | internal/flowcontrol/connection_flow_controller.go | IncrementHighestReceived | func (c *connectionFlowController) IncrementHighestReceived(increment protocol.ByteCount) error {
c.mutex.Lock()
defer c.mutex.Unlock()
c.highestReceived += increment
if c.checkFlowControlViolation() {
return qerr.Error(qerr.FlowControlError, fmt.Sprintf("Received %d bytes for the connection, allowed %d bytes", c.highestReceived, c.receiveWindow))
}
return nil
} | go | func (c *connectionFlowController) IncrementHighestReceived(increment protocol.ByteCount) error {
c.mutex.Lock()
defer c.mutex.Unlock()
c.highestReceived += increment
if c.checkFlowControlViolation() {
return qerr.Error(qerr.FlowControlError, fmt.Sprintf("Received %d bytes for the connection, allowed %d bytes", c.highestReceived, c.receiveWindow))
}
return nil
} | [
"func",
"(",
"c",
"*",
"connectionFlowController",
")",
"IncrementHighestReceived",
"(",
"increment",
"protocol",
".",
"ByteCount",
")",
"error",
"{",
"c",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"c",
".",
"highestReceived",
"+=",
"increment",
"\n",
"if",
"c",
".",
"checkFlowControlViolation",
"(",
")",
"{",
"return",
"qerr",
".",
"Error",
"(",
"qerr",
".",
"FlowControlError",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"c",
".",
"highestReceived",
",",
"c",
".",
"receiveWindow",
")",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // IncrementHighestReceived adds an increment to the highestReceived value | [
"IncrementHighestReceived",
"adds",
"an",
"increment",
"to",
"the",
"highestReceived",
"value"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/flowcontrol/connection_flow_controller.go#L46-L55 | train |
lucas-clemente/quic-go | internal/flowcontrol/connection_flow_controller.go | EnsureMinimumWindowSize | func (c *connectionFlowController) EnsureMinimumWindowSize(inc protocol.ByteCount) {
c.mutex.Lock()
if inc > c.receiveWindowSize {
c.logger.Debugf("Increasing receive flow control window for the connection to %d kB, in response to stream flow control window increase", c.receiveWindowSize/(1<<10))
c.receiveWindowSize = utils.MinByteCount(inc, c.maxReceiveWindowSize)
c.startNewAutoTuningEpoch()
}
c.mutex.Unlock()
} | go | func (c *connectionFlowController) EnsureMinimumWindowSize(inc protocol.ByteCount) {
c.mutex.Lock()
if inc > c.receiveWindowSize {
c.logger.Debugf("Increasing receive flow control window for the connection to %d kB, in response to stream flow control window increase", c.receiveWindowSize/(1<<10))
c.receiveWindowSize = utils.MinByteCount(inc, c.maxReceiveWindowSize)
c.startNewAutoTuningEpoch()
}
c.mutex.Unlock()
} | [
"func",
"(",
"c",
"*",
"connectionFlowController",
")",
"EnsureMinimumWindowSize",
"(",
"inc",
"protocol",
".",
"ByteCount",
")",
"{",
"c",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"if",
"inc",
">",
"c",
".",
"receiveWindowSize",
"{",
"c",
".",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"c",
".",
"receiveWindowSize",
"/",
"(",
"1",
"<<",
"10",
")",
")",
"\n",
"c",
".",
"receiveWindowSize",
"=",
"utils",
".",
"MinByteCount",
"(",
"inc",
",",
"c",
".",
"maxReceiveWindowSize",
")",
"\n",
"c",
".",
"startNewAutoTuningEpoch",
"(",
")",
"\n",
"}",
"\n",
"c",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"}"
] | // EnsureMinimumWindowSize sets a minimum window size
// it should make sure that the connection-level window is increased when a stream-level window grows | [
"EnsureMinimumWindowSize",
"sets",
"a",
"minimum",
"window",
"size",
"it",
"should",
"make",
"sure",
"that",
"the",
"connection",
"-",
"level",
"window",
"is",
"increased",
"when",
"a",
"stream",
"-",
"level",
"window",
"grows"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/flowcontrol/connection_flow_controller.go#L84-L92 | train |
lucas-clemente/quic-go | internal/qerr/quic_error.go | Error | func Error(errorCode ErrorCode, errorMessage string) *QuicError {
return &QuicError{
ErrorCode: errorCode,
ErrorMessage: errorMessage,
}
} | go | func Error(errorCode ErrorCode, errorMessage string) *QuicError {
return &QuicError{
ErrorCode: errorCode,
ErrorMessage: errorMessage,
}
} | [
"func",
"Error",
"(",
"errorCode",
"ErrorCode",
",",
"errorMessage",
"string",
")",
"*",
"QuicError",
"{",
"return",
"&",
"QuicError",
"{",
"ErrorCode",
":",
"errorCode",
",",
"ErrorMessage",
":",
"errorMessage",
",",
"}",
"\n",
"}"
] | // Error creates a new QuicError instance | [
"Error",
"creates",
"a",
"new",
"QuicError",
"instance"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/qerr/quic_error.go#L18-L23 | train |
lucas-clemente/quic-go | internal/qerr/quic_error.go | CryptoError | func CryptoError(tlsAlert uint8, errorMessage string) *QuicError {
return &QuicError{
ErrorCode: 0x100 + ErrorCode(tlsAlert),
ErrorMessage: errorMessage,
}
} | go | func CryptoError(tlsAlert uint8, errorMessage string) *QuicError {
return &QuicError{
ErrorCode: 0x100 + ErrorCode(tlsAlert),
ErrorMessage: errorMessage,
}
} | [
"func",
"CryptoError",
"(",
"tlsAlert",
"uint8",
",",
"errorMessage",
"string",
")",
"*",
"QuicError",
"{",
"return",
"&",
"QuicError",
"{",
"ErrorCode",
":",
"0x100",
"+",
"ErrorCode",
"(",
"tlsAlert",
")",
",",
"ErrorMessage",
":",
"errorMessage",
",",
"}",
"\n",
"}"
] | // CryptoError create a new QuicError instance for a crypto error | [
"CryptoError",
"create",
"a",
"new",
"QuicError",
"instance",
"for",
"a",
"crypto",
"error"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/qerr/quic_error.go#L34-L39 | train |
lucas-clemente/quic-go | internal/qerr/quic_error.go | ToQuicError | func ToQuicError(err error) *QuicError {
switch e := err.(type) {
case *QuicError:
return e
case ErrorCode:
return Error(e, "")
}
return Error(InternalError, err.Error())
} | go | func ToQuicError(err error) *QuicError {
switch e := err.(type) {
case *QuicError:
return e
case ErrorCode:
return Error(e, "")
}
return Error(InternalError, err.Error())
} | [
"func",
"ToQuicError",
"(",
"err",
"error",
")",
"*",
"QuicError",
"{",
"switch",
"e",
":=",
"err",
".",
"(",
"type",
")",
"{",
"case",
"*",
"QuicError",
":",
"return",
"e",
"\n",
"case",
"ErrorCode",
":",
"return",
"Error",
"(",
"e",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"Error",
"(",
"InternalError",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}"
] | // ToQuicError converts an arbitrary error to a QuicError. It leaves QuicErrors
// unchanged, and properly handles `ErrorCode`s. | [
"ToQuicError",
"converts",
"an",
"arbitrary",
"error",
"to",
"a",
"QuicError",
".",
"It",
"leaves",
"QuicErrors",
"unchanged",
"and",
"properly",
"handles",
"ErrorCode",
"s",
"."
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/qerr/quic_error.go#L65-L73 | train |
lucas-clemente/quic-go | internal/congestion/cubic.go | NewCubic | func NewCubic(clock Clock) *Cubic {
c := &Cubic{
clock: clock,
numConnections: defaultNumConnections,
}
c.Reset()
return c
} | go | func NewCubic(clock Clock) *Cubic {
c := &Cubic{
clock: clock,
numConnections: defaultNumConnections,
}
c.Reset()
return c
} | [
"func",
"NewCubic",
"(",
"clock",
"Clock",
")",
"*",
"Cubic",
"{",
"c",
":=",
"&",
"Cubic",
"{",
"clock",
":",
"clock",
",",
"numConnections",
":",
"defaultNumConnections",
",",
"}",
"\n",
"c",
".",
"Reset",
"(",
")",
"\n",
"return",
"c",
"\n",
"}"
] | // NewCubic returns a new Cubic instance | [
"NewCubic",
"returns",
"a",
"new",
"Cubic",
"instance"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/congestion/cubic.go#L66-L73 | train |
lucas-clemente/quic-go | internal/congestion/cubic.go | Reset | func (c *Cubic) Reset() {
c.epoch = time.Time{}
c.lastMaxCongestionWindow = 0
c.ackedBytesCount = 0
c.estimatedTCPcongestionWindow = 0
c.originPointCongestionWindow = 0
c.timeToOriginPoint = 0
c.lastTargetCongestionWindow = 0
} | go | func (c *Cubic) Reset() {
c.epoch = time.Time{}
c.lastMaxCongestionWindow = 0
c.ackedBytesCount = 0
c.estimatedTCPcongestionWindow = 0
c.originPointCongestionWindow = 0
c.timeToOriginPoint = 0
c.lastTargetCongestionWindow = 0
} | [
"func",
"(",
"c",
"*",
"Cubic",
")",
"Reset",
"(",
")",
"{",
"c",
".",
"epoch",
"=",
"time",
".",
"Time",
"{",
"}",
"\n",
"c",
".",
"lastMaxCongestionWindow",
"=",
"0",
"\n",
"c",
".",
"ackedBytesCount",
"=",
"0",
"\n",
"c",
".",
"estimatedTCPcongestionWindow",
"=",
"0",
"\n",
"c",
".",
"originPointCongestionWindow",
"=",
"0",
"\n",
"c",
".",
"timeToOriginPoint",
"=",
"0",
"\n",
"c",
".",
"lastTargetCongestionWindow",
"=",
"0",
"\n",
"}"
] | // Reset is called after a timeout to reset the cubic state | [
"Reset",
"is",
"called",
"after",
"a",
"timeout",
"to",
"reset",
"the",
"cubic",
"state"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/congestion/cubic.go#L76-L84 | train |
lucas-clemente/quic-go | internal/congestion/cubic.go | CongestionWindowAfterPacketLoss | func (c *Cubic) CongestionWindowAfterPacketLoss(currentCongestionWindow protocol.ByteCount) protocol.ByteCount {
if currentCongestionWindow+protocol.DefaultTCPMSS < c.lastMaxCongestionWindow {
// We never reached the old max, so assume we are competing with another
// flow. Use our extra back off factor to allow the other flow to go up.
c.lastMaxCongestionWindow = protocol.ByteCount(c.betaLastMax() * float32(currentCongestionWindow))
} else {
c.lastMaxCongestionWindow = currentCongestionWindow
}
c.epoch = time.Time{} // Reset time.
return protocol.ByteCount(float32(currentCongestionWindow) * c.beta())
} | go | func (c *Cubic) CongestionWindowAfterPacketLoss(currentCongestionWindow protocol.ByteCount) protocol.ByteCount {
if currentCongestionWindow+protocol.DefaultTCPMSS < c.lastMaxCongestionWindow {
// We never reached the old max, so assume we are competing with another
// flow. Use our extra back off factor to allow the other flow to go up.
c.lastMaxCongestionWindow = protocol.ByteCount(c.betaLastMax() * float32(currentCongestionWindow))
} else {
c.lastMaxCongestionWindow = currentCongestionWindow
}
c.epoch = time.Time{} // Reset time.
return protocol.ByteCount(float32(currentCongestionWindow) * c.beta())
} | [
"func",
"(",
"c",
"*",
"Cubic",
")",
"CongestionWindowAfterPacketLoss",
"(",
"currentCongestionWindow",
"protocol",
".",
"ByteCount",
")",
"protocol",
".",
"ByteCount",
"{",
"if",
"currentCongestionWindow",
"+",
"protocol",
".",
"DefaultTCPMSS",
"<",
"c",
".",
"lastMaxCongestionWindow",
"{",
"// We never reached the old max, so assume we are competing with another",
"// flow. Use our extra back off factor to allow the other flow to go up.",
"c",
".",
"lastMaxCongestionWindow",
"=",
"protocol",
".",
"ByteCount",
"(",
"c",
".",
"betaLastMax",
"(",
")",
"*",
"float32",
"(",
"currentCongestionWindow",
")",
")",
"\n",
"}",
"else",
"{",
"c",
".",
"lastMaxCongestionWindow",
"=",
"currentCongestionWindow",
"\n",
"}",
"\n",
"c",
".",
"epoch",
"=",
"time",
".",
"Time",
"{",
"}",
"// Reset time.",
"\n",
"return",
"protocol",
".",
"ByteCount",
"(",
"float32",
"(",
"currentCongestionWindow",
")",
"*",
"c",
".",
"beta",
"(",
")",
")",
"\n",
"}"
] | // CongestionWindowAfterPacketLoss computes a new congestion window to use after
// a loss event. Returns the new congestion window in packets. The new
// congestion window is a multiplicative decrease of our current window. | [
"CongestionWindowAfterPacketLoss",
"computes",
"a",
"new",
"congestion",
"window",
"to",
"use",
"after",
"a",
"loss",
"event",
".",
"Returns",
"the",
"new",
"congestion",
"window",
"in",
"packets",
".",
"The",
"new",
"congestion",
"window",
"is",
"a",
"multiplicative",
"decrease",
"of",
"our",
"current",
"window",
"."
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/congestion/cubic.go#L127-L137 | train |
lucas-clemente/quic-go | internal/congestion/cubic.go | CongestionWindowAfterAck | func (c *Cubic) CongestionWindowAfterAck(
ackedBytes protocol.ByteCount,
currentCongestionWindow protocol.ByteCount,
delayMin time.Duration,
eventTime time.Time,
) protocol.ByteCount {
c.ackedBytesCount += ackedBytes
if c.epoch.IsZero() {
// First ACK after a loss event.
c.epoch = eventTime // Start of epoch.
c.ackedBytesCount = ackedBytes // Reset count.
// Reset estimated_tcp_congestion_window_ to be in sync with cubic.
c.estimatedTCPcongestionWindow = currentCongestionWindow
if c.lastMaxCongestionWindow <= currentCongestionWindow {
c.timeToOriginPoint = 0
c.originPointCongestionWindow = currentCongestionWindow
} else {
c.timeToOriginPoint = uint32(math.Cbrt(float64(cubeFactor * (c.lastMaxCongestionWindow - currentCongestionWindow))))
c.originPointCongestionWindow = c.lastMaxCongestionWindow
}
}
// Change the time unit from microseconds to 2^10 fractions per second. Take
// the round trip time in account. This is done to allow us to use shift as a
// divide operator.
elapsedTime := int64(eventTime.Add(delayMin).Sub(c.epoch)/time.Microsecond) << 10 / (1000 * 1000)
// Right-shifts of negative, signed numbers have implementation-dependent
// behavior, so force the offset to be positive, as is done in the kernel.
offset := int64(c.timeToOriginPoint) - elapsedTime
if offset < 0 {
offset = -offset
}
deltaCongestionWindow := protocol.ByteCount(cubeCongestionWindowScale*offset*offset*offset) * protocol.DefaultTCPMSS >> cubeScale
var targetCongestionWindow protocol.ByteCount
if elapsedTime > int64(c.timeToOriginPoint) {
targetCongestionWindow = c.originPointCongestionWindow + deltaCongestionWindow
} else {
targetCongestionWindow = c.originPointCongestionWindow - deltaCongestionWindow
}
// Limit the CWND increase to half the acked bytes.
targetCongestionWindow = utils.MinByteCount(targetCongestionWindow, currentCongestionWindow+c.ackedBytesCount/2)
// Increase the window by approximately Alpha * 1 MSS of bytes every
// time we ack an estimated tcp window of bytes. For small
// congestion windows (less than 25), the formula below will
// increase slightly slower than linearly per estimated tcp window
// of bytes.
c.estimatedTCPcongestionWindow += protocol.ByteCount(float32(c.ackedBytesCount) * c.alpha() * float32(protocol.DefaultTCPMSS) / float32(c.estimatedTCPcongestionWindow))
c.ackedBytesCount = 0
// We have a new cubic congestion window.
c.lastTargetCongestionWindow = targetCongestionWindow
// Compute target congestion_window based on cubic target and estimated TCP
// congestion_window, use highest (fastest).
if targetCongestionWindow < c.estimatedTCPcongestionWindow {
targetCongestionWindow = c.estimatedTCPcongestionWindow
}
return targetCongestionWindow
} | go | func (c *Cubic) CongestionWindowAfterAck(
ackedBytes protocol.ByteCount,
currentCongestionWindow protocol.ByteCount,
delayMin time.Duration,
eventTime time.Time,
) protocol.ByteCount {
c.ackedBytesCount += ackedBytes
if c.epoch.IsZero() {
// First ACK after a loss event.
c.epoch = eventTime // Start of epoch.
c.ackedBytesCount = ackedBytes // Reset count.
// Reset estimated_tcp_congestion_window_ to be in sync with cubic.
c.estimatedTCPcongestionWindow = currentCongestionWindow
if c.lastMaxCongestionWindow <= currentCongestionWindow {
c.timeToOriginPoint = 0
c.originPointCongestionWindow = currentCongestionWindow
} else {
c.timeToOriginPoint = uint32(math.Cbrt(float64(cubeFactor * (c.lastMaxCongestionWindow - currentCongestionWindow))))
c.originPointCongestionWindow = c.lastMaxCongestionWindow
}
}
// Change the time unit from microseconds to 2^10 fractions per second. Take
// the round trip time in account. This is done to allow us to use shift as a
// divide operator.
elapsedTime := int64(eventTime.Add(delayMin).Sub(c.epoch)/time.Microsecond) << 10 / (1000 * 1000)
// Right-shifts of negative, signed numbers have implementation-dependent
// behavior, so force the offset to be positive, as is done in the kernel.
offset := int64(c.timeToOriginPoint) - elapsedTime
if offset < 0 {
offset = -offset
}
deltaCongestionWindow := protocol.ByteCount(cubeCongestionWindowScale*offset*offset*offset) * protocol.DefaultTCPMSS >> cubeScale
var targetCongestionWindow protocol.ByteCount
if elapsedTime > int64(c.timeToOriginPoint) {
targetCongestionWindow = c.originPointCongestionWindow + deltaCongestionWindow
} else {
targetCongestionWindow = c.originPointCongestionWindow - deltaCongestionWindow
}
// Limit the CWND increase to half the acked bytes.
targetCongestionWindow = utils.MinByteCount(targetCongestionWindow, currentCongestionWindow+c.ackedBytesCount/2)
// Increase the window by approximately Alpha * 1 MSS of bytes every
// time we ack an estimated tcp window of bytes. For small
// congestion windows (less than 25), the formula below will
// increase slightly slower than linearly per estimated tcp window
// of bytes.
c.estimatedTCPcongestionWindow += protocol.ByteCount(float32(c.ackedBytesCount) * c.alpha() * float32(protocol.DefaultTCPMSS) / float32(c.estimatedTCPcongestionWindow))
c.ackedBytesCount = 0
// We have a new cubic congestion window.
c.lastTargetCongestionWindow = targetCongestionWindow
// Compute target congestion_window based on cubic target and estimated TCP
// congestion_window, use highest (fastest).
if targetCongestionWindow < c.estimatedTCPcongestionWindow {
targetCongestionWindow = c.estimatedTCPcongestionWindow
}
return targetCongestionWindow
} | [
"func",
"(",
"c",
"*",
"Cubic",
")",
"CongestionWindowAfterAck",
"(",
"ackedBytes",
"protocol",
".",
"ByteCount",
",",
"currentCongestionWindow",
"protocol",
".",
"ByteCount",
",",
"delayMin",
"time",
".",
"Duration",
",",
"eventTime",
"time",
".",
"Time",
",",
")",
"protocol",
".",
"ByteCount",
"{",
"c",
".",
"ackedBytesCount",
"+=",
"ackedBytes",
"\n\n",
"if",
"c",
".",
"epoch",
".",
"IsZero",
"(",
")",
"{",
"// First ACK after a loss event.",
"c",
".",
"epoch",
"=",
"eventTime",
"// Start of epoch.",
"\n",
"c",
".",
"ackedBytesCount",
"=",
"ackedBytes",
"// Reset count.",
"\n",
"// Reset estimated_tcp_congestion_window_ to be in sync with cubic.",
"c",
".",
"estimatedTCPcongestionWindow",
"=",
"currentCongestionWindow",
"\n",
"if",
"c",
".",
"lastMaxCongestionWindow",
"<=",
"currentCongestionWindow",
"{",
"c",
".",
"timeToOriginPoint",
"=",
"0",
"\n",
"c",
".",
"originPointCongestionWindow",
"=",
"currentCongestionWindow",
"\n",
"}",
"else",
"{",
"c",
".",
"timeToOriginPoint",
"=",
"uint32",
"(",
"math",
".",
"Cbrt",
"(",
"float64",
"(",
"cubeFactor",
"*",
"(",
"c",
".",
"lastMaxCongestionWindow",
"-",
"currentCongestionWindow",
")",
")",
")",
")",
"\n",
"c",
".",
"originPointCongestionWindow",
"=",
"c",
".",
"lastMaxCongestionWindow",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Change the time unit from microseconds to 2^10 fractions per second. Take",
"// the round trip time in account. This is done to allow us to use shift as a",
"// divide operator.",
"elapsedTime",
":=",
"int64",
"(",
"eventTime",
".",
"Add",
"(",
"delayMin",
")",
".",
"Sub",
"(",
"c",
".",
"epoch",
")",
"/",
"time",
".",
"Microsecond",
")",
"<<",
"10",
"/",
"(",
"1000",
"*",
"1000",
")",
"\n\n",
"// Right-shifts of negative, signed numbers have implementation-dependent",
"// behavior, so force the offset to be positive, as is done in the kernel.",
"offset",
":=",
"int64",
"(",
"c",
".",
"timeToOriginPoint",
")",
"-",
"elapsedTime",
"\n",
"if",
"offset",
"<",
"0",
"{",
"offset",
"=",
"-",
"offset",
"\n",
"}",
"\n\n",
"deltaCongestionWindow",
":=",
"protocol",
".",
"ByteCount",
"(",
"cubeCongestionWindowScale",
"*",
"offset",
"*",
"offset",
"*",
"offset",
")",
"*",
"protocol",
".",
"DefaultTCPMSS",
">>",
"cubeScale",
"\n",
"var",
"targetCongestionWindow",
"protocol",
".",
"ByteCount",
"\n",
"if",
"elapsedTime",
">",
"int64",
"(",
"c",
".",
"timeToOriginPoint",
")",
"{",
"targetCongestionWindow",
"=",
"c",
".",
"originPointCongestionWindow",
"+",
"deltaCongestionWindow",
"\n",
"}",
"else",
"{",
"targetCongestionWindow",
"=",
"c",
".",
"originPointCongestionWindow",
"-",
"deltaCongestionWindow",
"\n",
"}",
"\n",
"// Limit the CWND increase to half the acked bytes.",
"targetCongestionWindow",
"=",
"utils",
".",
"MinByteCount",
"(",
"targetCongestionWindow",
",",
"currentCongestionWindow",
"+",
"c",
".",
"ackedBytesCount",
"/",
"2",
")",
"\n\n",
"// Increase the window by approximately Alpha * 1 MSS of bytes every",
"// time we ack an estimated tcp window of bytes. For small",
"// congestion windows (less than 25), the formula below will",
"// increase slightly slower than linearly per estimated tcp window",
"// of bytes.",
"c",
".",
"estimatedTCPcongestionWindow",
"+=",
"protocol",
".",
"ByteCount",
"(",
"float32",
"(",
"c",
".",
"ackedBytesCount",
")",
"*",
"c",
".",
"alpha",
"(",
")",
"*",
"float32",
"(",
"protocol",
".",
"DefaultTCPMSS",
")",
"/",
"float32",
"(",
"c",
".",
"estimatedTCPcongestionWindow",
")",
")",
"\n",
"c",
".",
"ackedBytesCount",
"=",
"0",
"\n\n",
"// We have a new cubic congestion window.",
"c",
".",
"lastTargetCongestionWindow",
"=",
"targetCongestionWindow",
"\n\n",
"// Compute target congestion_window based on cubic target and estimated TCP",
"// congestion_window, use highest (fastest).",
"if",
"targetCongestionWindow",
"<",
"c",
".",
"estimatedTCPcongestionWindow",
"{",
"targetCongestionWindow",
"=",
"c",
".",
"estimatedTCPcongestionWindow",
"\n",
"}",
"\n",
"return",
"targetCongestionWindow",
"\n",
"}"
] | // CongestionWindowAfterAck computes a new congestion window to use after a received ACK.
// Returns the new congestion window in packets. The new congestion window
// follows a cubic function that depends on the time passed since last
// packet loss. | [
"CongestionWindowAfterAck",
"computes",
"a",
"new",
"congestion",
"window",
"to",
"use",
"after",
"a",
"received",
"ACK",
".",
"Returns",
"the",
"new",
"congestion",
"window",
"in",
"packets",
".",
"The",
"new",
"congestion",
"window",
"follows",
"a",
"cubic",
"function",
"that",
"depends",
"on",
"the",
"time",
"passed",
"since",
"last",
"packet",
"loss",
"."
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/congestion/cubic.go#L143-L205 | train |
lucas-clemente/quic-go | internal/mocks/congestion.go | NewMockSendAlgorithm | func NewMockSendAlgorithm(ctrl *gomock.Controller) *MockSendAlgorithm {
mock := &MockSendAlgorithm{ctrl: ctrl}
mock.recorder = &MockSendAlgorithmMockRecorder{mock}
return mock
} | go | func NewMockSendAlgorithm(ctrl *gomock.Controller) *MockSendAlgorithm {
mock := &MockSendAlgorithm{ctrl: ctrl}
mock.recorder = &MockSendAlgorithmMockRecorder{mock}
return mock
} | [
"func",
"NewMockSendAlgorithm",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockSendAlgorithm",
"{",
"mock",
":=",
"&",
"MockSendAlgorithm",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockSendAlgorithmMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockSendAlgorithm creates a new mock instance | [
"NewMockSendAlgorithm",
"creates",
"a",
"new",
"mock",
"instance"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/congestion.go#L27-L31 | train |
lucas-clemente/quic-go | internal/mocks/congestion.go | GetCongestionWindow | func (m *MockSendAlgorithm) GetCongestionWindow() protocol.ByteCount {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetCongestionWindow")
ret0, _ := ret[0].(protocol.ByteCount)
return ret0
} | go | func (m *MockSendAlgorithm) GetCongestionWindow() protocol.ByteCount {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetCongestionWindow")
ret0, _ := ret[0].(protocol.ByteCount)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockSendAlgorithm",
")",
"GetCongestionWindow",
"(",
")",
"protocol",
".",
"ByteCount",
"{",
"m",
".",
"ctrl",
".",
"T",
".",
"Helper",
"(",
")",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"protocol",
".",
"ByteCount",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // GetCongestionWindow mocks base method | [
"GetCongestionWindow",
"mocks",
"base",
"method"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/congestion.go#L39-L44 | train |
lucas-clemente/quic-go | internal/mocks/congestion.go | MaybeExitSlowStart | func (m *MockSendAlgorithm) MaybeExitSlowStart() {
m.ctrl.T.Helper()
m.ctrl.Call(m, "MaybeExitSlowStart")
} | go | func (m *MockSendAlgorithm) MaybeExitSlowStart() {
m.ctrl.T.Helper()
m.ctrl.Call(m, "MaybeExitSlowStart")
} | [
"func",
"(",
"m",
"*",
"MockSendAlgorithm",
")",
"MaybeExitSlowStart",
"(",
")",
"{",
"m",
".",
"ctrl",
".",
"T",
".",
"Helper",
"(",
")",
"\n",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // MaybeExitSlowStart mocks base method | [
"MaybeExitSlowStart",
"mocks",
"base",
"method"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/congestion.go#L53-L56 | train |
lucas-clemente/quic-go | internal/mocks/congestion.go | OnConnectionMigration | func (m *MockSendAlgorithm) OnConnectionMigration() {
m.ctrl.T.Helper()
m.ctrl.Call(m, "OnConnectionMigration")
} | go | func (m *MockSendAlgorithm) OnConnectionMigration() {
m.ctrl.T.Helper()
m.ctrl.Call(m, "OnConnectionMigration")
} | [
"func",
"(",
"m",
"*",
"MockSendAlgorithm",
")",
"OnConnectionMigration",
"(",
")",
"{",
"m",
".",
"ctrl",
".",
"T",
".",
"Helper",
"(",
")",
"\n",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // OnConnectionMigration mocks base method | [
"OnConnectionMigration",
"mocks",
"base",
"method"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/congestion.go#L65-L68 | train |
lucas-clemente/quic-go | internal/mocks/congestion.go | OnPacketAcked | func (m *MockSendAlgorithm) OnPacketAcked(arg0 protocol.PacketNumber, arg1, arg2 protocol.ByteCount, arg3 time.Time) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "OnPacketAcked", arg0, arg1, arg2, arg3)
} | go | func (m *MockSendAlgorithm) OnPacketAcked(arg0 protocol.PacketNumber, arg1, arg2 protocol.ByteCount, arg3 time.Time) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "OnPacketAcked", arg0, arg1, arg2, arg3)
} | [
"func",
"(",
"m",
"*",
"MockSendAlgorithm",
")",
"OnPacketAcked",
"(",
"arg0",
"protocol",
".",
"PacketNumber",
",",
"arg1",
",",
"arg2",
"protocol",
".",
"ByteCount",
",",
"arg3",
"time",
".",
"Time",
")",
"{",
"m",
".",
"ctrl",
".",
"T",
".",
"Helper",
"(",
")",
"\n",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
",",
"arg2",
",",
"arg3",
")",
"\n",
"}"
] | // OnPacketAcked mocks base method | [
"OnPacketAcked",
"mocks",
"base",
"method"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/congestion.go#L77-L80 | train |
lucas-clemente/quic-go | internal/mocks/congestion.go | OnPacketAcked | func (mr *MockSendAlgorithmMockRecorder) OnPacketAcked(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnPacketAcked", reflect.TypeOf((*MockSendAlgorithm)(nil).OnPacketAcked), arg0, arg1, arg2, arg3)
} | go | func (mr *MockSendAlgorithmMockRecorder) OnPacketAcked(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnPacketAcked", reflect.TypeOf((*MockSendAlgorithm)(nil).OnPacketAcked), arg0, arg1, arg2, arg3)
} | [
"func",
"(",
"mr",
"*",
"MockSendAlgorithmMockRecorder",
")",
"OnPacketAcked",
"(",
"arg0",
",",
"arg1",
",",
"arg2",
",",
"arg3",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"mr",
".",
"mock",
".",
"ctrl",
".",
"T",
".",
"Helper",
"(",
")",
"\n",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockSendAlgorithm",
")",
"(",
"nil",
")",
".",
"OnPacketAcked",
")",
",",
"arg0",
",",
"arg1",
",",
"arg2",
",",
"arg3",
")",
"\n",
"}"
] | // OnPacketAcked indicates an expected call of OnPacketAcked | [
"OnPacketAcked",
"indicates",
"an",
"expected",
"call",
"of",
"OnPacketAcked"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/congestion.go#L83-L86 | train |
lucas-clemente/quic-go | internal/mocks/congestion.go | OnPacketLost | func (m *MockSendAlgorithm) OnPacketLost(arg0 protocol.PacketNumber, arg1, arg2 protocol.ByteCount) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "OnPacketLost", arg0, arg1, arg2)
} | go | func (m *MockSendAlgorithm) OnPacketLost(arg0 protocol.PacketNumber, arg1, arg2 protocol.ByteCount) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "OnPacketLost", arg0, arg1, arg2)
} | [
"func",
"(",
"m",
"*",
"MockSendAlgorithm",
")",
"OnPacketLost",
"(",
"arg0",
"protocol",
".",
"PacketNumber",
",",
"arg1",
",",
"arg2",
"protocol",
".",
"ByteCount",
")",
"{",
"m",
".",
"ctrl",
".",
"T",
".",
"Helper",
"(",
")",
"\n",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
",",
"arg2",
")",
"\n",
"}"
] | // OnPacketLost mocks base method | [
"OnPacketLost",
"mocks",
"base",
"method"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/congestion.go#L89-L92 | train |
lucas-clemente/quic-go | internal/mocks/congestion.go | OnPacketSent | func (m *MockSendAlgorithm) OnPacketSent(arg0 time.Time, arg1 protocol.ByteCount, arg2 protocol.PacketNumber, arg3 protocol.ByteCount, arg4 bool) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "OnPacketSent", arg0, arg1, arg2, arg3, arg4)
} | go | func (m *MockSendAlgorithm) OnPacketSent(arg0 time.Time, arg1 protocol.ByteCount, arg2 protocol.PacketNumber, arg3 protocol.ByteCount, arg4 bool) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "OnPacketSent", arg0, arg1, arg2, arg3, arg4)
} | [
"func",
"(",
"m",
"*",
"MockSendAlgorithm",
")",
"OnPacketSent",
"(",
"arg0",
"time",
".",
"Time",
",",
"arg1",
"protocol",
".",
"ByteCount",
",",
"arg2",
"protocol",
".",
"PacketNumber",
",",
"arg3",
"protocol",
".",
"ByteCount",
",",
"arg4",
"bool",
")",
"{",
"m",
".",
"ctrl",
".",
"T",
".",
"Helper",
"(",
")",
"\n",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
",",
"arg2",
",",
"arg3",
",",
"arg4",
")",
"\n",
"}"
] | // OnPacketSent mocks base method | [
"OnPacketSent",
"mocks",
"base",
"method"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/congestion.go#L101-L104 | train |
lucas-clemente/quic-go | internal/mocks/congestion.go | OnRetransmissionTimeout | func (mr *MockSendAlgorithmMockRecorder) OnRetransmissionTimeout(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnRetransmissionTimeout", reflect.TypeOf((*MockSendAlgorithm)(nil).OnRetransmissionTimeout), arg0)
} | go | func (mr *MockSendAlgorithmMockRecorder) OnRetransmissionTimeout(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnRetransmissionTimeout", reflect.TypeOf((*MockSendAlgorithm)(nil).OnRetransmissionTimeout), arg0)
} | [
"func",
"(",
"mr",
"*",
"MockSendAlgorithmMockRecorder",
")",
"OnRetransmissionTimeout",
"(",
"arg0",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"mr",
".",
"mock",
".",
"ctrl",
".",
"T",
".",
"Helper",
"(",
")",
"\n",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockSendAlgorithm",
")",
"(",
"nil",
")",
".",
"OnRetransmissionTimeout",
")",
",",
"arg0",
")",
"\n",
"}"
] | // OnRetransmissionTimeout indicates an expected call of OnRetransmissionTimeout | [
"OnRetransmissionTimeout",
"indicates",
"an",
"expected",
"call",
"of",
"OnRetransmissionTimeout"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/congestion.go#L119-L122 | train |
lucas-clemente/quic-go | internal/mocks/congestion.go | SetNumEmulatedConnections | func (m *MockSendAlgorithm) SetNumEmulatedConnections(arg0 int) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "SetNumEmulatedConnections", arg0)
} | go | func (m *MockSendAlgorithm) SetNumEmulatedConnections(arg0 int) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "SetNumEmulatedConnections", arg0)
} | [
"func",
"(",
"m",
"*",
"MockSendAlgorithm",
")",
"SetNumEmulatedConnections",
"(",
"arg0",
"int",
")",
"{",
"m",
".",
"ctrl",
".",
"T",
".",
"Helper",
"(",
")",
"\n",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"}"
] | // SetNumEmulatedConnections mocks base method | [
"SetNumEmulatedConnections",
"mocks",
"base",
"method"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/congestion.go#L125-L128 | train |
lucas-clemente/quic-go | internal/mocks/congestion.go | SetSlowStartLargeReduction | func (m *MockSendAlgorithm) SetSlowStartLargeReduction(arg0 bool) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "SetSlowStartLargeReduction", arg0)
} | go | func (m *MockSendAlgorithm) SetSlowStartLargeReduction(arg0 bool) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "SetSlowStartLargeReduction", arg0)
} | [
"func",
"(",
"m",
"*",
"MockSendAlgorithm",
")",
"SetSlowStartLargeReduction",
"(",
"arg0",
"bool",
")",
"{",
"m",
".",
"ctrl",
".",
"T",
".",
"Helper",
"(",
")",
"\n",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"}"
] | // SetSlowStartLargeReduction mocks base method | [
"SetSlowStartLargeReduction",
"mocks",
"base",
"method"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/congestion.go#L137-L140 | train |
lucas-clemente/quic-go | internal/mocks/congestion.go | TimeUntilSend | func (m *MockSendAlgorithm) TimeUntilSend(arg0 protocol.ByteCount) time.Duration {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "TimeUntilSend", arg0)
ret0, _ := ret[0].(time.Duration)
return ret0
} | go | func (m *MockSendAlgorithm) TimeUntilSend(arg0 protocol.ByteCount) time.Duration {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "TimeUntilSend", arg0)
ret0, _ := ret[0].(time.Duration)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockSendAlgorithm",
")",
"TimeUntilSend",
"(",
"arg0",
"protocol",
".",
"ByteCount",
")",
"time",
".",
"Duration",
"{",
"m",
".",
"ctrl",
".",
"T",
".",
"Helper",
"(",
")",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"time",
".",
"Duration",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // TimeUntilSend mocks base method | [
"TimeUntilSend",
"mocks",
"base",
"method"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/congestion.go#L149-L154 | train |
lucas-clemente/quic-go | server.go | ListenAddr | func ListenAddr(addr string, tlsConf *tls.Config, config *Config) (Listener, error) {
udpAddr, err := net.ResolveUDPAddr("udp", addr)
if err != nil {
return nil, err
}
conn, err := net.ListenUDP("udp", udpAddr)
if err != nil {
return nil, err
}
serv, err := listen(conn, tlsConf, config)
if err != nil {
return nil, err
}
serv.createdPacketConn = true
return serv, nil
} | go | func ListenAddr(addr string, tlsConf *tls.Config, config *Config) (Listener, error) {
udpAddr, err := net.ResolveUDPAddr("udp", addr)
if err != nil {
return nil, err
}
conn, err := net.ListenUDP("udp", udpAddr)
if err != nil {
return nil, err
}
serv, err := listen(conn, tlsConf, config)
if err != nil {
return nil, err
}
serv.createdPacketConn = true
return serv, nil
} | [
"func",
"ListenAddr",
"(",
"addr",
"string",
",",
"tlsConf",
"*",
"tls",
".",
"Config",
",",
"config",
"*",
"Config",
")",
"(",
"Listener",
",",
"error",
")",
"{",
"udpAddr",
",",
"err",
":=",
"net",
".",
"ResolveUDPAddr",
"(",
"\"",
"\"",
",",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"conn",
",",
"err",
":=",
"net",
".",
"ListenUDP",
"(",
"\"",
"\"",
",",
"udpAddr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"serv",
",",
"err",
":=",
"listen",
"(",
"conn",
",",
"tlsConf",
",",
"config",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"serv",
".",
"createdPacketConn",
"=",
"true",
"\n",
"return",
"serv",
",",
"nil",
"\n",
"}"
] | // ListenAddr creates a QUIC server listening on a given address.
// The tls.Config must not be nil and must contain a certificate configuration.
// The quic.Config may be nil, in that case the default values will be used. | [
"ListenAddr",
"creates",
"a",
"QUIC",
"server",
"listening",
"on",
"a",
"given",
"address",
".",
"The",
"tls",
".",
"Config",
"must",
"not",
"be",
"nil",
"and",
"must",
"contain",
"a",
"certificate",
"configuration",
".",
"The",
"quic",
".",
"Config",
"may",
"be",
"nil",
"in",
"that",
"case",
"the",
"default",
"values",
"will",
"be",
"used",
"."
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/server.go#L112-L127 | train |
lucas-clemente/quic-go | server.go | Listen | func Listen(conn net.PacketConn, tlsConf *tls.Config, config *Config) (Listener, error) {
return listen(conn, tlsConf, config)
} | go | func Listen(conn net.PacketConn, tlsConf *tls.Config, config *Config) (Listener, error) {
return listen(conn, tlsConf, config)
} | [
"func",
"Listen",
"(",
"conn",
"net",
".",
"PacketConn",
",",
"tlsConf",
"*",
"tls",
".",
"Config",
",",
"config",
"*",
"Config",
")",
"(",
"Listener",
",",
"error",
")",
"{",
"return",
"listen",
"(",
"conn",
",",
"tlsConf",
",",
"config",
")",
"\n",
"}"
] | // Listen listens for QUIC connections on a given net.PacketConn.
// A single PacketConn only be used for a single call to Listen.
// The PacketConn can be used for simultaneous calls to Dial.
// QUIC connection IDs are used for demultiplexing the different connections.
// The tls.Config must not be nil and must contain a certificate configuration.
// The quic.Config may be nil, in that case the default values will be used. | [
"Listen",
"listens",
"for",
"QUIC",
"connections",
"on",
"a",
"given",
"net",
".",
"PacketConn",
".",
"A",
"single",
"PacketConn",
"only",
"be",
"used",
"for",
"a",
"single",
"call",
"to",
"Listen",
".",
"The",
"PacketConn",
"can",
"be",
"used",
"for",
"simultaneous",
"calls",
"to",
"Dial",
".",
"QUIC",
"connection",
"IDs",
"are",
"used",
"for",
"demultiplexing",
"the",
"different",
"connections",
".",
"The",
"tls",
".",
"Config",
"must",
"not",
"be",
"nil",
"and",
"must",
"contain",
"a",
"certificate",
"configuration",
".",
"The",
"quic",
".",
"Config",
"may",
"be",
"nil",
"in",
"that",
"case",
"the",
"default",
"values",
"will",
"be",
"used",
"."
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/server.go#L135-L137 | train |
lucas-clemente/quic-go | server.go | Accept | func (s *server) Accept() (Session, error) {
var sess Session
select {
case sess = <-s.sessionQueue:
return sess, nil
case <-s.errorChan:
return nil, s.serverError
}
} | go | func (s *server) Accept() (Session, error) {
var sess Session
select {
case sess = <-s.sessionQueue:
return sess, nil
case <-s.errorChan:
return nil, s.serverError
}
} | [
"func",
"(",
"s",
"*",
"server",
")",
"Accept",
"(",
")",
"(",
"Session",
",",
"error",
")",
"{",
"var",
"sess",
"Session",
"\n",
"select",
"{",
"case",
"sess",
"=",
"<-",
"s",
".",
"sessionQueue",
":",
"return",
"sess",
",",
"nil",
"\n",
"case",
"<-",
"s",
".",
"errorChan",
":",
"return",
"nil",
",",
"s",
".",
"serverError",
"\n",
"}",
"\n",
"}"
] | // Accept returns newly openend sessions | [
"Accept",
"returns",
"newly",
"openend",
"sessions"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/server.go#L279-L287 | train |
lucas-clemente/quic-go | server.go | Close | func (s *server) Close() error {
s.mutex.Lock()
defer s.mutex.Unlock()
if s.closed {
return nil
}
return s.closeWithMutex()
} | go | func (s *server) Close() error {
s.mutex.Lock()
defer s.mutex.Unlock()
if s.closed {
return nil
}
return s.closeWithMutex()
} | [
"func",
"(",
"s",
"*",
"server",
")",
"Close",
"(",
")",
"error",
"{",
"s",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"if",
"s",
".",
"closed",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"s",
".",
"closeWithMutex",
"(",
")",
"\n",
"}"
] | // Close the server | [
"Close",
"the",
"server"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/server.go#L290-L297 | train |
lucas-clemente/quic-go | http3/roundtrip.go | RoundTripOpt | func (r *RoundTripper) RoundTripOpt(req *http.Request, opt RoundTripOpt) (*http.Response, error) {
if req.URL == nil {
closeRequestBody(req)
return nil, errors.New("http3: nil Request.URL")
}
if req.URL.Host == "" {
closeRequestBody(req)
return nil, errors.New("http3: no Host in request URL")
}
if req.Header == nil {
closeRequestBody(req)
return nil, errors.New("http3: nil Request.Header")
}
if req.URL.Scheme == "https" {
for k, vv := range req.Header {
if !httpguts.ValidHeaderFieldName(k) {
return nil, fmt.Errorf("http3: invalid http header field name %q", k)
}
for _, v := range vv {
if !httpguts.ValidHeaderFieldValue(v) {
return nil, fmt.Errorf("http3: invalid http header field value %q for key %v", v, k)
}
}
}
} else {
closeRequestBody(req)
return nil, fmt.Errorf("http3: unsupported protocol scheme: %s", req.URL.Scheme)
}
if req.Method != "" && !validMethod(req.Method) {
closeRequestBody(req)
return nil, fmt.Errorf("http3: invalid method %q", req.Method)
}
hostname := authorityAddr("https", hostnameFromRequest(req))
cl, err := r.getClient(hostname, opt.OnlyCachedConn)
if err != nil {
return nil, err
}
return cl.RoundTrip(req)
} | go | func (r *RoundTripper) RoundTripOpt(req *http.Request, opt RoundTripOpt) (*http.Response, error) {
if req.URL == nil {
closeRequestBody(req)
return nil, errors.New("http3: nil Request.URL")
}
if req.URL.Host == "" {
closeRequestBody(req)
return nil, errors.New("http3: no Host in request URL")
}
if req.Header == nil {
closeRequestBody(req)
return nil, errors.New("http3: nil Request.Header")
}
if req.URL.Scheme == "https" {
for k, vv := range req.Header {
if !httpguts.ValidHeaderFieldName(k) {
return nil, fmt.Errorf("http3: invalid http header field name %q", k)
}
for _, v := range vv {
if !httpguts.ValidHeaderFieldValue(v) {
return nil, fmt.Errorf("http3: invalid http header field value %q for key %v", v, k)
}
}
}
} else {
closeRequestBody(req)
return nil, fmt.Errorf("http3: unsupported protocol scheme: %s", req.URL.Scheme)
}
if req.Method != "" && !validMethod(req.Method) {
closeRequestBody(req)
return nil, fmt.Errorf("http3: invalid method %q", req.Method)
}
hostname := authorityAddr("https", hostnameFromRequest(req))
cl, err := r.getClient(hostname, opt.OnlyCachedConn)
if err != nil {
return nil, err
}
return cl.RoundTrip(req)
} | [
"func",
"(",
"r",
"*",
"RoundTripper",
")",
"RoundTripOpt",
"(",
"req",
"*",
"http",
".",
"Request",
",",
"opt",
"RoundTripOpt",
")",
"(",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"if",
"req",
".",
"URL",
"==",
"nil",
"{",
"closeRequestBody",
"(",
"req",
")",
"\n",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"req",
".",
"URL",
".",
"Host",
"==",
"\"",
"\"",
"{",
"closeRequestBody",
"(",
"req",
")",
"\n",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"req",
".",
"Header",
"==",
"nil",
"{",
"closeRequestBody",
"(",
"req",
")",
"\n",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"req",
".",
"URL",
".",
"Scheme",
"==",
"\"",
"\"",
"{",
"for",
"k",
",",
"vv",
":=",
"range",
"req",
".",
"Header",
"{",
"if",
"!",
"httpguts",
".",
"ValidHeaderFieldName",
"(",
"k",
")",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"k",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"vv",
"{",
"if",
"!",
"httpguts",
".",
"ValidHeaderFieldValue",
"(",
"v",
")",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"v",
",",
"k",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"else",
"{",
"closeRequestBody",
"(",
"req",
")",
"\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"req",
".",
"URL",
".",
"Scheme",
")",
"\n",
"}",
"\n\n",
"if",
"req",
".",
"Method",
"!=",
"\"",
"\"",
"&&",
"!",
"validMethod",
"(",
"req",
".",
"Method",
")",
"{",
"closeRequestBody",
"(",
"req",
")",
"\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"req",
".",
"Method",
")",
"\n",
"}",
"\n\n",
"hostname",
":=",
"authorityAddr",
"(",
"\"",
"\"",
",",
"hostnameFromRequest",
"(",
"req",
")",
")",
"\n",
"cl",
",",
"err",
":=",
"r",
".",
"getClient",
"(",
"hostname",
",",
"opt",
".",
"OnlyCachedConn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"cl",
".",
"RoundTrip",
"(",
"req",
")",
"\n",
"}"
] | // RoundTripOpt is like RoundTrip, but takes options. | [
"RoundTripOpt",
"is",
"like",
"RoundTrip",
"but",
"takes",
"options",
"."
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/http3/roundtrip.go#L67-L108 | train |
lucas-clemente/quic-go | http3/roundtrip.go | RoundTrip | func (r *RoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
return r.RoundTripOpt(req, RoundTripOpt{})
} | go | func (r *RoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
return r.RoundTripOpt(req, RoundTripOpt{})
} | [
"func",
"(",
"r",
"*",
"RoundTripper",
")",
"RoundTrip",
"(",
"req",
"*",
"http",
".",
"Request",
")",
"(",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"return",
"r",
".",
"RoundTripOpt",
"(",
"req",
",",
"RoundTripOpt",
"{",
"}",
")",
"\n",
"}"
] | // RoundTrip does a round trip. | [
"RoundTrip",
"does",
"a",
"round",
"trip",
"."
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/http3/roundtrip.go#L111-L113 | train |
lucas-clemente/quic-go | http3/roundtrip.go | Close | func (r *RoundTripper) Close() error {
r.mutex.Lock()
defer r.mutex.Unlock()
for _, client := range r.clients {
if err := client.Close(); err != nil {
return err
}
}
r.clients = nil
return nil
} | go | func (r *RoundTripper) Close() error {
r.mutex.Lock()
defer r.mutex.Unlock()
for _, client := range r.clients {
if err := client.Close(); err != nil {
return err
}
}
r.clients = nil
return nil
} | [
"func",
"(",
"r",
"*",
"RoundTripper",
")",
"Close",
"(",
")",
"error",
"{",
"r",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"for",
"_",
",",
"client",
":=",
"range",
"r",
".",
"clients",
"{",
"if",
"err",
":=",
"client",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"r",
".",
"clients",
"=",
"nil",
"\n",
"return",
"nil",
"\n",
"}"
] | // Close closes the QUIC connections that this RoundTripper has used | [
"Close",
"closes",
"the",
"QUIC",
"connections",
"that",
"this",
"RoundTripper",
"has",
"used"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/http3/roundtrip.go#L141-L151 | train |
lucas-clemente/quic-go | internal/congestion/rtt_stats.go | SmoothedOrInitialRTT | func (r *RTTStats) SmoothedOrInitialRTT() time.Duration {
if r.smoothedRTT != 0 {
return r.smoothedRTT
}
return defaultInitialRTT
} | go | func (r *RTTStats) SmoothedOrInitialRTT() time.Duration {
if r.smoothedRTT != 0 {
return r.smoothedRTT
}
return defaultInitialRTT
} | [
"func",
"(",
"r",
"*",
"RTTStats",
")",
"SmoothedOrInitialRTT",
"(",
")",
"time",
".",
"Duration",
"{",
"if",
"r",
".",
"smoothedRTT",
"!=",
"0",
"{",
"return",
"r",
".",
"smoothedRTT",
"\n",
"}",
"\n",
"return",
"defaultInitialRTT",
"\n",
"}"
] | // SmoothedOrInitialRTT returns the EWMA smoothed RTT for the connection.
// If no valid updates have occurred, it returns the initial RTT. | [
"SmoothedOrInitialRTT",
"returns",
"the",
"EWMA",
"smoothed",
"RTT",
"for",
"the",
"connection",
".",
"If",
"no",
"valid",
"updates",
"have",
"occurred",
"it",
"returns",
"the",
"initial",
"RTT",
"."
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/congestion/rtt_stats.go#L45-L50 | train |
lucas-clemente/quic-go | internal/congestion/rtt_stats.go | UpdateRTT | func (r *RTTStats) UpdateRTT(sendDelta, ackDelay time.Duration, now time.Time) {
if sendDelta == utils.InfDuration || sendDelta <= 0 {
return
}
// Update r.minRTT first. r.minRTT does not use an rttSample corrected for
// ackDelay but the raw observed sendDelta, since poor clock granularity at
// the client may cause a high ackDelay to result in underestimation of the
// r.minRTT.
if r.minRTT == 0 || r.minRTT > sendDelta {
r.minRTT = sendDelta
}
// Correct for ackDelay if information received from the peer results in a
// an RTT sample at least as large as minRTT. Otherwise, only use the
// sendDelta.
sample := sendDelta
if sample-r.minRTT >= ackDelay {
sample -= ackDelay
}
r.latestRTT = sample
// First time call.
if r.smoothedRTT == 0 {
r.smoothedRTT = sample
r.meanDeviation = sample / 2
} else {
r.meanDeviation = time.Duration(oneMinusBeta*float32(r.meanDeviation/time.Microsecond)+rttBeta*float32(utils.AbsDuration(r.smoothedRTT-sample)/time.Microsecond)) * time.Microsecond
r.smoothedRTT = time.Duration((float32(r.smoothedRTT/time.Microsecond)*oneMinusAlpha)+(float32(sample/time.Microsecond)*rttAlpha)) * time.Microsecond
}
} | go | func (r *RTTStats) UpdateRTT(sendDelta, ackDelay time.Duration, now time.Time) {
if sendDelta == utils.InfDuration || sendDelta <= 0 {
return
}
// Update r.minRTT first. r.minRTT does not use an rttSample corrected for
// ackDelay but the raw observed sendDelta, since poor clock granularity at
// the client may cause a high ackDelay to result in underestimation of the
// r.minRTT.
if r.minRTT == 0 || r.minRTT > sendDelta {
r.minRTT = sendDelta
}
// Correct for ackDelay if information received from the peer results in a
// an RTT sample at least as large as minRTT. Otherwise, only use the
// sendDelta.
sample := sendDelta
if sample-r.minRTT >= ackDelay {
sample -= ackDelay
}
r.latestRTT = sample
// First time call.
if r.smoothedRTT == 0 {
r.smoothedRTT = sample
r.meanDeviation = sample / 2
} else {
r.meanDeviation = time.Duration(oneMinusBeta*float32(r.meanDeviation/time.Microsecond)+rttBeta*float32(utils.AbsDuration(r.smoothedRTT-sample)/time.Microsecond)) * time.Microsecond
r.smoothedRTT = time.Duration((float32(r.smoothedRTT/time.Microsecond)*oneMinusAlpha)+(float32(sample/time.Microsecond)*rttAlpha)) * time.Microsecond
}
} | [
"func",
"(",
"r",
"*",
"RTTStats",
")",
"UpdateRTT",
"(",
"sendDelta",
",",
"ackDelay",
"time",
".",
"Duration",
",",
"now",
"time",
".",
"Time",
")",
"{",
"if",
"sendDelta",
"==",
"utils",
".",
"InfDuration",
"||",
"sendDelta",
"<=",
"0",
"{",
"return",
"\n",
"}",
"\n\n",
"// Update r.minRTT first. r.minRTT does not use an rttSample corrected for",
"// ackDelay but the raw observed sendDelta, since poor clock granularity at",
"// the client may cause a high ackDelay to result in underestimation of the",
"// r.minRTT.",
"if",
"r",
".",
"minRTT",
"==",
"0",
"||",
"r",
".",
"minRTT",
">",
"sendDelta",
"{",
"r",
".",
"minRTT",
"=",
"sendDelta",
"\n",
"}",
"\n\n",
"// Correct for ackDelay if information received from the peer results in a",
"// an RTT sample at least as large as minRTT. Otherwise, only use the",
"// sendDelta.",
"sample",
":=",
"sendDelta",
"\n",
"if",
"sample",
"-",
"r",
".",
"minRTT",
">=",
"ackDelay",
"{",
"sample",
"-=",
"ackDelay",
"\n",
"}",
"\n",
"r",
".",
"latestRTT",
"=",
"sample",
"\n",
"// First time call.",
"if",
"r",
".",
"smoothedRTT",
"==",
"0",
"{",
"r",
".",
"smoothedRTT",
"=",
"sample",
"\n",
"r",
".",
"meanDeviation",
"=",
"sample",
"/",
"2",
"\n",
"}",
"else",
"{",
"r",
".",
"meanDeviation",
"=",
"time",
".",
"Duration",
"(",
"oneMinusBeta",
"*",
"float32",
"(",
"r",
".",
"meanDeviation",
"/",
"time",
".",
"Microsecond",
")",
"+",
"rttBeta",
"*",
"float32",
"(",
"utils",
".",
"AbsDuration",
"(",
"r",
".",
"smoothedRTT",
"-",
"sample",
")",
"/",
"time",
".",
"Microsecond",
")",
")",
"*",
"time",
".",
"Microsecond",
"\n",
"r",
".",
"smoothedRTT",
"=",
"time",
".",
"Duration",
"(",
"(",
"float32",
"(",
"r",
".",
"smoothedRTT",
"/",
"time",
".",
"Microsecond",
")",
"*",
"oneMinusAlpha",
")",
"+",
"(",
"float32",
"(",
"sample",
"/",
"time",
".",
"Microsecond",
")",
"*",
"rttAlpha",
")",
")",
"*",
"time",
".",
"Microsecond",
"\n",
"}",
"\n",
"}"
] | // UpdateRTT updates the RTT based on a new sample. | [
"UpdateRTT",
"updates",
"the",
"RTT",
"based",
"on",
"a",
"new",
"sample",
"."
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/congestion/rtt_stats.go#L56-L85 | train |
lucas-clemente/quic-go | internal/congestion/rtt_stats.go | OnConnectionMigration | func (r *RTTStats) OnConnectionMigration() {
r.latestRTT = 0
r.minRTT = 0
r.smoothedRTT = 0
r.meanDeviation = 0
} | go | func (r *RTTStats) OnConnectionMigration() {
r.latestRTT = 0
r.minRTT = 0
r.smoothedRTT = 0
r.meanDeviation = 0
} | [
"func",
"(",
"r",
"*",
"RTTStats",
")",
"OnConnectionMigration",
"(",
")",
"{",
"r",
".",
"latestRTT",
"=",
"0",
"\n",
"r",
".",
"minRTT",
"=",
"0",
"\n",
"r",
".",
"smoothedRTT",
"=",
"0",
"\n",
"r",
".",
"meanDeviation",
"=",
"0",
"\n",
"}"
] | // OnConnectionMigration is called when connection migrates and rtt measurement needs to be reset. | [
"OnConnectionMigration",
"is",
"called",
"when",
"connection",
"migrates",
"and",
"rtt",
"measurement",
"needs",
"to",
"be",
"reset",
"."
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/congestion/rtt_stats.go#L88-L93 | train |
lucas-clemente/quic-go | internal/congestion/rtt_stats.go | ExpireSmoothedMetrics | func (r *RTTStats) ExpireSmoothedMetrics() {
r.meanDeviation = utils.MaxDuration(r.meanDeviation, utils.AbsDuration(r.smoothedRTT-r.latestRTT))
r.smoothedRTT = utils.MaxDuration(r.smoothedRTT, r.latestRTT)
} | go | func (r *RTTStats) ExpireSmoothedMetrics() {
r.meanDeviation = utils.MaxDuration(r.meanDeviation, utils.AbsDuration(r.smoothedRTT-r.latestRTT))
r.smoothedRTT = utils.MaxDuration(r.smoothedRTT, r.latestRTT)
} | [
"func",
"(",
"r",
"*",
"RTTStats",
")",
"ExpireSmoothedMetrics",
"(",
")",
"{",
"r",
".",
"meanDeviation",
"=",
"utils",
".",
"MaxDuration",
"(",
"r",
".",
"meanDeviation",
",",
"utils",
".",
"AbsDuration",
"(",
"r",
".",
"smoothedRTT",
"-",
"r",
".",
"latestRTT",
")",
")",
"\n",
"r",
".",
"smoothedRTT",
"=",
"utils",
".",
"MaxDuration",
"(",
"r",
".",
"smoothedRTT",
",",
"r",
".",
"latestRTT",
")",
"\n",
"}"
] | // ExpireSmoothedMetrics causes the smoothed_rtt to be increased to the latest_rtt if the latest_rtt
// is larger. The mean deviation is increased to the most recent deviation if
// it's larger. | [
"ExpireSmoothedMetrics",
"causes",
"the",
"smoothed_rtt",
"to",
"be",
"increased",
"to",
"the",
"latest_rtt",
"if",
"the",
"latest_rtt",
"is",
"larger",
".",
"The",
"mean",
"deviation",
"is",
"increased",
"to",
"the",
"most",
"recent",
"deviation",
"if",
"it",
"s",
"larger",
"."
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/congestion/rtt_stats.go#L98-L101 | train |
lucas-clemente/quic-go | internal/wire/max_data_frame.go | parseMaxDataFrame | func parseMaxDataFrame(r *bytes.Reader, version protocol.VersionNumber) (*MaxDataFrame, error) {
if _, err := r.ReadByte(); err != nil {
return nil, err
}
frame := &MaxDataFrame{}
byteOffset, err := utils.ReadVarInt(r)
if err != nil {
return nil, err
}
frame.ByteOffset = protocol.ByteCount(byteOffset)
return frame, nil
} | go | func parseMaxDataFrame(r *bytes.Reader, version protocol.VersionNumber) (*MaxDataFrame, error) {
if _, err := r.ReadByte(); err != nil {
return nil, err
}
frame := &MaxDataFrame{}
byteOffset, err := utils.ReadVarInt(r)
if err != nil {
return nil, err
}
frame.ByteOffset = protocol.ByteCount(byteOffset)
return frame, nil
} | [
"func",
"parseMaxDataFrame",
"(",
"r",
"*",
"bytes",
".",
"Reader",
",",
"version",
"protocol",
".",
"VersionNumber",
")",
"(",
"*",
"MaxDataFrame",
",",
"error",
")",
"{",
"if",
"_",
",",
"err",
":=",
"r",
".",
"ReadByte",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"frame",
":=",
"&",
"MaxDataFrame",
"{",
"}",
"\n",
"byteOffset",
",",
"err",
":=",
"utils",
".",
"ReadVarInt",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"frame",
".",
"ByteOffset",
"=",
"protocol",
".",
"ByteCount",
"(",
"byteOffset",
")",
"\n",
"return",
"frame",
",",
"nil",
"\n",
"}"
] | // parseMaxDataFrame parses a MAX_DATA frame | [
"parseMaxDataFrame",
"parses",
"a",
"MAX_DATA",
"frame"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/wire/max_data_frame.go#L16-L28 | train |
lucas-clemente/quic-go | internal/wire/max_data_frame.go | Write | func (f *MaxDataFrame) Write(b *bytes.Buffer, version protocol.VersionNumber) error {
b.WriteByte(0x10)
utils.WriteVarInt(b, uint64(f.ByteOffset))
return nil
} | go | func (f *MaxDataFrame) Write(b *bytes.Buffer, version protocol.VersionNumber) error {
b.WriteByte(0x10)
utils.WriteVarInt(b, uint64(f.ByteOffset))
return nil
} | [
"func",
"(",
"f",
"*",
"MaxDataFrame",
")",
"Write",
"(",
"b",
"*",
"bytes",
".",
"Buffer",
",",
"version",
"protocol",
".",
"VersionNumber",
")",
"error",
"{",
"b",
".",
"WriteByte",
"(",
"0x10",
")",
"\n",
"utils",
".",
"WriteVarInt",
"(",
"b",
",",
"uint64",
"(",
"f",
".",
"ByteOffset",
")",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | //Write writes a MAX_STREAM_DATA frame | [
"Write",
"writes",
"a",
"MAX_STREAM_DATA",
"frame"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/wire/max_data_frame.go#L31-L35 | train |
lucas-clemente/quic-go | internal/congestion/cubic_sender.go | NewCubicSender | func NewCubicSender(clock Clock, rttStats *RTTStats, reno bool, initialCongestionWindow, initialMaxCongestionWindow protocol.ByteCount) SendAlgorithmWithDebugInfo {
return &cubicSender{
rttStats: rttStats,
initialCongestionWindow: initialCongestionWindow,
initialMaxCongestionWindow: initialMaxCongestionWindow,
congestionWindow: initialCongestionWindow,
minCongestionWindow: defaultMinimumCongestionWindow,
slowstartThreshold: initialMaxCongestionWindow,
maxCongestionWindow: initialMaxCongestionWindow,
numConnections: defaultNumConnections,
cubic: NewCubic(clock),
reno: reno,
}
} | go | func NewCubicSender(clock Clock, rttStats *RTTStats, reno bool, initialCongestionWindow, initialMaxCongestionWindow protocol.ByteCount) SendAlgorithmWithDebugInfo {
return &cubicSender{
rttStats: rttStats,
initialCongestionWindow: initialCongestionWindow,
initialMaxCongestionWindow: initialMaxCongestionWindow,
congestionWindow: initialCongestionWindow,
minCongestionWindow: defaultMinimumCongestionWindow,
slowstartThreshold: initialMaxCongestionWindow,
maxCongestionWindow: initialMaxCongestionWindow,
numConnections: defaultNumConnections,
cubic: NewCubic(clock),
reno: reno,
}
} | [
"func",
"NewCubicSender",
"(",
"clock",
"Clock",
",",
"rttStats",
"*",
"RTTStats",
",",
"reno",
"bool",
",",
"initialCongestionWindow",
",",
"initialMaxCongestionWindow",
"protocol",
".",
"ByteCount",
")",
"SendAlgorithmWithDebugInfo",
"{",
"return",
"&",
"cubicSender",
"{",
"rttStats",
":",
"rttStats",
",",
"initialCongestionWindow",
":",
"initialCongestionWindow",
",",
"initialMaxCongestionWindow",
":",
"initialMaxCongestionWindow",
",",
"congestionWindow",
":",
"initialCongestionWindow",
",",
"minCongestionWindow",
":",
"defaultMinimumCongestionWindow",
",",
"slowstartThreshold",
":",
"initialMaxCongestionWindow",
",",
"maxCongestionWindow",
":",
"initialMaxCongestionWindow",
",",
"numConnections",
":",
"defaultNumConnections",
",",
"cubic",
":",
"NewCubic",
"(",
"clock",
")",
",",
"reno",
":",
"reno",
",",
"}",
"\n",
"}"
] | // NewCubicSender makes a new cubic sender | [
"NewCubicSender",
"makes",
"a",
"new",
"cubic",
"sender"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/congestion/cubic_sender.go#L69-L82 | train |
lucas-clemente/quic-go | internal/congestion/cubic_sender.go | TimeUntilSend | func (c *cubicSender) TimeUntilSend(bytesInFlight protocol.ByteCount) time.Duration {
if c.InRecovery() {
// PRR is used when in recovery.
if c.prr.CanSend(c.GetCongestionWindow(), bytesInFlight, c.GetSlowStartThreshold()) {
return 0
}
}
return c.rttStats.SmoothedRTT() * time.Duration(protocol.DefaultTCPMSS) / time.Duration(2*c.GetCongestionWindow())
} | go | func (c *cubicSender) TimeUntilSend(bytesInFlight protocol.ByteCount) time.Duration {
if c.InRecovery() {
// PRR is used when in recovery.
if c.prr.CanSend(c.GetCongestionWindow(), bytesInFlight, c.GetSlowStartThreshold()) {
return 0
}
}
return c.rttStats.SmoothedRTT() * time.Duration(protocol.DefaultTCPMSS) / time.Duration(2*c.GetCongestionWindow())
} | [
"func",
"(",
"c",
"*",
"cubicSender",
")",
"TimeUntilSend",
"(",
"bytesInFlight",
"protocol",
".",
"ByteCount",
")",
"time",
".",
"Duration",
"{",
"if",
"c",
".",
"InRecovery",
"(",
")",
"{",
"// PRR is used when in recovery.",
"if",
"c",
".",
"prr",
".",
"CanSend",
"(",
"c",
".",
"GetCongestionWindow",
"(",
")",
",",
"bytesInFlight",
",",
"c",
".",
"GetSlowStartThreshold",
"(",
")",
")",
"{",
"return",
"0",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"c",
".",
"rttStats",
".",
"SmoothedRTT",
"(",
")",
"*",
"time",
".",
"Duration",
"(",
"protocol",
".",
"DefaultTCPMSS",
")",
"/",
"time",
".",
"Duration",
"(",
"2",
"*",
"c",
".",
"GetCongestionWindow",
"(",
")",
")",
"\n",
"}"
] | // TimeUntilSend returns when the next packet should be sent. | [
"TimeUntilSend",
"returns",
"when",
"the",
"next",
"packet",
"should",
"be",
"sent",
"."
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/congestion/cubic_sender.go#L85-L93 | train |
lucas-clemente/quic-go | internal/congestion/cubic_sender.go | maybeIncreaseCwnd | func (c *cubicSender) maybeIncreaseCwnd(
ackedPacketNumber protocol.PacketNumber,
ackedBytes protocol.ByteCount,
priorInFlight protocol.ByteCount,
eventTime time.Time,
) {
// Do not increase the congestion window unless the sender is close to using
// the current window.
if !c.isCwndLimited(priorInFlight) {
c.cubic.OnApplicationLimited()
return
}
if c.congestionWindow >= c.maxCongestionWindow {
return
}
if c.InSlowStart() {
// TCP slow start, exponential growth, increase by one for each ACK.
c.congestionWindow += protocol.DefaultTCPMSS
return
}
// Congestion avoidance
if c.reno {
// Classic Reno congestion avoidance.
c.numAckedPackets++
// Divide by num_connections to smoothly increase the CWND at a faster
// rate than conventional Reno.
if c.numAckedPackets*uint64(c.numConnections) >= uint64(c.congestionWindow)/uint64(protocol.DefaultTCPMSS) {
c.congestionWindow += protocol.DefaultTCPMSS
c.numAckedPackets = 0
}
} else {
c.congestionWindow = utils.MinByteCount(c.maxCongestionWindow, c.cubic.CongestionWindowAfterAck(ackedBytes, c.congestionWindow, c.rttStats.MinRTT(), eventTime))
}
} | go | func (c *cubicSender) maybeIncreaseCwnd(
ackedPacketNumber protocol.PacketNumber,
ackedBytes protocol.ByteCount,
priorInFlight protocol.ByteCount,
eventTime time.Time,
) {
// Do not increase the congestion window unless the sender is close to using
// the current window.
if !c.isCwndLimited(priorInFlight) {
c.cubic.OnApplicationLimited()
return
}
if c.congestionWindow >= c.maxCongestionWindow {
return
}
if c.InSlowStart() {
// TCP slow start, exponential growth, increase by one for each ACK.
c.congestionWindow += protocol.DefaultTCPMSS
return
}
// Congestion avoidance
if c.reno {
// Classic Reno congestion avoidance.
c.numAckedPackets++
// Divide by num_connections to smoothly increase the CWND at a faster
// rate than conventional Reno.
if c.numAckedPackets*uint64(c.numConnections) >= uint64(c.congestionWindow)/uint64(protocol.DefaultTCPMSS) {
c.congestionWindow += protocol.DefaultTCPMSS
c.numAckedPackets = 0
}
} else {
c.congestionWindow = utils.MinByteCount(c.maxCongestionWindow, c.cubic.CongestionWindowAfterAck(ackedBytes, c.congestionWindow, c.rttStats.MinRTT(), eventTime))
}
} | [
"func",
"(",
"c",
"*",
"cubicSender",
")",
"maybeIncreaseCwnd",
"(",
"ackedPacketNumber",
"protocol",
".",
"PacketNumber",
",",
"ackedBytes",
"protocol",
".",
"ByteCount",
",",
"priorInFlight",
"protocol",
".",
"ByteCount",
",",
"eventTime",
"time",
".",
"Time",
",",
")",
"{",
"// Do not increase the congestion window unless the sender is close to using",
"// the current window.",
"if",
"!",
"c",
".",
"isCwndLimited",
"(",
"priorInFlight",
")",
"{",
"c",
".",
"cubic",
".",
"OnApplicationLimited",
"(",
")",
"\n",
"return",
"\n",
"}",
"\n",
"if",
"c",
".",
"congestionWindow",
">=",
"c",
".",
"maxCongestionWindow",
"{",
"return",
"\n",
"}",
"\n",
"if",
"c",
".",
"InSlowStart",
"(",
")",
"{",
"// TCP slow start, exponential growth, increase by one for each ACK.",
"c",
".",
"congestionWindow",
"+=",
"protocol",
".",
"DefaultTCPMSS",
"\n",
"return",
"\n",
"}",
"\n",
"// Congestion avoidance",
"if",
"c",
".",
"reno",
"{",
"// Classic Reno congestion avoidance.",
"c",
".",
"numAckedPackets",
"++",
"\n",
"// Divide by num_connections to smoothly increase the CWND at a faster",
"// rate than conventional Reno.",
"if",
"c",
".",
"numAckedPackets",
"*",
"uint64",
"(",
"c",
".",
"numConnections",
")",
">=",
"uint64",
"(",
"c",
".",
"congestionWindow",
")",
"/",
"uint64",
"(",
"protocol",
".",
"DefaultTCPMSS",
")",
"{",
"c",
".",
"congestionWindow",
"+=",
"protocol",
".",
"DefaultTCPMSS",
"\n",
"c",
".",
"numAckedPackets",
"=",
"0",
"\n",
"}",
"\n",
"}",
"else",
"{",
"c",
".",
"congestionWindow",
"=",
"utils",
".",
"MinByteCount",
"(",
"c",
".",
"maxCongestionWindow",
",",
"c",
".",
"cubic",
".",
"CongestionWindowAfterAck",
"(",
"ackedBytes",
",",
"c",
".",
"congestionWindow",
",",
"c",
".",
"rttStats",
".",
"MinRTT",
"(",
")",
",",
"eventTime",
")",
")",
"\n",
"}",
"\n",
"}"
] | // Called when we receive an ack. Normal TCP tracks how many packets one ack
// represents, but quic has a separate ack for each packet. | [
"Called",
"when",
"we",
"receive",
"an",
"ack",
".",
"Normal",
"TCP",
"tracks",
"how",
"many",
"packets",
"one",
"ack",
"represents",
"but",
"quic",
"has",
"a",
"separate",
"ack",
"for",
"each",
"packet",
"."
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/congestion/cubic_sender.go#L218-L251 | train |
lucas-clemente/quic-go | internal/congestion/cubic_sender.go | BandwidthEstimate | func (c *cubicSender) BandwidthEstimate() Bandwidth {
srtt := c.rttStats.SmoothedRTT()
if srtt == 0 {
// If we haven't measured an rtt, the bandwidth estimate is unknown.
return 0
}
return BandwidthFromDelta(c.GetCongestionWindow(), srtt)
} | go | func (c *cubicSender) BandwidthEstimate() Bandwidth {
srtt := c.rttStats.SmoothedRTT()
if srtt == 0 {
// If we haven't measured an rtt, the bandwidth estimate is unknown.
return 0
}
return BandwidthFromDelta(c.GetCongestionWindow(), srtt)
} | [
"func",
"(",
"c",
"*",
"cubicSender",
")",
"BandwidthEstimate",
"(",
")",
"Bandwidth",
"{",
"srtt",
":=",
"c",
".",
"rttStats",
".",
"SmoothedRTT",
"(",
")",
"\n",
"if",
"srtt",
"==",
"0",
"{",
"// If we haven't measured an rtt, the bandwidth estimate is unknown.",
"return",
"0",
"\n",
"}",
"\n",
"return",
"BandwidthFromDelta",
"(",
"c",
".",
"GetCongestionWindow",
"(",
")",
",",
"srtt",
")",
"\n",
"}"
] | // BandwidthEstimate returns the current bandwidth estimate | [
"BandwidthEstimate",
"returns",
"the",
"current",
"bandwidth",
"estimate"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/congestion/cubic_sender.go#L264-L271 | train |
lucas-clemente/quic-go | internal/congestion/cubic_sender.go | SetNumEmulatedConnections | func (c *cubicSender) SetNumEmulatedConnections(n int) {
c.numConnections = utils.Max(n, 1)
c.cubic.SetNumConnections(c.numConnections)
} | go | func (c *cubicSender) SetNumEmulatedConnections(n int) {
c.numConnections = utils.Max(n, 1)
c.cubic.SetNumConnections(c.numConnections)
} | [
"func",
"(",
"c",
"*",
"cubicSender",
")",
"SetNumEmulatedConnections",
"(",
"n",
"int",
")",
"{",
"c",
".",
"numConnections",
"=",
"utils",
".",
"Max",
"(",
"n",
",",
"1",
")",
"\n",
"c",
".",
"cubic",
".",
"SetNumConnections",
"(",
"c",
".",
"numConnections",
")",
"\n",
"}"
] | // SetNumEmulatedConnections sets the number of emulated connections | [
"SetNumEmulatedConnections",
"sets",
"the",
"number",
"of",
"emulated",
"connections"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/congestion/cubic_sender.go#L279-L282 | train |
lucas-clemente/quic-go | internal/congestion/cubic_sender.go | OnRetransmissionTimeout | func (c *cubicSender) OnRetransmissionTimeout(packetsRetransmitted bool) {
c.largestSentAtLastCutback = 0
if !packetsRetransmitted {
return
}
c.hybridSlowStart.Restart()
c.cubic.Reset()
c.slowstartThreshold = c.congestionWindow / 2
c.congestionWindow = c.minCongestionWindow
} | go | func (c *cubicSender) OnRetransmissionTimeout(packetsRetransmitted bool) {
c.largestSentAtLastCutback = 0
if !packetsRetransmitted {
return
}
c.hybridSlowStart.Restart()
c.cubic.Reset()
c.slowstartThreshold = c.congestionWindow / 2
c.congestionWindow = c.minCongestionWindow
} | [
"func",
"(",
"c",
"*",
"cubicSender",
")",
"OnRetransmissionTimeout",
"(",
"packetsRetransmitted",
"bool",
")",
"{",
"c",
".",
"largestSentAtLastCutback",
"=",
"0",
"\n",
"if",
"!",
"packetsRetransmitted",
"{",
"return",
"\n",
"}",
"\n",
"c",
".",
"hybridSlowStart",
".",
"Restart",
"(",
")",
"\n",
"c",
".",
"cubic",
".",
"Reset",
"(",
")",
"\n",
"c",
".",
"slowstartThreshold",
"=",
"c",
".",
"congestionWindow",
"/",
"2",
"\n",
"c",
".",
"congestionWindow",
"=",
"c",
".",
"minCongestionWindow",
"\n",
"}"
] | // OnRetransmissionTimeout is called on an retransmission timeout | [
"OnRetransmissionTimeout",
"is",
"called",
"on",
"an",
"retransmission",
"timeout"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/congestion/cubic_sender.go#L285-L294 | train |
lucas-clemente/quic-go | internal/mocks/ackhandler/received_packet_handler.go | NewMockReceivedPacketHandler | func NewMockReceivedPacketHandler(ctrl *gomock.Controller) *MockReceivedPacketHandler {
mock := &MockReceivedPacketHandler{ctrl: ctrl}
mock.recorder = &MockReceivedPacketHandlerMockRecorder{mock}
return mock
} | go | func NewMockReceivedPacketHandler(ctrl *gomock.Controller) *MockReceivedPacketHandler {
mock := &MockReceivedPacketHandler{ctrl: ctrl}
mock.recorder = &MockReceivedPacketHandlerMockRecorder{mock}
return mock
} | [
"func",
"NewMockReceivedPacketHandler",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockReceivedPacketHandler",
"{",
"mock",
":=",
"&",
"MockReceivedPacketHandler",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockReceivedPacketHandlerMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockReceivedPacketHandler creates a new mock instance | [
"NewMockReceivedPacketHandler",
"creates",
"a",
"new",
"mock",
"instance"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/ackhandler/received_packet_handler.go#L28-L32 | train |
lucas-clemente/quic-go | internal/mocks/ackhandler/received_packet_handler.go | GetAckFrame | func (m *MockReceivedPacketHandler) GetAckFrame(arg0 protocol.EncryptionLevel) *wire.AckFrame {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetAckFrame", arg0)
ret0, _ := ret[0].(*wire.AckFrame)
return ret0
} | go | func (m *MockReceivedPacketHandler) GetAckFrame(arg0 protocol.EncryptionLevel) *wire.AckFrame {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetAckFrame", arg0)
ret0, _ := ret[0].(*wire.AckFrame)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockReceivedPacketHandler",
")",
"GetAckFrame",
"(",
"arg0",
"protocol",
".",
"EncryptionLevel",
")",
"*",
"wire",
".",
"AckFrame",
"{",
"m",
".",
"ctrl",
".",
"T",
".",
"Helper",
"(",
")",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"wire",
".",
"AckFrame",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // GetAckFrame mocks base method | [
"GetAckFrame",
"mocks",
"base",
"method"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/ackhandler/received_packet_handler.go#L40-L45 | train |
lucas-clemente/quic-go | internal/mocks/ackhandler/received_packet_handler.go | GetAckFrame | func (mr *MockReceivedPacketHandlerMockRecorder) GetAckFrame(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAckFrame", reflect.TypeOf((*MockReceivedPacketHandler)(nil).GetAckFrame), arg0)
} | go | func (mr *MockReceivedPacketHandlerMockRecorder) GetAckFrame(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAckFrame", reflect.TypeOf((*MockReceivedPacketHandler)(nil).GetAckFrame), arg0)
} | [
"func",
"(",
"mr",
"*",
"MockReceivedPacketHandlerMockRecorder",
")",
"GetAckFrame",
"(",
"arg0",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"mr",
".",
"mock",
".",
"ctrl",
".",
"T",
".",
"Helper",
"(",
")",
"\n",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockReceivedPacketHandler",
")",
"(",
"nil",
")",
".",
"GetAckFrame",
")",
",",
"arg0",
")",
"\n",
"}"
] | // GetAckFrame indicates an expected call of GetAckFrame | [
"GetAckFrame",
"indicates",
"an",
"expected",
"call",
"of",
"GetAckFrame"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/ackhandler/received_packet_handler.go#L48-L51 | train |
lucas-clemente/quic-go | internal/mocks/ackhandler/received_packet_handler.go | IgnoreBelow | func (m *MockReceivedPacketHandler) IgnoreBelow(arg0 protocol.PacketNumber) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "IgnoreBelow", arg0)
} | go | func (m *MockReceivedPacketHandler) IgnoreBelow(arg0 protocol.PacketNumber) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "IgnoreBelow", arg0)
} | [
"func",
"(",
"m",
"*",
"MockReceivedPacketHandler",
")",
"IgnoreBelow",
"(",
"arg0",
"protocol",
".",
"PacketNumber",
")",
"{",
"m",
".",
"ctrl",
".",
"T",
".",
"Helper",
"(",
")",
"\n",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"}"
] | // IgnoreBelow mocks base method | [
"IgnoreBelow",
"mocks",
"base",
"method"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/ackhandler/received_packet_handler.go#L68-L71 | train |
lucas-clemente/quic-go | internal/mocks/ackhandler/received_packet_handler.go | ReceivedPacket | func (m *MockReceivedPacketHandler) ReceivedPacket(arg0 protocol.PacketNumber, arg1 protocol.EncryptionLevel, arg2 time.Time, arg3 bool) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ReceivedPacket", arg0, arg1, arg2, arg3)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockReceivedPacketHandler) ReceivedPacket(arg0 protocol.PacketNumber, arg1 protocol.EncryptionLevel, arg2 time.Time, arg3 bool) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ReceivedPacket", arg0, arg1, arg2, arg3)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockReceivedPacketHandler",
")",
"ReceivedPacket",
"(",
"arg0",
"protocol",
".",
"PacketNumber",
",",
"arg1",
"protocol",
".",
"EncryptionLevel",
",",
"arg2",
"time",
".",
"Time",
",",
"arg3",
"bool",
")",
"error",
"{",
"m",
".",
"ctrl",
".",
"T",
".",
"Helper",
"(",
")",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
",",
"arg2",
",",
"arg3",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // ReceivedPacket mocks base method | [
"ReceivedPacket",
"mocks",
"base",
"method"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/ackhandler/received_packet_handler.go#L80-L85 | train |
lucas-clemente/quic-go | internal/mocks/ackhandler/received_packet_handler.go | ReceivedPacket | func (mr *MockReceivedPacketHandlerMockRecorder) ReceivedPacket(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceivedPacket", reflect.TypeOf((*MockReceivedPacketHandler)(nil).ReceivedPacket), arg0, arg1, arg2, arg3)
} | go | func (mr *MockReceivedPacketHandlerMockRecorder) ReceivedPacket(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceivedPacket", reflect.TypeOf((*MockReceivedPacketHandler)(nil).ReceivedPacket), arg0, arg1, arg2, arg3)
} | [
"func",
"(",
"mr",
"*",
"MockReceivedPacketHandlerMockRecorder",
")",
"ReceivedPacket",
"(",
"arg0",
",",
"arg1",
",",
"arg2",
",",
"arg3",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"mr",
".",
"mock",
".",
"ctrl",
".",
"T",
".",
"Helper",
"(",
")",
"\n",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockReceivedPacketHandler",
")",
"(",
"nil",
")",
".",
"ReceivedPacket",
")",
",",
"arg0",
",",
"arg1",
",",
"arg2",
",",
"arg3",
")",
"\n",
"}"
] | // ReceivedPacket indicates an expected call of ReceivedPacket | [
"ReceivedPacket",
"indicates",
"an",
"expected",
"call",
"of",
"ReceivedPacket"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/ackhandler/received_packet_handler.go#L88-L91 | train |
lucas-clemente/quic-go | internal/utils/host.go | HostnameFromAddr | func HostnameFromAddr(addr string) (string, error) {
p, err := url.Parse(addr)
if err != nil {
return "", err
}
h := p.Host
// copied from https://golang.org/src/net/http/transport.go
if hasPort(h) {
h = h[:strings.LastIndex(h, ":")]
}
return h, nil
} | go | func HostnameFromAddr(addr string) (string, error) {
p, err := url.Parse(addr)
if err != nil {
return "", err
}
h := p.Host
// copied from https://golang.org/src/net/http/transport.go
if hasPort(h) {
h = h[:strings.LastIndex(h, ":")]
}
return h, nil
} | [
"func",
"HostnameFromAddr",
"(",
"addr",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"p",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"h",
":=",
"p",
".",
"Host",
"\n\n",
"// copied from https://golang.org/src/net/http/transport.go",
"if",
"hasPort",
"(",
"h",
")",
"{",
"h",
"=",
"h",
"[",
":",
"strings",
".",
"LastIndex",
"(",
"h",
",",
"\"",
"\"",
")",
"]",
"\n",
"}",
"\n\n",
"return",
"h",
",",
"nil",
"\n",
"}"
] | // HostnameFromAddr determines the hostname in an address string | [
"HostnameFromAddr",
"determines",
"the",
"hostname",
"in",
"an",
"address",
"string"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/utils/host.go#L9-L22 | train |
lucas-clemente/quic-go | internal/ackhandler/packet_linkedlist.go | PushBackList | func (l *PacketList) PushBackList(other *PacketList) {
l.lazyInit()
for i, e := other.Len(), other.Front(); i > 0; i, e = i-1, e.Next() {
l.insertValue(e.Value, l.root.prev)
}
} | go | func (l *PacketList) PushBackList(other *PacketList) {
l.lazyInit()
for i, e := other.Len(), other.Front(); i > 0; i, e = i-1, e.Next() {
l.insertValue(e.Value, l.root.prev)
}
} | [
"func",
"(",
"l",
"*",
"PacketList",
")",
"PushBackList",
"(",
"other",
"*",
"PacketList",
")",
"{",
"l",
".",
"lazyInit",
"(",
")",
"\n",
"for",
"i",
",",
"e",
":=",
"other",
".",
"Len",
"(",
")",
",",
"other",
".",
"Front",
"(",
")",
";",
"i",
">",
"0",
";",
"i",
",",
"e",
"=",
"i",
"-",
"1",
",",
"e",
".",
"Next",
"(",
")",
"{",
"l",
".",
"insertValue",
"(",
"e",
".",
"Value",
",",
"l",
".",
"root",
".",
"prev",
")",
"\n",
"}",
"\n",
"}"
] | // PushBackList inserts a copy of an other list at the back of list l.
// The lists l and other may be the same. They must not be nil. | [
"PushBackList",
"inserts",
"a",
"copy",
"of",
"an",
"other",
"list",
"at",
"the",
"back",
"of",
"list",
"l",
".",
"The",
"lists",
"l",
"and",
"other",
"may",
"be",
"the",
"same",
".",
"They",
"must",
"not",
"be",
"nil",
"."
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/ackhandler/packet_linkedlist.go#L203-L208 | train |
lucas-clemente/quic-go | internal/mocks/ackhandler/sent_packet_handler.go | NewMockSentPacketHandler | func NewMockSentPacketHandler(ctrl *gomock.Controller) *MockSentPacketHandler {
mock := &MockSentPacketHandler{ctrl: ctrl}
mock.recorder = &MockSentPacketHandlerMockRecorder{mock}
return mock
} | go | func NewMockSentPacketHandler(ctrl *gomock.Controller) *MockSentPacketHandler {
mock := &MockSentPacketHandler{ctrl: ctrl}
mock.recorder = &MockSentPacketHandlerMockRecorder{mock}
return mock
} | [
"func",
"NewMockSentPacketHandler",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockSentPacketHandler",
"{",
"mock",
":=",
"&",
"MockSentPacketHandler",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockSentPacketHandlerMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockSentPacketHandler creates a new mock instance | [
"NewMockSentPacketHandler",
"creates",
"a",
"new",
"mock",
"instance"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/ackhandler/sent_packet_handler.go#L29-L33 | train |
lucas-clemente/quic-go | internal/mocks/ackhandler/sent_packet_handler.go | DequeuePacketForRetransmission | func (m *MockSentPacketHandler) DequeuePacketForRetransmission() *ackhandler.Packet {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DequeuePacketForRetransmission")
ret0, _ := ret[0].(*ackhandler.Packet)
return ret0
} | go | func (m *MockSentPacketHandler) DequeuePacketForRetransmission() *ackhandler.Packet {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DequeuePacketForRetransmission")
ret0, _ := ret[0].(*ackhandler.Packet)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockSentPacketHandler",
")",
"DequeuePacketForRetransmission",
"(",
")",
"*",
"ackhandler",
".",
"Packet",
"{",
"m",
".",
"ctrl",
".",
"T",
".",
"Helper",
"(",
")",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"ackhandler",
".",
"Packet",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // DequeuePacketForRetransmission mocks base method | [
"DequeuePacketForRetransmission",
"mocks",
"base",
"method"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/ackhandler/sent_packet_handler.go#L41-L46 | train |
lucas-clemente/quic-go | internal/mocks/ackhandler/sent_packet_handler.go | DequeueProbePacket | func (m *MockSentPacketHandler) DequeueProbePacket() (*ackhandler.Packet, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DequeueProbePacket")
ret0, _ := ret[0].(*ackhandler.Packet)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockSentPacketHandler) DequeueProbePacket() (*ackhandler.Packet, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DequeueProbePacket")
ret0, _ := ret[0].(*ackhandler.Packet)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockSentPacketHandler",
")",
"DequeueProbePacket",
"(",
")",
"(",
"*",
"ackhandler",
".",
"Packet",
",",
"error",
")",
"{",
"m",
".",
"ctrl",
".",
"T",
".",
"Helper",
"(",
")",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"ackhandler",
".",
"Packet",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // DequeueProbePacket mocks base method | [
"DequeueProbePacket",
"mocks",
"base",
"method"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/ackhandler/sent_packet_handler.go#L55-L61 | train |
lucas-clemente/quic-go | internal/mocks/ackhandler/sent_packet_handler.go | GetAlarmTimeout | func (m *MockSentPacketHandler) GetAlarmTimeout() time.Time {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetAlarmTimeout")
ret0, _ := ret[0].(time.Time)
return ret0
} | go | func (m *MockSentPacketHandler) GetAlarmTimeout() time.Time {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetAlarmTimeout")
ret0, _ := ret[0].(time.Time)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockSentPacketHandler",
")",
"GetAlarmTimeout",
"(",
")",
"time",
".",
"Time",
"{",
"m",
".",
"ctrl",
".",
"T",
".",
"Helper",
"(",
")",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"time",
".",
"Time",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // GetAlarmTimeout mocks base method | [
"GetAlarmTimeout",
"mocks",
"base",
"method"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/ackhandler/sent_packet_handler.go#L70-L75 | train |
lucas-clemente/quic-go | internal/mocks/ackhandler/sent_packet_handler.go | GetLowestPacketNotConfirmedAcked | func (m *MockSentPacketHandler) GetLowestPacketNotConfirmedAcked() protocol.PacketNumber {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetLowestPacketNotConfirmedAcked")
ret0, _ := ret[0].(protocol.PacketNumber)
return ret0
} | go | func (m *MockSentPacketHandler) GetLowestPacketNotConfirmedAcked() protocol.PacketNumber {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetLowestPacketNotConfirmedAcked")
ret0, _ := ret[0].(protocol.PacketNumber)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockSentPacketHandler",
")",
"GetLowestPacketNotConfirmedAcked",
"(",
")",
"protocol",
".",
"PacketNumber",
"{",
"m",
".",
"ctrl",
".",
"T",
".",
"Helper",
"(",
")",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"protocol",
".",
"PacketNumber",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // GetLowestPacketNotConfirmedAcked mocks base method | [
"GetLowestPacketNotConfirmedAcked",
"mocks",
"base",
"method"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/ackhandler/sent_packet_handler.go#L84-L89 | train |
lucas-clemente/quic-go | internal/mocks/ackhandler/sent_packet_handler.go | PeekPacketNumber | func (m *MockSentPacketHandler) PeekPacketNumber(arg0 protocol.EncryptionLevel) (protocol.PacketNumber, protocol.PacketNumberLen) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PeekPacketNumber", arg0)
ret0, _ := ret[0].(protocol.PacketNumber)
ret1, _ := ret[1].(protocol.PacketNumberLen)
return ret0, ret1
} | go | func (m *MockSentPacketHandler) PeekPacketNumber(arg0 protocol.EncryptionLevel) (protocol.PacketNumber, protocol.PacketNumberLen) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PeekPacketNumber", arg0)
ret0, _ := ret[0].(protocol.PacketNumber)
ret1, _ := ret[1].(protocol.PacketNumberLen)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockSentPacketHandler",
")",
"PeekPacketNumber",
"(",
"arg0",
"protocol",
".",
"EncryptionLevel",
")",
"(",
"protocol",
".",
"PacketNumber",
",",
"protocol",
".",
"PacketNumberLen",
")",
"{",
"m",
".",
"ctrl",
".",
"T",
".",
"Helper",
"(",
")",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"protocol",
".",
"PacketNumber",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"protocol",
".",
"PacketNumberLen",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // PeekPacketNumber mocks base method | [
"PeekPacketNumber",
"mocks",
"base",
"method"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/ackhandler/sent_packet_handler.go#L112-L118 | train |
lucas-clemente/quic-go | internal/mocks/ackhandler/sent_packet_handler.go | PopPacketNumber | func (m *MockSentPacketHandler) PopPacketNumber(arg0 protocol.EncryptionLevel) protocol.PacketNumber {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PopPacketNumber", arg0)
ret0, _ := ret[0].(protocol.PacketNumber)
return ret0
} | go | func (m *MockSentPacketHandler) PopPacketNumber(arg0 protocol.EncryptionLevel) protocol.PacketNumber {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PopPacketNumber", arg0)
ret0, _ := ret[0].(protocol.PacketNumber)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockSentPacketHandler",
")",
"PopPacketNumber",
"(",
"arg0",
"protocol",
".",
"EncryptionLevel",
")",
"protocol",
".",
"PacketNumber",
"{",
"m",
".",
"ctrl",
".",
"T",
".",
"Helper",
"(",
")",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"protocol",
".",
"PacketNumber",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // PopPacketNumber mocks base method | [
"PopPacketNumber",
"mocks",
"base",
"method"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/ackhandler/sent_packet_handler.go#L127-L132 | train |
lucas-clemente/quic-go | internal/mocks/ackhandler/sent_packet_handler.go | ReceivedAck | func (m *MockSentPacketHandler) ReceivedAck(arg0 *wire.AckFrame, arg1 protocol.PacketNumber, arg2 protocol.EncryptionLevel, arg3 time.Time) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ReceivedAck", arg0, arg1, arg2, arg3)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockSentPacketHandler) ReceivedAck(arg0 *wire.AckFrame, arg1 protocol.PacketNumber, arg2 protocol.EncryptionLevel, arg3 time.Time) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ReceivedAck", arg0, arg1, arg2, arg3)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockSentPacketHandler",
")",
"ReceivedAck",
"(",
"arg0",
"*",
"wire",
".",
"AckFrame",
",",
"arg1",
"protocol",
".",
"PacketNumber",
",",
"arg2",
"protocol",
".",
"EncryptionLevel",
",",
"arg3",
"time",
".",
"Time",
")",
"error",
"{",
"m",
".",
"ctrl",
".",
"T",
".",
"Helper",
"(",
")",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
",",
"arg2",
",",
"arg3",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // ReceivedAck mocks base method | [
"ReceivedAck",
"mocks",
"base",
"method"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/ackhandler/sent_packet_handler.go#L141-L146 | train |
lucas-clemente/quic-go | internal/mocks/ackhandler/sent_packet_handler.go | ReceivedAck | func (mr *MockSentPacketHandlerMockRecorder) ReceivedAck(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceivedAck", reflect.TypeOf((*MockSentPacketHandler)(nil).ReceivedAck), arg0, arg1, arg2, arg3)
} | go | func (mr *MockSentPacketHandlerMockRecorder) ReceivedAck(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceivedAck", reflect.TypeOf((*MockSentPacketHandler)(nil).ReceivedAck), arg0, arg1, arg2, arg3)
} | [
"func",
"(",
"mr",
"*",
"MockSentPacketHandlerMockRecorder",
")",
"ReceivedAck",
"(",
"arg0",
",",
"arg1",
",",
"arg2",
",",
"arg3",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"mr",
".",
"mock",
".",
"ctrl",
".",
"T",
".",
"Helper",
"(",
")",
"\n",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockSentPacketHandler",
")",
"(",
"nil",
")",
".",
"ReceivedAck",
")",
",",
"arg0",
",",
"arg1",
",",
"arg2",
",",
"arg3",
")",
"\n",
"}"
] | // ReceivedAck indicates an expected call of ReceivedAck | [
"ReceivedAck",
"indicates",
"an",
"expected",
"call",
"of",
"ReceivedAck"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/ackhandler/sent_packet_handler.go#L149-L152 | train |
lucas-clemente/quic-go | internal/mocks/ackhandler/sent_packet_handler.go | ResetForRetry | func (m *MockSentPacketHandler) ResetForRetry() error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ResetForRetry")
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockSentPacketHandler) ResetForRetry() error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ResetForRetry")
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockSentPacketHandler",
")",
"ResetForRetry",
"(",
")",
"error",
"{",
"m",
".",
"ctrl",
".",
"T",
".",
"Helper",
"(",
")",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // ResetForRetry mocks base method | [
"ResetForRetry",
"mocks",
"base",
"method"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/ackhandler/sent_packet_handler.go#L155-L160 | train |
lucas-clemente/quic-go | internal/mocks/ackhandler/sent_packet_handler.go | SendMode | func (m *MockSentPacketHandler) SendMode() ackhandler.SendMode {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SendMode")
ret0, _ := ret[0].(ackhandler.SendMode)
return ret0
} | go | func (m *MockSentPacketHandler) SendMode() ackhandler.SendMode {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SendMode")
ret0, _ := ret[0].(ackhandler.SendMode)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockSentPacketHandler",
")",
"SendMode",
"(",
")",
"ackhandler",
".",
"SendMode",
"{",
"m",
".",
"ctrl",
".",
"T",
".",
"Helper",
"(",
")",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"ackhandler",
".",
"SendMode",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // SendMode mocks base method | [
"SendMode",
"mocks",
"base",
"method"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/ackhandler/sent_packet_handler.go#L169-L174 | train |
lucas-clemente/quic-go | internal/mocks/ackhandler/sent_packet_handler.go | SentPacket | func (m *MockSentPacketHandler) SentPacket(arg0 *ackhandler.Packet) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "SentPacket", arg0)
} | go | func (m *MockSentPacketHandler) SentPacket(arg0 *ackhandler.Packet) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "SentPacket", arg0)
} | [
"func",
"(",
"m",
"*",
"MockSentPacketHandler",
")",
"SentPacket",
"(",
"arg0",
"*",
"ackhandler",
".",
"Packet",
")",
"{",
"m",
".",
"ctrl",
".",
"T",
".",
"Helper",
"(",
")",
"\n",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"}"
] | // SentPacket mocks base method | [
"SentPacket",
"mocks",
"base",
"method"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/ackhandler/sent_packet_handler.go#L183-L186 | train |
lucas-clemente/quic-go | internal/mocks/ackhandler/sent_packet_handler.go | SentPacket | func (mr *MockSentPacketHandlerMockRecorder) SentPacket(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SentPacket", reflect.TypeOf((*MockSentPacketHandler)(nil).SentPacket), arg0)
} | go | func (mr *MockSentPacketHandlerMockRecorder) SentPacket(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SentPacket", reflect.TypeOf((*MockSentPacketHandler)(nil).SentPacket), arg0)
} | [
"func",
"(",
"mr",
"*",
"MockSentPacketHandlerMockRecorder",
")",
"SentPacket",
"(",
"arg0",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"mr",
".",
"mock",
".",
"ctrl",
".",
"T",
".",
"Helper",
"(",
")",
"\n",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockSentPacketHandler",
")",
"(",
"nil",
")",
".",
"SentPacket",
")",
",",
"arg0",
")",
"\n",
"}"
] | // SentPacket indicates an expected call of SentPacket | [
"SentPacket",
"indicates",
"an",
"expected",
"call",
"of",
"SentPacket"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/ackhandler/sent_packet_handler.go#L189-L192 | train |
lucas-clemente/quic-go | internal/mocks/ackhandler/sent_packet_handler.go | SentPacketsAsRetransmission | func (m *MockSentPacketHandler) SentPacketsAsRetransmission(arg0 []*ackhandler.Packet, arg1 protocol.PacketNumber) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "SentPacketsAsRetransmission", arg0, arg1)
} | go | func (m *MockSentPacketHandler) SentPacketsAsRetransmission(arg0 []*ackhandler.Packet, arg1 protocol.PacketNumber) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "SentPacketsAsRetransmission", arg0, arg1)
} | [
"func",
"(",
"m",
"*",
"MockSentPacketHandler",
")",
"SentPacketsAsRetransmission",
"(",
"arg0",
"[",
"]",
"*",
"ackhandler",
".",
"Packet",
",",
"arg1",
"protocol",
".",
"PacketNumber",
")",
"{",
"m",
".",
"ctrl",
".",
"T",
".",
"Helper",
"(",
")",
"\n",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
")",
"\n",
"}"
] | // SentPacketsAsRetransmission mocks base method | [
"SentPacketsAsRetransmission",
"mocks",
"base",
"method"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/ackhandler/sent_packet_handler.go#L195-L198 | train |
lucas-clemente/quic-go | internal/mocks/ackhandler/sent_packet_handler.go | SetHandshakeComplete | func (m *MockSentPacketHandler) SetHandshakeComplete() {
m.ctrl.T.Helper()
m.ctrl.Call(m, "SetHandshakeComplete")
} | go | func (m *MockSentPacketHandler) SetHandshakeComplete() {
m.ctrl.T.Helper()
m.ctrl.Call(m, "SetHandshakeComplete")
} | [
"func",
"(",
"m",
"*",
"MockSentPacketHandler",
")",
"SetHandshakeComplete",
"(",
")",
"{",
"m",
".",
"ctrl",
".",
"T",
".",
"Helper",
"(",
")",
"\n",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // SetHandshakeComplete mocks base method | [
"SetHandshakeComplete",
"mocks",
"base",
"method"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/ackhandler/sent_packet_handler.go#L207-L210 | train |
lucas-clemente/quic-go | internal/mocks/ackhandler/sent_packet_handler.go | ShouldSendNumPackets | func (m *MockSentPacketHandler) ShouldSendNumPackets() int {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ShouldSendNumPackets")
ret0, _ := ret[0].(int)
return ret0
} | go | func (m *MockSentPacketHandler) ShouldSendNumPackets() int {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ShouldSendNumPackets")
ret0, _ := ret[0].(int)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockSentPacketHandler",
")",
"ShouldSendNumPackets",
"(",
")",
"int",
"{",
"m",
".",
"ctrl",
".",
"T",
".",
"Helper",
"(",
")",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"int",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // ShouldSendNumPackets mocks base method | [
"ShouldSendNumPackets",
"mocks",
"base",
"method"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/ackhandler/sent_packet_handler.go#L219-L224 | train |
lucas-clemente/quic-go | internal/handshake/cookie_generator.go | NewCookieGenerator | func NewCookieGenerator() (*CookieGenerator, error) {
cookieProtector, err := newCookieProtector()
if err != nil {
return nil, err
}
return &CookieGenerator{
cookieProtector: cookieProtector,
}, nil
} | go | func NewCookieGenerator() (*CookieGenerator, error) {
cookieProtector, err := newCookieProtector()
if err != nil {
return nil, err
}
return &CookieGenerator{
cookieProtector: cookieProtector,
}, nil
} | [
"func",
"NewCookieGenerator",
"(",
")",
"(",
"*",
"CookieGenerator",
",",
"error",
")",
"{",
"cookieProtector",
",",
"err",
":=",
"newCookieProtector",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"CookieGenerator",
"{",
"cookieProtector",
":",
"cookieProtector",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewCookieGenerator initializes a new CookieGenerator | [
"NewCookieGenerator",
"initializes",
"a",
"new",
"CookieGenerator"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/handshake/cookie_generator.go#L39-L47 | train |
lucas-clemente/quic-go | internal/handshake/cookie_generator.go | NewToken | func (g *CookieGenerator) NewToken(raddr net.Addr, origConnID protocol.ConnectionID) ([]byte, error) {
data, err := asn1.Marshal(token{
RemoteAddr: encodeRemoteAddr(raddr),
OriginalDestConnectionID: origConnID,
Timestamp: time.Now().Unix(),
})
if err != nil {
return nil, err
}
return g.cookieProtector.NewToken(data)
} | go | func (g *CookieGenerator) NewToken(raddr net.Addr, origConnID protocol.ConnectionID) ([]byte, error) {
data, err := asn1.Marshal(token{
RemoteAddr: encodeRemoteAddr(raddr),
OriginalDestConnectionID: origConnID,
Timestamp: time.Now().Unix(),
})
if err != nil {
return nil, err
}
return g.cookieProtector.NewToken(data)
} | [
"func",
"(",
"g",
"*",
"CookieGenerator",
")",
"NewToken",
"(",
"raddr",
"net",
".",
"Addr",
",",
"origConnID",
"protocol",
".",
"ConnectionID",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"data",
",",
"err",
":=",
"asn1",
".",
"Marshal",
"(",
"token",
"{",
"RemoteAddr",
":",
"encodeRemoteAddr",
"(",
"raddr",
")",
",",
"OriginalDestConnectionID",
":",
"origConnID",
",",
"Timestamp",
":",
"time",
".",
"Now",
"(",
")",
".",
"Unix",
"(",
")",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"g",
".",
"cookieProtector",
".",
"NewToken",
"(",
"data",
")",
"\n",
"}"
] | // NewToken generates a new Cookie for a given source address | [
"NewToken",
"generates",
"a",
"new",
"Cookie",
"for",
"a",
"given",
"source",
"address"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/handshake/cookie_generator.go#L50-L60 | train |
lucas-clemente/quic-go | internal/handshake/cookie_generator.go | DecodeToken | func (g *CookieGenerator) DecodeToken(encrypted []byte) (*Cookie, error) {
// if the client didn't send any Cookie, DecodeToken will be called with a nil-slice
if len(encrypted) == 0 {
return nil, nil
}
data, err := g.cookieProtector.DecodeToken(encrypted)
if err != nil {
return nil, err
}
t := &token{}
rest, err := asn1.Unmarshal(data, t)
if err != nil {
return nil, err
}
if len(rest) != 0 {
return nil, fmt.Errorf("rest when unpacking token: %d", len(rest))
}
cookie := &Cookie{
RemoteAddr: decodeRemoteAddr(t.RemoteAddr),
SentTime: time.Unix(t.Timestamp, 0),
}
if len(t.OriginalDestConnectionID) > 0 {
cookie.OriginalDestConnectionID = protocol.ConnectionID(t.OriginalDestConnectionID)
}
return cookie, nil
} | go | func (g *CookieGenerator) DecodeToken(encrypted []byte) (*Cookie, error) {
// if the client didn't send any Cookie, DecodeToken will be called with a nil-slice
if len(encrypted) == 0 {
return nil, nil
}
data, err := g.cookieProtector.DecodeToken(encrypted)
if err != nil {
return nil, err
}
t := &token{}
rest, err := asn1.Unmarshal(data, t)
if err != nil {
return nil, err
}
if len(rest) != 0 {
return nil, fmt.Errorf("rest when unpacking token: %d", len(rest))
}
cookie := &Cookie{
RemoteAddr: decodeRemoteAddr(t.RemoteAddr),
SentTime: time.Unix(t.Timestamp, 0),
}
if len(t.OriginalDestConnectionID) > 0 {
cookie.OriginalDestConnectionID = protocol.ConnectionID(t.OriginalDestConnectionID)
}
return cookie, nil
} | [
"func",
"(",
"g",
"*",
"CookieGenerator",
")",
"DecodeToken",
"(",
"encrypted",
"[",
"]",
"byte",
")",
"(",
"*",
"Cookie",
",",
"error",
")",
"{",
"// if the client didn't send any Cookie, DecodeToken will be called with a nil-slice",
"if",
"len",
"(",
"encrypted",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n\n",
"data",
",",
"err",
":=",
"g",
".",
"cookieProtector",
".",
"DecodeToken",
"(",
"encrypted",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"t",
":=",
"&",
"token",
"{",
"}",
"\n",
"rest",
",",
"err",
":=",
"asn1",
".",
"Unmarshal",
"(",
"data",
",",
"t",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"len",
"(",
"rest",
")",
"!=",
"0",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"len",
"(",
"rest",
")",
")",
"\n",
"}",
"\n",
"cookie",
":=",
"&",
"Cookie",
"{",
"RemoteAddr",
":",
"decodeRemoteAddr",
"(",
"t",
".",
"RemoteAddr",
")",
",",
"SentTime",
":",
"time",
".",
"Unix",
"(",
"t",
".",
"Timestamp",
",",
"0",
")",
",",
"}",
"\n",
"if",
"len",
"(",
"t",
".",
"OriginalDestConnectionID",
")",
">",
"0",
"{",
"cookie",
".",
"OriginalDestConnectionID",
"=",
"protocol",
".",
"ConnectionID",
"(",
"t",
".",
"OriginalDestConnectionID",
")",
"\n",
"}",
"\n",
"return",
"cookie",
",",
"nil",
"\n",
"}"
] | // DecodeToken decodes a Cookie | [
"DecodeToken",
"decodes",
"a",
"Cookie"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/handshake/cookie_generator.go#L63-L89 | train |
lucas-clemente/quic-go | internal/handshake/cookie_generator.go | encodeRemoteAddr | func encodeRemoteAddr(remoteAddr net.Addr) []byte {
if udpAddr, ok := remoteAddr.(*net.UDPAddr); ok {
return append([]byte{cookiePrefixIP}, udpAddr.IP...)
}
return append([]byte{cookiePrefixString}, []byte(remoteAddr.String())...)
} | go | func encodeRemoteAddr(remoteAddr net.Addr) []byte {
if udpAddr, ok := remoteAddr.(*net.UDPAddr); ok {
return append([]byte{cookiePrefixIP}, udpAddr.IP...)
}
return append([]byte{cookiePrefixString}, []byte(remoteAddr.String())...)
} | [
"func",
"encodeRemoteAddr",
"(",
"remoteAddr",
"net",
".",
"Addr",
")",
"[",
"]",
"byte",
"{",
"if",
"udpAddr",
",",
"ok",
":=",
"remoteAddr",
".",
"(",
"*",
"net",
".",
"UDPAddr",
")",
";",
"ok",
"{",
"return",
"append",
"(",
"[",
"]",
"byte",
"{",
"cookiePrefixIP",
"}",
",",
"udpAddr",
".",
"IP",
"...",
")",
"\n",
"}",
"\n",
"return",
"append",
"(",
"[",
"]",
"byte",
"{",
"cookiePrefixString",
"}",
",",
"[",
"]",
"byte",
"(",
"remoteAddr",
".",
"String",
"(",
")",
")",
"...",
")",
"\n",
"}"
] | // encodeRemoteAddr encodes a remote address such that it can be saved in the Cookie | [
"encodeRemoteAddr",
"encodes",
"a",
"remote",
"address",
"such",
"that",
"it",
"can",
"be",
"saved",
"in",
"the",
"Cookie"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/handshake/cookie_generator.go#L92-L97 | train |
lucas-clemente/quic-go | internal/handshake/cookie_generator.go | decodeRemoteAddr | func decodeRemoteAddr(data []byte) string {
// data will never be empty for a Cookie that we generated. Check it to be on the safe side
if len(data) == 0 {
return ""
}
if data[0] == cookiePrefixIP {
return net.IP(data[1:]).String()
}
return string(data[1:])
} | go | func decodeRemoteAddr(data []byte) string {
// data will never be empty for a Cookie that we generated. Check it to be on the safe side
if len(data) == 0 {
return ""
}
if data[0] == cookiePrefixIP {
return net.IP(data[1:]).String()
}
return string(data[1:])
} | [
"func",
"decodeRemoteAddr",
"(",
"data",
"[",
"]",
"byte",
")",
"string",
"{",
"// data will never be empty for a Cookie that we generated. Check it to be on the safe side",
"if",
"len",
"(",
"data",
")",
"==",
"0",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"if",
"data",
"[",
"0",
"]",
"==",
"cookiePrefixIP",
"{",
"return",
"net",
".",
"IP",
"(",
"data",
"[",
"1",
":",
"]",
")",
".",
"String",
"(",
")",
"\n",
"}",
"\n",
"return",
"string",
"(",
"data",
"[",
"1",
":",
"]",
")",
"\n",
"}"
] | // decodeRemoteAddr decodes the remote address saved in the Cookie | [
"decodeRemoteAddr",
"decodes",
"the",
"remote",
"address",
"saved",
"in",
"the",
"Cookie"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/handshake/cookie_generator.go#L100-L109 | train |
lucas-clemente/quic-go | session.go | handlePacket | func (s *session) handlePacket(p *receivedPacket) {
if s.closed.Get() {
s.handlePacketAfterClosed(p)
}
// Discard packets once the amount of queued packets is larger than
// the channel size, protocol.MaxSessionUnprocessedPackets
select {
case s.receivedPackets <- p:
default:
}
} | go | func (s *session) handlePacket(p *receivedPacket) {
if s.closed.Get() {
s.handlePacketAfterClosed(p)
}
// Discard packets once the amount of queued packets is larger than
// the channel size, protocol.MaxSessionUnprocessedPackets
select {
case s.receivedPackets <- p:
default:
}
} | [
"func",
"(",
"s",
"*",
"session",
")",
"handlePacket",
"(",
"p",
"*",
"receivedPacket",
")",
"{",
"if",
"s",
".",
"closed",
".",
"Get",
"(",
")",
"{",
"s",
".",
"handlePacketAfterClosed",
"(",
"p",
")",
"\n",
"}",
"\n",
"// Discard packets once the amount of queued packets is larger than",
"// the channel size, protocol.MaxSessionUnprocessedPackets",
"select",
"{",
"case",
"s",
".",
"receivedPackets",
"<-",
"p",
":",
"default",
":",
"}",
"\n",
"}"
] | // handlePacket is called by the server with a new packet | [
"handlePacket",
"is",
"called",
"by",
"the",
"server",
"with",
"a",
"new",
"packet"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/session.go#L720-L730 | train |
lucas-clemente/quic-go | session.go | closeLocal | func (s *session) closeLocal(e error) {
s.closeOnce.Do(func() {
if e == nil {
s.logger.Infof("Closing session.")
} else {
s.logger.Errorf("Closing session with error: %s", e)
}
s.sessionRunner.Retire(s.srcConnID)
s.closeChan <- closeError{err: e, sendClose: true, remote: false}
})
} | go | func (s *session) closeLocal(e error) {
s.closeOnce.Do(func() {
if e == nil {
s.logger.Infof("Closing session.")
} else {
s.logger.Errorf("Closing session with error: %s", e)
}
s.sessionRunner.Retire(s.srcConnID)
s.closeChan <- closeError{err: e, sendClose: true, remote: false}
})
} | [
"func",
"(",
"s",
"*",
"session",
")",
"closeLocal",
"(",
"e",
"error",
")",
"{",
"s",
".",
"closeOnce",
".",
"Do",
"(",
"func",
"(",
")",
"{",
"if",
"e",
"==",
"nil",
"{",
"s",
".",
"logger",
".",
"Infof",
"(",
"\"",
"\"",
")",
"\n",
"}",
"else",
"{",
"s",
".",
"logger",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"e",
")",
"\n",
"}",
"\n",
"s",
".",
"sessionRunner",
".",
"Retire",
"(",
"s",
".",
"srcConnID",
")",
"\n",
"s",
".",
"closeChan",
"<-",
"closeError",
"{",
"err",
":",
"e",
",",
"sendClose",
":",
"true",
",",
"remote",
":",
"false",
"}",
"\n",
"}",
")",
"\n",
"}"
] | // closeLocal closes the session and send a CONNECTION_CLOSE containing the error | [
"closeLocal",
"closes",
"the",
"session",
"and",
"send",
"a",
"CONNECTION_CLOSE",
"containing",
"the",
"error"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/session.go#L840-L850 | train |
lucas-clemente/quic-go | session.go | destroy | func (s *session) destroy(e error) {
s.closeOnce.Do(func() {
if nerr, ok := e.(net.Error); ok && nerr.Timeout() {
s.logger.Errorf("Destroying session %s: %s", s.destConnID, e)
} else {
s.logger.Errorf("Destroying session %s with error: %s", s.destConnID, e)
}
s.sessionRunner.Remove(s.srcConnID)
s.closeChan <- closeError{err: e, sendClose: false, remote: false}
})
} | go | func (s *session) destroy(e error) {
s.closeOnce.Do(func() {
if nerr, ok := e.(net.Error); ok && nerr.Timeout() {
s.logger.Errorf("Destroying session %s: %s", s.destConnID, e)
} else {
s.logger.Errorf("Destroying session %s with error: %s", s.destConnID, e)
}
s.sessionRunner.Remove(s.srcConnID)
s.closeChan <- closeError{err: e, sendClose: false, remote: false}
})
} | [
"func",
"(",
"s",
"*",
"session",
")",
"destroy",
"(",
"e",
"error",
")",
"{",
"s",
".",
"closeOnce",
".",
"Do",
"(",
"func",
"(",
")",
"{",
"if",
"nerr",
",",
"ok",
":=",
"e",
".",
"(",
"net",
".",
"Error",
")",
";",
"ok",
"&&",
"nerr",
".",
"Timeout",
"(",
")",
"{",
"s",
".",
"logger",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"s",
".",
"destConnID",
",",
"e",
")",
"\n",
"}",
"else",
"{",
"s",
".",
"logger",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"s",
".",
"destConnID",
",",
"e",
")",
"\n",
"}",
"\n",
"s",
".",
"sessionRunner",
".",
"Remove",
"(",
"s",
".",
"srcConnID",
")",
"\n",
"s",
".",
"closeChan",
"<-",
"closeError",
"{",
"err",
":",
"e",
",",
"sendClose",
":",
"false",
",",
"remote",
":",
"false",
"}",
"\n",
"}",
")",
"\n",
"}"
] | // destroy closes the session without sending the error on the wire | [
"destroy",
"closes",
"the",
"session",
"without",
"sending",
"the",
"error",
"on",
"the",
"wire"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/session.go#L853-L863 | train |
lucas-clemente/quic-go | session.go | closeForRecreating | func (s *session) closeForRecreating() protocol.PacketNumber {
s.destroy(errCloseForRecreating)
nextPN, _ := s.sentPacketHandler.PeekPacketNumber(protocol.EncryptionInitial)
return nextPN
} | go | func (s *session) closeForRecreating() protocol.PacketNumber {
s.destroy(errCloseForRecreating)
nextPN, _ := s.sentPacketHandler.PeekPacketNumber(protocol.EncryptionInitial)
return nextPN
} | [
"func",
"(",
"s",
"*",
"session",
")",
"closeForRecreating",
"(",
")",
"protocol",
".",
"PacketNumber",
"{",
"s",
".",
"destroy",
"(",
"errCloseForRecreating",
")",
"\n",
"nextPN",
",",
"_",
":=",
"s",
".",
"sentPacketHandler",
".",
"PeekPacketNumber",
"(",
"protocol",
".",
"EncryptionInitial",
")",
"\n",
"return",
"nextPN",
"\n",
"}"
] | // closeForRecreating closes the session in order to recreate it immediately afterwards
// It returns the first packet number that should be used in the new session. | [
"closeForRecreating",
"closes",
"the",
"session",
"in",
"order",
"to",
"recreate",
"it",
"immediately",
"afterwards",
"It",
"returns",
"the",
"first",
"packet",
"number",
"that",
"should",
"be",
"used",
"in",
"the",
"new",
"session",
"."
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/session.go#L867-L871 | train |
lucas-clemente/quic-go | session.go | Close | func (s *session) Close() error {
s.closeLocal(nil)
<-s.ctx.Done()
return nil
} | go | func (s *session) Close() error {
s.closeLocal(nil)
<-s.ctx.Done()
return nil
} | [
"func",
"(",
"s",
"*",
"session",
")",
"Close",
"(",
")",
"error",
"{",
"s",
".",
"closeLocal",
"(",
"nil",
")",
"\n",
"<-",
"s",
".",
"ctx",
".",
"Done",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // Close the connection. It sends a qerr.NoError.
// It waits until the run loop has stopped before returning | [
"Close",
"the",
"connection",
".",
"It",
"sends",
"a",
"qerr",
".",
"NoError",
".",
"It",
"waits",
"until",
"the",
"run",
"loop",
"has",
"stopped",
"before",
"returning"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/session.go#L883-L887 | train |
lucas-clemente/quic-go | session.go | maybeSendRetransmission | func (s *session) maybeSendRetransmission() (bool, error) {
retransmitPacket := s.sentPacketHandler.DequeuePacketForRetransmission()
if retransmitPacket == nil {
return false, nil
}
s.logger.Debugf("Dequeueing retransmission for packet 0x%x (%s)", retransmitPacket.PacketNumber, retransmitPacket.EncryptionLevel)
packets, err := s.packer.PackRetransmission(retransmitPacket)
if err != nil {
return false, err
}
ackhandlerPackets := make([]*ackhandler.Packet, len(packets))
for i, packet := range packets {
ackhandlerPackets[i] = packet.ToAckHandlerPacket()
}
s.sentPacketHandler.SentPacketsAsRetransmission(ackhandlerPackets, retransmitPacket.PacketNumber)
for _, packet := range packets {
if err := s.sendPackedPacket(packet); err != nil {
return false, err
}
}
return true, nil
} | go | func (s *session) maybeSendRetransmission() (bool, error) {
retransmitPacket := s.sentPacketHandler.DequeuePacketForRetransmission()
if retransmitPacket == nil {
return false, nil
}
s.logger.Debugf("Dequeueing retransmission for packet 0x%x (%s)", retransmitPacket.PacketNumber, retransmitPacket.EncryptionLevel)
packets, err := s.packer.PackRetransmission(retransmitPacket)
if err != nil {
return false, err
}
ackhandlerPackets := make([]*ackhandler.Packet, len(packets))
for i, packet := range packets {
ackhandlerPackets[i] = packet.ToAckHandlerPacket()
}
s.sentPacketHandler.SentPacketsAsRetransmission(ackhandlerPackets, retransmitPacket.PacketNumber)
for _, packet := range packets {
if err := s.sendPackedPacket(packet); err != nil {
return false, err
}
}
return true, nil
} | [
"func",
"(",
"s",
"*",
"session",
")",
"maybeSendRetransmission",
"(",
")",
"(",
"bool",
",",
"error",
")",
"{",
"retransmitPacket",
":=",
"s",
".",
"sentPacketHandler",
".",
"DequeuePacketForRetransmission",
"(",
")",
"\n",
"if",
"retransmitPacket",
"==",
"nil",
"{",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n\n",
"s",
".",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"retransmitPacket",
".",
"PacketNumber",
",",
"retransmitPacket",
".",
"EncryptionLevel",
")",
"\n",
"packets",
",",
"err",
":=",
"s",
".",
"packer",
".",
"PackRetransmission",
"(",
"retransmitPacket",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"ackhandlerPackets",
":=",
"make",
"(",
"[",
"]",
"*",
"ackhandler",
".",
"Packet",
",",
"len",
"(",
"packets",
")",
")",
"\n",
"for",
"i",
",",
"packet",
":=",
"range",
"packets",
"{",
"ackhandlerPackets",
"[",
"i",
"]",
"=",
"packet",
".",
"ToAckHandlerPacket",
"(",
")",
"\n",
"}",
"\n",
"s",
".",
"sentPacketHandler",
".",
"SentPacketsAsRetransmission",
"(",
"ackhandlerPackets",
",",
"retransmitPacket",
".",
"PacketNumber",
")",
"\n",
"for",
"_",
",",
"packet",
":=",
"range",
"packets",
"{",
"if",
"err",
":=",
"s",
".",
"sendPackedPacket",
"(",
"packet",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"true",
",",
"nil",
"\n",
"}"
] | // maybeSendRetransmission sends retransmissions for at most one packet.
// It takes care that Initials aren't retransmitted, if a packet from the server was already received. | [
"maybeSendRetransmission",
"sends",
"retransmissions",
"for",
"at",
"most",
"one",
"packet",
".",
"It",
"takes",
"care",
"that",
"Initials",
"aren",
"t",
"retransmitted",
"if",
"a",
"packet",
"from",
"the",
"server",
"was",
"already",
"received",
"."
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/session.go#L1049-L1071 | train |
lucas-clemente/quic-go | internal/handshake/cookie_protector.go | newCookieProtector | func newCookieProtector() (cookieProtector, error) {
secret := make([]byte, cookieSecretSize)
if _, err := rand.Read(secret); err != nil {
return nil, err
}
return &cookieProtectorImpl{secret: secret}, nil
} | go | func newCookieProtector() (cookieProtector, error) {
secret := make([]byte, cookieSecretSize)
if _, err := rand.Read(secret); err != nil {
return nil, err
}
return &cookieProtectorImpl{secret: secret}, nil
} | [
"func",
"newCookieProtector",
"(",
")",
"(",
"cookieProtector",
",",
"error",
")",
"{",
"secret",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"cookieSecretSize",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"rand",
".",
"Read",
"(",
"secret",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"cookieProtectorImpl",
"{",
"secret",
":",
"secret",
"}",
",",
"nil",
"\n",
"}"
] | // newCookieProtector creates a source for source address tokens | [
"newCookieProtector",
"creates",
"a",
"source",
"for",
"source",
"address",
"tokens"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/handshake/cookie_protector.go#L33-L39 | train |
lucas-clemente/quic-go | http3/server.go | Serve | func (s *Server) Serve(conn net.PacketConn) error {
return s.serveImpl(s.TLSConfig, conn)
} | go | func (s *Server) Serve(conn net.PacketConn) error {
return s.serveImpl(s.TLSConfig, conn)
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"Serve",
"(",
"conn",
"net",
".",
"PacketConn",
")",
"error",
"{",
"return",
"s",
".",
"serveImpl",
"(",
"s",
".",
"TLSConfig",
",",
"conn",
")",
"\n",
"}"
] | // Serve an existing UDP connection. | [
"Serve",
"an",
"existing",
"UDP",
"connection",
"."
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/http3/server.go#L72-L74 | train |
lucas-clemente/quic-go | http3/server.go | ListenAndServe | func ListenAndServe(addr, certFile, keyFile string, handler http.Handler) error {
// Load certs
var err error
certs := make([]tls.Certificate, 1)
certs[0], err = tls.LoadX509KeyPair(certFile, keyFile)
if err != nil {
return err
}
// We currently only use the cert-related stuff from tls.Config,
// so we don't need to make a full copy.
config := &tls.Config{
Certificates: certs,
}
// Open the listeners
udpAddr, err := net.ResolveUDPAddr("udp", addr)
if err != nil {
return err
}
udpConn, err := net.ListenUDP("udp", udpAddr)
if err != nil {
return err
}
defer udpConn.Close()
tcpAddr, err := net.ResolveTCPAddr("tcp", addr)
if err != nil {
return err
}
tcpConn, err := net.ListenTCP("tcp", tcpAddr)
if err != nil {
return err
}
defer tcpConn.Close()
tlsConn := tls.NewListener(tcpConn, config)
defer tlsConn.Close()
// Start the servers
httpServer := &http.Server{
Addr: addr,
TLSConfig: config,
}
quicServer := &Server{
Server: httpServer,
}
if handler == nil {
handler = http.DefaultServeMux
}
httpServer.Handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
quicServer.SetQuicHeaders(w.Header())
handler.ServeHTTP(w, r)
})
hErr := make(chan error)
qErr := make(chan error)
go func() {
hErr <- httpServer.Serve(tlsConn)
}()
go func() {
qErr <- quicServer.Serve(udpConn)
}()
select {
case err := <-hErr:
quicServer.Close()
return err
case err := <-qErr:
// Cannot close the HTTP server or wait for requests to complete properly :/
return err
}
} | go | func ListenAndServe(addr, certFile, keyFile string, handler http.Handler) error {
// Load certs
var err error
certs := make([]tls.Certificate, 1)
certs[0], err = tls.LoadX509KeyPair(certFile, keyFile)
if err != nil {
return err
}
// We currently only use the cert-related stuff from tls.Config,
// so we don't need to make a full copy.
config := &tls.Config{
Certificates: certs,
}
// Open the listeners
udpAddr, err := net.ResolveUDPAddr("udp", addr)
if err != nil {
return err
}
udpConn, err := net.ListenUDP("udp", udpAddr)
if err != nil {
return err
}
defer udpConn.Close()
tcpAddr, err := net.ResolveTCPAddr("tcp", addr)
if err != nil {
return err
}
tcpConn, err := net.ListenTCP("tcp", tcpAddr)
if err != nil {
return err
}
defer tcpConn.Close()
tlsConn := tls.NewListener(tcpConn, config)
defer tlsConn.Close()
// Start the servers
httpServer := &http.Server{
Addr: addr,
TLSConfig: config,
}
quicServer := &Server{
Server: httpServer,
}
if handler == nil {
handler = http.DefaultServeMux
}
httpServer.Handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
quicServer.SetQuicHeaders(w.Header())
handler.ServeHTTP(w, r)
})
hErr := make(chan error)
qErr := make(chan error)
go func() {
hErr <- httpServer.Serve(tlsConn)
}()
go func() {
qErr <- quicServer.Serve(udpConn)
}()
select {
case err := <-hErr:
quicServer.Close()
return err
case err := <-qErr:
// Cannot close the HTTP server or wait for requests to complete properly :/
return err
}
} | [
"func",
"ListenAndServe",
"(",
"addr",
",",
"certFile",
",",
"keyFile",
"string",
",",
"handler",
"http",
".",
"Handler",
")",
"error",
"{",
"// Load certs",
"var",
"err",
"error",
"\n",
"certs",
":=",
"make",
"(",
"[",
"]",
"tls",
".",
"Certificate",
",",
"1",
")",
"\n",
"certs",
"[",
"0",
"]",
",",
"err",
"=",
"tls",
".",
"LoadX509KeyPair",
"(",
"certFile",
",",
"keyFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"// We currently only use the cert-related stuff from tls.Config,",
"// so we don't need to make a full copy.",
"config",
":=",
"&",
"tls",
".",
"Config",
"{",
"Certificates",
":",
"certs",
",",
"}",
"\n\n",
"// Open the listeners",
"udpAddr",
",",
"err",
":=",
"net",
".",
"ResolveUDPAddr",
"(",
"\"",
"\"",
",",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"udpConn",
",",
"err",
":=",
"net",
".",
"ListenUDP",
"(",
"\"",
"\"",
",",
"udpAddr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"udpConn",
".",
"Close",
"(",
")",
"\n\n",
"tcpAddr",
",",
"err",
":=",
"net",
".",
"ResolveTCPAddr",
"(",
"\"",
"\"",
",",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"tcpConn",
",",
"err",
":=",
"net",
".",
"ListenTCP",
"(",
"\"",
"\"",
",",
"tcpAddr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"tcpConn",
".",
"Close",
"(",
")",
"\n\n",
"tlsConn",
":=",
"tls",
".",
"NewListener",
"(",
"tcpConn",
",",
"config",
")",
"\n",
"defer",
"tlsConn",
".",
"Close",
"(",
")",
"\n\n",
"// Start the servers",
"httpServer",
":=",
"&",
"http",
".",
"Server",
"{",
"Addr",
":",
"addr",
",",
"TLSConfig",
":",
"config",
",",
"}",
"\n\n",
"quicServer",
":=",
"&",
"Server",
"{",
"Server",
":",
"httpServer",
",",
"}",
"\n\n",
"if",
"handler",
"==",
"nil",
"{",
"handler",
"=",
"http",
".",
"DefaultServeMux",
"\n",
"}",
"\n",
"httpServer",
".",
"Handler",
"=",
"http",
".",
"HandlerFunc",
"(",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"quicServer",
".",
"SetQuicHeaders",
"(",
"w",
".",
"Header",
"(",
")",
")",
"\n",
"handler",
".",
"ServeHTTP",
"(",
"w",
",",
"r",
")",
"\n",
"}",
")",
"\n\n",
"hErr",
":=",
"make",
"(",
"chan",
"error",
")",
"\n",
"qErr",
":=",
"make",
"(",
"chan",
"error",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"hErr",
"<-",
"httpServer",
".",
"Serve",
"(",
"tlsConn",
")",
"\n",
"}",
"(",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"qErr",
"<-",
"quicServer",
".",
"Serve",
"(",
"udpConn",
")",
"\n",
"}",
"(",
")",
"\n\n",
"select",
"{",
"case",
"err",
":=",
"<-",
"hErr",
":",
"quicServer",
".",
"Close",
"(",
")",
"\n",
"return",
"err",
"\n",
"case",
"err",
":=",
"<-",
"qErr",
":",
"// Cannot close the HTTP server or wait for requests to complete properly :/",
"return",
"err",
"\n",
"}",
"\n",
"}"
] | // ListenAndServe listens on the given network address for both, TLS and QUIC
// connetions in parallel. It returns if one of the two returns an error.
// http.DefaultServeMux is used when handler is nil.
// The correct Alt-Svc headers for QUIC are set. | [
"ListenAndServe",
"listens",
"on",
"the",
"given",
"network",
"address",
"for",
"both",
"TLS",
"and",
"QUIC",
"connetions",
"in",
"parallel",
".",
"It",
"returns",
"if",
"one",
"of",
"the",
"two",
"returns",
"an",
"error",
".",
"http",
".",
"DefaultServeMux",
"is",
"used",
"when",
"handler",
"is",
"nil",
".",
"The",
"correct",
"Alt",
"-",
"Svc",
"headers",
"for",
"QUIC",
"are",
"set",
"."
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/http3/server.go#L282-L355 | train |
lucas-clemente/quic-go | example/echo/echo.go | main | func main() {
go func() { log.Fatal(echoServer()) }()
err := clientMain()
if err != nil {
panic(err)
}
} | go | func main() {
go func() { log.Fatal(echoServer()) }()
err := clientMain()
if err != nil {
panic(err)
}
} | [
"func",
"main",
"(",
")",
"{",
"go",
"func",
"(",
")",
"{",
"log",
".",
"Fatal",
"(",
"echoServer",
"(",
")",
")",
"}",
"(",
")",
"\n\n",
"err",
":=",
"clientMain",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"}"
] | // We start a server echoing data on the first stream the client opens,
// then connect with a client, send the message, and wait for its receipt. | [
"We",
"start",
"a",
"server",
"echoing",
"data",
"on",
"the",
"first",
"stream",
"the",
"client",
"opens",
"then",
"connect",
"with",
"a",
"client",
"send",
"the",
"message",
"and",
"wait",
"for",
"its",
"receipt",
"."
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/example/echo/echo.go#L23-L30 | train |
lucas-clemente/quic-go | example/echo/echo.go | echoServer | func echoServer() error {
listener, err := quic.ListenAddr(addr, generateTLSConfig(), nil)
if err != nil {
return err
}
sess, err := listener.Accept()
if err != nil {
return err
}
stream, err := sess.AcceptStream()
if err != nil {
panic(err)
}
// Echo through the loggingWriter
_, err = io.Copy(loggingWriter{stream}, stream)
return err
} | go | func echoServer() error {
listener, err := quic.ListenAddr(addr, generateTLSConfig(), nil)
if err != nil {
return err
}
sess, err := listener.Accept()
if err != nil {
return err
}
stream, err := sess.AcceptStream()
if err != nil {
panic(err)
}
// Echo through the loggingWriter
_, err = io.Copy(loggingWriter{stream}, stream)
return err
} | [
"func",
"echoServer",
"(",
")",
"error",
"{",
"listener",
",",
"err",
":=",
"quic",
".",
"ListenAddr",
"(",
"addr",
",",
"generateTLSConfig",
"(",
")",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"sess",
",",
"err",
":=",
"listener",
".",
"Accept",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"stream",
",",
"err",
":=",
"sess",
".",
"AcceptStream",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"// Echo through the loggingWriter",
"_",
",",
"err",
"=",
"io",
".",
"Copy",
"(",
"loggingWriter",
"{",
"stream",
"}",
",",
"stream",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Start a server that echos all data on the first stream opened by the client | [
"Start",
"a",
"server",
"that",
"echos",
"all",
"data",
"on",
"the",
"first",
"stream",
"opened",
"by",
"the",
"client"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/example/echo/echo.go#L33-L49 | train |
lucas-clemente/quic-go | example/echo/echo.go | generateTLSConfig | func generateTLSConfig() *tls.Config {
key, err := rsa.GenerateKey(rand.Reader, 1024)
if err != nil {
panic(err)
}
template := x509.Certificate{SerialNumber: big.NewInt(1)}
certDER, err := x509.CreateCertificate(rand.Reader, &template, &template, &key.PublicKey, key)
if err != nil {
panic(err)
}
keyPEM := pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(key)})
certPEM := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: certDER})
tlsCert, err := tls.X509KeyPair(certPEM, keyPEM)
if err != nil {
panic(err)
}
return &tls.Config{Certificates: []tls.Certificate{tlsCert}}
} | go | func generateTLSConfig() *tls.Config {
key, err := rsa.GenerateKey(rand.Reader, 1024)
if err != nil {
panic(err)
}
template := x509.Certificate{SerialNumber: big.NewInt(1)}
certDER, err := x509.CreateCertificate(rand.Reader, &template, &template, &key.PublicKey, key)
if err != nil {
panic(err)
}
keyPEM := pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(key)})
certPEM := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: certDER})
tlsCert, err := tls.X509KeyPair(certPEM, keyPEM)
if err != nil {
panic(err)
}
return &tls.Config{Certificates: []tls.Certificate{tlsCert}}
} | [
"func",
"generateTLSConfig",
"(",
")",
"*",
"tls",
".",
"Config",
"{",
"key",
",",
"err",
":=",
"rsa",
".",
"GenerateKey",
"(",
"rand",
".",
"Reader",
",",
"1024",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"template",
":=",
"x509",
".",
"Certificate",
"{",
"SerialNumber",
":",
"big",
".",
"NewInt",
"(",
"1",
")",
"}",
"\n",
"certDER",
",",
"err",
":=",
"x509",
".",
"CreateCertificate",
"(",
"rand",
".",
"Reader",
",",
"&",
"template",
",",
"&",
"template",
",",
"&",
"key",
".",
"PublicKey",
",",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"keyPEM",
":=",
"pem",
".",
"EncodeToMemory",
"(",
"&",
"pem",
".",
"Block",
"{",
"Type",
":",
"\"",
"\"",
",",
"Bytes",
":",
"x509",
".",
"MarshalPKCS1PrivateKey",
"(",
"key",
")",
"}",
")",
"\n",
"certPEM",
":=",
"pem",
".",
"EncodeToMemory",
"(",
"&",
"pem",
".",
"Block",
"{",
"Type",
":",
"\"",
"\"",
",",
"Bytes",
":",
"certDER",
"}",
")",
"\n\n",
"tlsCert",
",",
"err",
":=",
"tls",
".",
"X509KeyPair",
"(",
"certPEM",
",",
"keyPEM",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"tls",
".",
"Config",
"{",
"Certificates",
":",
"[",
"]",
"tls",
".",
"Certificate",
"{",
"tlsCert",
"}",
"}",
"\n",
"}"
] | // Setup a bare-bones TLS config for the server | [
"Setup",
"a",
"bare",
"-",
"bones",
"TLS",
"config",
"for",
"the",
"server"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/example/echo/echo.go#L87-L105 | train |
lucas-clemente/quic-go | crypto_stream.go | GetCryptoData | func (s *cryptoStreamImpl) GetCryptoData() []byte {
if len(s.msgBuf) < 4 {
return nil
}
msgLen := 4 + int(s.msgBuf[1])<<16 + int(s.msgBuf[2])<<8 + int(s.msgBuf[3])
if len(s.msgBuf) < msgLen {
return nil
}
msg := make([]byte, msgLen)
copy(msg, s.msgBuf[:msgLen])
s.msgBuf = s.msgBuf[msgLen:]
return msg
} | go | func (s *cryptoStreamImpl) GetCryptoData() []byte {
if len(s.msgBuf) < 4 {
return nil
}
msgLen := 4 + int(s.msgBuf[1])<<16 + int(s.msgBuf[2])<<8 + int(s.msgBuf[3])
if len(s.msgBuf) < msgLen {
return nil
}
msg := make([]byte, msgLen)
copy(msg, s.msgBuf[:msgLen])
s.msgBuf = s.msgBuf[msgLen:]
return msg
} | [
"func",
"(",
"s",
"*",
"cryptoStreamImpl",
")",
"GetCryptoData",
"(",
")",
"[",
"]",
"byte",
"{",
"if",
"len",
"(",
"s",
".",
"msgBuf",
")",
"<",
"4",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"msgLen",
":=",
"4",
"+",
"int",
"(",
"s",
".",
"msgBuf",
"[",
"1",
"]",
")",
"<<",
"16",
"+",
"int",
"(",
"s",
".",
"msgBuf",
"[",
"2",
"]",
")",
"<<",
"8",
"+",
"int",
"(",
"s",
".",
"msgBuf",
"[",
"3",
"]",
")",
"\n",
"if",
"len",
"(",
"s",
".",
"msgBuf",
")",
"<",
"msgLen",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"msg",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"msgLen",
")",
"\n",
"copy",
"(",
"msg",
",",
"s",
".",
"msgBuf",
"[",
":",
"msgLen",
"]",
")",
"\n",
"s",
".",
"msgBuf",
"=",
"s",
".",
"msgBuf",
"[",
"msgLen",
":",
"]",
"\n",
"return",
"msg",
"\n",
"}"
] | // GetCryptoData retrieves data that was received in CRYPTO frames | [
"GetCryptoData",
"retrieves",
"data",
"that",
"was",
"received",
"in",
"CRYPTO",
"frames"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/crypto_stream.go#L96-L108 | train |
lucas-clemente/quic-go | crypto_stream.go | Write | func (s *cryptoStreamImpl) Write(p []byte) (int, error) {
s.writeBuf = append(s.writeBuf, p...)
return len(p), nil
} | go | func (s *cryptoStreamImpl) Write(p []byte) (int, error) {
s.writeBuf = append(s.writeBuf, p...)
return len(p), nil
} | [
"func",
"(",
"s",
"*",
"cryptoStreamImpl",
")",
"Write",
"(",
"p",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"s",
".",
"writeBuf",
"=",
"append",
"(",
"s",
".",
"writeBuf",
",",
"p",
"...",
")",
"\n",
"return",
"len",
"(",
"p",
")",
",",
"nil",
"\n",
"}"
] | // Writes writes data that should be sent out in CRYPTO frames | [
"Writes",
"writes",
"data",
"that",
"should",
"be",
"sent",
"out",
"in",
"CRYPTO",
"frames"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/crypto_stream.go#L119-L122 | train |
lucas-clemente/quic-go | internal/wire/stop_sending_frame.go | parseStopSendingFrame | func parseStopSendingFrame(r *bytes.Reader, _ protocol.VersionNumber) (*StopSendingFrame, error) {
if _, err := r.ReadByte(); err != nil {
return nil, err
}
streamID, err := utils.ReadVarInt(r)
if err != nil {
return nil, err
}
errorCode, err := utils.BigEndian.ReadUint16(r)
if err != nil {
return nil, err
}
return &StopSendingFrame{
StreamID: protocol.StreamID(streamID),
ErrorCode: protocol.ApplicationErrorCode(errorCode),
}, nil
} | go | func parseStopSendingFrame(r *bytes.Reader, _ protocol.VersionNumber) (*StopSendingFrame, error) {
if _, err := r.ReadByte(); err != nil {
return nil, err
}
streamID, err := utils.ReadVarInt(r)
if err != nil {
return nil, err
}
errorCode, err := utils.BigEndian.ReadUint16(r)
if err != nil {
return nil, err
}
return &StopSendingFrame{
StreamID: protocol.StreamID(streamID),
ErrorCode: protocol.ApplicationErrorCode(errorCode),
}, nil
} | [
"func",
"parseStopSendingFrame",
"(",
"r",
"*",
"bytes",
".",
"Reader",
",",
"_",
"protocol",
".",
"VersionNumber",
")",
"(",
"*",
"StopSendingFrame",
",",
"error",
")",
"{",
"if",
"_",
",",
"err",
":=",
"r",
".",
"ReadByte",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"streamID",
",",
"err",
":=",
"utils",
".",
"ReadVarInt",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"errorCode",
",",
"err",
":=",
"utils",
".",
"BigEndian",
".",
"ReadUint16",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"StopSendingFrame",
"{",
"StreamID",
":",
"protocol",
".",
"StreamID",
"(",
"streamID",
")",
",",
"ErrorCode",
":",
"protocol",
".",
"ApplicationErrorCode",
"(",
"errorCode",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] | // parseStopSendingFrame parses a STOP_SENDING frame | [
"parseStopSendingFrame",
"parses",
"a",
"STOP_SENDING",
"frame"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/wire/stop_sending_frame.go#L17-L35 | train |
lucas-clemente/quic-go | internal/wire/frame_parser.go | ParseNext | func (p *frameParser) ParseNext(r *bytes.Reader, encLevel protocol.EncryptionLevel) (Frame, error) {
for r.Len() != 0 {
typeByte, _ := r.ReadByte()
if typeByte == 0x0 { // PADDING frame
continue
}
r.UnreadByte()
return p.parseFrame(r, typeByte, encLevel)
}
return nil, nil
} | go | func (p *frameParser) ParseNext(r *bytes.Reader, encLevel protocol.EncryptionLevel) (Frame, error) {
for r.Len() != 0 {
typeByte, _ := r.ReadByte()
if typeByte == 0x0 { // PADDING frame
continue
}
r.UnreadByte()
return p.parseFrame(r, typeByte, encLevel)
}
return nil, nil
} | [
"func",
"(",
"p",
"*",
"frameParser",
")",
"ParseNext",
"(",
"r",
"*",
"bytes",
".",
"Reader",
",",
"encLevel",
"protocol",
".",
"EncryptionLevel",
")",
"(",
"Frame",
",",
"error",
")",
"{",
"for",
"r",
".",
"Len",
"(",
")",
"!=",
"0",
"{",
"typeByte",
",",
"_",
":=",
"r",
".",
"ReadByte",
"(",
")",
"\n",
"if",
"typeByte",
"==",
"0x0",
"{",
"// PADDING frame",
"continue",
"\n",
"}",
"\n",
"r",
".",
"UnreadByte",
"(",
")",
"\n\n",
"return",
"p",
".",
"parseFrame",
"(",
"r",
",",
"typeByte",
",",
"encLevel",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"nil",
"\n",
"}"
] | // ParseNextFrame parses the next frame
// It skips PADDING frames. | [
"ParseNextFrame",
"parses",
"the",
"next",
"frame",
"It",
"skips",
"PADDING",
"frames",
"."
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/wire/frame_parser.go#L24-L35 | train |
lucas-clemente/quic-go | receive_stream.go | Read | func (s *receiveStream) Read(p []byte) (int, error) {
s.mutex.Lock()
completed, n, err := s.readImpl(p)
s.mutex.Unlock()
if completed {
s.streamCompleted()
}
return n, err
} | go | func (s *receiveStream) Read(p []byte) (int, error) {
s.mutex.Lock()
completed, n, err := s.readImpl(p)
s.mutex.Unlock()
if completed {
s.streamCompleted()
}
return n, err
} | [
"func",
"(",
"s",
"*",
"receiveStream",
")",
"Read",
"(",
"p",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"s",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"completed",
",",
"n",
",",
"err",
":=",
"s",
".",
"readImpl",
"(",
"p",
")",
"\n",
"s",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"completed",
"{",
"s",
".",
"streamCompleted",
"(",
")",
"\n",
"}",
"\n",
"return",
"n",
",",
"err",
"\n",
"}"
] | // Read implements io.Reader. It is not thread safe! | [
"Read",
"implements",
"io",
".",
"Reader",
".",
"It",
"is",
"not",
"thread",
"safe!"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/receive_stream.go#L80-L89 | train |
lucas-clemente/quic-go | internal/mocks/quic/session.go | NewMockSession | func NewMockSession(ctrl *gomock.Controller) *MockSession {
mock := &MockSession{ctrl: ctrl}
mock.recorder = &MockSessionMockRecorder{mock}
return mock
} | go | func NewMockSession(ctrl *gomock.Controller) *MockSession {
mock := &MockSession{ctrl: ctrl}
mock.recorder = &MockSessionMockRecorder{mock}
return mock
} | [
"func",
"NewMockSession",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockSession",
"{",
"mock",
":=",
"&",
"MockSession",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockSessionMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockSession creates a new mock instance | [
"NewMockSession",
"creates",
"a",
"new",
"mock",
"instance"
] | c135b4f1e34c621c24563def836af2c04af90ae6 | https://github.com/lucas-clemente/quic-go/blob/c135b4f1e34c621c24563def836af2c04af90ae6/internal/mocks/quic/session.go#L30-L34 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.