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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
gliderlabs/logspout | healthcheck/healthcheck.go | HealthCheck | func HealthCheck() http.Handler {
r := mux.NewRouter()
r.HandleFunc("/health", func(w http.ResponseWriter, req *http.Request) {
w.Write([]byte("Healthy!\n"))
})
return r
} | go | func HealthCheck() http.Handler {
r := mux.NewRouter()
r.HandleFunc("/health", func(w http.ResponseWriter, req *http.Request) {
w.Write([]byte("Healthy!\n"))
})
return r
} | [
"func",
"HealthCheck",
"(",
")",
"http",
".",
"Handler",
"{",
"r",
":=",
"mux",
".",
"NewRouter",
"(",
")",
"\n",
"r",
".",
"HandleFunc",
"(",
"\"",
"\"",
",",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
")",
"{",
"w",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"\"",
"\\n",
"\"",
")",
")",
"\n",
"}",
")",
"\n",
"return",
"r",
"\n",
"}"
] | // HealthCheck returns a http.Handler for the health check | [
"HealthCheck",
"returns",
"a",
"http",
".",
"Handler",
"for",
"the",
"health",
"check"
] | 29d77641f9664a74fafea2ce655f610d796a63d4 | https://github.com/gliderlabs/logspout/blob/29d77641f9664a74fafea2ce655f610d796a63d4/healthcheck/healthcheck.go#L15-L21 | train |
gliderlabs/logspout | router/types.go | AdapterTransport | func (r *Route) AdapterTransport(dfault string) string {
parts := strings.Split(r.Adapter, "+")
if len(parts) > 1 {
return parts[1]
}
return dfault
} | go | func (r *Route) AdapterTransport(dfault string) string {
parts := strings.Split(r.Adapter, "+")
if len(parts) > 1 {
return parts[1]
}
return dfault
} | [
"func",
"(",
"r",
"*",
"Route",
")",
"AdapterTransport",
"(",
"dfault",
"string",
")",
"string",
"{",
"parts",
":=",
"strings",
".",
"Split",
"(",
"r",
".",
"Adapter",
",",
"\"",
"\"",
")",
"\n",
"if",
"len",
"(",
"parts",
")",
">",
"1",
"{",
"return",
"parts",
"[",
"1",
"]",
"\n",
"}",
"\n",
"return",
"dfault",
"\n",
"}"
] | // AdapterTransport returns a route's adapter transport string | [
"AdapterTransport",
"returns",
"a",
"route",
"s",
"adapter",
"transport",
"string"
] | 29d77641f9664a74fafea2ce655f610d796a63d4 | https://github.com/gliderlabs/logspout/blob/29d77641f9664a74fafea2ce655f610d796a63d4/router/types.go#L81-L87 | train |
gliderlabs/logspout | router/types.go | Closer | func (r *Route) Closer() <-chan bool {
if r.closerRcv != nil {
return r.closerRcv
}
return r.closer
} | go | func (r *Route) Closer() <-chan bool {
if r.closerRcv != nil {
return r.closerRcv
}
return r.closer
} | [
"func",
"(",
"r",
"*",
"Route",
")",
"Closer",
"(",
")",
"<-",
"chan",
"bool",
"{",
"if",
"r",
".",
"closerRcv",
"!=",
"nil",
"{",
"return",
"r",
".",
"closerRcv",
"\n",
"}",
"\n",
"return",
"r",
".",
"closer",
"\n",
"}"
] | // Closer returns a route's closerRcv | [
"Closer",
"returns",
"a",
"route",
"s",
"closerRcv"
] | 29d77641f9664a74fafea2ce655f610d796a63d4 | https://github.com/gliderlabs/logspout/blob/29d77641f9664a74fafea2ce655f610d796a63d4/router/types.go#L90-L95 | train |
gliderlabs/logspout | router/types.go | MultiContainer | func (r *Route) MultiContainer() bool {
return r.matchAll() || strings.Contains(r.FilterName, "*")
} | go | func (r *Route) MultiContainer() bool {
return r.matchAll() || strings.Contains(r.FilterName, "*")
} | [
"func",
"(",
"r",
"*",
"Route",
")",
"MultiContainer",
"(",
")",
"bool",
"{",
"return",
"r",
".",
"matchAll",
"(",
")",
"||",
"strings",
".",
"Contains",
"(",
"r",
".",
"FilterName",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // MultiContainer returns whether the Route is matching multiple containers or not | [
"MultiContainer",
"returns",
"whether",
"the",
"Route",
"is",
"matching",
"multiple",
"containers",
"or",
"not"
] | 29d77641f9664a74fafea2ce655f610d796a63d4 | https://github.com/gliderlabs/logspout/blob/29d77641f9664a74fafea2ce655f610d796a63d4/router/types.go#L115-L117 | train |
gliderlabs/logspout | router/types.go | MatchContainer | func (r *Route) MatchContainer(id, name string, labels map[string]string) bool {
if r.matchAll() {
return true
}
if r.FilterID != "" && !strings.HasPrefix(id, r.FilterID) {
return false
}
match, err := path.Match(r.FilterName, name)
if err != nil || (r.FilterName != "" && !match) {
return false
}
for _, label := range r.FilterLabels {
labelParts := strings.SplitN(label, ":", 2)
if len(labelParts) > 1 {
labelKey := labelParts[0]
labelValue := labelParts[1]
labelMatch, labelErr := path.Match(labelValue, labels[labelKey])
if labelErr != nil || (labelValue != "" && !labelMatch) {
return false
}
}
}
return true
} | go | func (r *Route) MatchContainer(id, name string, labels map[string]string) bool {
if r.matchAll() {
return true
}
if r.FilterID != "" && !strings.HasPrefix(id, r.FilterID) {
return false
}
match, err := path.Match(r.FilterName, name)
if err != nil || (r.FilterName != "" && !match) {
return false
}
for _, label := range r.FilterLabels {
labelParts := strings.SplitN(label, ":", 2)
if len(labelParts) > 1 {
labelKey := labelParts[0]
labelValue := labelParts[1]
labelMatch, labelErr := path.Match(labelValue, labels[labelKey])
if labelErr != nil || (labelValue != "" && !labelMatch) {
return false
}
}
}
return true
} | [
"func",
"(",
"r",
"*",
"Route",
")",
"MatchContainer",
"(",
"id",
",",
"name",
"string",
",",
"labels",
"map",
"[",
"string",
"]",
"string",
")",
"bool",
"{",
"if",
"r",
".",
"matchAll",
"(",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"if",
"r",
".",
"FilterID",
"!=",
"\"",
"\"",
"&&",
"!",
"strings",
".",
"HasPrefix",
"(",
"id",
",",
"r",
".",
"FilterID",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"match",
",",
"err",
":=",
"path",
".",
"Match",
"(",
"r",
".",
"FilterName",
",",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"||",
"(",
"r",
".",
"FilterName",
"!=",
"\"",
"\"",
"&&",
"!",
"match",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"for",
"_",
",",
"label",
":=",
"range",
"r",
".",
"FilterLabels",
"{",
"labelParts",
":=",
"strings",
".",
"SplitN",
"(",
"label",
",",
"\"",
"\"",
",",
"2",
")",
"\n",
"if",
"len",
"(",
"labelParts",
")",
">",
"1",
"{",
"labelKey",
":=",
"labelParts",
"[",
"0",
"]",
"\n",
"labelValue",
":=",
"labelParts",
"[",
"1",
"]",
"\n",
"labelMatch",
",",
"labelErr",
":=",
"path",
".",
"Match",
"(",
"labelValue",
",",
"labels",
"[",
"labelKey",
"]",
")",
"\n",
"if",
"labelErr",
"!=",
"nil",
"||",
"(",
"labelValue",
"!=",
"\"",
"\"",
"&&",
"!",
"labelMatch",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"true",
"\n",
"}"
] | // MatchContainer returns whether the Route is responsible for a given container | [
"MatchContainer",
"returns",
"whether",
"the",
"Route",
"is",
"responsible",
"for",
"a",
"given",
"container"
] | 29d77641f9664a74fafea2ce655f610d796a63d4 | https://github.com/gliderlabs/logspout/blob/29d77641f9664a74fafea2ce655f610d796a63d4/router/types.go#L120-L144 | train |
gliderlabs/logspout | router/types.go | MatchMessage | func (r *Route) MatchMessage(message *Message) bool {
if r.matchAll() {
return true
}
if len(r.FilterSources) > 0 && !contains(r.FilterSources, message.Source) {
return false
}
return true
} | go | func (r *Route) MatchMessage(message *Message) bool {
if r.matchAll() {
return true
}
if len(r.FilterSources) > 0 && !contains(r.FilterSources, message.Source) {
return false
}
return true
} | [
"func",
"(",
"r",
"*",
"Route",
")",
"MatchMessage",
"(",
"message",
"*",
"Message",
")",
"bool",
"{",
"if",
"r",
".",
"matchAll",
"(",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"if",
"len",
"(",
"r",
".",
"FilterSources",
")",
">",
"0",
"&&",
"!",
"contains",
"(",
"r",
".",
"FilterSources",
",",
"message",
".",
"Source",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] | // MatchMessage returns whether the Route is responsible for a given Message | [
"MatchMessage",
"returns",
"whether",
"the",
"Route",
"is",
"responsible",
"for",
"a",
"given",
"Message"
] | 29d77641f9664a74fafea2ce655f610d796a63d4 | https://github.com/gliderlabs/logspout/blob/29d77641f9664a74fafea2ce655f610d796a63d4/router/types.go#L147-L155 | train |
gliderlabs/logspout | router/persist.go | Remove | func (fs RouteFileStore) Remove(id string) bool {
if _, err := os.Stat(fs.Filename(id)); err == nil {
if err := os.Remove(fs.Filename(id)); err != nil {
return true
}
}
return false
} | go | func (fs RouteFileStore) Remove(id string) bool {
if _, err := os.Stat(fs.Filename(id)); err == nil {
if err := os.Remove(fs.Filename(id)); err != nil {
return true
}
}
return false
} | [
"func",
"(",
"fs",
"RouteFileStore",
")",
"Remove",
"(",
"id",
"string",
")",
"bool",
"{",
"if",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"fs",
".",
"Filename",
"(",
"id",
")",
")",
";",
"err",
"==",
"nil",
"{",
"if",
"err",
":=",
"os",
".",
"Remove",
"(",
"fs",
".",
"Filename",
"(",
"id",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // Remove removes route from the RouteFileStore based on id | [
"Remove",
"removes",
"route",
"from",
"the",
"RouteFileStore",
"based",
"on",
"id"
] | 29d77641f9664a74fafea2ce655f610d796a63d4 | https://github.com/gliderlabs/logspout/blob/29d77641f9664a74fafea2ce655f610d796a63d4/router/persist.go#L58-L65 | train |
gliderlabs/logspout | router/routes.go | Load | func (rm *RouteManager) Load(persistor RouteStore) error {
routes, err := persistor.GetAll()
if err != nil {
return err
}
for _, route := range routes {
rm.Add(route)
}
rm.persistor = persistor
return nil
} | go | func (rm *RouteManager) Load(persistor RouteStore) error {
routes, err := persistor.GetAll()
if err != nil {
return err
}
for _, route := range routes {
rm.Add(route)
}
rm.persistor = persistor
return nil
} | [
"func",
"(",
"rm",
"*",
"RouteManager",
")",
"Load",
"(",
"persistor",
"RouteStore",
")",
"error",
"{",
"routes",
",",
"err",
":=",
"persistor",
".",
"GetAll",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"for",
"_",
",",
"route",
":=",
"range",
"routes",
"{",
"rm",
".",
"Add",
"(",
"route",
")",
"\n",
"}",
"\n",
"rm",
".",
"persistor",
"=",
"persistor",
"\n",
"return",
"nil",
"\n",
"}"
] | // Load loads all route from a RouteStore | [
"Load",
"loads",
"all",
"route",
"from",
"a",
"RouteStore"
] | 29d77641f9664a74fafea2ce655f610d796a63d4 | https://github.com/gliderlabs/logspout/blob/29d77641f9664a74fafea2ce655f610d796a63d4/router/routes.go#L35-L45 | train |
gliderlabs/logspout | router/routes.go | Get | func (rm *RouteManager) Get(id string) (*Route, error) {
rm.Lock()
defer rm.Unlock()
route, ok := rm.routes[id]
if !ok {
return nil, os.ErrNotExist
}
return route, nil
} | go | func (rm *RouteManager) Get(id string) (*Route, error) {
rm.Lock()
defer rm.Unlock()
route, ok := rm.routes[id]
if !ok {
return nil, os.ErrNotExist
}
return route, nil
} | [
"func",
"(",
"rm",
"*",
"RouteManager",
")",
"Get",
"(",
"id",
"string",
")",
"(",
"*",
"Route",
",",
"error",
")",
"{",
"rm",
".",
"Lock",
"(",
")",
"\n",
"defer",
"rm",
".",
"Unlock",
"(",
")",
"\n",
"route",
",",
"ok",
":=",
"rm",
".",
"routes",
"[",
"id",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"os",
".",
"ErrNotExist",
"\n",
"}",
"\n",
"return",
"route",
",",
"nil",
"\n",
"}"
] | // Get returns a Route based on id | [
"Get",
"returns",
"a",
"Route",
"based",
"on",
"id"
] | 29d77641f9664a74fafea2ce655f610d796a63d4 | https://github.com/gliderlabs/logspout/blob/29d77641f9664a74fafea2ce655f610d796a63d4/router/routes.go#L48-L56 | train |
gliderlabs/logspout | router/routes.go | GetAll | func (rm *RouteManager) GetAll() ([]*Route, error) {
rm.Lock()
defer rm.Unlock()
routes := make([]*Route, 0)
for _, route := range rm.routes {
routes = append(routes, route)
}
return routes, nil
} | go | func (rm *RouteManager) GetAll() ([]*Route, error) {
rm.Lock()
defer rm.Unlock()
routes := make([]*Route, 0)
for _, route := range rm.routes {
routes = append(routes, route)
}
return routes, nil
} | [
"func",
"(",
"rm",
"*",
"RouteManager",
")",
"GetAll",
"(",
")",
"(",
"[",
"]",
"*",
"Route",
",",
"error",
")",
"{",
"rm",
".",
"Lock",
"(",
")",
"\n",
"defer",
"rm",
".",
"Unlock",
"(",
")",
"\n",
"routes",
":=",
"make",
"(",
"[",
"]",
"*",
"Route",
",",
"0",
")",
"\n",
"for",
"_",
",",
"route",
":=",
"range",
"rm",
".",
"routes",
"{",
"routes",
"=",
"append",
"(",
"routes",
",",
"route",
")",
"\n",
"}",
"\n",
"return",
"routes",
",",
"nil",
"\n",
"}"
] | // GetAll returns all routes in the RouteManager | [
"GetAll",
"returns",
"all",
"routes",
"in",
"the",
"RouteManager"
] | 29d77641f9664a74fafea2ce655f610d796a63d4 | https://github.com/gliderlabs/logspout/blob/29d77641f9664a74fafea2ce655f610d796a63d4/router/routes.go#L59-L67 | train |
gliderlabs/logspout | router/routes.go | Remove | func (rm *RouteManager) Remove(id string) bool {
rm.Lock()
defer rm.Unlock()
route, ok := rm.routes[id]
if ok && route.closer != nil {
route.closer <- true
}
delete(rm.routes, id)
if rm.persistor != nil {
rm.persistor.Remove(id)
}
return ok
} | go | func (rm *RouteManager) Remove(id string) bool {
rm.Lock()
defer rm.Unlock()
route, ok := rm.routes[id]
if ok && route.closer != nil {
route.closer <- true
}
delete(rm.routes, id)
if rm.persistor != nil {
rm.persistor.Remove(id)
}
return ok
} | [
"func",
"(",
"rm",
"*",
"RouteManager",
")",
"Remove",
"(",
"id",
"string",
")",
"bool",
"{",
"rm",
".",
"Lock",
"(",
")",
"\n",
"defer",
"rm",
".",
"Unlock",
"(",
")",
"\n",
"route",
",",
"ok",
":=",
"rm",
".",
"routes",
"[",
"id",
"]",
"\n",
"if",
"ok",
"&&",
"route",
".",
"closer",
"!=",
"nil",
"{",
"route",
".",
"closer",
"<-",
"true",
"\n",
"}",
"\n",
"delete",
"(",
"rm",
".",
"routes",
",",
"id",
")",
"\n",
"if",
"rm",
".",
"persistor",
"!=",
"nil",
"{",
"rm",
".",
"persistor",
".",
"Remove",
"(",
"id",
")",
"\n",
"}",
"\n",
"return",
"ok",
"\n",
"}"
] | // Remove removes a route from a RouteManager based on id | [
"Remove",
"removes",
"a",
"route",
"from",
"a",
"RouteManager",
"based",
"on",
"id"
] | 29d77641f9664a74fafea2ce655f610d796a63d4 | https://github.com/gliderlabs/logspout/blob/29d77641f9664a74fafea2ce655f610d796a63d4/router/routes.go#L70-L82 | train |
gliderlabs/logspout | router/routes.go | AddFromURI | func (rm *RouteManager) AddFromURI(uri string) error {
expandedRoute := os.ExpandEnv(uri)
u, err := url.Parse(expandedRoute)
if err != nil {
return err
}
r := &Route{
Address: u.Host,
Adapter: u.Scheme,
Options: make(map[string]string),
}
if u.RawQuery != "" {
params, err := url.ParseQuery(u.RawQuery)
if err != nil {
return err
}
for key := range params {
value := params.Get(key)
switch key {
case "filter.id":
r.FilterID = value
case "filter.name":
r.FilterName = value
case "filter.labels":
r.FilterLabels = strings.Split(value, ",")
case "filter.sources":
r.FilterSources = strings.Split(value, ",")
default:
r.Options[key] = value
}
}
}
return rm.Add(r)
} | go | func (rm *RouteManager) AddFromURI(uri string) error {
expandedRoute := os.ExpandEnv(uri)
u, err := url.Parse(expandedRoute)
if err != nil {
return err
}
r := &Route{
Address: u.Host,
Adapter: u.Scheme,
Options: make(map[string]string),
}
if u.RawQuery != "" {
params, err := url.ParseQuery(u.RawQuery)
if err != nil {
return err
}
for key := range params {
value := params.Get(key)
switch key {
case "filter.id":
r.FilterID = value
case "filter.name":
r.FilterName = value
case "filter.labels":
r.FilterLabels = strings.Split(value, ",")
case "filter.sources":
r.FilterSources = strings.Split(value, ",")
default:
r.Options[key] = value
}
}
}
return rm.Add(r)
} | [
"func",
"(",
"rm",
"*",
"RouteManager",
")",
"AddFromURI",
"(",
"uri",
"string",
")",
"error",
"{",
"expandedRoute",
":=",
"os",
".",
"ExpandEnv",
"(",
"uri",
")",
"\n",
"u",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"expandedRoute",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"r",
":=",
"&",
"Route",
"{",
"Address",
":",
"u",
".",
"Host",
",",
"Adapter",
":",
"u",
".",
"Scheme",
",",
"Options",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
",",
"}",
"\n",
"if",
"u",
".",
"RawQuery",
"!=",
"\"",
"\"",
"{",
"params",
",",
"err",
":=",
"url",
".",
"ParseQuery",
"(",
"u",
".",
"RawQuery",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"for",
"key",
":=",
"range",
"params",
"{",
"value",
":=",
"params",
".",
"Get",
"(",
"key",
")",
"\n",
"switch",
"key",
"{",
"case",
"\"",
"\"",
":",
"r",
".",
"FilterID",
"=",
"value",
"\n",
"case",
"\"",
"\"",
":",
"r",
".",
"FilterName",
"=",
"value",
"\n",
"case",
"\"",
"\"",
":",
"r",
".",
"FilterLabels",
"=",
"strings",
".",
"Split",
"(",
"value",
",",
"\"",
"\"",
")",
"\n",
"case",
"\"",
"\"",
":",
"r",
".",
"FilterSources",
"=",
"strings",
".",
"Split",
"(",
"value",
",",
"\"",
"\"",
")",
"\n",
"default",
":",
"r",
".",
"Options",
"[",
"key",
"]",
"=",
"value",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"rm",
".",
"Add",
"(",
"r",
")",
"\n",
"}"
] | // AddFromURI creates a new route from an URI string and adds it to the RouteManager | [
"AddFromURI",
"creates",
"a",
"new",
"route",
"from",
"an",
"URI",
"string",
"and",
"adds",
"it",
"to",
"the",
"RouteManager"
] | 29d77641f9664a74fafea2ce655f610d796a63d4 | https://github.com/gliderlabs/logspout/blob/29d77641f9664a74fafea2ce655f610d796a63d4/router/routes.go#L85-L118 | train |
gliderlabs/logspout | router/routes.go | Add | func (rm *RouteManager) Add(route *Route) error {
rm.Lock()
defer rm.Unlock()
factory, found := AdapterFactories.Lookup(route.AdapterType())
if !found {
return errors.New("bad adapter: " + route.Adapter)
}
adapter, err := factory(route)
if err != nil {
return err
}
if route.ID == "" {
h := sha1.New()
io.WriteString(h, strconv.Itoa(int(time.Now().UnixNano())))
route.ID = fmt.Sprintf("%x", h.Sum(nil))[:12]
}
route.closer = make(chan bool)
route.adapter = adapter
//Stop any existing route with this ID:
if rm.routes[route.ID] != nil {
rm.routes[route.ID].closer <- true
}
rm.routes[route.ID] = route
if rm.persistor != nil {
if err := rm.persistor.Add(route); err != nil {
log.Println("persistor:", err)
}
}
if rm.routing {
go rm.route(route)
}
return nil
} | go | func (rm *RouteManager) Add(route *Route) error {
rm.Lock()
defer rm.Unlock()
factory, found := AdapterFactories.Lookup(route.AdapterType())
if !found {
return errors.New("bad adapter: " + route.Adapter)
}
adapter, err := factory(route)
if err != nil {
return err
}
if route.ID == "" {
h := sha1.New()
io.WriteString(h, strconv.Itoa(int(time.Now().UnixNano())))
route.ID = fmt.Sprintf("%x", h.Sum(nil))[:12]
}
route.closer = make(chan bool)
route.adapter = adapter
//Stop any existing route with this ID:
if rm.routes[route.ID] != nil {
rm.routes[route.ID].closer <- true
}
rm.routes[route.ID] = route
if rm.persistor != nil {
if err := rm.persistor.Add(route); err != nil {
log.Println("persistor:", err)
}
}
if rm.routing {
go rm.route(route)
}
return nil
} | [
"func",
"(",
"rm",
"*",
"RouteManager",
")",
"Add",
"(",
"route",
"*",
"Route",
")",
"error",
"{",
"rm",
".",
"Lock",
"(",
")",
"\n",
"defer",
"rm",
".",
"Unlock",
"(",
")",
"\n",
"factory",
",",
"found",
":=",
"AdapterFactories",
".",
"Lookup",
"(",
"route",
".",
"AdapterType",
"(",
")",
")",
"\n",
"if",
"!",
"found",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
"+",
"route",
".",
"Adapter",
")",
"\n",
"}",
"\n",
"adapter",
",",
"err",
":=",
"factory",
"(",
"route",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"route",
".",
"ID",
"==",
"\"",
"\"",
"{",
"h",
":=",
"sha1",
".",
"New",
"(",
")",
"\n",
"io",
".",
"WriteString",
"(",
"h",
",",
"strconv",
".",
"Itoa",
"(",
"int",
"(",
"time",
".",
"Now",
"(",
")",
".",
"UnixNano",
"(",
")",
")",
")",
")",
"\n",
"route",
".",
"ID",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"h",
".",
"Sum",
"(",
"nil",
")",
")",
"[",
":",
"12",
"]",
"\n",
"}",
"\n",
"route",
".",
"closer",
"=",
"make",
"(",
"chan",
"bool",
")",
"\n",
"route",
".",
"adapter",
"=",
"adapter",
"\n",
"//Stop any existing route with this ID:",
"if",
"rm",
".",
"routes",
"[",
"route",
".",
"ID",
"]",
"!=",
"nil",
"{",
"rm",
".",
"routes",
"[",
"route",
".",
"ID",
"]",
".",
"closer",
"<-",
"true",
"\n",
"}",
"\n\n",
"rm",
".",
"routes",
"[",
"route",
".",
"ID",
"]",
"=",
"route",
"\n",
"if",
"rm",
".",
"persistor",
"!=",
"nil",
"{",
"if",
"err",
":=",
"rm",
".",
"persistor",
".",
"Add",
"(",
"route",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Println",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"rm",
".",
"routing",
"{",
"go",
"rm",
".",
"route",
"(",
"route",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Add adds a route to the RouteManager | [
"Add",
"adds",
"a",
"route",
"to",
"the",
"RouteManager"
] | 29d77641f9664a74fafea2ce655f610d796a63d4 | https://github.com/gliderlabs/logspout/blob/29d77641f9664a74fafea2ce655f610d796a63d4/router/routes.go#L121-L154 | train |
gliderlabs/logspout | router/routes.go | Route | func (rm *RouteManager) Route(route *Route, logstream chan *Message) {
for _, router := range LogRouters.All() {
go router.Route(route, logstream)
}
} | go | func (rm *RouteManager) Route(route *Route, logstream chan *Message) {
for _, router := range LogRouters.All() {
go router.Route(route, logstream)
}
} | [
"func",
"(",
"rm",
"*",
"RouteManager",
")",
"Route",
"(",
"route",
"*",
"Route",
",",
"logstream",
"chan",
"*",
"Message",
")",
"{",
"for",
"_",
",",
"router",
":=",
"range",
"LogRouters",
".",
"All",
"(",
")",
"{",
"go",
"router",
".",
"Route",
"(",
"route",
",",
"logstream",
")",
"\n",
"}",
"\n",
"}"
] | // Route takes a logstream and route and passes them off to all configure LogRouters | [
"Route",
"takes",
"a",
"logstream",
"and",
"route",
"and",
"passes",
"them",
"off",
"to",
"all",
"configure",
"LogRouters"
] | 29d77641f9664a74fafea2ce655f610d796a63d4 | https://github.com/gliderlabs/logspout/blob/29d77641f9664a74fafea2ce655f610d796a63d4/router/routes.go#L164-L168 | train |
gliderlabs/logspout | router/routes.go | RoutingFrom | func (rm *RouteManager) RoutingFrom(containerID string) bool {
for _, router := range LogRouters.All() {
if router.RoutingFrom(containerID) {
return true
}
}
return false
} | go | func (rm *RouteManager) RoutingFrom(containerID string) bool {
for _, router := range LogRouters.All() {
if router.RoutingFrom(containerID) {
return true
}
}
return false
} | [
"func",
"(",
"rm",
"*",
"RouteManager",
")",
"RoutingFrom",
"(",
"containerID",
"string",
")",
"bool",
"{",
"for",
"_",
",",
"router",
":=",
"range",
"LogRouters",
".",
"All",
"(",
")",
"{",
"if",
"router",
".",
"RoutingFrom",
"(",
"containerID",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // RoutingFrom returns whether a given container is routing through the RouteManager | [
"RoutingFrom",
"returns",
"whether",
"a",
"given",
"container",
"is",
"routing",
"through",
"the",
"RouteManager"
] | 29d77641f9664a74fafea2ce655f610d796a63d4 | https://github.com/gliderlabs/logspout/blob/29d77641f9664a74fafea2ce655f610d796a63d4/router/routes.go#L171-L178 | train |
gliderlabs/logspout | router/routes.go | Run | func (rm *RouteManager) Run() error {
rm.Lock()
for _, route := range rm.routes {
rm.wg.Add(1)
go func(route *Route) {
rm.route(route)
rm.wg.Done()
}(route)
}
rm.routing = true
rm.Unlock()
rm.wg.Wait()
// Temp fix to allow logspout to run without routes defined.
if len(rm.routes) == 0 {
select {}
}
return nil
} | go | func (rm *RouteManager) Run() error {
rm.Lock()
for _, route := range rm.routes {
rm.wg.Add(1)
go func(route *Route) {
rm.route(route)
rm.wg.Done()
}(route)
}
rm.routing = true
rm.Unlock()
rm.wg.Wait()
// Temp fix to allow logspout to run without routes defined.
if len(rm.routes) == 0 {
select {}
}
return nil
} | [
"func",
"(",
"rm",
"*",
"RouteManager",
")",
"Run",
"(",
")",
"error",
"{",
"rm",
".",
"Lock",
"(",
")",
"\n",
"for",
"_",
",",
"route",
":=",
"range",
"rm",
".",
"routes",
"{",
"rm",
".",
"wg",
".",
"Add",
"(",
"1",
")",
"\n",
"go",
"func",
"(",
"route",
"*",
"Route",
")",
"{",
"rm",
".",
"route",
"(",
"route",
")",
"\n",
"rm",
".",
"wg",
".",
"Done",
"(",
")",
"\n",
"}",
"(",
"route",
")",
"\n",
"}",
"\n",
"rm",
".",
"routing",
"=",
"true",
"\n",
"rm",
".",
"Unlock",
"(",
")",
"\n",
"rm",
".",
"wg",
".",
"Wait",
"(",
")",
"\n",
"// Temp fix to allow logspout to run without routes defined.",
"if",
"len",
"(",
"rm",
".",
"routes",
")",
"==",
"0",
"{",
"select",
"{",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Run executes the RouteManager | [
"Run",
"executes",
"the",
"RouteManager"
] | 29d77641f9664a74fafea2ce655f610d796a63d4 | https://github.com/gliderlabs/logspout/blob/29d77641f9664a74fafea2ce655f610d796a63d4/router/routes.go#L181-L198 | train |
gliderlabs/logspout | router/routes.go | Setup | func (rm *RouteManager) Setup() error {
var uris string
if os.Getenv("ROUTE_URIS") != "" {
uris = os.Getenv("ROUTE_URIS")
}
if len(os.Args) > 1 {
uris = os.Args[1]
}
if uris != "" {
for _, uri := range strings.Split(uris, ",") {
err := rm.AddFromURI(uri)
if err != nil {
return err
}
}
}
persistPath := getopt("ROUTESPATH", "/mnt/routes")
if _, err := os.Stat(persistPath); err == nil {
return rm.Load(RouteFileStore(persistPath))
}
return nil
} | go | func (rm *RouteManager) Setup() error {
var uris string
if os.Getenv("ROUTE_URIS") != "" {
uris = os.Getenv("ROUTE_URIS")
}
if len(os.Args) > 1 {
uris = os.Args[1]
}
if uris != "" {
for _, uri := range strings.Split(uris, ",") {
err := rm.AddFromURI(uri)
if err != nil {
return err
}
}
}
persistPath := getopt("ROUTESPATH", "/mnt/routes")
if _, err := os.Stat(persistPath); err == nil {
return rm.Load(RouteFileStore(persistPath))
}
return nil
} | [
"func",
"(",
"rm",
"*",
"RouteManager",
")",
"Setup",
"(",
")",
"error",
"{",
"var",
"uris",
"string",
"\n",
"if",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"!=",
"\"",
"\"",
"{",
"uris",
"=",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"os",
".",
"Args",
")",
">",
"1",
"{",
"uris",
"=",
"os",
".",
"Args",
"[",
"1",
"]",
"\n",
"}",
"\n",
"if",
"uris",
"!=",
"\"",
"\"",
"{",
"for",
"_",
",",
"uri",
":=",
"range",
"strings",
".",
"Split",
"(",
"uris",
",",
"\"",
"\"",
")",
"{",
"err",
":=",
"rm",
".",
"AddFromURI",
"(",
"uri",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"persistPath",
":=",
"getopt",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"persistPath",
")",
";",
"err",
"==",
"nil",
"{",
"return",
"rm",
".",
"Load",
"(",
"RouteFileStore",
"(",
"persistPath",
")",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Setup configures the RouteManager | [
"Setup",
"configures",
"the",
"RouteManager"
] | 29d77641f9664a74fafea2ce655f610d796a63d4 | https://github.com/gliderlabs/logspout/blob/29d77641f9664a74fafea2ce655f610d796a63d4/router/routes.go#L206-L228 | train |
gliderlabs/logspout | adapters/raw/raw.go | NewRawAdapter | func NewRawAdapter(route *router.Route) (router.LogAdapter, error) {
transport, found := router.AdapterTransports.Lookup(route.AdapterTransport("udp"))
if !found {
return nil, errors.New("bad transport: " + route.Adapter)
}
conn, err := transport.Dial(route.Address, route.Options)
if err != nil {
return nil, err
}
tmplStr := "{{.Data}}\n"
if os.Getenv("RAW_FORMAT") != "" {
tmplStr = os.Getenv("RAW_FORMAT")
}
tmpl, err := template.New("raw").Funcs(funcs).Parse(tmplStr)
if err != nil {
return nil, err
}
return &Adapter{
route: route,
conn: conn,
tmpl: tmpl,
}, nil
} | go | func NewRawAdapter(route *router.Route) (router.LogAdapter, error) {
transport, found := router.AdapterTransports.Lookup(route.AdapterTransport("udp"))
if !found {
return nil, errors.New("bad transport: " + route.Adapter)
}
conn, err := transport.Dial(route.Address, route.Options)
if err != nil {
return nil, err
}
tmplStr := "{{.Data}}\n"
if os.Getenv("RAW_FORMAT") != "" {
tmplStr = os.Getenv("RAW_FORMAT")
}
tmpl, err := template.New("raw").Funcs(funcs).Parse(tmplStr)
if err != nil {
return nil, err
}
return &Adapter{
route: route,
conn: conn,
tmpl: tmpl,
}, nil
} | [
"func",
"NewRawAdapter",
"(",
"route",
"*",
"router",
".",
"Route",
")",
"(",
"router",
".",
"LogAdapter",
",",
"error",
")",
"{",
"transport",
",",
"found",
":=",
"router",
".",
"AdapterTransports",
".",
"Lookup",
"(",
"route",
".",
"AdapterTransport",
"(",
"\"",
"\"",
")",
")",
"\n",
"if",
"!",
"found",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
"+",
"route",
".",
"Adapter",
")",
"\n",
"}",
"\n",
"conn",
",",
"err",
":=",
"transport",
".",
"Dial",
"(",
"route",
".",
"Address",
",",
"route",
".",
"Options",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"tmplStr",
":=",
"\"",
"\\n",
"\"",
"\n",
"if",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"!=",
"\"",
"\"",
"{",
"tmplStr",
"=",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"tmpl",
",",
"err",
":=",
"template",
".",
"New",
"(",
"\"",
"\"",
")",
".",
"Funcs",
"(",
"funcs",
")",
".",
"Parse",
"(",
"tmplStr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"Adapter",
"{",
"route",
":",
"route",
",",
"conn",
":",
"conn",
",",
"tmpl",
":",
"tmpl",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewRawAdapter returns a configured raw.Adapter | [
"NewRawAdapter",
"returns",
"a",
"configured",
"raw",
".",
"Adapter"
] | 29d77641f9664a74fafea2ce655f610d796a63d4 | https://github.com/gliderlabs/logspout/blob/29d77641f9664a74fafea2ce655f610d796a63d4/adapters/raw/raw.go#L32-L54 | train |
gliderlabs/logspout | adapters/multiline/multiline.go | NewMultilineAdapter | func NewMultilineAdapter(route *router.Route) (a router.LogAdapter, err error) {
enableByDefault := true
enableStr := os.Getenv("MULTILINE_ENABLE_DEFAULT")
if enableStr != "" {
var err error
enableByDefault, err = strconv.ParseBool(enableStr)
if err != nil {
return nil, errors.New("multiline: invalid value for MULTILINE_ENABLE_DEFAULT (must be true|false): " + enableStr)
}
}
pattern := os.Getenv("MULTILINE_PATTERN")
if pattern == "" {
pattern = `^\s`
}
separator := os.Getenv("MULTILINE_SEPARATOR")
if separator == "" {
separator = "\n"
}
patternRegexp, err := regexp.Compile(pattern)
if err != nil {
return nil, errors.New("multiline: invalid value for MULTILINE_PATTERN (must be regexp): " + pattern)
}
matchType := os.Getenv("MULTILINE_MATCH")
if matchType == "" {
matchType = matchNonFirst
}
matchType = strings.ToLower(matchType)
matchFirstLine := false
negateMatch := false
switch matchType {
case matchFirst:
matchFirstLine = true
negateMatch = false
case matchLast:
matchFirstLine = false
negateMatch = false
case matchNonFirst:
matchFirstLine = true
negateMatch = true
case matchNonLast:
matchFirstLine = false
negateMatch = true
default:
return nil, errors.New("multiline: invalid value for MULTILINE_MATCH (must be one of first|last|nonfirst|nonlast): " + matchType)
}
flushAfter := 500 * time.Millisecond
flushAfterStr := os.Getenv("MULTILINE_FLUSH_AFTER")
if flushAfterStr != "" {
timeoutMS, err := strconv.Atoi(flushAfterStr)
if err != nil {
return nil, errors.New("multiline: invalid value for multiline_timeout (must be number): " + flushAfterStr)
}
flushAfter = time.Duration(timeoutMS) * time.Millisecond
}
parts := strings.SplitN(route.Adapter, "+", 2)
if len(parts) != 2 {
return nil, errors.New("multiline: adapter must have a sub-adapter, eg: multiline+raw+tcp")
}
originalAdapter := route.Adapter
route.Adapter = parts[1]
factory, found := router.AdapterFactories.Lookup(route.AdapterType())
if !found {
return nil, errors.New("bad adapter: " + originalAdapter)
}
subAdapter, err := factory(route)
if err != nil {
return nil, err
}
route.Adapter = originalAdapter
out := make(chan *router.Message)
checkInterval := flushAfter / 2
return &Adapter{
out: out,
subAdapter: subAdapter,
enableByDefault: enableByDefault,
pattern: patternRegexp,
separator: separator,
matchFirstLine: matchFirstLine,
negateMatch: negateMatch,
flushAfter: flushAfter,
checkInterval: checkInterval,
buffers: make(map[string]*router.Message),
nextCheck: time.After(checkInterval),
}, nil
} | go | func NewMultilineAdapter(route *router.Route) (a router.LogAdapter, err error) {
enableByDefault := true
enableStr := os.Getenv("MULTILINE_ENABLE_DEFAULT")
if enableStr != "" {
var err error
enableByDefault, err = strconv.ParseBool(enableStr)
if err != nil {
return nil, errors.New("multiline: invalid value for MULTILINE_ENABLE_DEFAULT (must be true|false): " + enableStr)
}
}
pattern := os.Getenv("MULTILINE_PATTERN")
if pattern == "" {
pattern = `^\s`
}
separator := os.Getenv("MULTILINE_SEPARATOR")
if separator == "" {
separator = "\n"
}
patternRegexp, err := regexp.Compile(pattern)
if err != nil {
return nil, errors.New("multiline: invalid value for MULTILINE_PATTERN (must be regexp): " + pattern)
}
matchType := os.Getenv("MULTILINE_MATCH")
if matchType == "" {
matchType = matchNonFirst
}
matchType = strings.ToLower(matchType)
matchFirstLine := false
negateMatch := false
switch matchType {
case matchFirst:
matchFirstLine = true
negateMatch = false
case matchLast:
matchFirstLine = false
negateMatch = false
case matchNonFirst:
matchFirstLine = true
negateMatch = true
case matchNonLast:
matchFirstLine = false
negateMatch = true
default:
return nil, errors.New("multiline: invalid value for MULTILINE_MATCH (must be one of first|last|nonfirst|nonlast): " + matchType)
}
flushAfter := 500 * time.Millisecond
flushAfterStr := os.Getenv("MULTILINE_FLUSH_AFTER")
if flushAfterStr != "" {
timeoutMS, err := strconv.Atoi(flushAfterStr)
if err != nil {
return nil, errors.New("multiline: invalid value for multiline_timeout (must be number): " + flushAfterStr)
}
flushAfter = time.Duration(timeoutMS) * time.Millisecond
}
parts := strings.SplitN(route.Adapter, "+", 2)
if len(parts) != 2 {
return nil, errors.New("multiline: adapter must have a sub-adapter, eg: multiline+raw+tcp")
}
originalAdapter := route.Adapter
route.Adapter = parts[1]
factory, found := router.AdapterFactories.Lookup(route.AdapterType())
if !found {
return nil, errors.New("bad adapter: " + originalAdapter)
}
subAdapter, err := factory(route)
if err != nil {
return nil, err
}
route.Adapter = originalAdapter
out := make(chan *router.Message)
checkInterval := flushAfter / 2
return &Adapter{
out: out,
subAdapter: subAdapter,
enableByDefault: enableByDefault,
pattern: patternRegexp,
separator: separator,
matchFirstLine: matchFirstLine,
negateMatch: negateMatch,
flushAfter: flushAfter,
checkInterval: checkInterval,
buffers: make(map[string]*router.Message),
nextCheck: time.After(checkInterval),
}, nil
} | [
"func",
"NewMultilineAdapter",
"(",
"route",
"*",
"router",
".",
"Route",
")",
"(",
"a",
"router",
".",
"LogAdapter",
",",
"err",
"error",
")",
"{",
"enableByDefault",
":=",
"true",
"\n",
"enableStr",
":=",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"\n",
"if",
"enableStr",
"!=",
"\"",
"\"",
"{",
"var",
"err",
"error",
"\n",
"enableByDefault",
",",
"err",
"=",
"strconv",
".",
"ParseBool",
"(",
"enableStr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
"+",
"enableStr",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"pattern",
":=",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"\n",
"if",
"pattern",
"==",
"\"",
"\"",
"{",
"pattern",
"=",
"`^\\s`",
"\n",
"}",
"\n\n",
"separator",
":=",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"\n",
"if",
"separator",
"==",
"\"",
"\"",
"{",
"separator",
"=",
"\"",
"\\n",
"\"",
"\n",
"}",
"\n",
"patternRegexp",
",",
"err",
":=",
"regexp",
".",
"Compile",
"(",
"pattern",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
"+",
"pattern",
")",
"\n",
"}",
"\n\n",
"matchType",
":=",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"\n",
"if",
"matchType",
"==",
"\"",
"\"",
"{",
"matchType",
"=",
"matchNonFirst",
"\n",
"}",
"\n",
"matchType",
"=",
"strings",
".",
"ToLower",
"(",
"matchType",
")",
"\n",
"matchFirstLine",
":=",
"false",
"\n",
"negateMatch",
":=",
"false",
"\n",
"switch",
"matchType",
"{",
"case",
"matchFirst",
":",
"matchFirstLine",
"=",
"true",
"\n",
"negateMatch",
"=",
"false",
"\n",
"case",
"matchLast",
":",
"matchFirstLine",
"=",
"false",
"\n",
"negateMatch",
"=",
"false",
"\n",
"case",
"matchNonFirst",
":",
"matchFirstLine",
"=",
"true",
"\n",
"negateMatch",
"=",
"true",
"\n",
"case",
"matchNonLast",
":",
"matchFirstLine",
"=",
"false",
"\n",
"negateMatch",
"=",
"true",
"\n",
"default",
":",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
"+",
"matchType",
")",
"\n",
"}",
"\n\n",
"flushAfter",
":=",
"500",
"*",
"time",
".",
"Millisecond",
"\n",
"flushAfterStr",
":=",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"\n",
"if",
"flushAfterStr",
"!=",
"\"",
"\"",
"{",
"timeoutMS",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"flushAfterStr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
"+",
"flushAfterStr",
")",
"\n",
"}",
"\n",
"flushAfter",
"=",
"time",
".",
"Duration",
"(",
"timeoutMS",
")",
"*",
"time",
".",
"Millisecond",
"\n",
"}",
"\n\n",
"parts",
":=",
"strings",
".",
"SplitN",
"(",
"route",
".",
"Adapter",
",",
"\"",
"\"",
",",
"2",
")",
"\n",
"if",
"len",
"(",
"parts",
")",
"!=",
"2",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"originalAdapter",
":=",
"route",
".",
"Adapter",
"\n",
"route",
".",
"Adapter",
"=",
"parts",
"[",
"1",
"]",
"\n",
"factory",
",",
"found",
":=",
"router",
".",
"AdapterFactories",
".",
"Lookup",
"(",
"route",
".",
"AdapterType",
"(",
")",
")",
"\n",
"if",
"!",
"found",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
"+",
"originalAdapter",
")",
"\n",
"}",
"\n",
"subAdapter",
",",
"err",
":=",
"factory",
"(",
"route",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"route",
".",
"Adapter",
"=",
"originalAdapter",
"\n\n",
"out",
":=",
"make",
"(",
"chan",
"*",
"router",
".",
"Message",
")",
"\n",
"checkInterval",
":=",
"flushAfter",
"/",
"2",
"\n\n",
"return",
"&",
"Adapter",
"{",
"out",
":",
"out",
",",
"subAdapter",
":",
"subAdapter",
",",
"enableByDefault",
":",
"enableByDefault",
",",
"pattern",
":",
"patternRegexp",
",",
"separator",
":",
"separator",
",",
"matchFirstLine",
":",
"matchFirstLine",
",",
"negateMatch",
":",
"negateMatch",
",",
"flushAfter",
":",
"flushAfter",
",",
"checkInterval",
":",
"checkInterval",
",",
"buffers",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"router",
".",
"Message",
")",
",",
"nextCheck",
":",
"time",
".",
"After",
"(",
"checkInterval",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewMultilineAdapter returns a configured multiline.Adapter | [
"NewMultilineAdapter",
"returns",
"a",
"configured",
"multiline",
".",
"Adapter"
] | 29d77641f9664a74fafea2ce655f610d796a63d4 | https://github.com/gliderlabs/logspout/blob/29d77641f9664a74fafea2ce655f610d796a63d4/adapters/multiline/multiline.go#L43-L135 | train |
gliderlabs/logspout | adapters/multiline/multiline.go | Stream | func (a *Adapter) Stream(logstream chan *router.Message) {
wg := sync.WaitGroup{}
wg.Add(1)
go func() {
a.subAdapter.Stream(a.out)
wg.Done()
}()
defer func() {
for _, message := range a.buffers {
a.out <- message
}
close(a.out)
wg.Wait()
}()
for {
select {
case message, ok := <-logstream:
if !ok {
return
}
if !multilineContainer(message.Container, a.enableByDefault) {
a.out <- message
continue
}
cID := message.Container.ID
old, oldExists := a.buffers[cID]
if a.isFirstLine(message) {
if oldExists {
a.out <- old
}
a.buffers[cID] = message
} else {
isLastLine := a.isLastLine(message)
if oldExists {
old.Data += a.separator + message.Data
message = old
}
if isLastLine {
a.out <- message
if oldExists {
delete(a.buffers, cID)
}
} else {
a.buffers[cID] = message
}
}
case <-a.nextCheck:
now := time.Now()
for key, message := range a.buffers {
if message.Time.Add(a.flushAfter).After(now) {
a.out <- message
delete(a.buffers, key)
}
}
a.nextCheck = time.After(a.checkInterval)
}
}
} | go | func (a *Adapter) Stream(logstream chan *router.Message) {
wg := sync.WaitGroup{}
wg.Add(1)
go func() {
a.subAdapter.Stream(a.out)
wg.Done()
}()
defer func() {
for _, message := range a.buffers {
a.out <- message
}
close(a.out)
wg.Wait()
}()
for {
select {
case message, ok := <-logstream:
if !ok {
return
}
if !multilineContainer(message.Container, a.enableByDefault) {
a.out <- message
continue
}
cID := message.Container.ID
old, oldExists := a.buffers[cID]
if a.isFirstLine(message) {
if oldExists {
a.out <- old
}
a.buffers[cID] = message
} else {
isLastLine := a.isLastLine(message)
if oldExists {
old.Data += a.separator + message.Data
message = old
}
if isLastLine {
a.out <- message
if oldExists {
delete(a.buffers, cID)
}
} else {
a.buffers[cID] = message
}
}
case <-a.nextCheck:
now := time.Now()
for key, message := range a.buffers {
if message.Time.Add(a.flushAfter).After(now) {
a.out <- message
delete(a.buffers, key)
}
}
a.nextCheck = time.After(a.checkInterval)
}
}
} | [
"func",
"(",
"a",
"*",
"Adapter",
")",
"Stream",
"(",
"logstream",
"chan",
"*",
"router",
".",
"Message",
")",
"{",
"wg",
":=",
"sync",
".",
"WaitGroup",
"{",
"}",
"\n",
"wg",
".",
"Add",
"(",
"1",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"a",
".",
"subAdapter",
".",
"Stream",
"(",
"a",
".",
"out",
")",
"\n",
"wg",
".",
"Done",
"(",
")",
"\n",
"}",
"(",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"for",
"_",
",",
"message",
":=",
"range",
"a",
".",
"buffers",
"{",
"a",
".",
"out",
"<-",
"message",
"\n",
"}",
"\n\n",
"close",
"(",
"a",
".",
"out",
")",
"\n",
"wg",
".",
"Wait",
"(",
")",
"\n",
"}",
"(",
")",
"\n\n",
"for",
"{",
"select",
"{",
"case",
"message",
",",
"ok",
":=",
"<-",
"logstream",
":",
"if",
"!",
"ok",
"{",
"return",
"\n",
"}",
"\n\n",
"if",
"!",
"multilineContainer",
"(",
"message",
".",
"Container",
",",
"a",
".",
"enableByDefault",
")",
"{",
"a",
".",
"out",
"<-",
"message",
"\n",
"continue",
"\n",
"}",
"\n\n",
"cID",
":=",
"message",
".",
"Container",
".",
"ID",
"\n",
"old",
",",
"oldExists",
":=",
"a",
".",
"buffers",
"[",
"cID",
"]",
"\n",
"if",
"a",
".",
"isFirstLine",
"(",
"message",
")",
"{",
"if",
"oldExists",
"{",
"a",
".",
"out",
"<-",
"old",
"\n",
"}",
"\n\n",
"a",
".",
"buffers",
"[",
"cID",
"]",
"=",
"message",
"\n",
"}",
"else",
"{",
"isLastLine",
":=",
"a",
".",
"isLastLine",
"(",
"message",
")",
"\n",
"if",
"oldExists",
"{",
"old",
".",
"Data",
"+=",
"a",
".",
"separator",
"+",
"message",
".",
"Data",
"\n",
"message",
"=",
"old",
"\n",
"}",
"\n\n",
"if",
"isLastLine",
"{",
"a",
".",
"out",
"<-",
"message",
"\n",
"if",
"oldExists",
"{",
"delete",
"(",
"a",
".",
"buffers",
",",
"cID",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"a",
".",
"buffers",
"[",
"cID",
"]",
"=",
"message",
"\n",
"}",
"\n",
"}",
"\n",
"case",
"<-",
"a",
".",
"nextCheck",
":",
"now",
":=",
"time",
".",
"Now",
"(",
")",
"\n\n",
"for",
"key",
",",
"message",
":=",
"range",
"a",
".",
"buffers",
"{",
"if",
"message",
".",
"Time",
".",
"Add",
"(",
"a",
".",
"flushAfter",
")",
".",
"After",
"(",
"now",
")",
"{",
"a",
".",
"out",
"<-",
"message",
"\n",
"delete",
"(",
"a",
".",
"buffers",
",",
"key",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"a",
".",
"nextCheck",
"=",
"time",
".",
"After",
"(",
"a",
".",
"checkInterval",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Stream sends log data to the next adapter | [
"Stream",
"sends",
"log",
"data",
"to",
"the",
"next",
"adapter"
] | 29d77641f9664a74fafea2ce655f610d796a63d4 | https://github.com/gliderlabs/logspout/blob/29d77641f9664a74fafea2ce655f610d796a63d4/adapters/multiline/multiline.go#L138-L204 | train |
gliderlabs/logspout | router/pump.go | Setup | func (p *LogsPump) Setup() error {
var err error
p.client, err = docker.NewClientFromEnv()
return err
} | go | func (p *LogsPump) Setup() error {
var err error
p.client, err = docker.NewClientFromEnv()
return err
} | [
"func",
"(",
"p",
"*",
"LogsPump",
")",
"Setup",
"(",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"p",
".",
"client",
",",
"err",
"=",
"docker",
".",
"NewClientFromEnv",
"(",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Setup configures the pump | [
"Setup",
"configures",
"the",
"pump"
] | 29d77641f9664a74fafea2ce655f610d796a63d4 | https://github.com/gliderlabs/logspout/blob/29d77641f9664a74fafea2ce655f610d796a63d4/router/pump.go#L137-L141 | train |
gliderlabs/logspout | router/pump.go | Run | func (p *LogsPump) Run() error {
inactivityTimeout := getInactivityTimeoutFromEnv()
debug("pump.Run(): using inactivity timeout: ", inactivityTimeout)
containers, err := p.client.ListContainers(docker.ListContainersOptions{})
if err != nil {
return err
}
for _, listing := range containers {
p.pumpLogs(&docker.APIEvents{
ID: normalID(listing.ID),
Status: "start",
}, false, inactivityTimeout)
}
events := make(chan *docker.APIEvents)
err = p.client.AddEventListener(events)
if err != nil {
return err
}
for event := range events {
debug("pump.Run() event:", normalID(event.ID), event.Status)
switch event.Status {
case "start", "restart":
go p.pumpLogs(event, backlog(), inactivityTimeout)
case "rename":
go p.rename(event)
case "die":
go p.update(event)
}
}
return errors.New("docker event stream closed")
} | go | func (p *LogsPump) Run() error {
inactivityTimeout := getInactivityTimeoutFromEnv()
debug("pump.Run(): using inactivity timeout: ", inactivityTimeout)
containers, err := p.client.ListContainers(docker.ListContainersOptions{})
if err != nil {
return err
}
for _, listing := range containers {
p.pumpLogs(&docker.APIEvents{
ID: normalID(listing.ID),
Status: "start",
}, false, inactivityTimeout)
}
events := make(chan *docker.APIEvents)
err = p.client.AddEventListener(events)
if err != nil {
return err
}
for event := range events {
debug("pump.Run() event:", normalID(event.ID), event.Status)
switch event.Status {
case "start", "restart":
go p.pumpLogs(event, backlog(), inactivityTimeout)
case "rename":
go p.rename(event)
case "die":
go p.update(event)
}
}
return errors.New("docker event stream closed")
} | [
"func",
"(",
"p",
"*",
"LogsPump",
")",
"Run",
"(",
")",
"error",
"{",
"inactivityTimeout",
":=",
"getInactivityTimeoutFromEnv",
"(",
")",
"\n",
"debug",
"(",
"\"",
"\"",
",",
"inactivityTimeout",
")",
"\n\n",
"containers",
",",
"err",
":=",
"p",
".",
"client",
".",
"ListContainers",
"(",
"docker",
".",
"ListContainersOptions",
"{",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"for",
"_",
",",
"listing",
":=",
"range",
"containers",
"{",
"p",
".",
"pumpLogs",
"(",
"&",
"docker",
".",
"APIEvents",
"{",
"ID",
":",
"normalID",
"(",
"listing",
".",
"ID",
")",
",",
"Status",
":",
"\"",
"\"",
",",
"}",
",",
"false",
",",
"inactivityTimeout",
")",
"\n",
"}",
"\n",
"events",
":=",
"make",
"(",
"chan",
"*",
"docker",
".",
"APIEvents",
")",
"\n",
"err",
"=",
"p",
".",
"client",
".",
"AddEventListener",
"(",
"events",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"for",
"event",
":=",
"range",
"events",
"{",
"debug",
"(",
"\"",
"\"",
",",
"normalID",
"(",
"event",
".",
"ID",
")",
",",
"event",
".",
"Status",
")",
"\n",
"switch",
"event",
".",
"Status",
"{",
"case",
"\"",
"\"",
",",
"\"",
"\"",
":",
"go",
"p",
".",
"pumpLogs",
"(",
"event",
",",
"backlog",
"(",
")",
",",
"inactivityTimeout",
")",
"\n",
"case",
"\"",
"\"",
":",
"go",
"p",
".",
"rename",
"(",
"event",
")",
"\n",
"case",
"\"",
"\"",
":",
"go",
"p",
".",
"update",
"(",
"event",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}"
] | // Run executes the pump | [
"Run",
"executes",
"the",
"pump"
] | 29d77641f9664a74fafea2ce655f610d796a63d4 | https://github.com/gliderlabs/logspout/blob/29d77641f9664a74fafea2ce655f610d796a63d4/router/pump.go#L157-L188 | train |
gliderlabs/logspout | router/pump.go | RoutingFrom | func (p *LogsPump) RoutingFrom(id string) bool {
p.mu.Lock()
defer p.mu.Unlock()
_, monitoring := p.pumps[normalID(id)]
return monitoring
} | go | func (p *LogsPump) RoutingFrom(id string) bool {
p.mu.Lock()
defer p.mu.Unlock()
_, monitoring := p.pumps[normalID(id)]
return monitoring
} | [
"func",
"(",
"p",
"*",
"LogsPump",
")",
"RoutingFrom",
"(",
"id",
"string",
")",
"bool",
"{",
"p",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"_",
",",
"monitoring",
":=",
"p",
".",
"pumps",
"[",
"normalID",
"(",
"id",
")",
"]",
"\n",
"return",
"monitoring",
"\n",
"}"
] | // RoutingFrom returns whether a container id is routing from this pump | [
"RoutingFrom",
"returns",
"whether",
"a",
"container",
"id",
"is",
"routing",
"from",
"this",
"pump"
] | 29d77641f9664a74fafea2ce655f610d796a63d4 | https://github.com/gliderlabs/logspout/blob/29d77641f9664a74fafea2ce655f610d796a63d4/router/pump.go#L297-L302 | train |
gliderlabs/logspout | router/pump.go | Route | func (p *LogsPump) Route(route *Route, logstream chan *Message) {
p.mu.Lock()
for _, pump := range p.pumps {
if route.MatchContainer(
normalID(pump.container.ID),
normalName(pump.container.Name),
pump.container.Config.Labels) {
pump.add(logstream, route)
defer pump.remove(logstream)
}
}
updates := make(chan *update)
p.routes[updates] = struct{}{}
p.mu.Unlock()
defer func() {
p.mu.Lock()
delete(p.routes, updates)
p.mu.Unlock()
route.closed = true
}()
for {
select {
case event := <-updates:
switch event.Status {
case "start", "restart":
if route.MatchContainer(
normalID(event.pump.container.ID),
normalName(event.pump.container.Name),
event.pump.container.Config.Labels) {
event.pump.add(logstream, route)
defer event.pump.remove(logstream)
}
case "die":
if strings.HasPrefix(route.FilterID, event.ID) {
// If the route is just about a single container,
// we can stop routing when it dies.
return
}
}
case <-route.Closer():
return
}
}
} | go | func (p *LogsPump) Route(route *Route, logstream chan *Message) {
p.mu.Lock()
for _, pump := range p.pumps {
if route.MatchContainer(
normalID(pump.container.ID),
normalName(pump.container.Name),
pump.container.Config.Labels) {
pump.add(logstream, route)
defer pump.remove(logstream)
}
}
updates := make(chan *update)
p.routes[updates] = struct{}{}
p.mu.Unlock()
defer func() {
p.mu.Lock()
delete(p.routes, updates)
p.mu.Unlock()
route.closed = true
}()
for {
select {
case event := <-updates:
switch event.Status {
case "start", "restart":
if route.MatchContainer(
normalID(event.pump.container.ID),
normalName(event.pump.container.Name),
event.pump.container.Config.Labels) {
event.pump.add(logstream, route)
defer event.pump.remove(logstream)
}
case "die":
if strings.HasPrefix(route.FilterID, event.ID) {
// If the route is just about a single container,
// we can stop routing when it dies.
return
}
}
case <-route.Closer():
return
}
}
} | [
"func",
"(",
"p",
"*",
"LogsPump",
")",
"Route",
"(",
"route",
"*",
"Route",
",",
"logstream",
"chan",
"*",
"Message",
")",
"{",
"p",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"for",
"_",
",",
"pump",
":=",
"range",
"p",
".",
"pumps",
"{",
"if",
"route",
".",
"MatchContainer",
"(",
"normalID",
"(",
"pump",
".",
"container",
".",
"ID",
")",
",",
"normalName",
"(",
"pump",
".",
"container",
".",
"Name",
")",
",",
"pump",
".",
"container",
".",
"Config",
".",
"Labels",
")",
"{",
"pump",
".",
"add",
"(",
"logstream",
",",
"route",
")",
"\n",
"defer",
"pump",
".",
"remove",
"(",
"logstream",
")",
"\n",
"}",
"\n",
"}",
"\n",
"updates",
":=",
"make",
"(",
"chan",
"*",
"update",
")",
"\n",
"p",
".",
"routes",
"[",
"updates",
"]",
"=",
"struct",
"{",
"}",
"{",
"}",
"\n",
"p",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"p",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"delete",
"(",
"p",
".",
"routes",
",",
"updates",
")",
"\n",
"p",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"route",
".",
"closed",
"=",
"true",
"\n",
"}",
"(",
")",
"\n",
"for",
"{",
"select",
"{",
"case",
"event",
":=",
"<-",
"updates",
":",
"switch",
"event",
".",
"Status",
"{",
"case",
"\"",
"\"",
",",
"\"",
"\"",
":",
"if",
"route",
".",
"MatchContainer",
"(",
"normalID",
"(",
"event",
".",
"pump",
".",
"container",
".",
"ID",
")",
",",
"normalName",
"(",
"event",
".",
"pump",
".",
"container",
".",
"Name",
")",
",",
"event",
".",
"pump",
".",
"container",
".",
"Config",
".",
"Labels",
")",
"{",
"event",
".",
"pump",
".",
"add",
"(",
"logstream",
",",
"route",
")",
"\n",
"defer",
"event",
".",
"pump",
".",
"remove",
"(",
"logstream",
")",
"\n",
"}",
"\n",
"case",
"\"",
"\"",
":",
"if",
"strings",
".",
"HasPrefix",
"(",
"route",
".",
"FilterID",
",",
"event",
".",
"ID",
")",
"{",
"// If the route is just about a single container,",
"// we can stop routing when it dies.",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"case",
"<-",
"route",
".",
"Closer",
"(",
")",
":",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Route takes a logstream and routes it according to the supplied Route | [
"Route",
"takes",
"a",
"logstream",
"and",
"routes",
"it",
"according",
"to",
"the",
"supplied",
"Route"
] | 29d77641f9664a74fafea2ce655f610d796a63d4 | https://github.com/gliderlabs/logspout/blob/29d77641f9664a74fafea2ce655f610d796a63d4/router/pump.go#L305-L350 | train |
urfave/negroni | recovery.go | RequestDescription | func (p *PanicInformation) RequestDescription() string {
if p.Request == nil {
return nilRequestMessage
}
var queryOutput string
if p.Request.URL.RawQuery != "" {
queryOutput = "?" + p.Request.URL.RawQuery
}
return fmt.Sprintf("%s %s%s", p.Request.Method, p.Request.URL.Path, queryOutput)
} | go | func (p *PanicInformation) RequestDescription() string {
if p.Request == nil {
return nilRequestMessage
}
var queryOutput string
if p.Request.URL.RawQuery != "" {
queryOutput = "?" + p.Request.URL.RawQuery
}
return fmt.Sprintf("%s %s%s", p.Request.Method, p.Request.URL.Path, queryOutput)
} | [
"func",
"(",
"p",
"*",
"PanicInformation",
")",
"RequestDescription",
"(",
")",
"string",
"{",
"if",
"p",
".",
"Request",
"==",
"nil",
"{",
"return",
"nilRequestMessage",
"\n",
"}",
"\n\n",
"var",
"queryOutput",
"string",
"\n",
"if",
"p",
".",
"Request",
".",
"URL",
".",
"RawQuery",
"!=",
"\"",
"\"",
"{",
"queryOutput",
"=",
"\"",
"\"",
"+",
"p",
".",
"Request",
".",
"URL",
".",
"RawQuery",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"p",
".",
"Request",
".",
"Method",
",",
"p",
".",
"Request",
".",
"URL",
".",
"Path",
",",
"queryOutput",
")",
"\n",
"}"
] | // RequestDescription returns a printable description of the url | [
"RequestDescription",
"returns",
"a",
"printable",
"description",
"of",
"the",
"url"
] | 0ce192d0bd24e9ec58b05bc72b3eac5bcc4f6517 | https://github.com/urfave/negroni/blob/0ce192d0bd24e9ec58b05bc72b3eac5bcc4f6517/recovery.go#L84-L95 | train |
urfave/negroni | negroni.go | Wrap | func Wrap(handler http.Handler) Handler {
return HandlerFunc(func(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
handler.ServeHTTP(rw, r)
next(rw, r)
})
} | go | func Wrap(handler http.Handler) Handler {
return HandlerFunc(func(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
handler.ServeHTTP(rw, r)
next(rw, r)
})
} | [
"func",
"Wrap",
"(",
"handler",
"http",
".",
"Handler",
")",
"Handler",
"{",
"return",
"HandlerFunc",
"(",
"func",
"(",
"rw",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"next",
"http",
".",
"HandlerFunc",
")",
"{",
"handler",
".",
"ServeHTTP",
"(",
"rw",
",",
"r",
")",
"\n",
"next",
"(",
"rw",
",",
"r",
")",
"\n",
"}",
")",
"\n",
"}"
] | // Wrap converts a http.Handler into a negroni.Handler so it can be used as a Negroni
// middleware. The next http.HandlerFunc is automatically called after the Handler
// is executed. | [
"Wrap",
"converts",
"a",
"http",
".",
"Handler",
"into",
"a",
"negroni",
".",
"Handler",
"so",
"it",
"can",
"be",
"used",
"as",
"a",
"Negroni",
"middleware",
".",
"The",
"next",
"http",
".",
"HandlerFunc",
"is",
"automatically",
"called",
"after",
"the",
"Handler",
"is",
"executed",
"."
] | 0ce192d0bd24e9ec58b05bc72b3eac5bcc4f6517 | https://github.com/urfave/negroni/blob/0ce192d0bd24e9ec58b05bc72b3eac5bcc4f6517/negroni.go#L44-L49 | train |
urfave/negroni | negroni.go | WrapFunc | func WrapFunc(handlerFunc http.HandlerFunc) Handler {
return HandlerFunc(func(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
handlerFunc(rw, r)
next(rw, r)
})
} | go | func WrapFunc(handlerFunc http.HandlerFunc) Handler {
return HandlerFunc(func(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
handlerFunc(rw, r)
next(rw, r)
})
} | [
"func",
"WrapFunc",
"(",
"handlerFunc",
"http",
".",
"HandlerFunc",
")",
"Handler",
"{",
"return",
"HandlerFunc",
"(",
"func",
"(",
"rw",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"next",
"http",
".",
"HandlerFunc",
")",
"{",
"handlerFunc",
"(",
"rw",
",",
"r",
")",
"\n",
"next",
"(",
"rw",
",",
"r",
")",
"\n",
"}",
")",
"\n",
"}"
] | // WrapFunc converts a http.HandlerFunc into a negroni.Handler so it can be used as a Negroni
// middleware. The next http.HandlerFunc is automatically called after the Handler
// is executed. | [
"WrapFunc",
"converts",
"a",
"http",
".",
"HandlerFunc",
"into",
"a",
"negroni",
".",
"Handler",
"so",
"it",
"can",
"be",
"used",
"as",
"a",
"Negroni",
"middleware",
".",
"The",
"next",
"http",
".",
"HandlerFunc",
"is",
"automatically",
"called",
"after",
"the",
"Handler",
"is",
"executed",
"."
] | 0ce192d0bd24e9ec58b05bc72b3eac5bcc4f6517 | https://github.com/urfave/negroni/blob/0ce192d0bd24e9ec58b05bc72b3eac5bcc4f6517/negroni.go#L54-L59 | train |
urfave/negroni | negroni.go | New | func New(handlers ...Handler) *Negroni {
return &Negroni{
handlers: handlers,
middleware: build(handlers),
}
} | go | func New(handlers ...Handler) *Negroni {
return &Negroni{
handlers: handlers,
middleware: build(handlers),
}
} | [
"func",
"New",
"(",
"handlers",
"...",
"Handler",
")",
"*",
"Negroni",
"{",
"return",
"&",
"Negroni",
"{",
"handlers",
":",
"handlers",
",",
"middleware",
":",
"build",
"(",
"handlers",
")",
",",
"}",
"\n",
"}"
] | // New returns a new Negroni instance with no middleware preconfigured. | [
"New",
"returns",
"a",
"new",
"Negroni",
"instance",
"with",
"no",
"middleware",
"preconfigured",
"."
] | 0ce192d0bd24e9ec58b05bc72b3eac5bcc4f6517 | https://github.com/urfave/negroni/blob/0ce192d0bd24e9ec58b05bc72b3eac5bcc4f6517/negroni.go#L70-L75 | train |
urfave/negroni | negroni.go | With | func (n *Negroni) With(handlers ...Handler) *Negroni {
currentHandlers := make([]Handler, len(n.handlers))
copy(currentHandlers, n.handlers)
return New(
append(currentHandlers, handlers...)...,
)
} | go | func (n *Negroni) With(handlers ...Handler) *Negroni {
currentHandlers := make([]Handler, len(n.handlers))
copy(currentHandlers, n.handlers)
return New(
append(currentHandlers, handlers...)...,
)
} | [
"func",
"(",
"n",
"*",
"Negroni",
")",
"With",
"(",
"handlers",
"...",
"Handler",
")",
"*",
"Negroni",
"{",
"currentHandlers",
":=",
"make",
"(",
"[",
"]",
"Handler",
",",
"len",
"(",
"n",
".",
"handlers",
")",
")",
"\n",
"copy",
"(",
"currentHandlers",
",",
"n",
".",
"handlers",
")",
"\n",
"return",
"New",
"(",
"append",
"(",
"currentHandlers",
",",
"handlers",
"...",
")",
"...",
",",
")",
"\n",
"}"
] | // With returns a new Negroni instance that is a combination of the negroni
// receiver's handlers and the provided handlers. | [
"With",
"returns",
"a",
"new",
"Negroni",
"instance",
"that",
"is",
"a",
"combination",
"of",
"the",
"negroni",
"receiver",
"s",
"handlers",
"and",
"the",
"provided",
"handlers",
"."
] | 0ce192d0bd24e9ec58b05bc72b3eac5bcc4f6517 | https://github.com/urfave/negroni/blob/0ce192d0bd24e9ec58b05bc72b3eac5bcc4f6517/negroni.go#L79-L85 | train |
urfave/negroni | negroni.go | Use | func (n *Negroni) Use(handler Handler) {
if handler == nil {
panic("handler cannot be nil")
}
n.handlers = append(n.handlers, handler)
n.middleware = build(n.handlers)
} | go | func (n *Negroni) Use(handler Handler) {
if handler == nil {
panic("handler cannot be nil")
}
n.handlers = append(n.handlers, handler)
n.middleware = build(n.handlers)
} | [
"func",
"(",
"n",
"*",
"Negroni",
")",
"Use",
"(",
"handler",
"Handler",
")",
"{",
"if",
"handler",
"==",
"nil",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"n",
".",
"handlers",
"=",
"append",
"(",
"n",
".",
"handlers",
",",
"handler",
")",
"\n",
"n",
".",
"middleware",
"=",
"build",
"(",
"n",
".",
"handlers",
")",
"\n",
"}"
] | // Use adds a Handler onto the middleware stack. Handlers are invoked in the order they are added to a Negroni. | [
"Use",
"adds",
"a",
"Handler",
"onto",
"the",
"middleware",
"stack",
".",
"Handlers",
"are",
"invoked",
"in",
"the",
"order",
"they",
"are",
"added",
"to",
"a",
"Negroni",
"."
] | 0ce192d0bd24e9ec58b05bc72b3eac5bcc4f6517 | https://github.com/urfave/negroni/blob/0ce192d0bd24e9ec58b05bc72b3eac5bcc4f6517/negroni.go#L102-L109 | train |
urfave/negroni | negroni.go | UseFunc | func (n *Negroni) UseFunc(handlerFunc func(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc)) {
n.Use(HandlerFunc(handlerFunc))
} | go | func (n *Negroni) UseFunc(handlerFunc func(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc)) {
n.Use(HandlerFunc(handlerFunc))
} | [
"func",
"(",
"n",
"*",
"Negroni",
")",
"UseFunc",
"(",
"handlerFunc",
"func",
"(",
"rw",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"next",
"http",
".",
"HandlerFunc",
")",
")",
"{",
"n",
".",
"Use",
"(",
"HandlerFunc",
"(",
"handlerFunc",
")",
")",
"\n",
"}"
] | // UseFunc adds a Negroni-style handler function onto the middleware stack. | [
"UseFunc",
"adds",
"a",
"Negroni",
"-",
"style",
"handler",
"function",
"onto",
"the",
"middleware",
"stack",
"."
] | 0ce192d0bd24e9ec58b05bc72b3eac5bcc4f6517 | https://github.com/urfave/negroni/blob/0ce192d0bd24e9ec58b05bc72b3eac5bcc4f6517/negroni.go#L112-L114 | train |
urfave/negroni | negroni.go | UseHandler | func (n *Negroni) UseHandler(handler http.Handler) {
n.Use(Wrap(handler))
} | go | func (n *Negroni) UseHandler(handler http.Handler) {
n.Use(Wrap(handler))
} | [
"func",
"(",
"n",
"*",
"Negroni",
")",
"UseHandler",
"(",
"handler",
"http",
".",
"Handler",
")",
"{",
"n",
".",
"Use",
"(",
"Wrap",
"(",
"handler",
")",
")",
"\n",
"}"
] | // UseHandler adds a http.Handler onto the middleware stack. Handlers are invoked in the order they are added to a Negroni. | [
"UseHandler",
"adds",
"a",
"http",
".",
"Handler",
"onto",
"the",
"middleware",
"stack",
".",
"Handlers",
"are",
"invoked",
"in",
"the",
"order",
"they",
"are",
"added",
"to",
"a",
"Negroni",
"."
] | 0ce192d0bd24e9ec58b05bc72b3eac5bcc4f6517 | https://github.com/urfave/negroni/blob/0ce192d0bd24e9ec58b05bc72b3eac5bcc4f6517/negroni.go#L117-L119 | train |
urfave/negroni | negroni.go | UseHandlerFunc | func (n *Negroni) UseHandlerFunc(handlerFunc func(rw http.ResponseWriter, r *http.Request)) {
n.UseHandler(http.HandlerFunc(handlerFunc))
} | go | func (n *Negroni) UseHandlerFunc(handlerFunc func(rw http.ResponseWriter, r *http.Request)) {
n.UseHandler(http.HandlerFunc(handlerFunc))
} | [
"func",
"(",
"n",
"*",
"Negroni",
")",
"UseHandlerFunc",
"(",
"handlerFunc",
"func",
"(",
"rw",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
")",
"{",
"n",
".",
"UseHandler",
"(",
"http",
".",
"HandlerFunc",
"(",
"handlerFunc",
")",
")",
"\n",
"}"
] | // UseHandlerFunc adds a http.HandlerFunc-style handler function onto the middleware stack. | [
"UseHandlerFunc",
"adds",
"a",
"http",
".",
"HandlerFunc",
"-",
"style",
"handler",
"function",
"onto",
"the",
"middleware",
"stack",
"."
] | 0ce192d0bd24e9ec58b05bc72b3eac5bcc4f6517 | https://github.com/urfave/negroni/blob/0ce192d0bd24e9ec58b05bc72b3eac5bcc4f6517/negroni.go#L122-L124 | train |
urfave/negroni | negroni.go | Run | func (n *Negroni) Run(addr ...string) {
l := log.New(os.Stdout, "[negroni] ", 0)
finalAddr := detectAddress(addr...)
l.Printf("listening on %s", finalAddr)
l.Fatal(http.ListenAndServe(finalAddr, n))
} | go | func (n *Negroni) Run(addr ...string) {
l := log.New(os.Stdout, "[negroni] ", 0)
finalAddr := detectAddress(addr...)
l.Printf("listening on %s", finalAddr)
l.Fatal(http.ListenAndServe(finalAddr, n))
} | [
"func",
"(",
"n",
"*",
"Negroni",
")",
"Run",
"(",
"addr",
"...",
"string",
")",
"{",
"l",
":=",
"log",
".",
"New",
"(",
"os",
".",
"Stdout",
",",
"\"",
"\"",
",",
"0",
")",
"\n",
"finalAddr",
":=",
"detectAddress",
"(",
"addr",
"...",
")",
"\n",
"l",
".",
"Printf",
"(",
"\"",
"\"",
",",
"finalAddr",
")",
"\n",
"l",
".",
"Fatal",
"(",
"http",
".",
"ListenAndServe",
"(",
"finalAddr",
",",
"n",
")",
")",
"\n",
"}"
] | // Run is a convenience function that runs the negroni stack as an HTTP
// server. The addr string, if provided, takes the same format as http.ListenAndServe.
// If no address is provided but the PORT environment variable is set, the PORT value is used.
// If neither is provided, the address' value will equal the DefaultAddress constant. | [
"Run",
"is",
"a",
"convenience",
"function",
"that",
"runs",
"the",
"negroni",
"stack",
"as",
"an",
"HTTP",
"server",
".",
"The",
"addr",
"string",
"if",
"provided",
"takes",
"the",
"same",
"format",
"as",
"http",
".",
"ListenAndServe",
".",
"If",
"no",
"address",
"is",
"provided",
"but",
"the",
"PORT",
"environment",
"variable",
"is",
"set",
"the",
"PORT",
"value",
"is",
"used",
".",
"If",
"neither",
"is",
"provided",
"the",
"address",
"value",
"will",
"equal",
"the",
"DefaultAddress",
"constant",
"."
] | 0ce192d0bd24e9ec58b05bc72b3eac5bcc4f6517 | https://github.com/urfave/negroni/blob/0ce192d0bd24e9ec58b05bc72b3eac5bcc4f6517/negroni.go#L130-L135 | train |
siddontang/ledisdb | ledis/migrate.go | LDump | func (db *DB) LDump(key []byte) ([]byte, error) {
v, err := db.LRange(key, 0, -1)
if err != nil {
return nil, err
} else if len(v) == 0 {
return nil, err
}
return rdb.Dump(rdb.List(v))
} | go | func (db *DB) LDump(key []byte) ([]byte, error) {
v, err := db.LRange(key, 0, -1)
if err != nil {
return nil, err
} else if len(v) == 0 {
return nil, err
}
return rdb.Dump(rdb.List(v))
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"LDump",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"v",
",",
"err",
":=",
"db",
".",
"LRange",
"(",
"key",
",",
"0",
",",
"-",
"1",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"else",
"if",
"len",
"(",
"v",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"rdb",
".",
"Dump",
"(",
"rdb",
".",
"List",
"(",
"v",
")",
")",
"\n",
"}"
] | // LDump dumps the list value of key | [
"LDump",
"dumps",
"the",
"list",
"value",
"of",
"key"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/migrate.go#L30-L39 | train |
siddontang/ledisdb | ledis/migrate.go | HDump | func (db *DB) HDump(key []byte) ([]byte, error) {
v, err := db.HGetAll(key)
if err != nil {
return nil, err
} else if len(v) == 0 {
return nil, err
}
o := make(rdb.Hash, len(v))
for i := 0; i < len(v); i++ {
o[i].Field = v[i].Field
o[i].Value = v[i].Value
}
return rdb.Dump(o)
} | go | func (db *DB) HDump(key []byte) ([]byte, error) {
v, err := db.HGetAll(key)
if err != nil {
return nil, err
} else if len(v) == 0 {
return nil, err
}
o := make(rdb.Hash, len(v))
for i := 0; i < len(v); i++ {
o[i].Field = v[i].Field
o[i].Value = v[i].Value
}
return rdb.Dump(o)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"HDump",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"v",
",",
"err",
":=",
"db",
".",
"HGetAll",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"else",
"if",
"len",
"(",
"v",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"o",
":=",
"make",
"(",
"rdb",
".",
"Hash",
",",
"len",
"(",
"v",
")",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"v",
")",
";",
"i",
"++",
"{",
"o",
"[",
"i",
"]",
".",
"Field",
"=",
"v",
"[",
"i",
"]",
".",
"Field",
"\n",
"o",
"[",
"i",
"]",
".",
"Value",
"=",
"v",
"[",
"i",
"]",
".",
"Value",
"\n",
"}",
"\n\n",
"return",
"rdb",
".",
"Dump",
"(",
"o",
")",
"\n",
"}"
] | // HDump dumps the hash value of key | [
"HDump",
"dumps",
"the",
"hash",
"value",
"of",
"key"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/migrate.go#L42-L57 | train |
siddontang/ledisdb | ledis/migrate.go | SDump | func (db *DB) SDump(key []byte) ([]byte, error) {
v, err := db.SMembers(key)
if err != nil {
return nil, err
} else if len(v) == 0 {
return nil, err
}
return rdb.Dump(rdb.Set(v))
} | go | func (db *DB) SDump(key []byte) ([]byte, error) {
v, err := db.SMembers(key)
if err != nil {
return nil, err
} else if len(v) == 0 {
return nil, err
}
return rdb.Dump(rdb.Set(v))
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"SDump",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"v",
",",
"err",
":=",
"db",
".",
"SMembers",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"else",
"if",
"len",
"(",
"v",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"rdb",
".",
"Dump",
"(",
"rdb",
".",
"Set",
"(",
"v",
")",
")",
"\n",
"}"
] | // SDump dumps the set value of key | [
"SDump",
"dumps",
"the",
"set",
"value",
"of",
"key"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/migrate.go#L60-L69 | train |
siddontang/ledisdb | ledis/migrate.go | ZDump | func (db *DB) ZDump(key []byte) ([]byte, error) {
v, err := db.ZRangeByScore(key, MinScore, MaxScore, 0, -1)
if err != nil {
return nil, err
} else if len(v) == 0 {
return nil, err
}
o := make(rdb.ZSet, len(v))
for i := 0; i < len(v); i++ {
o[i].Member = v[i].Member
o[i].Score = float64(v[i].Score)
}
return rdb.Dump(o)
} | go | func (db *DB) ZDump(key []byte) ([]byte, error) {
v, err := db.ZRangeByScore(key, MinScore, MaxScore, 0, -1)
if err != nil {
return nil, err
} else if len(v) == 0 {
return nil, err
}
o := make(rdb.ZSet, len(v))
for i := 0; i < len(v); i++ {
o[i].Member = v[i].Member
o[i].Score = float64(v[i].Score)
}
return rdb.Dump(o)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZDump",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"v",
",",
"err",
":=",
"db",
".",
"ZRangeByScore",
"(",
"key",
",",
"MinScore",
",",
"MaxScore",
",",
"0",
",",
"-",
"1",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"else",
"if",
"len",
"(",
"v",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"o",
":=",
"make",
"(",
"rdb",
".",
"ZSet",
",",
"len",
"(",
"v",
")",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"v",
")",
";",
"i",
"++",
"{",
"o",
"[",
"i",
"]",
".",
"Member",
"=",
"v",
"[",
"i",
"]",
".",
"Member",
"\n",
"o",
"[",
"i",
"]",
".",
"Score",
"=",
"float64",
"(",
"v",
"[",
"i",
"]",
".",
"Score",
")",
"\n",
"}",
"\n\n",
"return",
"rdb",
".",
"Dump",
"(",
"o",
")",
"\n",
"}"
] | // ZDump dumps the zset value of key | [
"ZDump",
"dumps",
"the",
"zset",
"value",
"of",
"key"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/migrate.go#L72-L87 | train |
siddontang/ledisdb | ledis/t_list.go | LIndex | func (db *DB) LIndex(key []byte, index int32) ([]byte, error) {
if err := checkKeySize(key); err != nil {
return nil, err
}
var seq int32
var headSeq int32
var tailSeq int32
var err error
metaKey := db.lEncodeMetaKey(key)
it := db.bucket.NewIterator()
defer it.Close()
headSeq, tailSeq, _, err = db.lGetMeta(it, metaKey)
if err != nil {
return nil, err
}
if index >= 0 {
seq = headSeq + index
} else {
seq = tailSeq + index + 1
}
sk := db.lEncodeListKey(key, seq)
v := it.Find(sk)
return v, nil
} | go | func (db *DB) LIndex(key []byte, index int32) ([]byte, error) {
if err := checkKeySize(key); err != nil {
return nil, err
}
var seq int32
var headSeq int32
var tailSeq int32
var err error
metaKey := db.lEncodeMetaKey(key)
it := db.bucket.NewIterator()
defer it.Close()
headSeq, tailSeq, _, err = db.lGetMeta(it, metaKey)
if err != nil {
return nil, err
}
if index >= 0 {
seq = headSeq + index
} else {
seq = tailSeq + index + 1
}
sk := db.lEncodeListKey(key, seq)
v := it.Find(sk)
return v, nil
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"LIndex",
"(",
"key",
"[",
"]",
"byte",
",",
"index",
"int32",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"seq",
"int32",
"\n",
"var",
"headSeq",
"int32",
"\n",
"var",
"tailSeq",
"int32",
"\n",
"var",
"err",
"error",
"\n\n",
"metaKey",
":=",
"db",
".",
"lEncodeMetaKey",
"(",
"key",
")",
"\n\n",
"it",
":=",
"db",
".",
"bucket",
".",
"NewIterator",
"(",
")",
"\n",
"defer",
"it",
".",
"Close",
"(",
")",
"\n\n",
"headSeq",
",",
"tailSeq",
",",
"_",
",",
"err",
"=",
"db",
".",
"lGetMeta",
"(",
"it",
",",
"metaKey",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"index",
">=",
"0",
"{",
"seq",
"=",
"headSeq",
"+",
"index",
"\n",
"}",
"else",
"{",
"seq",
"=",
"tailSeq",
"+",
"index",
"+",
"1",
"\n",
"}",
"\n\n",
"sk",
":=",
"db",
".",
"lEncodeListKey",
"(",
"key",
",",
"seq",
")",
"\n",
"v",
":=",
"it",
".",
"Find",
"(",
"sk",
")",
"\n\n",
"return",
"v",
",",
"nil",
"\n",
"}"
] | // LIndex returns the value at index. | [
"LIndex",
"returns",
"the",
"value",
"at",
"index",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_list.go#L425-L455 | train |
siddontang/ledisdb | ledis/t_list.go | LLen | func (db *DB) LLen(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
ek := db.lEncodeMetaKey(key)
_, _, size, err := db.lGetMeta(nil, ek)
return int64(size), err
} | go | func (db *DB) LLen(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
ek := db.lEncodeMetaKey(key)
_, _, size, err := db.lGetMeta(nil, ek)
return int64(size), err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"LLen",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"ek",
":=",
"db",
".",
"lEncodeMetaKey",
"(",
"key",
")",
"\n",
"_",
",",
"_",
",",
"size",
",",
"err",
":=",
"db",
".",
"lGetMeta",
"(",
"nil",
",",
"ek",
")",
"\n",
"return",
"int64",
"(",
"size",
")",
",",
"err",
"\n",
"}"
] | // LLen gets the length of the list. | [
"LLen",
"gets",
"the",
"length",
"of",
"the",
"list",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_list.go#L458-L466 | train |
siddontang/ledisdb | ledis/t_list.go | LPop | func (db *DB) LPop(key []byte) ([]byte, error) {
return db.lpop(key, listHeadSeq)
} | go | func (db *DB) LPop(key []byte) ([]byte, error) {
return db.lpop(key, listHeadSeq)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"LPop",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"return",
"db",
".",
"lpop",
"(",
"key",
",",
"listHeadSeq",
")",
"\n",
"}"
] | // LPop pops the value. | [
"LPop",
"pops",
"the",
"value",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_list.go#L469-L471 | train |
siddontang/ledisdb | ledis/t_list.go | LTrim | func (db *DB) LTrim(key []byte, start, stop int64) error {
return db.ltrim2(key, start, stop)
} | go | func (db *DB) LTrim(key []byte, start, stop int64) error {
return db.ltrim2(key, start, stop)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"LTrim",
"(",
"key",
"[",
"]",
"byte",
",",
"start",
",",
"stop",
"int64",
")",
"error",
"{",
"return",
"db",
".",
"ltrim2",
"(",
"key",
",",
"start",
",",
"stop",
")",
"\n",
"}"
] | // LTrim trims the value from start to stop. | [
"LTrim",
"trims",
"the",
"value",
"from",
"start",
"to",
"stop",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_list.go#L474-L476 | train |
siddontang/ledisdb | ledis/t_list.go | LTrimFront | func (db *DB) LTrimFront(key []byte, trimSize int32) (int32, error) {
return db.ltrim(key, trimSize, listHeadSeq)
} | go | func (db *DB) LTrimFront(key []byte, trimSize int32) (int32, error) {
return db.ltrim(key, trimSize, listHeadSeq)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"LTrimFront",
"(",
"key",
"[",
"]",
"byte",
",",
"trimSize",
"int32",
")",
"(",
"int32",
",",
"error",
")",
"{",
"return",
"db",
".",
"ltrim",
"(",
"key",
",",
"trimSize",
",",
"listHeadSeq",
")",
"\n",
"}"
] | // LTrimFront trims the value from top. | [
"LTrimFront",
"trims",
"the",
"value",
"from",
"top",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_list.go#L479-L481 | train |
siddontang/ledisdb | ledis/t_list.go | LTrimBack | func (db *DB) LTrimBack(key []byte, trimSize int32) (int32, error) {
return db.ltrim(key, trimSize, listTailSeq)
} | go | func (db *DB) LTrimBack(key []byte, trimSize int32) (int32, error) {
return db.ltrim(key, trimSize, listTailSeq)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"LTrimBack",
"(",
"key",
"[",
"]",
"byte",
",",
"trimSize",
"int32",
")",
"(",
"int32",
",",
"error",
")",
"{",
"return",
"db",
".",
"ltrim",
"(",
"key",
",",
"trimSize",
",",
"listTailSeq",
")",
"\n",
"}"
] | // LTrimBack trims the value from back. | [
"LTrimBack",
"trims",
"the",
"value",
"from",
"back",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_list.go#L484-L486 | train |
siddontang/ledisdb | ledis/t_list.go | LPush | func (db *DB) LPush(key []byte, args ...[]byte) (int64, error) {
return db.lpush(key, listHeadSeq, args...)
} | go | func (db *DB) LPush(key []byte, args ...[]byte) (int64, error) {
return db.lpush(key, listHeadSeq, args...)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"LPush",
"(",
"key",
"[",
"]",
"byte",
",",
"args",
"...",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"return",
"db",
".",
"lpush",
"(",
"key",
",",
"listHeadSeq",
",",
"args",
"...",
")",
"\n",
"}"
] | // LPush push the value to the list. | [
"LPush",
"push",
"the",
"value",
"to",
"the",
"list",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_list.go#L489-L491 | train |
siddontang/ledisdb | ledis/t_list.go | LSet | func (db *DB) LSet(key []byte, index int32, value []byte) error {
if err := checkKeySize(key); err != nil {
return err
}
var seq int32
var headSeq int32
var tailSeq int32
//var size int32
var err error
t := db.listBatch
t.Lock()
defer t.Unlock()
metaKey := db.lEncodeMetaKey(key)
headSeq, tailSeq, _, err = db.lGetMeta(nil, metaKey)
if err != nil {
return err
}
if index >= 0 {
seq = headSeq + index
} else {
seq = tailSeq + index + 1
}
if seq < headSeq || seq > tailSeq {
return errListIndex
}
sk := db.lEncodeListKey(key, seq)
t.Put(sk, value)
err = t.Commit()
return err
} | go | func (db *DB) LSet(key []byte, index int32, value []byte) error {
if err := checkKeySize(key); err != nil {
return err
}
var seq int32
var headSeq int32
var tailSeq int32
//var size int32
var err error
t := db.listBatch
t.Lock()
defer t.Unlock()
metaKey := db.lEncodeMetaKey(key)
headSeq, tailSeq, _, err = db.lGetMeta(nil, metaKey)
if err != nil {
return err
}
if index >= 0 {
seq = headSeq + index
} else {
seq = tailSeq + index + 1
}
if seq < headSeq || seq > tailSeq {
return errListIndex
}
sk := db.lEncodeListKey(key, seq)
t.Put(sk, value)
err = t.Commit()
return err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"LSet",
"(",
"key",
"[",
"]",
"byte",
",",
"index",
"int32",
",",
"value",
"[",
"]",
"byte",
")",
"error",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"var",
"seq",
"int32",
"\n",
"var",
"headSeq",
"int32",
"\n",
"var",
"tailSeq",
"int32",
"\n",
"//var size int32",
"var",
"err",
"error",
"\n",
"t",
":=",
"db",
".",
"listBatch",
"\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n",
"metaKey",
":=",
"db",
".",
"lEncodeMetaKey",
"(",
"key",
")",
"\n\n",
"headSeq",
",",
"tailSeq",
",",
"_",
",",
"err",
"=",
"db",
".",
"lGetMeta",
"(",
"nil",
",",
"metaKey",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"index",
">=",
"0",
"{",
"seq",
"=",
"headSeq",
"+",
"index",
"\n",
"}",
"else",
"{",
"seq",
"=",
"tailSeq",
"+",
"index",
"+",
"1",
"\n",
"}",
"\n",
"if",
"seq",
"<",
"headSeq",
"||",
"seq",
">",
"tailSeq",
"{",
"return",
"errListIndex",
"\n",
"}",
"\n",
"sk",
":=",
"db",
".",
"lEncodeListKey",
"(",
"key",
",",
"seq",
")",
"\n",
"t",
".",
"Put",
"(",
"sk",
",",
"value",
")",
"\n",
"err",
"=",
"t",
".",
"Commit",
"(",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // LSet sets the value at index. | [
"LSet",
"sets",
"the",
"value",
"at",
"index",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_list.go#L494-L526 | train |
siddontang/ledisdb | ledis/t_list.go | LRange | func (db *DB) LRange(key []byte, start int32, stop int32) ([][]byte, error) {
if err := checkKeySize(key); err != nil {
return nil, err
}
var headSeq int32
var llen int32
var err error
metaKey := db.lEncodeMetaKey(key)
it := db.bucket.NewIterator()
defer it.Close()
if headSeq, _, llen, err = db.lGetMeta(it, metaKey); err != nil {
return nil, err
}
if start < 0 {
start = llen + start
}
if stop < 0 {
stop = llen + stop
}
if start < 0 {
start = 0
}
if start > stop || start >= llen {
return [][]byte{}, nil
}
if stop >= llen {
stop = llen - 1
}
limit := (stop - start) + 1
headSeq += start
v := make([][]byte, 0, limit)
startKey := db.lEncodeListKey(key, headSeq)
rit := store.NewRangeLimitIterator(it,
&store.Range{
Min: startKey,
Max: nil,
Type: store.RangeClose},
&store.Limit{
Offset: 0,
Count: int(limit)})
for ; rit.Valid(); rit.Next() {
v = append(v, rit.Value())
}
return v, nil
} | go | func (db *DB) LRange(key []byte, start int32, stop int32) ([][]byte, error) {
if err := checkKeySize(key); err != nil {
return nil, err
}
var headSeq int32
var llen int32
var err error
metaKey := db.lEncodeMetaKey(key)
it := db.bucket.NewIterator()
defer it.Close()
if headSeq, _, llen, err = db.lGetMeta(it, metaKey); err != nil {
return nil, err
}
if start < 0 {
start = llen + start
}
if stop < 0 {
stop = llen + stop
}
if start < 0 {
start = 0
}
if start > stop || start >= llen {
return [][]byte{}, nil
}
if stop >= llen {
stop = llen - 1
}
limit := (stop - start) + 1
headSeq += start
v := make([][]byte, 0, limit)
startKey := db.lEncodeListKey(key, headSeq)
rit := store.NewRangeLimitIterator(it,
&store.Range{
Min: startKey,
Max: nil,
Type: store.RangeClose},
&store.Limit{
Offset: 0,
Count: int(limit)})
for ; rit.Valid(); rit.Next() {
v = append(v, rit.Value())
}
return v, nil
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"LRange",
"(",
"key",
"[",
"]",
"byte",
",",
"start",
"int32",
",",
"stop",
"int32",
")",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"headSeq",
"int32",
"\n",
"var",
"llen",
"int32",
"\n",
"var",
"err",
"error",
"\n\n",
"metaKey",
":=",
"db",
".",
"lEncodeMetaKey",
"(",
"key",
")",
"\n\n",
"it",
":=",
"db",
".",
"bucket",
".",
"NewIterator",
"(",
")",
"\n",
"defer",
"it",
".",
"Close",
"(",
")",
"\n\n",
"if",
"headSeq",
",",
"_",
",",
"llen",
",",
"err",
"=",
"db",
".",
"lGetMeta",
"(",
"it",
",",
"metaKey",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"start",
"<",
"0",
"{",
"start",
"=",
"llen",
"+",
"start",
"\n",
"}",
"\n",
"if",
"stop",
"<",
"0",
"{",
"stop",
"=",
"llen",
"+",
"stop",
"\n",
"}",
"\n",
"if",
"start",
"<",
"0",
"{",
"start",
"=",
"0",
"\n",
"}",
"\n\n",
"if",
"start",
">",
"stop",
"||",
"start",
">=",
"llen",
"{",
"return",
"[",
"]",
"[",
"]",
"byte",
"{",
"}",
",",
"nil",
"\n",
"}",
"\n\n",
"if",
"stop",
">=",
"llen",
"{",
"stop",
"=",
"llen",
"-",
"1",
"\n",
"}",
"\n\n",
"limit",
":=",
"(",
"stop",
"-",
"start",
")",
"+",
"1",
"\n",
"headSeq",
"+=",
"start",
"\n\n",
"v",
":=",
"make",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"0",
",",
"limit",
")",
"\n\n",
"startKey",
":=",
"db",
".",
"lEncodeListKey",
"(",
"key",
",",
"headSeq",
")",
"\n",
"rit",
":=",
"store",
".",
"NewRangeLimitIterator",
"(",
"it",
",",
"&",
"store",
".",
"Range",
"{",
"Min",
":",
"startKey",
",",
"Max",
":",
"nil",
",",
"Type",
":",
"store",
".",
"RangeClose",
"}",
",",
"&",
"store",
".",
"Limit",
"{",
"Offset",
":",
"0",
",",
"Count",
":",
"int",
"(",
"limit",
")",
"}",
")",
"\n\n",
"for",
";",
"rit",
".",
"Valid",
"(",
")",
";",
"rit",
".",
"Next",
"(",
")",
"{",
"v",
"=",
"append",
"(",
"v",
",",
"rit",
".",
"Value",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"v",
",",
"nil",
"\n",
"}"
] | // LRange gets the value of list at range. | [
"LRange",
"gets",
"the",
"value",
"of",
"list",
"at",
"range",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_list.go#L529-L585 | train |
siddontang/ledisdb | ledis/t_list.go | RPop | func (db *DB) RPop(key []byte) ([]byte, error) {
return db.lpop(key, listTailSeq)
} | go | func (db *DB) RPop(key []byte) ([]byte, error) {
return db.lpop(key, listTailSeq)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"RPop",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"return",
"db",
".",
"lpop",
"(",
"key",
",",
"listTailSeq",
")",
"\n",
"}"
] | // RPop rpops the value. | [
"RPop",
"rpops",
"the",
"value",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_list.go#L588-L590 | train |
siddontang/ledisdb | ledis/t_list.go | RPush | func (db *DB) RPush(key []byte, args ...[]byte) (int64, error) {
return db.lpush(key, listTailSeq, args...)
} | go | func (db *DB) RPush(key []byte, args ...[]byte) (int64, error) {
return db.lpush(key, listTailSeq, args...)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"RPush",
"(",
"key",
"[",
"]",
"byte",
",",
"args",
"...",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"return",
"db",
".",
"lpush",
"(",
"key",
",",
"listTailSeq",
",",
"args",
"...",
")",
"\n",
"}"
] | // RPush rpushs the value . | [
"RPush",
"rpushs",
"the",
"value",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_list.go#L593-L595 | train |
siddontang/ledisdb | ledis/t_list.go | LClear | func (db *DB) LClear(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.listBatch
t.Lock()
defer t.Unlock()
num := db.lDelete(t, key)
db.rmExpire(t, ListType, key)
err := t.Commit()
return num, err
} | go | func (db *DB) LClear(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.listBatch
t.Lock()
defer t.Unlock()
num := db.lDelete(t, key)
db.rmExpire(t, ListType, key)
err := t.Commit()
return num, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"LClear",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"t",
":=",
"db",
".",
"listBatch",
"\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n\n",
"num",
":=",
"db",
".",
"lDelete",
"(",
"t",
",",
"key",
")",
"\n",
"db",
".",
"rmExpire",
"(",
"t",
",",
"ListType",
",",
"key",
")",
"\n\n",
"err",
":=",
"t",
".",
"Commit",
"(",
")",
"\n",
"return",
"num",
",",
"err",
"\n",
"}"
] | // LClear clears the list. | [
"LClear",
"clears",
"the",
"list",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_list.go#L598-L612 | train |
siddontang/ledisdb | ledis/t_list.go | LMclear | func (db *DB) LMclear(keys ...[]byte) (int64, error) {
t := db.listBatch
t.Lock()
defer t.Unlock()
for _, key := range keys {
if err := checkKeySize(key); err != nil {
return 0, err
}
db.lDelete(t, key)
db.rmExpire(t, ListType, key)
}
err := t.Commit()
return int64(len(keys)), err
} | go | func (db *DB) LMclear(keys ...[]byte) (int64, error) {
t := db.listBatch
t.Lock()
defer t.Unlock()
for _, key := range keys {
if err := checkKeySize(key); err != nil {
return 0, err
}
db.lDelete(t, key)
db.rmExpire(t, ListType, key)
}
err := t.Commit()
return int64(len(keys)), err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"LMclear",
"(",
"keys",
"...",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"t",
":=",
"db",
".",
"listBatch",
"\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n\n",
"for",
"_",
",",
"key",
":=",
"range",
"keys",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"db",
".",
"lDelete",
"(",
"t",
",",
"key",
")",
"\n",
"db",
".",
"rmExpire",
"(",
"t",
",",
"ListType",
",",
"key",
")",
"\n\n",
"}",
"\n\n",
"err",
":=",
"t",
".",
"Commit",
"(",
")",
"\n",
"return",
"int64",
"(",
"len",
"(",
"keys",
")",
")",
",",
"err",
"\n",
"}"
] | // LMclear clears multi lists. | [
"LMclear",
"clears",
"multi",
"lists",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_list.go#L615-L632 | train |
siddontang/ledisdb | ledis/t_list.go | LExpire | func (db *DB) LExpire(key []byte, duration int64) (int64, error) {
if duration <= 0 {
return 0, errExpireValue
}
return db.lExpireAt(key, time.Now().Unix()+duration)
} | go | func (db *DB) LExpire(key []byte, duration int64) (int64, error) {
if duration <= 0 {
return 0, errExpireValue
}
return db.lExpireAt(key, time.Now().Unix()+duration)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"LExpire",
"(",
"key",
"[",
"]",
"byte",
",",
"duration",
"int64",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"duration",
"<=",
"0",
"{",
"return",
"0",
",",
"errExpireValue",
"\n",
"}",
"\n\n",
"return",
"db",
".",
"lExpireAt",
"(",
"key",
",",
"time",
".",
"Now",
"(",
")",
".",
"Unix",
"(",
")",
"+",
"duration",
")",
"\n",
"}"
] | // LExpire expires the list. | [
"LExpire",
"expires",
"the",
"list",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_list.go#L642-L648 | train |
siddontang/ledisdb | ledis/t_list.go | LExpireAt | func (db *DB) LExpireAt(key []byte, when int64) (int64, error) {
if when <= time.Now().Unix() {
return 0, errExpireValue
}
return db.lExpireAt(key, when)
} | go | func (db *DB) LExpireAt(key []byte, when int64) (int64, error) {
if when <= time.Now().Unix() {
return 0, errExpireValue
}
return db.lExpireAt(key, when)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"LExpireAt",
"(",
"key",
"[",
"]",
"byte",
",",
"when",
"int64",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"when",
"<=",
"time",
".",
"Now",
"(",
")",
".",
"Unix",
"(",
")",
"{",
"return",
"0",
",",
"errExpireValue",
"\n",
"}",
"\n\n",
"return",
"db",
".",
"lExpireAt",
"(",
"key",
",",
"when",
")",
"\n",
"}"
] | // LExpireAt expires the list at when. | [
"LExpireAt",
"expires",
"the",
"list",
"at",
"when",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_list.go#L651-L657 | train |
siddontang/ledisdb | ledis/t_list.go | LTTL | func (db *DB) LTTL(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return -1, err
}
return db.ttl(ListType, key)
} | go | func (db *DB) LTTL(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return -1, err
}
return db.ttl(ListType, key)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"LTTL",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"-",
"1",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"db",
".",
"ttl",
"(",
"ListType",
",",
"key",
")",
"\n",
"}"
] | // LTTL gets the TTL of list. | [
"LTTL",
"gets",
"the",
"TTL",
"of",
"list",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_list.go#L660-L666 | train |
siddontang/ledisdb | ledis/t_list.go | LPersist | func (db *DB) LPersist(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.listBatch
t.Lock()
defer t.Unlock()
n, err := db.rmExpire(t, ListType, key)
if err != nil {
return 0, err
}
err = t.Commit()
return n, err
} | go | func (db *DB) LPersist(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.listBatch
t.Lock()
defer t.Unlock()
n, err := db.rmExpire(t, ListType, key)
if err != nil {
return 0, err
}
err = t.Commit()
return n, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"LPersist",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"t",
":=",
"db",
".",
"listBatch",
"\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n\n",
"n",
",",
"err",
":=",
"db",
".",
"rmExpire",
"(",
"t",
",",
"ListType",
",",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"t",
".",
"Commit",
"(",
")",
"\n",
"return",
"n",
",",
"err",
"\n",
"}"
] | // LPersist removes the TTL of list. | [
"LPersist",
"removes",
"the",
"TTL",
"of",
"list",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_list.go#L669-L685 | train |
siddontang/ledisdb | ledis/t_list.go | BLPop | func (db *DB) BLPop(keys [][]byte, timeout time.Duration) ([]interface{}, error) {
return db.lblockPop(keys, listHeadSeq, timeout)
} | go | func (db *DB) BLPop(keys [][]byte, timeout time.Duration) ([]interface{}, error) {
return db.lblockPop(keys, listHeadSeq, timeout)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"BLPop",
"(",
"keys",
"[",
"]",
"[",
"]",
"byte",
",",
"timeout",
"time",
".",
"Duration",
")",
"(",
"[",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"return",
"db",
".",
"lblockPop",
"(",
"keys",
",",
"listHeadSeq",
",",
"timeout",
")",
"\n",
"}"
] | // BLPop pops the list with block way. | [
"BLPop",
"pops",
"the",
"list",
"with",
"block",
"way",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_list.go#L698-L700 | train |
siddontang/ledisdb | ledis/t_list.go | BRPop | func (db *DB) BRPop(keys [][]byte, timeout time.Duration) ([]interface{}, error) {
return db.lblockPop(keys, listTailSeq, timeout)
} | go | func (db *DB) BRPop(keys [][]byte, timeout time.Duration) ([]interface{}, error) {
return db.lblockPop(keys, listTailSeq, timeout)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"BRPop",
"(",
"keys",
"[",
"]",
"[",
"]",
"byte",
",",
"timeout",
"time",
".",
"Duration",
")",
"(",
"[",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"return",
"db",
".",
"lblockPop",
"(",
"keys",
",",
"listTailSeq",
",",
"timeout",
")",
"\n",
"}"
] | // BRPop bpops the list with block way. | [
"BRPop",
"bpops",
"the",
"list",
"with",
"block",
"way",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_list.go#L703-L705 | train |
siddontang/ledisdb | ledis/t_list.go | LKeyExists | func (db *DB) LKeyExists(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
sk := db.lEncodeMetaKey(key)
v, err := db.bucket.Get(sk)
if v != nil && err == nil {
return 1, nil
}
return 0, err
} | go | func (db *DB) LKeyExists(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
sk := db.lEncodeMetaKey(key)
v, err := db.bucket.Get(sk)
if v != nil && err == nil {
return 1, nil
}
return 0, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"LKeyExists",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"sk",
":=",
"db",
".",
"lEncodeMetaKey",
"(",
"key",
")",
"\n",
"v",
",",
"err",
":=",
"db",
".",
"bucket",
".",
"Get",
"(",
"sk",
")",
"\n",
"if",
"v",
"!=",
"nil",
"&&",
"err",
"==",
"nil",
"{",
"return",
"1",
",",
"nil",
"\n",
"}",
"\n",
"return",
"0",
",",
"err",
"\n",
"}"
] | // LKeyExists check list existed or not. | [
"LKeyExists",
"check",
"list",
"existed",
"or",
"not",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_list.go#L708-L718 | train |
siddontang/ledisdb | server/cmd_migrate.go | xrestoreCommand | func xrestoreCommand(c *client) error {
args := c.args
if len(args) != 4 {
return ErrCmdParams
}
// tp := strings.ToUpper(string(args[2]))
key := args[1]
ttl, err := ledis.StrInt64(args[2], nil)
if err != nil {
return err
}
data := args[3]
if err = c.db.Restore(key, ttl, data); err != nil {
return err
} else {
c.resp.writeStatus(OK)
}
return nil
} | go | func xrestoreCommand(c *client) error {
args := c.args
if len(args) != 4 {
return ErrCmdParams
}
// tp := strings.ToUpper(string(args[2]))
key := args[1]
ttl, err := ledis.StrInt64(args[2], nil)
if err != nil {
return err
}
data := args[3]
if err = c.db.Restore(key, ttl, data); err != nil {
return err
} else {
c.resp.writeStatus(OK)
}
return nil
} | [
"func",
"xrestoreCommand",
"(",
"c",
"*",
"client",
")",
"error",
"{",
"args",
":=",
"c",
".",
"args",
"\n",
"if",
"len",
"(",
"args",
")",
"!=",
"4",
"{",
"return",
"ErrCmdParams",
"\n",
"}",
"\n\n",
"//\ttp := strings.ToUpper(string(args[2]))",
"key",
":=",
"args",
"[",
"1",
"]",
"\n",
"ttl",
",",
"err",
":=",
"ledis",
".",
"StrInt64",
"(",
"args",
"[",
"2",
"]",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"data",
":=",
"args",
"[",
"3",
"]",
"\n\n",
"if",
"err",
"=",
"c",
".",
"db",
".",
"Restore",
"(",
"key",
",",
"ttl",
",",
"data",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"else",
"{",
"c",
".",
"resp",
".",
"writeStatus",
"(",
"OK",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // maybe only used in xcodis for redis data port | [
"maybe",
"only",
"used",
"in",
"xcodis",
"for",
"redis",
"data",
"port"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/server/cmd_migrate.go#L115-L136 | train |
siddontang/ledisdb | server/cmd_migrate.go | xmigratedbCommand | func xmigratedbCommand(c *client) error {
args := c.args
if len(args) != 6 {
return ErrCmdParams
}
addr := fmt.Sprintf("%s:%s", string(args[0]), string(args[1]))
if addr == c.app.cfg.Addr {
//same server， can not migrate
return fmt.Errorf("migrate in same server is not allowed")
}
tp := strings.ToUpper(string(args[2]))
count, err := ledis.StrInt64(args[3], nil)
if err != nil {
return err
} else if count <= 0 {
count = 10
}
db, err := parseMigrateDB(c, args[4])
if err != nil {
return err
}
timeout, err := ledis.StrInt64(args[5], nil)
if err != nil {
return err
} else if timeout < 0 {
return fmt.Errorf("invalid timeout %d", timeout)
}
keys, err := xscan(c.db, tp, int(count))
if err != nil {
return err
} else if len(keys) == 0 {
c.resp.writeInteger(0)
return nil
}
conn, err := getMigrateDBConn(c, addr, db)
if err != nil {
return err
}
defer conn.Close()
migrateNum := int64(0)
for _, key := range keys {
err = migrateKey(c, conn, tp, key, timeout)
if err != nil {
if err == errNoKey || err == errKeyInMigrating {
continue
} else {
return err
}
}
migrateNum++
}
c.resp.writeInteger(migrateNum)
return nil
} | go | func xmigratedbCommand(c *client) error {
args := c.args
if len(args) != 6 {
return ErrCmdParams
}
addr := fmt.Sprintf("%s:%s", string(args[0]), string(args[1]))
if addr == c.app.cfg.Addr {
//same server， can not migrate
return fmt.Errorf("migrate in same server is not allowed")
}
tp := strings.ToUpper(string(args[2]))
count, err := ledis.StrInt64(args[3], nil)
if err != nil {
return err
} else if count <= 0 {
count = 10
}
db, err := parseMigrateDB(c, args[4])
if err != nil {
return err
}
timeout, err := ledis.StrInt64(args[5], nil)
if err != nil {
return err
} else if timeout < 0 {
return fmt.Errorf("invalid timeout %d", timeout)
}
keys, err := xscan(c.db, tp, int(count))
if err != nil {
return err
} else if len(keys) == 0 {
c.resp.writeInteger(0)
return nil
}
conn, err := getMigrateDBConn(c, addr, db)
if err != nil {
return err
}
defer conn.Close()
migrateNum := int64(0)
for _, key := range keys {
err = migrateKey(c, conn, tp, key, timeout)
if err != nil {
if err == errNoKey || err == errKeyInMigrating {
continue
} else {
return err
}
}
migrateNum++
}
c.resp.writeInteger(migrateNum)
return nil
} | [
"func",
"xmigratedbCommand",
"(",
"c",
"*",
"client",
")",
"error",
"{",
"args",
":=",
"c",
".",
"args",
"\n",
"if",
"len",
"(",
"args",
")",
"!=",
"6",
"{",
"return",
"ErrCmdParams",
"\n",
"}",
"\n\n",
"addr",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"string",
"(",
"args",
"[",
"0",
"]",
")",
",",
"string",
"(",
"args",
"[",
"1",
"]",
")",
")",
"\n",
"if",
"addr",
"==",
"c",
".",
"app",
".",
"cfg",
".",
"Addr",
"{",
"//same server， can not migrate",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"tp",
":=",
"strings",
".",
"ToUpper",
"(",
"string",
"(",
"args",
"[",
"2",
"]",
")",
")",
"\n\n",
"count",
",",
"err",
":=",
"ledis",
".",
"StrInt64",
"(",
"args",
"[",
"3",
"]",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"else",
"if",
"count",
"<=",
"0",
"{",
"count",
"=",
"10",
"\n",
"}",
"\n\n",
"db",
",",
"err",
":=",
"parseMigrateDB",
"(",
"c",
",",
"args",
"[",
"4",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"timeout",
",",
"err",
":=",
"ledis",
".",
"StrInt64",
"(",
"args",
"[",
"5",
"]",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"else",
"if",
"timeout",
"<",
"0",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"timeout",
")",
"\n",
"}",
"\n\n",
"keys",
",",
"err",
":=",
"xscan",
"(",
"c",
".",
"db",
",",
"tp",
",",
"int",
"(",
"count",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"else",
"if",
"len",
"(",
"keys",
")",
"==",
"0",
"{",
"c",
".",
"resp",
".",
"writeInteger",
"(",
"0",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"conn",
",",
"err",
":=",
"getMigrateDBConn",
"(",
"c",
",",
"addr",
",",
"db",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"conn",
".",
"Close",
"(",
")",
"\n\n",
"migrateNum",
":=",
"int64",
"(",
"0",
")",
"\n",
"for",
"_",
",",
"key",
":=",
"range",
"keys",
"{",
"err",
"=",
"migrateKey",
"(",
"c",
",",
"conn",
",",
"tp",
",",
"key",
",",
"timeout",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"errNoKey",
"||",
"err",
"==",
"errKeyInMigrating",
"{",
"continue",
"\n",
"}",
"else",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"migrateNum",
"++",
"\n",
"}",
"\n\n",
"c",
".",
"resp",
".",
"writeInteger",
"(",
"migrateNum",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | //XMIGRATEDB host port tp count db timeout
//select count tp type keys and migrate
//will block any other write operations
//maybe only for xcodis | [
"XMIGRATEDB",
"host",
"port",
"tp",
"count",
"db",
"timeout",
"select",
"count",
"tp",
"type",
"keys",
"and",
"migrate",
"will",
"block",
"any",
"other",
"write",
"operations",
"maybe",
"only",
"for",
"xcodis"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/server/cmd_migrate.go#L307-L371 | train |
siddontang/ledisdb | server/cmd_migrate.go | xmigrateCommand | func xmigrateCommand(c *client) error {
args := c.args
if len(args) != 6 {
return ErrCmdParams
}
addr := fmt.Sprintf("%s:%s", string(args[0]), string(args[1]))
if addr == c.app.cfg.Addr {
//same server， can not migrate
return fmt.Errorf("migrate in same server is not allowed")
}
tp := strings.ToUpper(string(args[2]))
key := args[3]
db, err := parseMigrateDB(c, args[4])
if err != nil {
return err
}
timeout, err := ledis.StrInt64(args[5], nil)
if err != nil {
return err
} else if timeout < 0 {
return fmt.Errorf("invalid timeout %d", timeout)
}
conn, err := getMigrateDBConn(c, addr, db)
if err != nil {
return err
}
defer conn.Close()
// if key is in migrating, we will wait 500ms and retry again
for i := 0; i < 10; i++ {
if tp == "ALL" {
// if tp is ALL, we will migrate the key in all types
// this feature is useful for xcodis RESTORE or other commands that we don't know the data type exactly
err = migrateAllTypeKeys(c, conn, key, timeout)
} else {
err = migrateKey(c, conn, tp, key, timeout)
}
if err != errKeyInMigrating {
break
} else {
log.Infof("%s key %s is in migrating, wait 500ms and retry", tp, key)
time.Sleep(500 * time.Millisecond)
}
}
if err != nil {
if err == errNoKey {
c.resp.writeStatus(NOKEY)
return nil
} else {
return err
}
}
c.resp.writeStatus(OK)
return nil
} | go | func xmigrateCommand(c *client) error {
args := c.args
if len(args) != 6 {
return ErrCmdParams
}
addr := fmt.Sprintf("%s:%s", string(args[0]), string(args[1]))
if addr == c.app.cfg.Addr {
//same server， can not migrate
return fmt.Errorf("migrate in same server is not allowed")
}
tp := strings.ToUpper(string(args[2]))
key := args[3]
db, err := parseMigrateDB(c, args[4])
if err != nil {
return err
}
timeout, err := ledis.StrInt64(args[5], nil)
if err != nil {
return err
} else if timeout < 0 {
return fmt.Errorf("invalid timeout %d", timeout)
}
conn, err := getMigrateDBConn(c, addr, db)
if err != nil {
return err
}
defer conn.Close()
// if key is in migrating, we will wait 500ms and retry again
for i := 0; i < 10; i++ {
if tp == "ALL" {
// if tp is ALL, we will migrate the key in all types
// this feature is useful for xcodis RESTORE or other commands that we don't know the data type exactly
err = migrateAllTypeKeys(c, conn, key, timeout)
} else {
err = migrateKey(c, conn, tp, key, timeout)
}
if err != errKeyInMigrating {
break
} else {
log.Infof("%s key %s is in migrating, wait 500ms and retry", tp, key)
time.Sleep(500 * time.Millisecond)
}
}
if err != nil {
if err == errNoKey {
c.resp.writeStatus(NOKEY)
return nil
} else {
return err
}
}
c.resp.writeStatus(OK)
return nil
} | [
"func",
"xmigrateCommand",
"(",
"c",
"*",
"client",
")",
"error",
"{",
"args",
":=",
"c",
".",
"args",
"\n\n",
"if",
"len",
"(",
"args",
")",
"!=",
"6",
"{",
"return",
"ErrCmdParams",
"\n",
"}",
"\n\n",
"addr",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"string",
"(",
"args",
"[",
"0",
"]",
")",
",",
"string",
"(",
"args",
"[",
"1",
"]",
")",
")",
"\n",
"if",
"addr",
"==",
"c",
".",
"app",
".",
"cfg",
".",
"Addr",
"{",
"//same server， can not migrate",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"tp",
":=",
"strings",
".",
"ToUpper",
"(",
"string",
"(",
"args",
"[",
"2",
"]",
")",
")",
"\n",
"key",
":=",
"args",
"[",
"3",
"]",
"\n",
"db",
",",
"err",
":=",
"parseMigrateDB",
"(",
"c",
",",
"args",
"[",
"4",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"timeout",
",",
"err",
":=",
"ledis",
".",
"StrInt64",
"(",
"args",
"[",
"5",
"]",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"else",
"if",
"timeout",
"<",
"0",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"timeout",
")",
"\n",
"}",
"\n\n",
"conn",
",",
"err",
":=",
"getMigrateDBConn",
"(",
"c",
",",
"addr",
",",
"db",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"conn",
".",
"Close",
"(",
")",
"\n\n",
"// if key is in migrating, we will wait 500ms and retry again",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"10",
";",
"i",
"++",
"{",
"if",
"tp",
"==",
"\"",
"\"",
"{",
"// if tp is ALL, we will migrate the key in all types",
"// this feature is useful for xcodis RESTORE or other commands that we don't know the data type exactly",
"err",
"=",
"migrateAllTypeKeys",
"(",
"c",
",",
"conn",
",",
"key",
",",
"timeout",
")",
"\n",
"}",
"else",
"{",
"err",
"=",
"migrateKey",
"(",
"c",
",",
"conn",
",",
"tp",
",",
"key",
",",
"timeout",
")",
"\n",
"}",
"\n\n",
"if",
"err",
"!=",
"errKeyInMigrating",
"{",
"break",
"\n",
"}",
"else",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"tp",
",",
"key",
")",
"\n",
"time",
".",
"Sleep",
"(",
"500",
"*",
"time",
".",
"Millisecond",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"errNoKey",
"{",
"c",
".",
"resp",
".",
"writeStatus",
"(",
"NOKEY",
")",
"\n",
"return",
"nil",
"\n",
"}",
"else",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"c",
".",
"resp",
".",
"writeStatus",
"(",
"OK",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | //XMIGRATE host port type key destination-db timeout
//will block any other write operations
//maybe only for xcodis | [
"XMIGRATE",
"host",
"port",
"type",
"key",
"destination",
"-",
"db",
"timeout",
"will",
"block",
"any",
"other",
"write",
"operations",
"maybe",
"only",
"for",
"xcodis"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/server/cmd_migrate.go#L386-L448 | train |
siddontang/ledisdb | ledis/dump.go | Read | func (h *DumpHead) Read(r io.Reader) error {
return binary.Read(r, binary.BigEndian, &h.CommitID)
} | go | func (h *DumpHead) Read(r io.Reader) error {
return binary.Read(r, binary.BigEndian, &h.CommitID)
} | [
"func",
"(",
"h",
"*",
"DumpHead",
")",
"Read",
"(",
"r",
"io",
".",
"Reader",
")",
"error",
"{",
"return",
"binary",
".",
"Read",
"(",
"r",
",",
"binary",
".",
"BigEndian",
",",
"&",
"h",
".",
"CommitID",
")",
"\n",
"}"
] | // Read reads meta from the Reader. | [
"Read",
"reads",
"meta",
"from",
"the",
"Reader",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/dump.go#L20-L22 | train |
siddontang/ledisdb | ledis/dump.go | Write | func (h *DumpHead) Write(w io.Writer) error {
return binary.Write(w, binary.BigEndian, h.CommitID)
} | go | func (h *DumpHead) Write(w io.Writer) error {
return binary.Write(w, binary.BigEndian, h.CommitID)
} | [
"func",
"(",
"h",
"*",
"DumpHead",
")",
"Write",
"(",
"w",
"io",
".",
"Writer",
")",
"error",
"{",
"return",
"binary",
".",
"Write",
"(",
"w",
",",
"binary",
".",
"BigEndian",
",",
"h",
".",
"CommitID",
")",
"\n",
"}"
] | // Write writes meta to the Writer | [
"Write",
"writes",
"meta",
"to",
"the",
"Writer"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/dump.go#L25-L27 | train |
siddontang/ledisdb | ledis/dump.go | DumpFile | func (l *Ledis) DumpFile(path string) error {
f, err := os.Create(path)
if err != nil {
return err
}
defer f.Close()
return l.Dump(f)
} | go | func (l *Ledis) DumpFile(path string) error {
f, err := os.Create(path)
if err != nil {
return err
}
defer f.Close()
return l.Dump(f)
} | [
"func",
"(",
"l",
"*",
"Ledis",
")",
"DumpFile",
"(",
"path",
"string",
")",
"error",
"{",
"f",
",",
"err",
":=",
"os",
".",
"Create",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"f",
".",
"Close",
"(",
")",
"\n\n",
"return",
"l",
".",
"Dump",
"(",
"f",
")",
"\n",
"}"
] | // DumpFile dumps data to the file | [
"DumpFile",
"dumps",
"data",
"to",
"the",
"file"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/dump.go#L30-L38 | train |
siddontang/ledisdb | ledis/dump.go | Dump | func (l *Ledis) Dump(w io.Writer) error {
var err error
var commitID uint64
var snap *store.Snapshot
l.wLock.Lock()
if l.r != nil {
if commitID, err = l.r.LastCommitID(); err != nil {
l.wLock.Unlock()
return err
}
}
if snap, err = l.ldb.NewSnapshot(); err != nil {
l.wLock.Unlock()
return err
}
defer snap.Close()
l.wLock.Unlock()
wb := bufio.NewWriterSize(w, 4096)
h := &DumpHead{commitID}
if err = h.Write(wb); err != nil {
return err
}
it := snap.NewIterator()
defer it.Close()
it.SeekToFirst()
compressBuf := make([]byte, 4096)
var key []byte
var value []byte
for ; it.Valid(); it.Next() {
key = it.RawKey()
value = it.RawValue()
if key, err = snappy.Encode(compressBuf, key); err != nil {
return err
}
if err = binary.Write(wb, binary.BigEndian, uint16(len(key))); err != nil {
return err
}
if _, err = wb.Write(key); err != nil {
return err
}
if value, err = snappy.Encode(compressBuf, value); err != nil {
return err
}
if err = binary.Write(wb, binary.BigEndian, uint32(len(value))); err != nil {
return err
}
if _, err = wb.Write(value); err != nil {
return err
}
}
if err = wb.Flush(); err != nil {
return err
}
compressBuf = nil
return nil
} | go | func (l *Ledis) Dump(w io.Writer) error {
var err error
var commitID uint64
var snap *store.Snapshot
l.wLock.Lock()
if l.r != nil {
if commitID, err = l.r.LastCommitID(); err != nil {
l.wLock.Unlock()
return err
}
}
if snap, err = l.ldb.NewSnapshot(); err != nil {
l.wLock.Unlock()
return err
}
defer snap.Close()
l.wLock.Unlock()
wb := bufio.NewWriterSize(w, 4096)
h := &DumpHead{commitID}
if err = h.Write(wb); err != nil {
return err
}
it := snap.NewIterator()
defer it.Close()
it.SeekToFirst()
compressBuf := make([]byte, 4096)
var key []byte
var value []byte
for ; it.Valid(); it.Next() {
key = it.RawKey()
value = it.RawValue()
if key, err = snappy.Encode(compressBuf, key); err != nil {
return err
}
if err = binary.Write(wb, binary.BigEndian, uint16(len(key))); err != nil {
return err
}
if _, err = wb.Write(key); err != nil {
return err
}
if value, err = snappy.Encode(compressBuf, value); err != nil {
return err
}
if err = binary.Write(wb, binary.BigEndian, uint32(len(value))); err != nil {
return err
}
if _, err = wb.Write(value); err != nil {
return err
}
}
if err = wb.Flush(); err != nil {
return err
}
compressBuf = nil
return nil
} | [
"func",
"(",
"l",
"*",
"Ledis",
")",
"Dump",
"(",
"w",
"io",
".",
"Writer",
")",
"error",
"{",
"var",
"err",
"error",
"\n\n",
"var",
"commitID",
"uint64",
"\n",
"var",
"snap",
"*",
"store",
".",
"Snapshot",
"\n\n",
"l",
".",
"wLock",
".",
"Lock",
"(",
")",
"\n\n",
"if",
"l",
".",
"r",
"!=",
"nil",
"{",
"if",
"commitID",
",",
"err",
"=",
"l",
".",
"r",
".",
"LastCommitID",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"l",
".",
"wLock",
".",
"Unlock",
"(",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"snap",
",",
"err",
"=",
"l",
".",
"ldb",
".",
"NewSnapshot",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"l",
".",
"wLock",
".",
"Unlock",
"(",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"snap",
".",
"Close",
"(",
")",
"\n\n",
"l",
".",
"wLock",
".",
"Unlock",
"(",
")",
"\n\n",
"wb",
":=",
"bufio",
".",
"NewWriterSize",
"(",
"w",
",",
"4096",
")",
"\n\n",
"h",
":=",
"&",
"DumpHead",
"{",
"commitID",
"}",
"\n\n",
"if",
"err",
"=",
"h",
".",
"Write",
"(",
"wb",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"it",
":=",
"snap",
".",
"NewIterator",
"(",
")",
"\n",
"defer",
"it",
".",
"Close",
"(",
")",
"\n",
"it",
".",
"SeekToFirst",
"(",
")",
"\n\n",
"compressBuf",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"4096",
")",
"\n\n",
"var",
"key",
"[",
"]",
"byte",
"\n",
"var",
"value",
"[",
"]",
"byte",
"\n",
"for",
";",
"it",
".",
"Valid",
"(",
")",
";",
"it",
".",
"Next",
"(",
")",
"{",
"key",
"=",
"it",
".",
"RawKey",
"(",
")",
"\n",
"value",
"=",
"it",
".",
"RawValue",
"(",
")",
"\n\n",
"if",
"key",
",",
"err",
"=",
"snappy",
".",
"Encode",
"(",
"compressBuf",
",",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
"=",
"binary",
".",
"Write",
"(",
"wb",
",",
"binary",
".",
"BigEndian",
",",
"uint16",
"(",
"len",
"(",
"key",
")",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"err",
"=",
"wb",
".",
"Write",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"value",
",",
"err",
"=",
"snappy",
".",
"Encode",
"(",
"compressBuf",
",",
"value",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
"=",
"binary",
".",
"Write",
"(",
"wb",
",",
"binary",
".",
"BigEndian",
",",
"uint32",
"(",
"len",
"(",
"value",
")",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"err",
"=",
"wb",
".",
"Write",
"(",
"value",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"err",
"=",
"wb",
".",
"Flush",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"compressBuf",
"=",
"nil",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Dump dumps data to the Writer. | [
"Dump",
"dumps",
"data",
"to",
"the",
"Writer",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/dump.go#L41-L116 | train |
siddontang/ledisdb | ledis/dump.go | LoadDumpFile | func (l *Ledis) LoadDumpFile(path string) (*DumpHead, error) {
f, err := os.Open(path)
if err != nil {
return nil, err
}
defer f.Close()
return l.LoadDump(f)
} | go | func (l *Ledis) LoadDumpFile(path string) (*DumpHead, error) {
f, err := os.Open(path)
if err != nil {
return nil, err
}
defer f.Close()
return l.LoadDump(f)
} | [
"func",
"(",
"l",
"*",
"Ledis",
")",
"LoadDumpFile",
"(",
"path",
"string",
")",
"(",
"*",
"DumpHead",
",",
"error",
")",
"{",
"f",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"f",
".",
"Close",
"(",
")",
"\n\n",
"return",
"l",
".",
"LoadDump",
"(",
"f",
")",
"\n",
"}"
] | // LoadDumpFile clears all data and loads dump file to db | [
"LoadDumpFile",
"clears",
"all",
"data",
"and",
"loads",
"dump",
"file",
"to",
"db"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/dump.go#L119-L127 | train |
siddontang/ledisdb | ledis/dump.go | LoadDump | func (l *Ledis) LoadDump(r io.Reader) (*DumpHead, error) {
l.wLock.Lock()
defer l.wLock.Unlock()
var err error
if err = l.flushAll(); err != nil {
return nil, err
}
rb := bufio.NewReaderSize(r, 4096)
h := new(DumpHead)
if err = h.Read(rb); err != nil {
return nil, err
}
var keyLen uint16
var valueLen uint32
var keyBuf bytes.Buffer
var valueBuf bytes.Buffer
deKeyBuf := make([]byte, 4096)
deValueBuf := make([]byte, 4096)
var key, value []byte
wb := l.ldb.NewWriteBatch()
defer wb.Close()
n := 0
for {
if err = binary.Read(rb, binary.BigEndian, &keyLen); err != nil && err != io.EOF {
return nil, err
} else if err == io.EOF {
break
}
if _, err = io.CopyN(&keyBuf, rb, int64(keyLen)); err != nil {
return nil, err
}
if key, err = snappy.Decode(deKeyBuf, keyBuf.Bytes()); err != nil {
return nil, err
}
if err = binary.Read(rb, binary.BigEndian, &valueLen); err != nil {
return nil, err
}
if _, err = io.CopyN(&valueBuf, rb, int64(valueLen)); err != nil {
return nil, err
}
if value, err = snappy.Decode(deValueBuf, valueBuf.Bytes()); err != nil {
return nil, err
}
wb.Put(key, value)
n++
if n%1024 == 0 {
if err = wb.Commit(); err != nil {
return nil, err
}
}
// if err = l.ldb.Put(key, value); err != nil {
// return nil, err
// }
keyBuf.Reset()
valueBuf.Reset()
}
if err = wb.Commit(); err != nil {
return nil, err
}
deKeyBuf = nil
deValueBuf = nil
if l.r != nil {
if err := l.r.UpdateCommitID(h.CommitID); err != nil {
return nil, err
}
}
return h, nil
} | go | func (l *Ledis) LoadDump(r io.Reader) (*DumpHead, error) {
l.wLock.Lock()
defer l.wLock.Unlock()
var err error
if err = l.flushAll(); err != nil {
return nil, err
}
rb := bufio.NewReaderSize(r, 4096)
h := new(DumpHead)
if err = h.Read(rb); err != nil {
return nil, err
}
var keyLen uint16
var valueLen uint32
var keyBuf bytes.Buffer
var valueBuf bytes.Buffer
deKeyBuf := make([]byte, 4096)
deValueBuf := make([]byte, 4096)
var key, value []byte
wb := l.ldb.NewWriteBatch()
defer wb.Close()
n := 0
for {
if err = binary.Read(rb, binary.BigEndian, &keyLen); err != nil && err != io.EOF {
return nil, err
} else if err == io.EOF {
break
}
if _, err = io.CopyN(&keyBuf, rb, int64(keyLen)); err != nil {
return nil, err
}
if key, err = snappy.Decode(deKeyBuf, keyBuf.Bytes()); err != nil {
return nil, err
}
if err = binary.Read(rb, binary.BigEndian, &valueLen); err != nil {
return nil, err
}
if _, err = io.CopyN(&valueBuf, rb, int64(valueLen)); err != nil {
return nil, err
}
if value, err = snappy.Decode(deValueBuf, valueBuf.Bytes()); err != nil {
return nil, err
}
wb.Put(key, value)
n++
if n%1024 == 0 {
if err = wb.Commit(); err != nil {
return nil, err
}
}
// if err = l.ldb.Put(key, value); err != nil {
// return nil, err
// }
keyBuf.Reset()
valueBuf.Reset()
}
if err = wb.Commit(); err != nil {
return nil, err
}
deKeyBuf = nil
deValueBuf = nil
if l.r != nil {
if err := l.r.UpdateCommitID(h.CommitID); err != nil {
return nil, err
}
}
return h, nil
} | [
"func",
"(",
"l",
"*",
"Ledis",
")",
"LoadDump",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"*",
"DumpHead",
",",
"error",
")",
"{",
"l",
".",
"wLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"l",
".",
"wLock",
".",
"Unlock",
"(",
")",
"\n\n",
"var",
"err",
"error",
"\n",
"if",
"err",
"=",
"l",
".",
"flushAll",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"rb",
":=",
"bufio",
".",
"NewReaderSize",
"(",
"r",
",",
"4096",
")",
"\n\n",
"h",
":=",
"new",
"(",
"DumpHead",
")",
"\n\n",
"if",
"err",
"=",
"h",
".",
"Read",
"(",
"rb",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"keyLen",
"uint16",
"\n",
"var",
"valueLen",
"uint32",
"\n\n",
"var",
"keyBuf",
"bytes",
".",
"Buffer",
"\n",
"var",
"valueBuf",
"bytes",
".",
"Buffer",
"\n\n",
"deKeyBuf",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"4096",
")",
"\n",
"deValueBuf",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"4096",
")",
"\n\n",
"var",
"key",
",",
"value",
"[",
"]",
"byte",
"\n\n",
"wb",
":=",
"l",
".",
"ldb",
".",
"NewWriteBatch",
"(",
")",
"\n",
"defer",
"wb",
".",
"Close",
"(",
")",
"\n\n",
"n",
":=",
"0",
"\n\n",
"for",
"{",
"if",
"err",
"=",
"binary",
".",
"Read",
"(",
"rb",
",",
"binary",
".",
"BigEndian",
",",
"&",
"keyLen",
")",
";",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"io",
".",
"EOF",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"else",
"if",
"err",
"==",
"io",
".",
"EOF",
"{",
"break",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"err",
"=",
"io",
".",
"CopyN",
"(",
"&",
"keyBuf",
",",
"rb",
",",
"int64",
"(",
"keyLen",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"key",
",",
"err",
"=",
"snappy",
".",
"Decode",
"(",
"deKeyBuf",
",",
"keyBuf",
".",
"Bytes",
"(",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
"=",
"binary",
".",
"Read",
"(",
"rb",
",",
"binary",
".",
"BigEndian",
",",
"&",
"valueLen",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"err",
"=",
"io",
".",
"CopyN",
"(",
"&",
"valueBuf",
",",
"rb",
",",
"int64",
"(",
"valueLen",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"value",
",",
"err",
"=",
"snappy",
".",
"Decode",
"(",
"deValueBuf",
",",
"valueBuf",
".",
"Bytes",
"(",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"wb",
".",
"Put",
"(",
"key",
",",
"value",
")",
"\n",
"n",
"++",
"\n",
"if",
"n",
"%",
"1024",
"==",
"0",
"{",
"if",
"err",
"=",
"wb",
".",
"Commit",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"// if err = l.ldb.Put(key, value); err != nil {",
"// \treturn nil, err",
"// }",
"keyBuf",
".",
"Reset",
"(",
")",
"\n",
"valueBuf",
".",
"Reset",
"(",
")",
"\n",
"}",
"\n\n",
"if",
"err",
"=",
"wb",
".",
"Commit",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"deKeyBuf",
"=",
"nil",
"\n",
"deValueBuf",
"=",
"nil",
"\n\n",
"if",
"l",
".",
"r",
"!=",
"nil",
"{",
"if",
"err",
":=",
"l",
".",
"r",
".",
"UpdateCommitID",
"(",
"h",
".",
"CommitID",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"h",
",",
"nil",
"\n",
"}"
] | // LoadDump clears all data and loads dump file to db | [
"LoadDump",
"clears",
"all",
"data",
"and",
"loads",
"dump",
"file",
"to",
"db"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/dump.go#L130-L220 | train |
siddontang/ledisdb | ledis/t_set.go | SAdd | func (db *DB) SAdd(key []byte, args ...[]byte) (int64, error) {
t := db.setBatch
t.Lock()
defer t.Unlock()
var err error
var ek []byte
var num int64
for i := 0; i < len(args); i++ {
if err := checkSetKMSize(key, args[i]); err != nil {
return 0, err
}
ek = db.sEncodeSetKey(key, args[i])
if v, err := db.bucket.Get(ek); err != nil {
return 0, err
} else if v == nil {
num++
}
t.Put(ek, nil)
}
if _, err = db.sIncrSize(key, num); err != nil {
return 0, err
}
err = t.Commit()
return num, err
} | go | func (db *DB) SAdd(key []byte, args ...[]byte) (int64, error) {
t := db.setBatch
t.Lock()
defer t.Unlock()
var err error
var ek []byte
var num int64
for i := 0; i < len(args); i++ {
if err := checkSetKMSize(key, args[i]); err != nil {
return 0, err
}
ek = db.sEncodeSetKey(key, args[i])
if v, err := db.bucket.Get(ek); err != nil {
return 0, err
} else if v == nil {
num++
}
t.Put(ek, nil)
}
if _, err = db.sIncrSize(key, num); err != nil {
return 0, err
}
err = t.Commit()
return num, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"SAdd",
"(",
"key",
"[",
"]",
"byte",
",",
"args",
"...",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"t",
":=",
"db",
".",
"setBatch",
"\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n\n",
"var",
"err",
"error",
"\n",
"var",
"ek",
"[",
"]",
"byte",
"\n",
"var",
"num",
"int64",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"args",
")",
";",
"i",
"++",
"{",
"if",
"err",
":=",
"checkSetKMSize",
"(",
"key",
",",
"args",
"[",
"i",
"]",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"ek",
"=",
"db",
".",
"sEncodeSetKey",
"(",
"key",
",",
"args",
"[",
"i",
"]",
")",
"\n\n",
"if",
"v",
",",
"err",
":=",
"db",
".",
"bucket",
".",
"Get",
"(",
"ek",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"else",
"if",
"v",
"==",
"nil",
"{",
"num",
"++",
"\n",
"}",
"\n\n",
"t",
".",
"Put",
"(",
"ek",
",",
"nil",
")",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"err",
"=",
"db",
".",
"sIncrSize",
"(",
"key",
",",
"num",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"t",
".",
"Commit",
"(",
")",
"\n",
"return",
"num",
",",
"err",
"\n\n",
"}"
] | // SAdd adds the value to the set. | [
"SAdd",
"adds",
"the",
"value",
"to",
"the",
"set",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_set.go#L210-L241 | train |
siddontang/ledisdb | ledis/t_set.go | SCard | func (db *DB) SCard(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
sk := db.sEncodeSizeKey(key)
return Int64(db.bucket.Get(sk))
} | go | func (db *DB) SCard(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
sk := db.sEncodeSizeKey(key)
return Int64(db.bucket.Get(sk))
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"SCard",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"sk",
":=",
"db",
".",
"sEncodeSizeKey",
"(",
"key",
")",
"\n\n",
"return",
"Int64",
"(",
"db",
".",
"bucket",
".",
"Get",
"(",
"sk",
")",
")",
"\n",
"}"
] | // SCard gets the size of set. | [
"SCard",
"gets",
"the",
"size",
"of",
"set",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_set.go#L244-L252 | train |
siddontang/ledisdb | ledis/t_set.go | SDiff | func (db *DB) SDiff(keys ...[]byte) ([][]byte, error) {
v, err := db.sDiffGeneric(keys...)
return v, err
} | go | func (db *DB) SDiff(keys ...[]byte) ([][]byte, error) {
v, err := db.sDiffGeneric(keys...)
return v, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"SDiff",
"(",
"keys",
"...",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"v",
",",
"err",
":=",
"db",
".",
"sDiffGeneric",
"(",
"keys",
"...",
")",
"\n",
"return",
"v",
",",
"err",
"\n",
"}"
] | // SDiff gets the different of sets. | [
"SDiff",
"gets",
"the",
"different",
"of",
"sets",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_set.go#L299-L302 | train |
siddontang/ledisdb | ledis/t_set.go | SDiffStore | func (db *DB) SDiffStore(dstKey []byte, keys ...[]byte) (int64, error) {
n, err := db.sStoreGeneric(dstKey, DiffType, keys...)
return n, err
} | go | func (db *DB) SDiffStore(dstKey []byte, keys ...[]byte) (int64, error) {
n, err := db.sStoreGeneric(dstKey, DiffType, keys...)
return n, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"SDiffStore",
"(",
"dstKey",
"[",
"]",
"byte",
",",
"keys",
"...",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"n",
",",
"err",
":=",
"db",
".",
"sStoreGeneric",
"(",
"dstKey",
",",
"DiffType",
",",
"keys",
"...",
")",
"\n",
"return",
"n",
",",
"err",
"\n",
"}"
] | // SDiffStore gets the different of sets and stores to dest set. | [
"SDiffStore",
"gets",
"the",
"different",
"of",
"sets",
"and",
"stores",
"to",
"dest",
"set",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_set.go#L305-L308 | train |
siddontang/ledisdb | ledis/t_set.go | SKeyExists | func (db *DB) SKeyExists(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
sk := db.sEncodeSizeKey(key)
v, err := db.bucket.Get(sk)
if v != nil && err == nil {
return 1, nil
}
return 0, err
} | go | func (db *DB) SKeyExists(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
sk := db.sEncodeSizeKey(key)
v, err := db.bucket.Get(sk)
if v != nil && err == nil {
return 1, nil
}
return 0, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"SKeyExists",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"sk",
":=",
"db",
".",
"sEncodeSizeKey",
"(",
"key",
")",
"\n",
"v",
",",
"err",
":=",
"db",
".",
"bucket",
".",
"Get",
"(",
"sk",
")",
"\n",
"if",
"v",
"!=",
"nil",
"&&",
"err",
"==",
"nil",
"{",
"return",
"1",
",",
"nil",
"\n",
"}",
"\n",
"return",
"0",
",",
"err",
"\n",
"}"
] | // SKeyExists checks whether set existed or not. | [
"SKeyExists",
"checks",
"whether",
"set",
"existed",
"or",
"not",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_set.go#L311-L321 | train |
siddontang/ledisdb | ledis/t_set.go | SInter | func (db *DB) SInter(keys ...[]byte) ([][]byte, error) {
v, err := db.sInterGeneric(keys...)
return v, err
} | go | func (db *DB) SInter(keys ...[]byte) ([][]byte, error) {
v, err := db.sInterGeneric(keys...)
return v, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"SInter",
"(",
"keys",
"...",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"v",
",",
"err",
":=",
"db",
".",
"sInterGeneric",
"(",
"keys",
"...",
")",
"\n",
"return",
"v",
",",
"err",
"\n\n",
"}"
] | // SInter intersects the sets. | [
"SInter",
"intersects",
"the",
"sets",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_set.go#L378-L382 | train |
siddontang/ledisdb | ledis/t_set.go | SInterStore | func (db *DB) SInterStore(dstKey []byte, keys ...[]byte) (int64, error) {
n, err := db.sStoreGeneric(dstKey, InterType, keys...)
return n, err
} | go | func (db *DB) SInterStore(dstKey []byte, keys ...[]byte) (int64, error) {
n, err := db.sStoreGeneric(dstKey, InterType, keys...)
return n, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"SInterStore",
"(",
"dstKey",
"[",
"]",
"byte",
",",
"keys",
"...",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"n",
",",
"err",
":=",
"db",
".",
"sStoreGeneric",
"(",
"dstKey",
",",
"InterType",
",",
"keys",
"...",
")",
"\n",
"return",
"n",
",",
"err",
"\n",
"}"
] | // SInterStore intersects the sets and stores to dest set. | [
"SInterStore",
"intersects",
"the",
"sets",
"and",
"stores",
"to",
"dest",
"set",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_set.go#L385-L388 | train |
siddontang/ledisdb | ledis/t_set.go | SIsMember | func (db *DB) SIsMember(key []byte, member []byte) (int64, error) {
ek := db.sEncodeSetKey(key, member)
var n int64 = 1
if v, err := db.bucket.Get(ek); err != nil {
return 0, err
} else if v == nil {
n = 0
}
return n, nil
} | go | func (db *DB) SIsMember(key []byte, member []byte) (int64, error) {
ek := db.sEncodeSetKey(key, member)
var n int64 = 1
if v, err := db.bucket.Get(ek); err != nil {
return 0, err
} else if v == nil {
n = 0
}
return n, nil
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"SIsMember",
"(",
"key",
"[",
"]",
"byte",
",",
"member",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"ek",
":=",
"db",
".",
"sEncodeSetKey",
"(",
"key",
",",
"member",
")",
"\n\n",
"var",
"n",
"int64",
"=",
"1",
"\n",
"if",
"v",
",",
"err",
":=",
"db",
".",
"bucket",
".",
"Get",
"(",
"ek",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"else",
"if",
"v",
"==",
"nil",
"{",
"n",
"=",
"0",
"\n",
"}",
"\n",
"return",
"n",
",",
"nil",
"\n",
"}"
] | // SIsMember checks member in set. | [
"SIsMember",
"checks",
"member",
"in",
"set",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_set.go#L391-L401 | train |
siddontang/ledisdb | ledis/t_set.go | SMembers | func (db *DB) SMembers(key []byte) ([][]byte, error) {
if err := checkKeySize(key); err != nil {
return nil, err
}
start := db.sEncodeStartKey(key)
stop := db.sEncodeStopKey(key)
v := make([][]byte, 0, 16)
it := db.bucket.RangeLimitIterator(start, stop, store.RangeROpen, 0, -1)
defer it.Close()
for ; it.Valid(); it.Next() {
_, m, err := db.sDecodeSetKey(it.Key())
if err != nil {
return nil, err
}
v = append(v, m)
}
return v, nil
} | go | func (db *DB) SMembers(key []byte) ([][]byte, error) {
if err := checkKeySize(key); err != nil {
return nil, err
}
start := db.sEncodeStartKey(key)
stop := db.sEncodeStopKey(key)
v := make([][]byte, 0, 16)
it := db.bucket.RangeLimitIterator(start, stop, store.RangeROpen, 0, -1)
defer it.Close()
for ; it.Valid(); it.Next() {
_, m, err := db.sDecodeSetKey(it.Key())
if err != nil {
return nil, err
}
v = append(v, m)
}
return v, nil
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"SMembers",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"start",
":=",
"db",
".",
"sEncodeStartKey",
"(",
"key",
")",
"\n",
"stop",
":=",
"db",
".",
"sEncodeStopKey",
"(",
"key",
")",
"\n\n",
"v",
":=",
"make",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"0",
",",
"16",
")",
"\n\n",
"it",
":=",
"db",
".",
"bucket",
".",
"RangeLimitIterator",
"(",
"start",
",",
"stop",
",",
"store",
".",
"RangeROpen",
",",
"0",
",",
"-",
"1",
")",
"\n",
"defer",
"it",
".",
"Close",
"(",
")",
"\n\n",
"for",
";",
"it",
".",
"Valid",
"(",
")",
";",
"it",
".",
"Next",
"(",
")",
"{",
"_",
",",
"m",
",",
"err",
":=",
"db",
".",
"sDecodeSetKey",
"(",
"it",
".",
"Key",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"v",
"=",
"append",
"(",
"v",
",",
"m",
")",
"\n",
"}",
"\n\n",
"return",
"v",
",",
"nil",
"\n",
"}"
] | // SMembers gets members of set. | [
"SMembers",
"gets",
"members",
"of",
"set",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_set.go#L404-L427 | train |
siddontang/ledisdb | ledis/t_set.go | SRem | func (db *DB) SRem(key []byte, args ...[]byte) (int64, error) {
t := db.setBatch
t.Lock()
defer t.Unlock()
var ek []byte
var v []byte
var err error
it := db.bucket.NewIterator()
defer it.Close()
var num int64
for i := 0; i < len(args); i++ {
if err := checkSetKMSize(key, args[i]); err != nil {
return 0, err
}
ek = db.sEncodeSetKey(key, args[i])
v = it.RawFind(ek)
if v == nil {
continue
} else {
num++
t.Delete(ek)
}
}
if _, err = db.sIncrSize(key, -num); err != nil {
return 0, err
}
err = t.Commit()
return num, err
} | go | func (db *DB) SRem(key []byte, args ...[]byte) (int64, error) {
t := db.setBatch
t.Lock()
defer t.Unlock()
var ek []byte
var v []byte
var err error
it := db.bucket.NewIterator()
defer it.Close()
var num int64
for i := 0; i < len(args); i++ {
if err := checkSetKMSize(key, args[i]); err != nil {
return 0, err
}
ek = db.sEncodeSetKey(key, args[i])
v = it.RawFind(ek)
if v == nil {
continue
} else {
num++
t.Delete(ek)
}
}
if _, err = db.sIncrSize(key, -num); err != nil {
return 0, err
}
err = t.Commit()
return num, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"SRem",
"(",
"key",
"[",
"]",
"byte",
",",
"args",
"...",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"t",
":=",
"db",
".",
"setBatch",
"\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n\n",
"var",
"ek",
"[",
"]",
"byte",
"\n",
"var",
"v",
"[",
"]",
"byte",
"\n",
"var",
"err",
"error",
"\n\n",
"it",
":=",
"db",
".",
"bucket",
".",
"NewIterator",
"(",
")",
"\n",
"defer",
"it",
".",
"Close",
"(",
")",
"\n\n",
"var",
"num",
"int64",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"args",
")",
";",
"i",
"++",
"{",
"if",
"err",
":=",
"checkSetKMSize",
"(",
"key",
",",
"args",
"[",
"i",
"]",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"ek",
"=",
"db",
".",
"sEncodeSetKey",
"(",
"key",
",",
"args",
"[",
"i",
"]",
")",
"\n\n",
"v",
"=",
"it",
".",
"RawFind",
"(",
"ek",
")",
"\n",
"if",
"v",
"==",
"nil",
"{",
"continue",
"\n",
"}",
"else",
"{",
"num",
"++",
"\n",
"t",
".",
"Delete",
"(",
"ek",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"err",
"=",
"db",
".",
"sIncrSize",
"(",
"key",
",",
"-",
"num",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"t",
".",
"Commit",
"(",
")",
"\n",
"return",
"num",
",",
"err",
"\n\n",
"}"
] | // SRem removes the members of set. | [
"SRem",
"removes",
"the",
"members",
"of",
"set",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_set.go#L430-L466 | train |
siddontang/ledisdb | ledis/t_set.go | SUnion | func (db *DB) SUnion(keys ...[]byte) ([][]byte, error) {
v, err := db.sUnionGeneric(keys...)
return v, err
} | go | func (db *DB) SUnion(keys ...[]byte) ([][]byte, error) {
v, err := db.sUnionGeneric(keys...)
return v, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"SUnion",
"(",
"keys",
"...",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"v",
",",
"err",
":=",
"db",
".",
"sUnionGeneric",
"(",
"keys",
"...",
")",
"\n",
"return",
"v",
",",
"err",
"\n",
"}"
] | // SUnion unions the sets. | [
"SUnion",
"unions",
"the",
"sets",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_set.go#L500-L503 | train |
siddontang/ledisdb | ledis/t_set.go | SUnionStore | func (db *DB) SUnionStore(dstKey []byte, keys ...[]byte) (int64, error) {
n, err := db.sStoreGeneric(dstKey, UnionType, keys...)
return n, err
} | go | func (db *DB) SUnionStore(dstKey []byte, keys ...[]byte) (int64, error) {
n, err := db.sStoreGeneric(dstKey, UnionType, keys...)
return n, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"SUnionStore",
"(",
"dstKey",
"[",
"]",
"byte",
",",
"keys",
"...",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"n",
",",
"err",
":=",
"db",
".",
"sStoreGeneric",
"(",
"dstKey",
",",
"UnionType",
",",
"keys",
"...",
")",
"\n",
"return",
"n",
",",
"err",
"\n",
"}"
] | // SUnionStore unions the sets and stores to the dest set. | [
"SUnionStore",
"unions",
"the",
"sets",
"and",
"stores",
"to",
"the",
"dest",
"set",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_set.go#L506-L509 | train |
siddontang/ledisdb | ledis/t_set.go | SClear | func (db *DB) SClear(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.setBatch
t.Lock()
defer t.Unlock()
num := db.sDelete(t, key)
db.rmExpire(t, SetType, key)
err := t.Commit()
return num, err
} | go | func (db *DB) SClear(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.setBatch
t.Lock()
defer t.Unlock()
num := db.sDelete(t, key)
db.rmExpire(t, SetType, key)
err := t.Commit()
return num, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"SClear",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"t",
":=",
"db",
".",
"setBatch",
"\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n\n",
"num",
":=",
"db",
".",
"sDelete",
"(",
"t",
",",
"key",
")",
"\n",
"db",
".",
"rmExpire",
"(",
"t",
",",
"SetType",
",",
"key",
")",
"\n\n",
"err",
":=",
"t",
".",
"Commit",
"(",
")",
"\n",
"return",
"num",
",",
"err",
"\n",
"}"
] | // SClear clears the set. | [
"SClear",
"clears",
"the",
"set",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_set.go#L564-L578 | train |
siddontang/ledisdb | ledis/t_set.go | SMclear | func (db *DB) SMclear(keys ...[]byte) (int64, error) {
t := db.setBatch
t.Lock()
defer t.Unlock()
for _, key := range keys {
if err := checkKeySize(key); err != nil {
return 0, err
}
db.sDelete(t, key)
db.rmExpire(t, SetType, key)
}
err := t.Commit()
return int64(len(keys)), err
} | go | func (db *DB) SMclear(keys ...[]byte) (int64, error) {
t := db.setBatch
t.Lock()
defer t.Unlock()
for _, key := range keys {
if err := checkKeySize(key); err != nil {
return 0, err
}
db.sDelete(t, key)
db.rmExpire(t, SetType, key)
}
err := t.Commit()
return int64(len(keys)), err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"SMclear",
"(",
"keys",
"...",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"t",
":=",
"db",
".",
"setBatch",
"\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n\n",
"for",
"_",
",",
"key",
":=",
"range",
"keys",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"db",
".",
"sDelete",
"(",
"t",
",",
"key",
")",
"\n",
"db",
".",
"rmExpire",
"(",
"t",
",",
"SetType",
",",
"key",
")",
"\n",
"}",
"\n\n",
"err",
":=",
"t",
".",
"Commit",
"(",
")",
"\n",
"return",
"int64",
"(",
"len",
"(",
"keys",
")",
")",
",",
"err",
"\n",
"}"
] | // SMclear clears multi sets. | [
"SMclear",
"clears",
"multi",
"sets",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_set.go#L581-L597 | train |
siddontang/ledisdb | ledis/t_set.go | SExpire | func (db *DB) SExpire(key []byte, duration int64) (int64, error) {
if duration <= 0 {
return 0, errExpireValue
}
return db.sExpireAt(key, time.Now().Unix()+duration)
} | go | func (db *DB) SExpire(key []byte, duration int64) (int64, error) {
if duration <= 0 {
return 0, errExpireValue
}
return db.sExpireAt(key, time.Now().Unix()+duration)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"SExpire",
"(",
"key",
"[",
"]",
"byte",
",",
"duration",
"int64",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"duration",
"<=",
"0",
"{",
"return",
"0",
",",
"errExpireValue",
"\n",
"}",
"\n\n",
"return",
"db",
".",
"sExpireAt",
"(",
"key",
",",
"time",
".",
"Now",
"(",
")",
".",
"Unix",
"(",
")",
"+",
"duration",
")",
"\n\n",
"}"
] | // SExpire expries the set. | [
"SExpire",
"expries",
"the",
"set",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_set.go#L600-L607 | train |
siddontang/ledisdb | ledis/t_set.go | SExpireAt | func (db *DB) SExpireAt(key []byte, when int64) (int64, error) {
if when <= time.Now().Unix() {
return 0, errExpireValue
}
return db.sExpireAt(key, when)
} | go | func (db *DB) SExpireAt(key []byte, when int64) (int64, error) {
if when <= time.Now().Unix() {
return 0, errExpireValue
}
return db.sExpireAt(key, when)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"SExpireAt",
"(",
"key",
"[",
"]",
"byte",
",",
"when",
"int64",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"when",
"<=",
"time",
".",
"Now",
"(",
")",
".",
"Unix",
"(",
")",
"{",
"return",
"0",
",",
"errExpireValue",
"\n",
"}",
"\n\n",
"return",
"db",
".",
"sExpireAt",
"(",
"key",
",",
"when",
")",
"\n\n",
"}"
] | // SExpireAt expires the set at when. | [
"SExpireAt",
"expires",
"the",
"set",
"at",
"when",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_set.go#L610-L617 | train |
siddontang/ledisdb | ledis/t_set.go | STTL | func (db *DB) STTL(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return -1, err
}
return db.ttl(SetType, key)
} | go | func (db *DB) STTL(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return -1, err
}
return db.ttl(SetType, key)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"STTL",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"-",
"1",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"db",
".",
"ttl",
"(",
"SetType",
",",
"key",
")",
"\n",
"}"
] | // STTL gets the TTL of set. | [
"STTL",
"gets",
"the",
"TTL",
"of",
"set",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_set.go#L620-L626 | train |
siddontang/ledisdb | ledis/t_set.go | SPersist | func (db *DB) SPersist(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.setBatch
t.Lock()
defer t.Unlock()
n, err := db.rmExpire(t, SetType, key)
if err != nil {
return 0, err
}
err = t.Commit()
return n, err
} | go | func (db *DB) SPersist(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.setBatch
t.Lock()
defer t.Unlock()
n, err := db.rmExpire(t, SetType, key)
if err != nil {
return 0, err
}
err = t.Commit()
return n, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"SPersist",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"t",
":=",
"db",
".",
"setBatch",
"\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n\n",
"n",
",",
"err",
":=",
"db",
".",
"rmExpire",
"(",
"t",
",",
"SetType",
",",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"err",
"=",
"t",
".",
"Commit",
"(",
")",
"\n",
"return",
"n",
",",
"err",
"\n",
"}"
] | // SPersist removes the TTL of set. | [
"SPersist",
"removes",
"the",
"TTL",
"of",
"set",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_set.go#L629-L644 | train |
siddontang/ledisdb | ledis/ledis.go | Open | func Open(cfg *config.Config) (*Ledis, error) {
if len(cfg.DataDir) == 0 {
cfg.DataDir = config.DefaultDataDir
}
if cfg.Databases == 0 {
cfg.Databases = 16
} else if cfg.Databases > MaxDatabases {
cfg.Databases = MaxDatabases
}
os.MkdirAll(cfg.DataDir, 0755)
var err error
l := new(Ledis)
l.cfg = cfg
if l.lock, err = filelock.Lock(path.Join(cfg.DataDir, "LOCK")); err != nil {
return nil, err
}
l.quit = make(chan struct{})
if l.ldb, err = store.Open(cfg); err != nil {
return nil, err
}
if cfg.UseReplication {
if l.r, err = rpl.NewReplication(cfg); err != nil {
return nil, err
}
l.rc = make(chan struct{}, 1)
l.rbatch = l.ldb.NewWriteBatch()
l.rDoneCh = make(chan struct{}, 1)
l.wg.Add(1)
go l.onReplication()
//first we must try wait all replication ok
//maybe some logs are not committed
l.WaitReplication()
} else {
l.r = nil
}
l.dbs = make(map[int]*DB, 16)
l.checkTTL()
return l, nil
} | go | func Open(cfg *config.Config) (*Ledis, error) {
if len(cfg.DataDir) == 0 {
cfg.DataDir = config.DefaultDataDir
}
if cfg.Databases == 0 {
cfg.Databases = 16
} else if cfg.Databases > MaxDatabases {
cfg.Databases = MaxDatabases
}
os.MkdirAll(cfg.DataDir, 0755)
var err error
l := new(Ledis)
l.cfg = cfg
if l.lock, err = filelock.Lock(path.Join(cfg.DataDir, "LOCK")); err != nil {
return nil, err
}
l.quit = make(chan struct{})
if l.ldb, err = store.Open(cfg); err != nil {
return nil, err
}
if cfg.UseReplication {
if l.r, err = rpl.NewReplication(cfg); err != nil {
return nil, err
}
l.rc = make(chan struct{}, 1)
l.rbatch = l.ldb.NewWriteBatch()
l.rDoneCh = make(chan struct{}, 1)
l.wg.Add(1)
go l.onReplication()
//first we must try wait all replication ok
//maybe some logs are not committed
l.WaitReplication()
} else {
l.r = nil
}
l.dbs = make(map[int]*DB, 16)
l.checkTTL()
return l, nil
} | [
"func",
"Open",
"(",
"cfg",
"*",
"config",
".",
"Config",
")",
"(",
"*",
"Ledis",
",",
"error",
")",
"{",
"if",
"len",
"(",
"cfg",
".",
"DataDir",
")",
"==",
"0",
"{",
"cfg",
".",
"DataDir",
"=",
"config",
".",
"DefaultDataDir",
"\n",
"}",
"\n\n",
"if",
"cfg",
".",
"Databases",
"==",
"0",
"{",
"cfg",
".",
"Databases",
"=",
"16",
"\n",
"}",
"else",
"if",
"cfg",
".",
"Databases",
">",
"MaxDatabases",
"{",
"cfg",
".",
"Databases",
"=",
"MaxDatabases",
"\n",
"}",
"\n\n",
"os",
".",
"MkdirAll",
"(",
"cfg",
".",
"DataDir",
",",
"0755",
")",
"\n\n",
"var",
"err",
"error",
"\n\n",
"l",
":=",
"new",
"(",
"Ledis",
")",
"\n",
"l",
".",
"cfg",
"=",
"cfg",
"\n\n",
"if",
"l",
".",
"lock",
",",
"err",
"=",
"filelock",
".",
"Lock",
"(",
"path",
".",
"Join",
"(",
"cfg",
".",
"DataDir",
",",
"\"",
"\"",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"l",
".",
"quit",
"=",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
"\n\n",
"if",
"l",
".",
"ldb",
",",
"err",
"=",
"store",
".",
"Open",
"(",
"cfg",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"cfg",
".",
"UseReplication",
"{",
"if",
"l",
".",
"r",
",",
"err",
"=",
"rpl",
".",
"NewReplication",
"(",
"cfg",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"l",
".",
"rc",
"=",
"make",
"(",
"chan",
"struct",
"{",
"}",
",",
"1",
")",
"\n",
"l",
".",
"rbatch",
"=",
"l",
".",
"ldb",
".",
"NewWriteBatch",
"(",
")",
"\n",
"l",
".",
"rDoneCh",
"=",
"make",
"(",
"chan",
"struct",
"{",
"}",
",",
"1",
")",
"\n\n",
"l",
".",
"wg",
".",
"Add",
"(",
"1",
")",
"\n",
"go",
"l",
".",
"onReplication",
"(",
")",
"\n\n",
"//first we must try wait all replication ok",
"//maybe some logs are not committed",
"l",
".",
"WaitReplication",
"(",
")",
"\n",
"}",
"else",
"{",
"l",
".",
"r",
"=",
"nil",
"\n",
"}",
"\n\n",
"l",
".",
"dbs",
"=",
"make",
"(",
"map",
"[",
"int",
"]",
"*",
"DB",
",",
"16",
")",
"\n\n",
"l",
".",
"checkTTL",
"(",
")",
"\n\n",
"return",
"l",
",",
"nil",
"\n",
"}"
] | // Open opens the Ledis with a config. | [
"Open",
"opens",
"the",
"Ledis",
"with",
"a",
"config",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/ledis.go#L47-L99 | train |
siddontang/ledisdb | ledis/ledis.go | Close | func (l *Ledis) Close() {
close(l.quit)
l.wg.Wait()
l.ldb.Close()
if l.r != nil {
l.r.Close()
//l.r = nil
}
if l.lock != nil {
l.lock.Close()
//l.lock = nil
}
} | go | func (l *Ledis) Close() {
close(l.quit)
l.wg.Wait()
l.ldb.Close()
if l.r != nil {
l.r.Close()
//l.r = nil
}
if l.lock != nil {
l.lock.Close()
//l.lock = nil
}
} | [
"func",
"(",
"l",
"*",
"Ledis",
")",
"Close",
"(",
")",
"{",
"close",
"(",
"l",
".",
"quit",
")",
"\n",
"l",
".",
"wg",
".",
"Wait",
"(",
")",
"\n\n",
"l",
".",
"ldb",
".",
"Close",
"(",
")",
"\n\n",
"if",
"l",
".",
"r",
"!=",
"nil",
"{",
"l",
".",
"r",
".",
"Close",
"(",
")",
"\n",
"//l.r = nil",
"}",
"\n\n",
"if",
"l",
".",
"lock",
"!=",
"nil",
"{",
"l",
".",
"lock",
".",
"Close",
"(",
")",
"\n",
"//l.lock = nil",
"}",
"\n",
"}"
] | // Close closes the Ledis. | [
"Close",
"closes",
"the",
"Ledis",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/ledis.go#L102-L117 | train |
siddontang/ledisdb | ledis/ledis.go | Select | func (l *Ledis) Select(index int) (*DB, error) {
if index < 0 || index >= l.cfg.Databases {
return nil, fmt.Errorf("invalid db index %d, must in [0, %d]", index, l.cfg.Databases-1)
}
l.dbLock.Lock()
defer l.dbLock.Unlock()
db, ok := l.dbs[index]
if ok {
return db, nil
}
db = l.newDB(index)
l.dbs[index] = db
go func(db *DB) {
l.ttlCheckerCh <- db.ttlChecker
}(db)
return db, nil
} | go | func (l *Ledis) Select(index int) (*DB, error) {
if index < 0 || index >= l.cfg.Databases {
return nil, fmt.Errorf("invalid db index %d, must in [0, %d]", index, l.cfg.Databases-1)
}
l.dbLock.Lock()
defer l.dbLock.Unlock()
db, ok := l.dbs[index]
if ok {
return db, nil
}
db = l.newDB(index)
l.dbs[index] = db
go func(db *DB) {
l.ttlCheckerCh <- db.ttlChecker
}(db)
return db, nil
} | [
"func",
"(",
"l",
"*",
"Ledis",
")",
"Select",
"(",
"index",
"int",
")",
"(",
"*",
"DB",
",",
"error",
")",
"{",
"if",
"index",
"<",
"0",
"||",
"index",
">=",
"l",
".",
"cfg",
".",
"Databases",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"index",
",",
"l",
".",
"cfg",
".",
"Databases",
"-",
"1",
")",
"\n",
"}",
"\n\n",
"l",
".",
"dbLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"l",
".",
"dbLock",
".",
"Unlock",
"(",
")",
"\n\n",
"db",
",",
"ok",
":=",
"l",
".",
"dbs",
"[",
"index",
"]",
"\n",
"if",
"ok",
"{",
"return",
"db",
",",
"nil",
"\n",
"}",
"\n\n",
"db",
"=",
"l",
".",
"newDB",
"(",
"index",
")",
"\n",
"l",
".",
"dbs",
"[",
"index",
"]",
"=",
"db",
"\n\n",
"go",
"func",
"(",
"db",
"*",
"DB",
")",
"{",
"l",
".",
"ttlCheckerCh",
"<-",
"db",
".",
"ttlChecker",
"\n",
"}",
"(",
"db",
")",
"\n\n",
"return",
"db",
",",
"nil",
"\n",
"}"
] | // Select chooses a database. | [
"Select",
"chooses",
"a",
"database",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/ledis.go#L120-L141 | train |
siddontang/ledisdb | ledis/ledis.go | FlushAll | func (l *Ledis) FlushAll() error {
l.wLock.Lock()
defer l.wLock.Unlock()
return l.flushAll()
} | go | func (l *Ledis) FlushAll() error {
l.wLock.Lock()
defer l.wLock.Unlock()
return l.flushAll()
} | [
"func",
"(",
"l",
"*",
"Ledis",
")",
"FlushAll",
"(",
")",
"error",
"{",
"l",
".",
"wLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"l",
".",
"wLock",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"l",
".",
"flushAll",
"(",
")",
"\n",
"}"
] | // FlushAll will clear all data and replication logs | [
"FlushAll",
"will",
"clear",
"all",
"data",
"and",
"replication",
"logs"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/ledis.go#L144-L149 | train |
siddontang/ledisdb | ledis/ledis.go | IsReadOnly | func (l *Ledis) IsReadOnly() bool {
if l.cfg.GetReadonly() {
return true
} else if l.r != nil {
if b, _ := l.r.CommitIDBehind(); b {
return true
}
}
return false
} | go | func (l *Ledis) IsReadOnly() bool {
if l.cfg.GetReadonly() {
return true
} else if l.r != nil {
if b, _ := l.r.CommitIDBehind(); b {
return true
}
}
return false
} | [
"func",
"(",
"l",
"*",
"Ledis",
")",
"IsReadOnly",
"(",
")",
"bool",
"{",
"if",
"l",
".",
"cfg",
".",
"GetReadonly",
"(",
")",
"{",
"return",
"true",
"\n",
"}",
"else",
"if",
"l",
".",
"r",
"!=",
"nil",
"{",
"if",
"b",
",",
"_",
":=",
"l",
".",
"r",
".",
"CommitIDBehind",
"(",
")",
";",
"b",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // IsReadOnly returns whether Ledis is read only or not. | [
"IsReadOnly",
"returns",
"whether",
"Ledis",
"is",
"read",
"only",
"or",
"not",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/ledis.go#L189-L198 | train |
siddontang/ledisdb | ledis/ledis.go | CompactStore | func (l *Ledis) CompactStore() error {
l.wLock.Lock()
defer l.wLock.Unlock()
return l.ldb.Compact()
} | go | func (l *Ledis) CompactStore() error {
l.wLock.Lock()
defer l.wLock.Unlock()
return l.ldb.Compact()
} | [
"func",
"(",
"l",
"*",
"Ledis",
")",
"CompactStore",
"(",
")",
"error",
"{",
"l",
".",
"wLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"l",
".",
"wLock",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"l",
".",
"ldb",
".",
"Compact",
"(",
")",
"\n",
"}"
] | // CompactStore compacts the backend storage. | [
"CompactStore",
"compacts",
"the",
"backend",
"storage",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/ledis.go#L243-L248 | train |
siddontang/ledisdb | store/iterator.go | Key | func (it *Iterator) Key() []byte {
k := it.it.Key()
if k == nil {
return nil
}
return append([]byte{}, k...)
} | go | func (it *Iterator) Key() []byte {
k := it.it.Key()
if k == nil {
return nil
}
return append([]byte{}, k...)
} | [
"func",
"(",
"it",
"*",
"Iterator",
")",
"Key",
"(",
")",
"[",
"]",
"byte",
"{",
"k",
":=",
"it",
".",
"it",
".",
"Key",
"(",
")",
"\n",
"if",
"k",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"append",
"(",
"[",
"]",
"byte",
"{",
"}",
",",
"k",
"...",
")",
"\n",
"}"
] | // Returns a copy of key. | [
"Returns",
"a",
"copy",
"of",
"key",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/store/iterator.go#L48-L55 | train |
siddontang/ledisdb | store/iterator.go | Value | func (it *Iterator) Value() []byte {
v := it.it.Value()
if v == nil {
return nil
}
return append([]byte{}, v...)
} | go | func (it *Iterator) Value() []byte {
v := it.it.Value()
if v == nil {
return nil
}
return append([]byte{}, v...)
} | [
"func",
"(",
"it",
"*",
"Iterator",
")",
"Value",
"(",
")",
"[",
"]",
"byte",
"{",
"v",
":=",
"it",
".",
"it",
".",
"Value",
"(",
")",
"\n",
"if",
"v",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"append",
"(",
"[",
"]",
"byte",
"{",
"}",
",",
"v",
"...",
")",
"\n",
"}"
] | // Returns a copy of value. | [
"Returns",
"a",
"copy",
"of",
"value",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/store/iterator.go#L58-L65 | train |
siddontang/ledisdb | store/iterator.go | BufKey | func (it *Iterator) BufKey(b []byte) []byte {
k := it.RawKey()
if k == nil {
return nil
}
if b == nil {
b = []byte{}
}
b = b[0:0]
return append(b, k...)
} | go | func (it *Iterator) BufKey(b []byte) []byte {
k := it.RawKey()
if k == nil {
return nil
}
if b == nil {
b = []byte{}
}
b = b[0:0]
return append(b, k...)
} | [
"func",
"(",
"it",
"*",
"Iterator",
")",
"BufKey",
"(",
"b",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"k",
":=",
"it",
".",
"RawKey",
"(",
")",
"\n",
"if",
"k",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"b",
"==",
"nil",
"{",
"b",
"=",
"[",
"]",
"byte",
"{",
"}",
"\n",
"}",
"\n\n",
"b",
"=",
"b",
"[",
"0",
":",
"0",
"]",
"\n",
"return",
"append",
"(",
"b",
",",
"k",
"...",
")",
"\n",
"}"
] | // Copy key to b, if b len is small or nil, returns a new one. | [
"Copy",
"key",
"to",
"b",
"if",
"b",
"len",
"is",
"small",
"or",
"nil",
"returns",
"a",
"new",
"one",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/store/iterator.go#L80-L91 | train |
siddontang/ledisdb | store/iterator.go | BufValue | func (it *Iterator) BufValue(b []byte) []byte {
v := it.RawValue()
if v == nil {
return nil
}
if b == nil {
b = []byte{}
}
b = b[0:0]
return append(b, v...)
} | go | func (it *Iterator) BufValue(b []byte) []byte {
v := it.RawValue()
if v == nil {
return nil
}
if b == nil {
b = []byte{}
}
b = b[0:0]
return append(b, v...)
} | [
"func",
"(",
"it",
"*",
"Iterator",
")",
"BufValue",
"(",
"b",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"v",
":=",
"it",
".",
"RawValue",
"(",
")",
"\n",
"if",
"v",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"b",
"==",
"nil",
"{",
"b",
"=",
"[",
"]",
"byte",
"{",
"}",
"\n",
"}",
"\n\n",
"b",
"=",
"b",
"[",
"0",
":",
"0",
"]",
"\n",
"return",
"append",
"(",
"b",
",",
"v",
"...",
")",
"\n",
"}"
] | // Copy value to b, if b len is small or nil, returns a new one. | [
"Copy",
"value",
"to",
"b",
"if",
"b",
"len",
"is",
"small",
"or",
"nil",
"returns",
"a",
"new",
"one",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/store/iterator.go#L94-L106 | train |
siddontang/ledisdb | store/iterator.go | Find | func (it *Iterator) Find(key []byte) []byte {
it.Seek(key)
if it.Valid() {
k := it.RawKey()
if k == nil {
return nil
} else if bytes.Equal(k, key) {
return it.Value()
}
}
return nil
} | go | func (it *Iterator) Find(key []byte) []byte {
it.Seek(key)
if it.Valid() {
k := it.RawKey()
if k == nil {
return nil
} else if bytes.Equal(k, key) {
return it.Value()
}
}
return nil
} | [
"func",
"(",
"it",
"*",
"Iterator",
")",
"Find",
"(",
"key",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"it",
".",
"Seek",
"(",
"key",
")",
"\n",
"if",
"it",
".",
"Valid",
"(",
")",
"{",
"k",
":=",
"it",
".",
"RawKey",
"(",
")",
"\n",
"if",
"k",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"else",
"if",
"bytes",
".",
"Equal",
"(",
"k",
",",
"key",
")",
"{",
"return",
"it",
".",
"Value",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Finds by key, if not found, nil returns. | [
"Finds",
"by",
"key",
"if",
"not",
"found",
"nil",
"returns",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/store/iterator.go#L146-L158 | train |
siddontang/ledisdb | store/iterator.go | RawFind | func (it *Iterator) RawFind(key []byte) []byte {
it.Seek(key)
if it.Valid() {
k := it.RawKey()
if k == nil {
return nil
} else if bytes.Equal(k, key) {
return it.RawValue()
}
}
return nil
} | go | func (it *Iterator) RawFind(key []byte) []byte {
it.Seek(key)
if it.Valid() {
k := it.RawKey()
if k == nil {
return nil
} else if bytes.Equal(k, key) {
return it.RawValue()
}
}
return nil
} | [
"func",
"(",
"it",
"*",
"Iterator",
")",
"RawFind",
"(",
"key",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"it",
".",
"Seek",
"(",
"key",
")",
"\n",
"if",
"it",
".",
"Valid",
"(",
")",
"{",
"k",
":=",
"it",
".",
"RawKey",
"(",
")",
"\n",
"if",
"k",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"else",
"if",
"bytes",
".",
"Equal",
"(",
"k",
",",
"key",
")",
"{",
"return",
"it",
".",
"RawValue",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Finds by key, if not found, nil returns, else a reference of value returns.
// you must be careful that it will be changed after next iterate. | [
"Finds",
"by",
"key",
"if",
"not",
"found",
"nil",
"returns",
"else",
"a",
"reference",
"of",
"value",
"returns",
".",
"you",
"must",
"be",
"careful",
"that",
"it",
"will",
"be",
"changed",
"after",
"next",
"iterate",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/store/iterator.go#L162-L174 | train |
siddontang/ledisdb | ledis/t_kv.go | Decr | func (db *DB) Decr(key []byte) (int64, error) {
return db.incr(key, -1)
} | go | func (db *DB) Decr(key []byte) (int64, error) {
return db.incr(key, -1)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"Decr",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"return",
"db",
".",
"incr",
"(",
"key",
",",
"-",
"1",
")",
"\n",
"}"
] | // Decr decreases the data. | [
"Decr",
"decreases",
"the",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L124-L126 | train |
siddontang/ledisdb | ledis/t_kv.go | DecrBy | func (db *DB) DecrBy(key []byte, decrement int64) (int64, error) {
return db.incr(key, -decrement)
} | go | func (db *DB) DecrBy(key []byte, decrement int64) (int64, error) {
return db.incr(key, -decrement)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"DecrBy",
"(",
"key",
"[",
"]",
"byte",
",",
"decrement",
"int64",
")",
"(",
"int64",
",",
"error",
")",
"{",
"return",
"db",
".",
"incr",
"(",
"key",
",",
"-",
"decrement",
")",
"\n",
"}"
] | // DecrBy decreases the data by decrement. | [
"DecrBy",
"decreases",
"the",
"data",
"by",
"decrement",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L129-L131 | train |
siddontang/ledisdb | ledis/t_kv.go | Del | func (db *DB) Del(keys ...[]byte) (int64, error) {
if len(keys) == 0 {
return 0, nil
}
codedKeys := make([][]byte, len(keys))
for i, k := range keys {
codedKeys[i] = db.encodeKVKey(k)
}
t := db.kvBatch
t.Lock()
defer t.Unlock()
for i, k := range keys {
t.Delete(codedKeys[i])
db.rmExpire(t, KVType, k)
}
err := t.Commit()
return int64(len(keys)), err
} | go | func (db *DB) Del(keys ...[]byte) (int64, error) {
if len(keys) == 0 {
return 0, nil
}
codedKeys := make([][]byte, len(keys))
for i, k := range keys {
codedKeys[i] = db.encodeKVKey(k)
}
t := db.kvBatch
t.Lock()
defer t.Unlock()
for i, k := range keys {
t.Delete(codedKeys[i])
db.rmExpire(t, KVType, k)
}
err := t.Commit()
return int64(len(keys)), err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"Del",
"(",
"keys",
"...",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"len",
"(",
"keys",
")",
"==",
"0",
"{",
"return",
"0",
",",
"nil",
"\n",
"}",
"\n\n",
"codedKeys",
":=",
"make",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"len",
"(",
"keys",
")",
")",
"\n",
"for",
"i",
",",
"k",
":=",
"range",
"keys",
"{",
"codedKeys",
"[",
"i",
"]",
"=",
"db",
".",
"encodeKVKey",
"(",
"k",
")",
"\n",
"}",
"\n\n",
"t",
":=",
"db",
".",
"kvBatch",
"\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n\n",
"for",
"i",
",",
"k",
":=",
"range",
"keys",
"{",
"t",
".",
"Delete",
"(",
"codedKeys",
"[",
"i",
"]",
")",
"\n",
"db",
".",
"rmExpire",
"(",
"t",
",",
"KVType",
",",
"k",
")",
"\n",
"}",
"\n\n",
"err",
":=",
"t",
".",
"Commit",
"(",
")",
"\n",
"return",
"int64",
"(",
"len",
"(",
"keys",
")",
")",
",",
"err",
"\n",
"}"
] | // Del deletes the data. | [
"Del",
"deletes",
"the",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L134-L155 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.