repo
stringlengths 5
67
| path
stringlengths 4
218
| func_name
stringlengths 0
151
| original_string
stringlengths 52
373k
| language
stringclasses 6
values | code
stringlengths 52
373k
| code_tokens
listlengths 10
512
| docstring
stringlengths 3
47.2k
| docstring_tokens
listlengths 3
234
| sha
stringlengths 40
40
| url
stringlengths 85
339
| partition
stringclasses 3
values |
|---|---|---|---|---|---|---|---|---|---|---|---|
onsi/gomega
|
gbytes/io_wrappers.go
|
TimeoutWriter
|
func TimeoutWriter(w io.Writer, timeout time.Duration) io.Writer {
return timeoutReaderWriterCloser{w: w, d: timeout}
}
|
go
|
func TimeoutWriter(w io.Writer, timeout time.Duration) io.Writer {
return timeoutReaderWriterCloser{w: w, d: timeout}
}
|
[
"func",
"TimeoutWriter",
"(",
"w",
"io",
".",
"Writer",
",",
"timeout",
"time",
".",
"Duration",
")",
"io",
".",
"Writer",
"{",
"return",
"timeoutReaderWriterCloser",
"{",
"w",
":",
"w",
",",
"d",
":",
"timeout",
"}",
"\n",
"}"
] |
// TimeoutWriter returns an io.Writer that wraps the passed-in io.Writer. If the underlying Writer fails to write within the alloted timeout ErrTimeout is returned.
|
[
"TimeoutWriter",
"returns",
"an",
"io",
".",
"Writer",
"that",
"wraps",
"the",
"passed",
"-",
"in",
"io",
".",
"Writer",
".",
"If",
"the",
"underlying",
"Writer",
"fails",
"to",
"write",
"within",
"the",
"alloted",
"timeout",
"ErrTimeout",
"is",
"returned",
"."
] |
f0e010e04c08c48a875f83d17df37b04eb3a985b
|
https://github.com/onsi/gomega/blob/f0e010e04c08c48a875f83d17df37b04eb3a985b/gbytes/io_wrappers.go#L23-L25
|
test
|
onsi/gomega
|
gstruct/errors/nested_types.go
|
Nest
|
func Nest(path string, err error) error {
if ag, ok := err.(AggregateError); ok {
var errs AggregateError
for _, e := range ag {
errs = append(errs, Nest(path, e))
}
return errs
}
if ne, ok := err.(*NestedError); ok {
return &NestedError{
Path: path + ne.Path,
Err: ne.Err,
}
}
return &NestedError{
Path: path,
Err: err,
}
}
|
go
|
func Nest(path string, err error) error {
if ag, ok := err.(AggregateError); ok {
var errs AggregateError
for _, e := range ag {
errs = append(errs, Nest(path, e))
}
return errs
}
if ne, ok := err.(*NestedError); ok {
return &NestedError{
Path: path + ne.Path,
Err: ne.Err,
}
}
return &NestedError{
Path: path,
Err: err,
}
}
|
[
"func",
"Nest",
"(",
"path",
"string",
",",
"err",
"error",
")",
"error",
"{",
"if",
"ag",
",",
"ok",
":=",
"err",
".",
"(",
"AggregateError",
")",
";",
"ok",
"{",
"var",
"errs",
"AggregateError",
"\n",
"for",
"_",
",",
"e",
":=",
"range",
"ag",
"{",
"errs",
"=",
"append",
"(",
"errs",
",",
"Nest",
"(",
"path",
",",
"e",
")",
")",
"\n",
"}",
"\n",
"return",
"errs",
"\n",
"}",
"\n",
"if",
"ne",
",",
"ok",
":=",
"err",
".",
"(",
"*",
"NestedError",
")",
";",
"ok",
"{",
"return",
"&",
"NestedError",
"{",
"Path",
":",
"path",
"+",
"ne",
".",
"Path",
",",
"Err",
":",
"ne",
".",
"Err",
",",
"}",
"\n",
"}",
"\n",
"return",
"&",
"NestedError",
"{",
"Path",
":",
"path",
",",
"Err",
":",
"err",
",",
"}",
"\n",
"}"
] |
// Create a NestedError with the given path.
// If err is a NestedError, prepend the path to it.
// If err is an AggregateError, recursively Nest each error.
|
[
"Create",
"a",
"NestedError",
"with",
"the",
"given",
"path",
".",
"If",
"err",
"is",
"a",
"NestedError",
"prepend",
"the",
"path",
"to",
"it",
".",
"If",
"err",
"is",
"an",
"AggregateError",
"recursively",
"Nest",
"each",
"error",
"."
] |
f0e010e04c08c48a875f83d17df37b04eb3a985b
|
https://github.com/onsi/gomega/blob/f0e010e04c08c48a875f83d17df37b04eb3a985b/gstruct/errors/nested_types.go#L34-L52
|
test
|
tsuru/tsuru
|
servicemanager/mock/servicemanager_mock.go
|
SetMockService
|
func SetMockService(m *MockService) {
m.Cache = &cache.MockAppCacheService{}
m.Plan = &app.MockPlanService{}
m.Platform = &app.MockPlatformService{}
m.PlatformImage = &image.MockPlatformImageService{}
m.Team = &auth.MockTeamService{}
m.UserQuota = "a.MockQuotaService{}
m.AppQuota = "a.MockQuotaService{}
m.Cluster = &provision.MockClusterService{}
m.ServiceBroker = &service.MockServiceBrokerService{}
m.ServiceBrokerCatalogCache = &service.MockServiceBrokerCatalogCacheService{}
servicemanager.AppCache = m.Cache
servicemanager.Plan = m.Plan
servicemanager.Platform = m.Platform
servicemanager.PlatformImage = m.PlatformImage
servicemanager.Team = m.Team
servicemanager.UserQuota = m.UserQuota
servicemanager.AppQuota = m.AppQuota
servicemanager.Cluster = m.Cluster
servicemanager.ServiceBroker = m.ServiceBroker
servicemanager.ServiceBrokerCatalogCache = m.ServiceBrokerCatalogCache
}
|
go
|
func SetMockService(m *MockService) {
m.Cache = &cache.MockAppCacheService{}
m.Plan = &app.MockPlanService{}
m.Platform = &app.MockPlatformService{}
m.PlatformImage = &image.MockPlatformImageService{}
m.Team = &auth.MockTeamService{}
m.UserQuota = "a.MockQuotaService{}
m.AppQuota = "a.MockQuotaService{}
m.Cluster = &provision.MockClusterService{}
m.ServiceBroker = &service.MockServiceBrokerService{}
m.ServiceBrokerCatalogCache = &service.MockServiceBrokerCatalogCacheService{}
servicemanager.AppCache = m.Cache
servicemanager.Plan = m.Plan
servicemanager.Platform = m.Platform
servicemanager.PlatformImage = m.PlatformImage
servicemanager.Team = m.Team
servicemanager.UserQuota = m.UserQuota
servicemanager.AppQuota = m.AppQuota
servicemanager.Cluster = m.Cluster
servicemanager.ServiceBroker = m.ServiceBroker
servicemanager.ServiceBrokerCatalogCache = m.ServiceBrokerCatalogCache
}
|
[
"func",
"SetMockService",
"(",
"m",
"*",
"MockService",
")",
"{",
"m",
".",
"Cache",
"=",
"&",
"cache",
".",
"MockAppCacheService",
"{",
"}",
"\n",
"m",
".",
"Plan",
"=",
"&",
"app",
".",
"MockPlanService",
"{",
"}",
"\n",
"m",
".",
"Platform",
"=",
"&",
"app",
".",
"MockPlatformService",
"{",
"}",
"\n",
"m",
".",
"PlatformImage",
"=",
"&",
"image",
".",
"MockPlatformImageService",
"{",
"}",
"\n",
"m",
".",
"Team",
"=",
"&",
"auth",
".",
"MockTeamService",
"{",
"}",
"\n",
"m",
".",
"UserQuota",
"=",
"&",
"quota",
".",
"MockQuotaService",
"{",
"}",
"\n",
"m",
".",
"AppQuota",
"=",
"&",
"quota",
".",
"MockQuotaService",
"{",
"}",
"\n",
"m",
".",
"Cluster",
"=",
"&",
"provision",
".",
"MockClusterService",
"{",
"}",
"\n",
"m",
".",
"ServiceBroker",
"=",
"&",
"service",
".",
"MockServiceBrokerService",
"{",
"}",
"\n",
"m",
".",
"ServiceBrokerCatalogCache",
"=",
"&",
"service",
".",
"MockServiceBrokerCatalogCacheService",
"{",
"}",
"\n",
"servicemanager",
".",
"AppCache",
"=",
"m",
".",
"Cache",
"\n",
"servicemanager",
".",
"Plan",
"=",
"m",
".",
"Plan",
"\n",
"servicemanager",
".",
"Platform",
"=",
"m",
".",
"Platform",
"\n",
"servicemanager",
".",
"PlatformImage",
"=",
"m",
".",
"PlatformImage",
"\n",
"servicemanager",
".",
"Team",
"=",
"m",
".",
"Team",
"\n",
"servicemanager",
".",
"UserQuota",
"=",
"m",
".",
"UserQuota",
"\n",
"servicemanager",
".",
"AppQuota",
"=",
"m",
".",
"AppQuota",
"\n",
"servicemanager",
".",
"Cluster",
"=",
"m",
".",
"Cluster",
"\n",
"servicemanager",
".",
"ServiceBroker",
"=",
"m",
".",
"ServiceBroker",
"\n",
"servicemanager",
".",
"ServiceBrokerCatalogCache",
"=",
"m",
".",
"ServiceBrokerCatalogCache",
"\n",
"}"
] |
// SetMockService return a new MockService and set as a servicemanager
|
[
"SetMockService",
"return",
"a",
"new",
"MockService",
"and",
"set",
"as",
"a",
"servicemanager"
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/servicemanager/mock/servicemanager_mock.go#L33-L54
|
test
|
tsuru/tsuru
|
iaas/machine.go
|
FindMachineByIdOrAddress
|
func FindMachineByIdOrAddress(id string, address string) (Machine, error) {
coll, err := collection()
if err != nil {
return Machine{}, err
}
defer coll.Close()
var result Machine
query := bson.M{}
if id != "" {
query["_id"] = id
} else {
query["address"] = address
}
err = coll.Find(query).One(&result)
if err == mgo.ErrNotFound {
err = ErrMachineNotFound
}
return result, err
}
|
go
|
func FindMachineByIdOrAddress(id string, address string) (Machine, error) {
coll, err := collection()
if err != nil {
return Machine{}, err
}
defer coll.Close()
var result Machine
query := bson.M{}
if id != "" {
query["_id"] = id
} else {
query["address"] = address
}
err = coll.Find(query).One(&result)
if err == mgo.ErrNotFound {
err = ErrMachineNotFound
}
return result, err
}
|
[
"func",
"FindMachineByIdOrAddress",
"(",
"id",
"string",
",",
"address",
"string",
")",
"(",
"Machine",
",",
"error",
")",
"{",
"coll",
",",
"err",
":=",
"collection",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"Machine",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"defer",
"coll",
".",
"Close",
"(",
")",
"\n",
"var",
"result",
"Machine",
"\n",
"query",
":=",
"bson",
".",
"M",
"{",
"}",
"\n",
"if",
"id",
"!=",
"\"\"",
"{",
"query",
"[",
"\"_id\"",
"]",
"=",
"id",
"\n",
"}",
"else",
"{",
"query",
"[",
"\"address\"",
"]",
"=",
"address",
"\n",
"}",
"\n",
"err",
"=",
"coll",
".",
"Find",
"(",
"query",
")",
".",
"One",
"(",
"&",
"result",
")",
"\n",
"if",
"err",
"==",
"mgo",
".",
"ErrNotFound",
"{",
"err",
"=",
"ErrMachineNotFound",
"\n",
"}",
"\n",
"return",
"result",
",",
"err",
"\n",
"}"
] |
// Uses id or address, this is only used because previously we didn't have
// iaas-id in node metadata.
|
[
"Uses",
"id",
"or",
"address",
"this",
"is",
"only",
"used",
"because",
"previously",
"we",
"didn",
"t",
"have",
"iaas",
"-",
"id",
"in",
"node",
"metadata",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/iaas/machine.go#L124-L142
|
test
|
tsuru/tsuru
|
io/flushing_writer.go
|
Write
|
func (w *FlushingWriter) Write(data []byte) (written int, err error) {
w.writeMutex.Lock()
defer w.writeMutex.Unlock()
w.wrote = true
written, err = w.ResponseWriter.Write(data)
if err != nil {
return
}
if f, ok := w.ResponseWriter.(http.Flusher); ok {
defer func() {
if r := recover(); r != nil {
msg := fmt.Sprintf("Error recovered on flushing writer: %#v", r)
log.Debugf(msg)
err = errors.Errorf(msg)
}
}()
f.Flush()
}
return
}
|
go
|
func (w *FlushingWriter) Write(data []byte) (written int, err error) {
w.writeMutex.Lock()
defer w.writeMutex.Unlock()
w.wrote = true
written, err = w.ResponseWriter.Write(data)
if err != nil {
return
}
if f, ok := w.ResponseWriter.(http.Flusher); ok {
defer func() {
if r := recover(); r != nil {
msg := fmt.Sprintf("Error recovered on flushing writer: %#v", r)
log.Debugf(msg)
err = errors.Errorf(msg)
}
}()
f.Flush()
}
return
}
|
[
"func",
"(",
"w",
"*",
"FlushingWriter",
")",
"Write",
"(",
"data",
"[",
"]",
"byte",
")",
"(",
"written",
"int",
",",
"err",
"error",
")",
"{",
"w",
".",
"writeMutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"w",
".",
"writeMutex",
".",
"Unlock",
"(",
")",
"\n",
"w",
".",
"wrote",
"=",
"true",
"\n",
"written",
",",
"err",
"=",
"w",
".",
"ResponseWriter",
".",
"Write",
"(",
"data",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"if",
"f",
",",
"ok",
":=",
"w",
".",
"ResponseWriter",
".",
"(",
"http",
".",
"Flusher",
")",
";",
"ok",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"r",
":=",
"recover",
"(",
")",
";",
"r",
"!=",
"nil",
"{",
"msg",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"Error recovered on flushing writer: %#v\"",
",",
"r",
")",
"\n",
"log",
".",
"Debugf",
"(",
"msg",
")",
"\n",
"err",
"=",
"errors",
".",
"Errorf",
"(",
"msg",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"f",
".",
"Flush",
"(",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// Write writes and flushes the data.
|
[
"Write",
"writes",
"and",
"flushes",
"the",
"data",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/io/flushing_writer.go#L32-L51
|
test
|
tsuru/tsuru
|
io/flushing_writer.go
|
Hijack
|
func (w *FlushingWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
if hijacker, ok := w.ResponseWriter.(http.Hijacker); ok {
return hijacker.Hijack()
}
return nil, nil, errors.New("cannot hijack connection")
}
|
go
|
func (w *FlushingWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
if hijacker, ok := w.ResponseWriter.(http.Hijacker); ok {
return hijacker.Hijack()
}
return nil, nil, errors.New("cannot hijack connection")
}
|
[
"func",
"(",
"w",
"*",
"FlushingWriter",
")",
"Hijack",
"(",
")",
"(",
"net",
".",
"Conn",
",",
"*",
"bufio",
".",
"ReadWriter",
",",
"error",
")",
"{",
"if",
"hijacker",
",",
"ok",
":=",
"w",
".",
"ResponseWriter",
".",
"(",
"http",
".",
"Hijacker",
")",
";",
"ok",
"{",
"return",
"hijacker",
".",
"Hijack",
"(",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"nil",
",",
"errors",
".",
"New",
"(",
"\"cannot hijack connection\"",
")",
"\n",
"}"
] |
// Hijack will hijack the underlying TCP connection, if available in the
// ResponseWriter.
|
[
"Hijack",
"will",
"hijack",
"the",
"underlying",
"TCP",
"connection",
"if",
"available",
"in",
"the",
"ResponseWriter",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/io/flushing_writer.go#L60-L65
|
test
|
tsuru/tsuru
|
app/deploy.go
|
ListDeploys
|
func ListDeploys(filter *Filter, skip, limit int) ([]DeployData, error) {
appsList, err := List(filter)
if err != nil {
return nil, err
}
apps := make([]string, len(appsList))
for i, a := range appsList {
apps[i] = a.GetName()
}
evts, err := event.List(&event.Filter{
Target: event.Target{Type: event.TargetTypeApp},
Raw: bson.M{"target.value": bson.M{"$in": apps}},
KindNames: []string{permission.PermAppDeploy.FullName()},
KindType: event.KindTypePermission,
Limit: limit,
Skip: skip,
})
if err != nil {
return nil, err
}
validImages, err := findValidImages(appsList...)
if err != nil {
return nil, err
}
list := make([]DeployData, len(evts))
for i := range evts {
list[i] = *eventToDeployData(&evts[i], validImages, false)
}
return list, nil
}
|
go
|
func ListDeploys(filter *Filter, skip, limit int) ([]DeployData, error) {
appsList, err := List(filter)
if err != nil {
return nil, err
}
apps := make([]string, len(appsList))
for i, a := range appsList {
apps[i] = a.GetName()
}
evts, err := event.List(&event.Filter{
Target: event.Target{Type: event.TargetTypeApp},
Raw: bson.M{"target.value": bson.M{"$in": apps}},
KindNames: []string{permission.PermAppDeploy.FullName()},
KindType: event.KindTypePermission,
Limit: limit,
Skip: skip,
})
if err != nil {
return nil, err
}
validImages, err := findValidImages(appsList...)
if err != nil {
return nil, err
}
list := make([]DeployData, len(evts))
for i := range evts {
list[i] = *eventToDeployData(&evts[i], validImages, false)
}
return list, nil
}
|
[
"func",
"ListDeploys",
"(",
"filter",
"*",
"Filter",
",",
"skip",
",",
"limit",
"int",
")",
"(",
"[",
"]",
"DeployData",
",",
"error",
")",
"{",
"appsList",
",",
"err",
":=",
"List",
"(",
"filter",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"apps",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"appsList",
")",
")",
"\n",
"for",
"i",
",",
"a",
":=",
"range",
"appsList",
"{",
"apps",
"[",
"i",
"]",
"=",
"a",
".",
"GetName",
"(",
")",
"\n",
"}",
"\n",
"evts",
",",
"err",
":=",
"event",
".",
"List",
"(",
"&",
"event",
".",
"Filter",
"{",
"Target",
":",
"event",
".",
"Target",
"{",
"Type",
":",
"event",
".",
"TargetTypeApp",
"}",
",",
"Raw",
":",
"bson",
".",
"M",
"{",
"\"target.value\"",
":",
"bson",
".",
"M",
"{",
"\"$in\"",
":",
"apps",
"}",
"}",
",",
"KindNames",
":",
"[",
"]",
"string",
"{",
"permission",
".",
"PermAppDeploy",
".",
"FullName",
"(",
")",
"}",
",",
"KindType",
":",
"event",
".",
"KindTypePermission",
",",
"Limit",
":",
"limit",
",",
"Skip",
":",
"skip",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"validImages",
",",
"err",
":=",
"findValidImages",
"(",
"appsList",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"list",
":=",
"make",
"(",
"[",
"]",
"DeployData",
",",
"len",
"(",
"evts",
")",
")",
"\n",
"for",
"i",
":=",
"range",
"evts",
"{",
"list",
"[",
"i",
"]",
"=",
"*",
"eventToDeployData",
"(",
"&",
"evts",
"[",
"i",
"]",
",",
"validImages",
",",
"false",
")",
"\n",
"}",
"\n",
"return",
"list",
",",
"nil",
"\n",
"}"
] |
// ListDeploys returns the list of deploy that match a given filter.
|
[
"ListDeploys",
"returns",
"the",
"list",
"of",
"deploy",
"that",
"match",
"a",
"given",
"filter",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/app/deploy.go#L75-L104
|
test
|
tsuru/tsuru
|
api/router/router.go
|
AddAll
|
func (r *DelayedRouter) AddAll(version, path string, h http.Handler) *mux.Route {
return r.addRoute(version, path, h, "GET", "POST", "PUT", "DELETE")
}
|
go
|
func (r *DelayedRouter) AddAll(version, path string, h http.Handler) *mux.Route {
return r.addRoute(version, path, h, "GET", "POST", "PUT", "DELETE")
}
|
[
"func",
"(",
"r",
"*",
"DelayedRouter",
")",
"AddAll",
"(",
"version",
",",
"path",
"string",
",",
"h",
"http",
".",
"Handler",
")",
"*",
"mux",
".",
"Route",
"{",
"return",
"r",
".",
"addRoute",
"(",
"version",
",",
"path",
",",
"h",
",",
"\"GET\"",
",",
"\"POST\"",
",",
"\"PUT\"",
",",
"\"DELETE\"",
")",
"\n",
"}"
] |
// AddAll binds a path to GET, POST, PUT and DELETE methods.
|
[
"AddAll",
"binds",
"a",
"path",
"to",
"GET",
"POST",
"PUT",
"and",
"DELETE",
"methods",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/api/router/router.go#L63-L65
|
test
|
tsuru/tsuru
|
cmd/saml.go
|
samlRequestTimeout
|
func samlRequestTimeout(schemeData map[string]string) int {
p := schemeData["request_timeout"]
timeout, _ := strconv.Atoi(p)
return timeout
}
|
go
|
func samlRequestTimeout(schemeData map[string]string) int {
p := schemeData["request_timeout"]
timeout, _ := strconv.Atoi(p)
return timeout
}
|
[
"func",
"samlRequestTimeout",
"(",
"schemeData",
"map",
"[",
"string",
"]",
"string",
")",
"int",
"{",
"p",
":=",
"schemeData",
"[",
"\"request_timeout\"",
"]",
"\n",
"timeout",
",",
"_",
":=",
"strconv",
".",
"Atoi",
"(",
"p",
")",
"\n",
"return",
"timeout",
"\n",
"}"
] |
//Return timeout in seconds
|
[
"Return",
"timeout",
"in",
"seconds"
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/cmd/saml.go#L66-L70
|
test
|
tsuru/tsuru
|
api/server.go
|
RegisterHandler
|
func RegisterHandler(path string, method string, h http.Handler) {
RegisterHandlerVersion("1.0", path, method, h)
}
|
go
|
func RegisterHandler(path string, method string, h http.Handler) {
RegisterHandlerVersion("1.0", path, method, h)
}
|
[
"func",
"RegisterHandler",
"(",
"path",
"string",
",",
"method",
"string",
",",
"h",
"http",
".",
"Handler",
")",
"{",
"RegisterHandlerVersion",
"(",
"\"1.0\"",
",",
"path",
",",
"method",
",",
"h",
")",
"\n",
"}"
] |
// RegisterHandler inserts a handler on a list of handlers for version 1.0
|
[
"RegisterHandler",
"inserts",
"a",
"handler",
"on",
"a",
"list",
"of",
"handlers",
"for",
"version",
"1",
".",
"0"
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/api/server.go#L71-L73
|
test
|
tsuru/tsuru
|
api/server.go
|
RegisterHandlerVersion
|
func RegisterHandlerVersion(version, path, method string, h http.Handler) {
var th TsuruHandler
th.version = version
th.path = path
th.method = method
th.h = h
tsuruHandlerList = append(tsuruHandlerList, th)
}
|
go
|
func RegisterHandlerVersion(version, path, method string, h http.Handler) {
var th TsuruHandler
th.version = version
th.path = path
th.method = method
th.h = h
tsuruHandlerList = append(tsuruHandlerList, th)
}
|
[
"func",
"RegisterHandlerVersion",
"(",
"version",
",",
"path",
",",
"method",
"string",
",",
"h",
"http",
".",
"Handler",
")",
"{",
"var",
"th",
"TsuruHandler",
"\n",
"th",
".",
"version",
"=",
"version",
"\n",
"th",
".",
"path",
"=",
"path",
"\n",
"th",
".",
"method",
"=",
"method",
"\n",
"th",
".",
"h",
"=",
"h",
"\n",
"tsuruHandlerList",
"=",
"append",
"(",
"tsuruHandlerList",
",",
"th",
")",
"\n",
"}"
] |
// RegisterHandlerVersion inserts a handler on a list of handlers
|
[
"RegisterHandlerVersion",
"inserts",
"a",
"handler",
"on",
"a",
"list",
"of",
"handlers"
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/api/server.go#L76-L83
|
test
|
tsuru/tsuru
|
hc/healthchecker.go
|
Check
|
func Check(names ...string) []Result {
results := make([]Result, 0, len(checkers))
nameSet := set.FromSlice(names)
isAll := nameSet.Includes("all")
for _, checker := range checkers {
if !isAll && !nameSet.Includes(checker.name) {
continue
}
startTime := time.Now()
if err := checker.check(); err != nil && err != ErrDisabledComponent {
results = append(results, Result{
Name: checker.name,
Status: "fail - " + err.Error(),
Duration: time.Since(startTime),
})
} else if err == nil {
results = append(results, Result{
Name: checker.name,
Status: HealthCheckOK,
Duration: time.Since(startTime),
})
}
}
return results
}
|
go
|
func Check(names ...string) []Result {
results := make([]Result, 0, len(checkers))
nameSet := set.FromSlice(names)
isAll := nameSet.Includes("all")
for _, checker := range checkers {
if !isAll && !nameSet.Includes(checker.name) {
continue
}
startTime := time.Now()
if err := checker.check(); err != nil && err != ErrDisabledComponent {
results = append(results, Result{
Name: checker.name,
Status: "fail - " + err.Error(),
Duration: time.Since(startTime),
})
} else if err == nil {
results = append(results, Result{
Name: checker.name,
Status: HealthCheckOK,
Duration: time.Since(startTime),
})
}
}
return results
}
|
[
"func",
"Check",
"(",
"names",
"...",
"string",
")",
"[",
"]",
"Result",
"{",
"results",
":=",
"make",
"(",
"[",
"]",
"Result",
",",
"0",
",",
"len",
"(",
"checkers",
")",
")",
"\n",
"nameSet",
":=",
"set",
".",
"FromSlice",
"(",
"names",
")",
"\n",
"isAll",
":=",
"nameSet",
".",
"Includes",
"(",
"\"all\"",
")",
"\n",
"for",
"_",
",",
"checker",
":=",
"range",
"checkers",
"{",
"if",
"!",
"isAll",
"&&",
"!",
"nameSet",
".",
"Includes",
"(",
"checker",
".",
"name",
")",
"{",
"continue",
"\n",
"}",
"\n",
"startTime",
":=",
"time",
".",
"Now",
"(",
")",
"\n",
"if",
"err",
":=",
"checker",
".",
"check",
"(",
")",
";",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"ErrDisabledComponent",
"{",
"results",
"=",
"append",
"(",
"results",
",",
"Result",
"{",
"Name",
":",
"checker",
".",
"name",
",",
"Status",
":",
"\"fail - \"",
"+",
"err",
".",
"Error",
"(",
")",
",",
"Duration",
":",
"time",
".",
"Since",
"(",
"startTime",
")",
",",
"}",
")",
"\n",
"}",
"else",
"if",
"err",
"==",
"nil",
"{",
"results",
"=",
"append",
"(",
"results",
",",
"Result",
"{",
"Name",
":",
"checker",
".",
"name",
",",
"Status",
":",
"HealthCheckOK",
",",
"Duration",
":",
"time",
".",
"Since",
"(",
"startTime",
")",
",",
"}",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"results",
"\n",
"}"
] |
// Check check the status of registered checkers matching names and return a
// list of results.
|
[
"Check",
"check",
"the",
"status",
"of",
"registered",
"checkers",
"matching",
"names",
"and",
"return",
"a",
"list",
"of",
"results",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/hc/healthchecker.go#L47-L71
|
test
|
tsuru/tsuru
|
git/git.go
|
DiscoverRepositoryPath
|
func DiscoverRepositoryPath(dir string) (string, error) {
_, err := os.Stat(dir)
if os.IsNotExist(err) {
return "", ErrRepositoryNotFound
}
dir = filepath.Join(dir, ".git")
for dir != "/.git" {
fi, err := os.Stat(dir)
if err == nil && fi.IsDir() {
return dir, nil
}
dir = filepath.Join(dir, "..", "..", ".git")
}
return "", ErrRepositoryNotFound
}
|
go
|
func DiscoverRepositoryPath(dir string) (string, error) {
_, err := os.Stat(dir)
if os.IsNotExist(err) {
return "", ErrRepositoryNotFound
}
dir = filepath.Join(dir, ".git")
for dir != "/.git" {
fi, err := os.Stat(dir)
if err == nil && fi.IsDir() {
return dir, nil
}
dir = filepath.Join(dir, "..", "..", ".git")
}
return "", ErrRepositoryNotFound
}
|
[
"func",
"DiscoverRepositoryPath",
"(",
"dir",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"dir",
")",
"\n",
"if",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"return",
"\"\"",
",",
"ErrRepositoryNotFound",
"\n",
"}",
"\n",
"dir",
"=",
"filepath",
".",
"Join",
"(",
"dir",
",",
"\".git\"",
")",
"\n",
"for",
"dir",
"!=",
"\"/.git\"",
"{",
"fi",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"dir",
")",
"\n",
"if",
"err",
"==",
"nil",
"&&",
"fi",
".",
"IsDir",
"(",
")",
"{",
"return",
"dir",
",",
"nil",
"\n",
"}",
"\n",
"dir",
"=",
"filepath",
".",
"Join",
"(",
"dir",
",",
"\"..\"",
",",
"\"..\"",
",",
"\".git\"",
")",
"\n",
"}",
"\n",
"return",
"\"\"",
",",
"ErrRepositoryNotFound",
"\n",
"}"
] |
// DiscoverRepositoryPath finds the path of the repository from a given
// directory. It returns the path to the repository, or an an empty string and
// a non-nil error if it can't find the repository.
|
[
"DiscoverRepositoryPath",
"finds",
"the",
"path",
"of",
"the",
"repository",
"from",
"a",
"given",
"directory",
".",
"It",
"returns",
"the",
"path",
"to",
"the",
"repository",
"or",
"an",
"an",
"empty",
"string",
"and",
"a",
"non",
"-",
"nil",
"error",
"if",
"it",
"can",
"t",
"find",
"the",
"repository",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/git/git.go#L27-L41
|
test
|
tsuru/tsuru
|
git/git.go
|
OpenRepository
|
func OpenRepository(p string) (*Repository, error) {
if !strings.HasSuffix(p, ".git") && !strings.HasSuffix(p, ".git/") {
p = filepath.Join(p, ".git")
}
p = strings.TrimRight(p, "/")
fi, err := os.Stat(filepath.Join(p, "config"))
if err == nil && !fi.IsDir() {
return &Repository{path: p}, nil
}
return nil, ErrRepositoryNotFound
}
|
go
|
func OpenRepository(p string) (*Repository, error) {
if !strings.HasSuffix(p, ".git") && !strings.HasSuffix(p, ".git/") {
p = filepath.Join(p, ".git")
}
p = strings.TrimRight(p, "/")
fi, err := os.Stat(filepath.Join(p, "config"))
if err == nil && !fi.IsDir() {
return &Repository{path: p}, nil
}
return nil, ErrRepositoryNotFound
}
|
[
"func",
"OpenRepository",
"(",
"p",
"string",
")",
"(",
"*",
"Repository",
",",
"error",
")",
"{",
"if",
"!",
"strings",
".",
"HasSuffix",
"(",
"p",
",",
"\".git\"",
")",
"&&",
"!",
"strings",
".",
"HasSuffix",
"(",
"p",
",",
"\".git/\"",
")",
"{",
"p",
"=",
"filepath",
".",
"Join",
"(",
"p",
",",
"\".git\"",
")",
"\n",
"}",
"\n",
"p",
"=",
"strings",
".",
"TrimRight",
"(",
"p",
",",
"\"/\"",
")",
"\n",
"fi",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"filepath",
".",
"Join",
"(",
"p",
",",
"\"config\"",
")",
")",
"\n",
"if",
"err",
"==",
"nil",
"&&",
"!",
"fi",
".",
"IsDir",
"(",
")",
"{",
"return",
"&",
"Repository",
"{",
"path",
":",
"p",
"}",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"ErrRepositoryNotFound",
"\n",
"}"
] |
// OpenRepository opens a repository by its filepath. You can use
// DiscoverRepositoryPath to discover the repository from any directory, and
// use the result of this call as parameter for OpenRepository.
//
// OpenRepository will return an error if the given path does not appear to be
// a git repository.
|
[
"OpenRepository",
"opens",
"a",
"repository",
"by",
"its",
"filepath",
".",
"You",
"can",
"use",
"DiscoverRepositoryPath",
"to",
"discover",
"the",
"repository",
"from",
"any",
"directory",
"and",
"use",
"the",
"result",
"of",
"this",
"call",
"as",
"parameter",
"for",
"OpenRepository",
".",
"OpenRepository",
"will",
"return",
"an",
"error",
"if",
"the",
"given",
"path",
"does",
"not",
"appear",
"to",
"be",
"a",
"git",
"repository",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/git/git.go#L54-L64
|
test
|
tsuru/tsuru
|
git/git.go
|
RemoteURL
|
func (r *Repository) RemoteURL(name string) (string, error) {
config, err := os.Open(filepath.Join(r.path, "config"))
if err != nil {
return "", err
}
defer config.Close()
line := fmt.Sprintf("[remote %q]", name)
scanner := bufio.NewScanner(config)
scanner.Split(bufio.ScanLines)
for scanner.Scan() {
if scanner.Text() == line {
scanner.Scan()
return strings.Split(scanner.Text(), " = ")[1], nil
}
}
return "", errRemoteNotFound{name}
}
|
go
|
func (r *Repository) RemoteURL(name string) (string, error) {
config, err := os.Open(filepath.Join(r.path, "config"))
if err != nil {
return "", err
}
defer config.Close()
line := fmt.Sprintf("[remote %q]", name)
scanner := bufio.NewScanner(config)
scanner.Split(bufio.ScanLines)
for scanner.Scan() {
if scanner.Text() == line {
scanner.Scan()
return strings.Split(scanner.Text(), " = ")[1], nil
}
}
return "", errRemoteNotFound{name}
}
|
[
"func",
"(",
"r",
"*",
"Repository",
")",
"RemoteURL",
"(",
"name",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"config",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"filepath",
".",
"Join",
"(",
"r",
".",
"path",
",",
"\"config\"",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"defer",
"config",
".",
"Close",
"(",
")",
"\n",
"line",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"[remote %q]\"",
",",
"name",
")",
"\n",
"scanner",
":=",
"bufio",
".",
"NewScanner",
"(",
"config",
")",
"\n",
"scanner",
".",
"Split",
"(",
"bufio",
".",
"ScanLines",
")",
"\n",
"for",
"scanner",
".",
"Scan",
"(",
")",
"{",
"if",
"scanner",
".",
"Text",
"(",
")",
"==",
"line",
"{",
"scanner",
".",
"Scan",
"(",
")",
"\n",
"return",
"strings",
".",
"Split",
"(",
"scanner",
".",
"Text",
"(",
")",
",",
"\" = \"",
")",
"[",
"1",
"]",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\"\"",
",",
"errRemoteNotFound",
"{",
"name",
"}",
"\n",
"}"
] |
// RemoteURL returns the URL of a remote by its name. Or an error, if the
// remote is not declared.
|
[
"RemoteURL",
"returns",
"the",
"URL",
"of",
"a",
"remote",
"by",
"its",
"name",
".",
"Or",
"an",
"error",
"if",
"the",
"remote",
"is",
"not",
"declared",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/git/git.go#L68-L84
|
test
|
tsuru/tsuru
|
provision/kubernetes/pkg/client/listers/tsuru/v1/app.go
|
List
|
func (s *appLister) List(selector labels.Selector) (ret []*v1.App, err error) {
err = cache.ListAll(s.indexer, selector, func(m interface{}) {
ret = append(ret, m.(*v1.App))
})
return ret, err
}
|
go
|
func (s *appLister) List(selector labels.Selector) (ret []*v1.App, err error) {
err = cache.ListAll(s.indexer, selector, func(m interface{}) {
ret = append(ret, m.(*v1.App))
})
return ret, err
}
|
[
"func",
"(",
"s",
"*",
"appLister",
")",
"List",
"(",
"selector",
"labels",
".",
"Selector",
")",
"(",
"ret",
"[",
"]",
"*",
"v1",
".",
"App",
",",
"err",
"error",
")",
"{",
"err",
"=",
"cache",
".",
"ListAll",
"(",
"s",
".",
"indexer",
",",
"selector",
",",
"func",
"(",
"m",
"interface",
"{",
"}",
")",
"{",
"ret",
"=",
"append",
"(",
"ret",
",",
"m",
".",
"(",
"*",
"v1",
".",
"App",
")",
")",
"\n",
"}",
")",
"\n",
"return",
"ret",
",",
"err",
"\n",
"}"
] |
// List lists all Apps in the indexer.
|
[
"List",
"lists",
"all",
"Apps",
"in",
"the",
"indexer",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/provision/kubernetes/pkg/client/listers/tsuru/v1/app.go#L38-L43
|
test
|
tsuru/tsuru
|
provision/kubernetes/pkg/client/listers/tsuru/v1/app.go
|
Apps
|
func (s *appLister) Apps(namespace string) AppNamespaceLister {
return appNamespaceLister{indexer: s.indexer, namespace: namespace}
}
|
go
|
func (s *appLister) Apps(namespace string) AppNamespaceLister {
return appNamespaceLister{indexer: s.indexer, namespace: namespace}
}
|
[
"func",
"(",
"s",
"*",
"appLister",
")",
"Apps",
"(",
"namespace",
"string",
")",
"AppNamespaceLister",
"{",
"return",
"appNamespaceLister",
"{",
"indexer",
":",
"s",
".",
"indexer",
",",
"namespace",
":",
"namespace",
"}",
"\n",
"}"
] |
// Apps returns an object that can list and get Apps.
|
[
"Apps",
"returns",
"an",
"object",
"that",
"can",
"list",
"and",
"get",
"Apps",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/provision/kubernetes/pkg/client/listers/tsuru/v1/app.go#L46-L48
|
test
|
tsuru/tsuru
|
provision/kubernetes/pkg/client/listers/tsuru/v1/app.go
|
List
|
func (s appNamespaceLister) List(selector labels.Selector) (ret []*v1.App, err error) {
err = cache.ListAllByNamespace(s.indexer, s.namespace, selector, func(m interface{}) {
ret = append(ret, m.(*v1.App))
})
return ret, err
}
|
go
|
func (s appNamespaceLister) List(selector labels.Selector) (ret []*v1.App, err error) {
err = cache.ListAllByNamespace(s.indexer, s.namespace, selector, func(m interface{}) {
ret = append(ret, m.(*v1.App))
})
return ret, err
}
|
[
"func",
"(",
"s",
"appNamespaceLister",
")",
"List",
"(",
"selector",
"labels",
".",
"Selector",
")",
"(",
"ret",
"[",
"]",
"*",
"v1",
".",
"App",
",",
"err",
"error",
")",
"{",
"err",
"=",
"cache",
".",
"ListAllByNamespace",
"(",
"s",
".",
"indexer",
",",
"s",
".",
"namespace",
",",
"selector",
",",
"func",
"(",
"m",
"interface",
"{",
"}",
")",
"{",
"ret",
"=",
"append",
"(",
"ret",
",",
"m",
".",
"(",
"*",
"v1",
".",
"App",
")",
")",
"\n",
"}",
")",
"\n",
"return",
"ret",
",",
"err",
"\n",
"}"
] |
// List lists all Apps in the indexer for a given namespace.
|
[
"List",
"lists",
"all",
"Apps",
"in",
"the",
"indexer",
"for",
"a",
"given",
"namespace",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/provision/kubernetes/pkg/client/listers/tsuru/v1/app.go#L67-L72
|
test
|
tsuru/tsuru
|
cmd/client.go
|
StreamJSONResponse
|
func StreamJSONResponse(w io.Writer, response *http.Response) error {
if response == nil {
return errors.New("response cannot be nil")
}
defer response.Body.Close()
var err error
output := tsuruio.NewStreamWriter(w, nil)
for n := int64(1); n > 0 && err == nil; n, err = io.Copy(output, response.Body) {
}
if err != nil {
return err
}
unparsed := output.Remaining()
if len(unparsed) > 0 {
return errors.Errorf("unparsed message error: %s", string(unparsed))
}
return nil
}
|
go
|
func StreamJSONResponse(w io.Writer, response *http.Response) error {
if response == nil {
return errors.New("response cannot be nil")
}
defer response.Body.Close()
var err error
output := tsuruio.NewStreamWriter(w, nil)
for n := int64(1); n > 0 && err == nil; n, err = io.Copy(output, response.Body) {
}
if err != nil {
return err
}
unparsed := output.Remaining()
if len(unparsed) > 0 {
return errors.Errorf("unparsed message error: %s", string(unparsed))
}
return nil
}
|
[
"func",
"StreamJSONResponse",
"(",
"w",
"io",
".",
"Writer",
",",
"response",
"*",
"http",
".",
"Response",
")",
"error",
"{",
"if",
"response",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"response cannot be nil\"",
")",
"\n",
"}",
"\n",
"defer",
"response",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"var",
"err",
"error",
"\n",
"output",
":=",
"tsuruio",
".",
"NewStreamWriter",
"(",
"w",
",",
"nil",
")",
"\n",
"for",
"n",
":=",
"int64",
"(",
"1",
")",
";",
"n",
">",
"0",
"&&",
"err",
"==",
"nil",
";",
"n",
",",
"err",
"=",
"io",
".",
"Copy",
"(",
"output",
",",
"response",
".",
"Body",
")",
"{",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"unparsed",
":=",
"output",
".",
"Remaining",
"(",
")",
"\n",
"if",
"len",
"(",
"unparsed",
")",
">",
"0",
"{",
"return",
"errors",
".",
"Errorf",
"(",
"\"unparsed message error: %s\"",
",",
"string",
"(",
"unparsed",
")",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// StreamJSONResponse supports the JSON streaming format from the tsuru API.
|
[
"StreamJSONResponse",
"supports",
"the",
"JSON",
"streaming",
"format",
"from",
"the",
"tsuru",
"API",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/cmd/client.go#L133-L150
|
test
|
tsuru/tsuru
|
db/storage/storage.go
|
DropDatabase
|
func (s *Storage) DropDatabase(name string) error {
return s.session.DB(name).DropDatabase()
}
|
go
|
func (s *Storage) DropDatabase(name string) error {
return s.session.DB(name).DropDatabase()
}
|
[
"func",
"(",
"s",
"*",
"Storage",
")",
"DropDatabase",
"(",
"name",
"string",
")",
"error",
"{",
"return",
"s",
".",
"session",
".",
"DB",
"(",
"name",
")",
".",
"DropDatabase",
"(",
")",
"\n",
"}"
] |
// DropDatabase drop database of any given name
|
[
"DropDatabase",
"drop",
"database",
"of",
"any",
"given",
"name"
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/db/storage/storage.go#L88-L90
|
test
|
tsuru/tsuru
|
db/storage/storage.go
|
Collection
|
func (s *Storage) Collection(name string) *Collection {
return &Collection{Collection: s.session.DB(s.dbname).C(name)}
}
|
go
|
func (s *Storage) Collection(name string) *Collection {
return &Collection{Collection: s.session.DB(s.dbname).C(name)}
}
|
[
"func",
"(",
"s",
"*",
"Storage",
")",
"Collection",
"(",
"name",
"string",
")",
"*",
"Collection",
"{",
"return",
"&",
"Collection",
"{",
"Collection",
":",
"s",
".",
"session",
".",
"DB",
"(",
"s",
".",
"dbname",
")",
".",
"C",
"(",
"name",
")",
"}",
"\n",
"}"
] |
// Collection returns a collection by its name.
//
// If the collection does not exist, MongoDB will create it.
|
[
"Collection",
"returns",
"a",
"collection",
"by",
"its",
"name",
".",
"If",
"the",
"collection",
"does",
"not",
"exist",
"MongoDB",
"will",
"create",
"it",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/db/storage/storage.go#L95-L97
|
test
|
tsuru/tsuru
|
log/log.go
|
SetLogger
|
func (t *Target) SetLogger(l Logger) {
t.mut.Lock()
defer t.mut.Unlock()
t.logger = l
}
|
go
|
func (t *Target) SetLogger(l Logger) {
t.mut.Lock()
defer t.mut.Unlock()
t.logger = l
}
|
[
"func",
"(",
"t",
"*",
"Target",
")",
"SetLogger",
"(",
"l",
"Logger",
")",
"{",
"t",
".",
"mut",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"mut",
".",
"Unlock",
"(",
")",
"\n",
"t",
".",
"logger",
"=",
"l",
"\n",
"}"
] |
// SetLogger defines a new logger for the current target.
//
// See the builtin log package for more details.
|
[
"SetLogger",
"defines",
"a",
"new",
"logger",
"for",
"the",
"current",
"target",
".",
"See",
"the",
"builtin",
"log",
"package",
"for",
"more",
"details",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/log/log.go#L68-L72
|
test
|
tsuru/tsuru
|
log/log.go
|
Error
|
func (t *Target) Error(v error) {
t.mut.RLock()
defer t.mut.RUnlock()
if t.logger != nil {
t.logger.Errorf("%+v", v)
}
}
|
go
|
func (t *Target) Error(v error) {
t.mut.RLock()
defer t.mut.RUnlock()
if t.logger != nil {
t.logger.Errorf("%+v", v)
}
}
|
[
"func",
"(",
"t",
"*",
"Target",
")",
"Error",
"(",
"v",
"error",
")",
"{",
"t",
".",
"mut",
".",
"RLock",
"(",
")",
"\n",
"defer",
"t",
".",
"mut",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"t",
".",
"logger",
"!=",
"nil",
"{",
"t",
".",
"logger",
".",
"Errorf",
"(",
"\"%+v\"",
",",
"v",
")",
"\n",
"}",
"\n",
"}"
] |
// Error writes the given values to the Target
// logger.
|
[
"Error",
"writes",
"the",
"given",
"values",
"to",
"the",
"Target",
"logger",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/log/log.go#L76-L82
|
test
|
tsuru/tsuru
|
log/log.go
|
Errorf
|
func (t *Target) Errorf(format string, v ...interface{}) {
t.mut.RLock()
defer t.mut.RUnlock()
if t.logger != nil {
t.logger.Errorf(format, v...)
for _, item := range v {
if _, hasStack := item.(withStack); hasStack {
t.logger.Errorf("stack for error: %+v", item)
}
}
}
}
|
go
|
func (t *Target) Errorf(format string, v ...interface{}) {
t.mut.RLock()
defer t.mut.RUnlock()
if t.logger != nil {
t.logger.Errorf(format, v...)
for _, item := range v {
if _, hasStack := item.(withStack); hasStack {
t.logger.Errorf("stack for error: %+v", item)
}
}
}
}
|
[
"func",
"(",
"t",
"*",
"Target",
")",
"Errorf",
"(",
"format",
"string",
",",
"v",
"...",
"interface",
"{",
"}",
")",
"{",
"t",
".",
"mut",
".",
"RLock",
"(",
")",
"\n",
"defer",
"t",
".",
"mut",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"t",
".",
"logger",
"!=",
"nil",
"{",
"t",
".",
"logger",
".",
"Errorf",
"(",
"format",
",",
"v",
"...",
")",
"\n",
"for",
"_",
",",
"item",
":=",
"range",
"v",
"{",
"if",
"_",
",",
"hasStack",
":=",
"item",
".",
"(",
"withStack",
")",
";",
"hasStack",
"{",
"t",
".",
"logger",
".",
"Errorf",
"(",
"\"stack for error: %+v\"",
",",
"item",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Errorf writes the formatted string to the Target
// logger.
|
[
"Errorf",
"writes",
"the",
"formatted",
"string",
"to",
"the",
"Target",
"logger",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/log/log.go#L90-L101
|
test
|
tsuru/tsuru
|
log/log.go
|
Fatal
|
func (t *Target) Fatal(v string) {
t.mut.RLock()
defer t.mut.RUnlock()
if t.logger != nil {
t.logger.Fatal(v)
}
}
|
go
|
func (t *Target) Fatal(v string) {
t.mut.RLock()
defer t.mut.RUnlock()
if t.logger != nil {
t.logger.Fatal(v)
}
}
|
[
"func",
"(",
"t",
"*",
"Target",
")",
"Fatal",
"(",
"v",
"string",
")",
"{",
"t",
".",
"mut",
".",
"RLock",
"(",
")",
"\n",
"defer",
"t",
".",
"mut",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"t",
".",
"logger",
"!=",
"nil",
"{",
"t",
".",
"logger",
".",
"Fatal",
"(",
"v",
")",
"\n",
"}",
"\n",
"}"
] |
// Fatal writes the given values to the Target
// logger.
|
[
"Fatal",
"writes",
"the",
"given",
"values",
"to",
"the",
"Target",
"logger",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/log/log.go#L105-L111
|
test
|
tsuru/tsuru
|
log/log.go
|
Debugf
|
func (t *Target) Debugf(format string, v ...interface{}) {
t.mut.RLock()
defer t.mut.RUnlock()
if t.logger != nil {
t.logger.Debugf(format, v...)
}
}
|
go
|
func (t *Target) Debugf(format string, v ...interface{}) {
t.mut.RLock()
defer t.mut.RUnlock()
if t.logger != nil {
t.logger.Debugf(format, v...)
}
}
|
[
"func",
"(",
"t",
"*",
"Target",
")",
"Debugf",
"(",
"format",
"string",
",",
"v",
"...",
"interface",
"{",
"}",
")",
"{",
"t",
".",
"mut",
".",
"RLock",
"(",
")",
"\n",
"defer",
"t",
".",
"mut",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"t",
".",
"logger",
"!=",
"nil",
"{",
"t",
".",
"logger",
".",
"Debugf",
"(",
"format",
",",
"v",
"...",
")",
"\n",
"}",
"\n",
"}"
] |
// Debugf writes the formatted string to the Target
// logger.
|
[
"Debugf",
"writes",
"the",
"formatted",
"string",
"to",
"the",
"Target",
"logger",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/log/log.go#L135-L141
|
test
|
tsuru/tsuru
|
log/log.go
|
GetStdLogger
|
func (t *Target) GetStdLogger() *log.Logger {
t.mut.RLock()
defer t.mut.RUnlock()
if t.logger != nil {
return t.logger.GetStdLogger()
}
return nil
}
|
go
|
func (t *Target) GetStdLogger() *log.Logger {
t.mut.RLock()
defer t.mut.RUnlock()
if t.logger != nil {
return t.logger.GetStdLogger()
}
return nil
}
|
[
"func",
"(",
"t",
"*",
"Target",
")",
"GetStdLogger",
"(",
")",
"*",
"log",
".",
"Logger",
"{",
"t",
".",
"mut",
".",
"RLock",
"(",
")",
"\n",
"defer",
"t",
".",
"mut",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"t",
".",
"logger",
"!=",
"nil",
"{",
"return",
"t",
".",
"logger",
".",
"GetStdLogger",
"(",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// GetStdLogger returns a standard Logger instance
// useful for configuring log in external packages.
|
[
"GetStdLogger",
"returns",
"a",
"standard",
"Logger",
"instance",
"useful",
"for",
"configuring",
"log",
"in",
"external",
"packages",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/log/log.go#L145-L152
|
test
|
tsuru/tsuru
|
provision/kubernetes/cluster.go
|
Namespace
|
func (c *ClusterClient) Namespace() string {
if c.CustomData != nil && c.CustomData[namespaceClusterKey] != "" {
return c.CustomData[namespaceClusterKey]
}
return "tsuru"
}
|
go
|
func (c *ClusterClient) Namespace() string {
if c.CustomData != nil && c.CustomData[namespaceClusterKey] != "" {
return c.CustomData[namespaceClusterKey]
}
return "tsuru"
}
|
[
"func",
"(",
"c",
"*",
"ClusterClient",
")",
"Namespace",
"(",
")",
"string",
"{",
"if",
"c",
".",
"CustomData",
"!=",
"nil",
"&&",
"c",
".",
"CustomData",
"[",
"namespaceClusterKey",
"]",
"!=",
"\"\"",
"{",
"return",
"c",
".",
"CustomData",
"[",
"namespaceClusterKey",
"]",
"\n",
"}",
"\n",
"return",
"\"tsuru\"",
"\n",
"}"
] |
// Namespace returns the namespace to be used by Custom Resources
|
[
"Namespace",
"returns",
"the",
"namespace",
"to",
"be",
"used",
"by",
"Custom",
"Resources"
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/provision/kubernetes/cluster.go#L210-L215
|
test
|
tsuru/tsuru
|
provision/docker/nodecontainer/nodecontainer.go
|
recreateContainers
|
func recreateContainers(p DockerProvisioner, w io.Writer, nodes ...cluster.Node) error {
return ensureContainersStarted(p, w, true, nil, nodes...)
}
|
go
|
func recreateContainers(p DockerProvisioner, w io.Writer, nodes ...cluster.Node) error {
return ensureContainersStarted(p, w, true, nil, nodes...)
}
|
[
"func",
"recreateContainers",
"(",
"p",
"DockerProvisioner",
",",
"w",
"io",
".",
"Writer",
",",
"nodes",
"...",
"cluster",
".",
"Node",
")",
"error",
"{",
"return",
"ensureContainersStarted",
"(",
"p",
",",
"w",
",",
"true",
",",
"nil",
",",
"nodes",
"...",
")",
"\n",
"}"
] |
// recreateContainers relaunch all node containers in the cluster for the given
// DockerProvisioner, logging progress to the given writer.
//
// It assumes that the given writer is thread safe.
|
[
"recreateContainers",
"relaunch",
"all",
"node",
"containers",
"in",
"the",
"cluster",
"for",
"the",
"given",
"DockerProvisioner",
"logging",
"progress",
"to",
"the",
"given",
"writer",
".",
"It",
"assumes",
"that",
"the",
"given",
"writer",
"is",
"thread",
"safe",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/provision/docker/nodecontainer/nodecontainer.go#L37-L39
|
test
|
tsuru/tsuru
|
cmd/tsurud/checker.go
|
checkProvisioner
|
func checkProvisioner() error {
if value, _ := config.Get("provisioner"); value == defaultProvisionerName || value == "" {
return checkDocker()
}
return nil
}
|
go
|
func checkProvisioner() error {
if value, _ := config.Get("provisioner"); value == defaultProvisionerName || value == "" {
return checkDocker()
}
return nil
}
|
[
"func",
"checkProvisioner",
"(",
")",
"error",
"{",
"if",
"value",
",",
"_",
":=",
"config",
".",
"Get",
"(",
"\"provisioner\"",
")",
";",
"value",
"==",
"defaultProvisionerName",
"||",
"value",
"==",
"\"\"",
"{",
"return",
"checkDocker",
"(",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Check provisioner configs
|
[
"Check",
"provisioner",
"configs"
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/cmd/tsurud/checker.go#L40-L45
|
test
|
tsuru/tsuru
|
cmd/tsurud/checker.go
|
checkDocker
|
func checkDocker() error {
if _, err := config.Get("docker"); err != nil {
return errors.New("Config error: you should configure docker.")
}
err := checkDockerBasicConfig()
if err != nil {
return err
}
err = checkScheduler()
if err != nil {
return err
}
err = checkRouter()
if err != nil {
return err
}
return checkCluster()
}
|
go
|
func checkDocker() error {
if _, err := config.Get("docker"); err != nil {
return errors.New("Config error: you should configure docker.")
}
err := checkDockerBasicConfig()
if err != nil {
return err
}
err = checkScheduler()
if err != nil {
return err
}
err = checkRouter()
if err != nil {
return err
}
return checkCluster()
}
|
[
"func",
"checkDocker",
"(",
")",
"error",
"{",
"if",
"_",
",",
"err",
":=",
"config",
".",
"Get",
"(",
"\"docker\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"Config error: you should configure docker.\"",
")",
"\n",
"}",
"\n",
"err",
":=",
"checkDockerBasicConfig",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"err",
"=",
"checkScheduler",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"err",
"=",
"checkRouter",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"checkCluster",
"(",
")",
"\n",
"}"
] |
// Check Docker configs
|
[
"Check",
"Docker",
"configs"
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/cmd/tsurud/checker.go#L66-L83
|
test
|
tsuru/tsuru
|
cmd/tsurud/checker.go
|
checkScheduler
|
func checkScheduler() error {
if servers, err := config.Get("docker:servers"); err == nil && servers != nil {
return errors.Errorf(`Using docker:servers is deprecated, please remove it your config and use "tsuru docker-node-add" do add docker nodes.`)
}
isSegregate, err := config.GetBool("docker:segregate")
if err == nil {
if isSegregate {
return config.NewWarning(`Setting "docker:segregate" is not necessary anymore, this is the default behavior from now on.`)
} else {
return errors.Errorf(`You must remove "docker:segregate" from your config.`)
}
}
return nil
}
|
go
|
func checkScheduler() error {
if servers, err := config.Get("docker:servers"); err == nil && servers != nil {
return errors.Errorf(`Using docker:servers is deprecated, please remove it your config and use "tsuru docker-node-add" do add docker nodes.`)
}
isSegregate, err := config.GetBool("docker:segregate")
if err == nil {
if isSegregate {
return config.NewWarning(`Setting "docker:segregate" is not necessary anymore, this is the default behavior from now on.`)
} else {
return errors.Errorf(`You must remove "docker:segregate" from your config.`)
}
}
return nil
}
|
[
"func",
"checkScheduler",
"(",
")",
"error",
"{",
"if",
"servers",
",",
"err",
":=",
"config",
".",
"Get",
"(",
"\"docker:servers\"",
")",
";",
"err",
"==",
"nil",
"&&",
"servers",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Errorf",
"(",
"`Using docker:servers is deprecated, please remove it your config and use \"tsuru docker-node-add\" do add docker nodes.`",
")",
"\n",
"}",
"\n",
"isSegregate",
",",
"err",
":=",
"config",
".",
"GetBool",
"(",
"\"docker:segregate\"",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"if",
"isSegregate",
"{",
"return",
"config",
".",
"NewWarning",
"(",
"`Setting \"docker:segregate\" is not necessary anymore, this is the default behavior from now on.`",
")",
"\n",
"}",
"else",
"{",
"return",
"errors",
".",
"Errorf",
"(",
"`You must remove \"docker:segregate\" from your config.`",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Check Schedulers
// It verifies your scheduler configuration and validates related confs.
|
[
"Check",
"Schedulers",
"It",
"verifies",
"your",
"scheduler",
"configuration",
"and",
"validates",
"related",
"confs",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/cmd/tsurud/checker.go#L108-L121
|
test
|
tsuru/tsuru
|
cmd/tsurud/checker.go
|
checkRouter
|
func checkRouter() error {
defaultRouter, _ := config.GetString("docker:router")
if defaultRouter == "" {
return errors.Errorf(`You must configure a default router in "docker:router".`)
}
isHipacheOld := false
if defaultRouter == "hipache" {
hipacheOld, _ := config.Get("hipache")
isHipacheOld = hipacheOld != nil
}
routerConf, _ := config.Get("routers:" + defaultRouter)
if isHipacheOld {
return config.NewWarning(`Setting "hipache:*" config entries is deprecated. You should configure your router with "routers:*". See http://docs.tsuru.io/en/latest/reference/config.html#routers for more details.`)
}
if routerConf == nil {
return errors.Errorf(`You must configure your default router %q in "routers:%s".`, defaultRouter, defaultRouter)
}
routerType, _ := config.Get("routers:" + defaultRouter + ":type")
if routerType == nil {
return errors.Errorf(`You must configure your default router type in "routers:%s:type".`, defaultRouter)
}
return nil
}
|
go
|
func checkRouter() error {
defaultRouter, _ := config.GetString("docker:router")
if defaultRouter == "" {
return errors.Errorf(`You must configure a default router in "docker:router".`)
}
isHipacheOld := false
if defaultRouter == "hipache" {
hipacheOld, _ := config.Get("hipache")
isHipacheOld = hipacheOld != nil
}
routerConf, _ := config.Get("routers:" + defaultRouter)
if isHipacheOld {
return config.NewWarning(`Setting "hipache:*" config entries is deprecated. You should configure your router with "routers:*". See http://docs.tsuru.io/en/latest/reference/config.html#routers for more details.`)
}
if routerConf == nil {
return errors.Errorf(`You must configure your default router %q in "routers:%s".`, defaultRouter, defaultRouter)
}
routerType, _ := config.Get("routers:" + defaultRouter + ":type")
if routerType == nil {
return errors.Errorf(`You must configure your default router type in "routers:%s:type".`, defaultRouter)
}
return nil
}
|
[
"func",
"checkRouter",
"(",
")",
"error",
"{",
"defaultRouter",
",",
"_",
":=",
"config",
".",
"GetString",
"(",
"\"docker:router\"",
")",
"\n",
"if",
"defaultRouter",
"==",
"\"\"",
"{",
"return",
"errors",
".",
"Errorf",
"(",
"`You must configure a default router in \"docker:router\".`",
")",
"\n",
"}",
"\n",
"isHipacheOld",
":=",
"false",
"\n",
"if",
"defaultRouter",
"==",
"\"hipache\"",
"{",
"hipacheOld",
",",
"_",
":=",
"config",
".",
"Get",
"(",
"\"hipache\"",
")",
"\n",
"isHipacheOld",
"=",
"hipacheOld",
"!=",
"nil",
"\n",
"}",
"\n",
"routerConf",
",",
"_",
":=",
"config",
".",
"Get",
"(",
"\"routers:\"",
"+",
"defaultRouter",
")",
"\n",
"if",
"isHipacheOld",
"{",
"return",
"config",
".",
"NewWarning",
"(",
"`Setting \"hipache:*\" config entries is deprecated. You should configure your router with \"routers:*\". See http://docs.tsuru.io/en/latest/reference/config.html#routers for more details.`",
")",
"\n",
"}",
"\n",
"if",
"routerConf",
"==",
"nil",
"{",
"return",
"errors",
".",
"Errorf",
"(",
"`You must configure your default router %q in \"routers:%s\".`",
",",
"defaultRouter",
",",
"defaultRouter",
")",
"\n",
"}",
"\n",
"routerType",
",",
"_",
":=",
"config",
".",
"Get",
"(",
"\"routers:\"",
"+",
"defaultRouter",
"+",
"\":type\"",
")",
"\n",
"if",
"routerType",
"==",
"nil",
"{",
"return",
"errors",
".",
"Errorf",
"(",
"`You must configure your default router type in \"routers:%s:type\".`",
",",
"defaultRouter",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Check Router
// It verifies your router configuration and validates related confs.
|
[
"Check",
"Router",
"It",
"verifies",
"your",
"router",
"configuration",
"and",
"validates",
"related",
"confs",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/cmd/tsurud/checker.go#L125-L147
|
test
|
tsuru/tsuru
|
provision/provision.go
|
Available
|
func (u *Unit) Available() bool {
return u.Status == StatusStarted ||
u.Status == StatusStarting ||
u.Status == StatusError
}
|
go
|
func (u *Unit) Available() bool {
return u.Status == StatusStarted ||
u.Status == StatusStarting ||
u.Status == StatusError
}
|
[
"func",
"(",
"u",
"*",
"Unit",
")",
"Available",
"(",
")",
"bool",
"{",
"return",
"u",
".",
"Status",
"==",
"StatusStarted",
"||",
"u",
".",
"Status",
"==",
"StatusStarting",
"||",
"u",
".",
"Status",
"==",
"StatusError",
"\n",
"}"
] |
// Available returns true if the unit is available. It will return true
// whenever the unit itself is available, even when the application process is
// not.
|
[
"Available",
"returns",
"true",
"if",
"the",
"unit",
"is",
"available",
".",
"It",
"will",
"return",
"true",
"whenever",
"the",
"unit",
"itself",
"is",
"available",
"even",
"when",
"the",
"application",
"process",
"is",
"not",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/provision/provision.go#L189-L193
|
test
|
tsuru/tsuru
|
provision/provision.go
|
Get
|
func Get(name string) (Provisioner, error) {
pFunc, ok := provisioners[name]
if !ok {
return nil, errors.Errorf("unknown provisioner: %q", name)
}
return pFunc()
}
|
go
|
func Get(name string) (Provisioner, error) {
pFunc, ok := provisioners[name]
if !ok {
return nil, errors.Errorf("unknown provisioner: %q", name)
}
return pFunc()
}
|
[
"func",
"Get",
"(",
"name",
"string",
")",
"(",
"Provisioner",
",",
"error",
")",
"{",
"pFunc",
",",
"ok",
":=",
"provisioners",
"[",
"name",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"Errorf",
"(",
"\"unknown provisioner: %q\"",
",",
"name",
")",
"\n",
"}",
"\n",
"return",
"pFunc",
"(",
")",
"\n",
"}"
] |
// Get gets the named provisioner from the registry.
|
[
"Get",
"gets",
"the",
"named",
"provisioner",
"from",
"the",
"registry",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/provision/provision.go#L621-L627
|
test
|
tsuru/tsuru
|
provision/provision.go
|
Registry
|
func Registry() ([]Provisioner, error) {
registry := make([]Provisioner, 0, len(provisioners))
for _, pFunc := range provisioners {
p, err := pFunc()
if err != nil {
return nil, err
}
registry = append(registry, p)
}
return registry, nil
}
|
go
|
func Registry() ([]Provisioner, error) {
registry := make([]Provisioner, 0, len(provisioners))
for _, pFunc := range provisioners {
p, err := pFunc()
if err != nil {
return nil, err
}
registry = append(registry, p)
}
return registry, nil
}
|
[
"func",
"Registry",
"(",
")",
"(",
"[",
"]",
"Provisioner",
",",
"error",
")",
"{",
"registry",
":=",
"make",
"(",
"[",
"]",
"Provisioner",
",",
"0",
",",
"len",
"(",
"provisioners",
")",
")",
"\n",
"for",
"_",
",",
"pFunc",
":=",
"range",
"provisioners",
"{",
"p",
",",
"err",
":=",
"pFunc",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"registry",
"=",
"append",
"(",
"registry",
",",
"p",
")",
"\n",
"}",
"\n",
"return",
"registry",
",",
"nil",
"\n",
"}"
] |
// Registry returns the list of registered provisioners.
|
[
"Registry",
"returns",
"the",
"list",
"of",
"registered",
"provisioners",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/provision/provision.go#L637-L647
|
test
|
tsuru/tsuru
|
provision/provision.go
|
Error
|
func (e *Error) Error() string {
var err string
if e.Err != nil {
err = e.Err.Error() + ": " + e.Reason
} else {
err = e.Reason
}
return err
}
|
go
|
func (e *Error) Error() string {
var err string
if e.Err != nil {
err = e.Err.Error() + ": " + e.Reason
} else {
err = e.Reason
}
return err
}
|
[
"func",
"(",
"e",
"*",
"Error",
")",
"Error",
"(",
")",
"string",
"{",
"var",
"err",
"string",
"\n",
"if",
"e",
".",
"Err",
"!=",
"nil",
"{",
"err",
"=",
"e",
".",
"Err",
".",
"Error",
"(",
")",
"+",
"\": \"",
"+",
"e",
".",
"Reason",
"\n",
"}",
"else",
"{",
"err",
"=",
"e",
".",
"Reason",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] |
// Error is the string representation of a provisioning error.
|
[
"Error",
"is",
"the",
"string",
"representation",
"of",
"a",
"provisioning",
"error",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/provision/provision.go#L679-L687
|
test
|
tsuru/tsuru
|
cmd/cmd.go
|
validateVersion
|
func validateVersion(supported, current string) bool {
if supported == "" {
return true
}
vSupported, err := goVersion.NewVersion(supported)
if err != nil {
return false
}
vCurrent, err := goVersion.NewVersion(current)
if err != nil {
return false
}
return vCurrent.Compare(vSupported) >= 0
}
|
go
|
func validateVersion(supported, current string) bool {
if supported == "" {
return true
}
vSupported, err := goVersion.NewVersion(supported)
if err != nil {
return false
}
vCurrent, err := goVersion.NewVersion(current)
if err != nil {
return false
}
return vCurrent.Compare(vSupported) >= 0
}
|
[
"func",
"validateVersion",
"(",
"supported",
",",
"current",
"string",
")",
"bool",
"{",
"if",
"supported",
"==",
"\"\"",
"{",
"return",
"true",
"\n",
"}",
"\n",
"vSupported",
",",
"err",
":=",
"goVersion",
".",
"NewVersion",
"(",
"supported",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"vCurrent",
",",
"err",
":=",
"goVersion",
".",
"NewVersion",
"(",
"current",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"vCurrent",
".",
"Compare",
"(",
"vSupported",
")",
">=",
"0",
"\n",
"}"
] |
// validateVersion checks whether current version is greater or equal to
// supported version.
|
[
"validateVersion",
"checks",
"whether",
"current",
"version",
"is",
"greater",
"or",
"equal",
"to",
"supported",
"version",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/cmd/cmd.go#L641-L654
|
test
|
tsuru/tsuru
|
cmd/target.go
|
ReadTarget
|
func ReadTarget() (string, error) {
if target := os.Getenv("TSURU_TARGET"); target != "" {
targets, err := getTargets()
if err == nil {
if val, ok := targets[target]; ok {
return val, nil
}
}
return target, nil
}
targetPath := JoinWithUserDir(".tsuru", "target")
target, err := readTarget(targetPath)
if err == errUndefinedTarget {
copyTargetFiles()
target, err = readTarget(JoinWithUserDir(".tsuru_target"))
}
return target, err
}
|
go
|
func ReadTarget() (string, error) {
if target := os.Getenv("TSURU_TARGET"); target != "" {
targets, err := getTargets()
if err == nil {
if val, ok := targets[target]; ok {
return val, nil
}
}
return target, nil
}
targetPath := JoinWithUserDir(".tsuru", "target")
target, err := readTarget(targetPath)
if err == errUndefinedTarget {
copyTargetFiles()
target, err = readTarget(JoinWithUserDir(".tsuru_target"))
}
return target, err
}
|
[
"func",
"ReadTarget",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"target",
":=",
"os",
".",
"Getenv",
"(",
"\"TSURU_TARGET\"",
")",
";",
"target",
"!=",
"\"\"",
"{",
"targets",
",",
"err",
":=",
"getTargets",
"(",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"if",
"val",
",",
"ok",
":=",
"targets",
"[",
"target",
"]",
";",
"ok",
"{",
"return",
"val",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"target",
",",
"nil",
"\n",
"}",
"\n",
"targetPath",
":=",
"JoinWithUserDir",
"(",
"\".tsuru\"",
",",
"\"target\"",
")",
"\n",
"target",
",",
"err",
":=",
"readTarget",
"(",
"targetPath",
")",
"\n",
"if",
"err",
"==",
"errUndefinedTarget",
"{",
"copyTargetFiles",
"(",
")",
"\n",
"target",
",",
"err",
"=",
"readTarget",
"(",
"JoinWithUserDir",
"(",
"\".tsuru_target\"",
")",
")",
"\n",
"}",
"\n",
"return",
"target",
",",
"err",
"\n",
"}"
] |
// ReadTarget returns the current target, as defined in the TSURU_TARGET
// environment variable or in the target file.
|
[
"ReadTarget",
"returns",
"the",
"current",
"target",
"as",
"defined",
"in",
"the",
"TSURU_TARGET",
"environment",
"variable",
"or",
"in",
"the",
"target",
"file",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/cmd/target.go#L97-L114
|
test
|
tsuru/tsuru
|
cmd/target.go
|
WriteTarget
|
func WriteTarget(t string) error {
targetPath := JoinWithUserDir(".tsuru", "target")
targetFile, err := filesystem().OpenFile(targetPath, syscall.O_WRONLY|syscall.O_CREAT|syscall.O_TRUNC, 0600)
if err != nil {
return err
}
defer targetFile.Close()
n, err := targetFile.WriteString(t)
if n != len(t) || err != nil {
return errors.New("Failed to write the target file")
}
return nil
}
|
go
|
func WriteTarget(t string) error {
targetPath := JoinWithUserDir(".tsuru", "target")
targetFile, err := filesystem().OpenFile(targetPath, syscall.O_WRONLY|syscall.O_CREAT|syscall.O_TRUNC, 0600)
if err != nil {
return err
}
defer targetFile.Close()
n, err := targetFile.WriteString(t)
if n != len(t) || err != nil {
return errors.New("Failed to write the target file")
}
return nil
}
|
[
"func",
"WriteTarget",
"(",
"t",
"string",
")",
"error",
"{",
"targetPath",
":=",
"JoinWithUserDir",
"(",
"\".tsuru\"",
",",
"\"target\"",
")",
"\n",
"targetFile",
",",
"err",
":=",
"filesystem",
"(",
")",
".",
"OpenFile",
"(",
"targetPath",
",",
"syscall",
".",
"O_WRONLY",
"|",
"syscall",
".",
"O_CREAT",
"|",
"syscall",
".",
"O_TRUNC",
",",
"0600",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"targetFile",
".",
"Close",
"(",
")",
"\n",
"n",
",",
"err",
":=",
"targetFile",
".",
"WriteString",
"(",
"t",
")",
"\n",
"if",
"n",
"!=",
"len",
"(",
"t",
")",
"||",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"Failed to write the target file\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// WriteTarget writes the given endpoint to the target file.
|
[
"WriteTarget",
"writes",
"the",
"given",
"endpoint",
"to",
"the",
"target",
"file",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/cmd/target.go#L177-L189
|
test
|
tsuru/tsuru
|
cmd/target.go
|
WriteOnTargetList
|
func WriteOnTargetList(label, target string) error {
label = strings.TrimSpace(label)
target = strings.TrimSpace(target)
targetExist, err := CheckIfTargetLabelExists(label)
if err != nil {
return err
}
if targetExist {
return errors.New("Target label provided already exists")
}
targetsPath := JoinWithUserDir(".tsuru", "targets")
targetsFile, err := filesystem().OpenFile(targetsPath, syscall.O_RDWR|syscall.O_CREAT|syscall.O_APPEND, 0600)
if err != nil {
return err
}
defer targetsFile.Close()
content := label + "\t" + target + "\n"
n, err := targetsFile.WriteString(content)
if n != len(content) || err != nil {
return errors.New("Failed to write the target file")
}
return nil
}
|
go
|
func WriteOnTargetList(label, target string) error {
label = strings.TrimSpace(label)
target = strings.TrimSpace(target)
targetExist, err := CheckIfTargetLabelExists(label)
if err != nil {
return err
}
if targetExist {
return errors.New("Target label provided already exists")
}
targetsPath := JoinWithUserDir(".tsuru", "targets")
targetsFile, err := filesystem().OpenFile(targetsPath, syscall.O_RDWR|syscall.O_CREAT|syscall.O_APPEND, 0600)
if err != nil {
return err
}
defer targetsFile.Close()
content := label + "\t" + target + "\n"
n, err := targetsFile.WriteString(content)
if n != len(content) || err != nil {
return errors.New("Failed to write the target file")
}
return nil
}
|
[
"func",
"WriteOnTargetList",
"(",
"label",
",",
"target",
"string",
")",
"error",
"{",
"label",
"=",
"strings",
".",
"TrimSpace",
"(",
"label",
")",
"\n",
"target",
"=",
"strings",
".",
"TrimSpace",
"(",
"target",
")",
"\n",
"targetExist",
",",
"err",
":=",
"CheckIfTargetLabelExists",
"(",
"label",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"targetExist",
"{",
"return",
"errors",
".",
"New",
"(",
"\"Target label provided already exists\"",
")",
"\n",
"}",
"\n",
"targetsPath",
":=",
"JoinWithUserDir",
"(",
"\".tsuru\"",
",",
"\"targets\"",
")",
"\n",
"targetsFile",
",",
"err",
":=",
"filesystem",
"(",
")",
".",
"OpenFile",
"(",
"targetsPath",
",",
"syscall",
".",
"O_RDWR",
"|",
"syscall",
".",
"O_CREAT",
"|",
"syscall",
".",
"O_APPEND",
",",
"0600",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"targetsFile",
".",
"Close",
"(",
")",
"\n",
"content",
":=",
"label",
"+",
"\"\\t\"",
"+",
"\\t",
"+",
"target",
"\n",
"\"\\n\"",
"\n",
"\\n",
"\n",
"n",
",",
"err",
":=",
"targetsFile",
".",
"WriteString",
"(",
"content",
")",
"\n",
"}"
] |
// WriteOnTargetList writes the given target in the target list file.
|
[
"WriteOnTargetList",
"writes",
"the",
"given",
"target",
"in",
"the",
"target",
"list",
"file",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/cmd/target.go#L246-L268
|
test
|
tsuru/tsuru
|
db/storage.go
|
Conn
|
func Conn() (*Storage, error) {
var (
strg Storage
err error
)
url, dbname := DbConfig("")
strg.Storage, err = storage.Open(url, dbname)
return &strg, err
}
|
go
|
func Conn() (*Storage, error) {
var (
strg Storage
err error
)
url, dbname := DbConfig("")
strg.Storage, err = storage.Open(url, dbname)
return &strg, err
}
|
[
"func",
"Conn",
"(",
")",
"(",
"*",
"Storage",
",",
"error",
")",
"{",
"var",
"(",
"strg",
"Storage",
"\n",
"err",
"error",
"\n",
")",
"\n",
"url",
",",
"dbname",
":=",
"DbConfig",
"(",
"\"\"",
")",
"\n",
"strg",
".",
"Storage",
",",
"err",
"=",
"storage",
".",
"Open",
"(",
"url",
",",
"dbname",
")",
"\n",
"return",
"&",
"strg",
",",
"err",
"\n",
"}"
] |
// Conn reads the tsuru config and calls storage.Open to get a database connection.
//
// Most tsuru packages should probably use this function. storage.Open is intended for
// use when supporting more than one database.
|
[
"Conn",
"reads",
"the",
"tsuru",
"config",
"and",
"calls",
"storage",
".",
"Open",
"to",
"get",
"a",
"database",
"connection",
".",
"Most",
"tsuru",
"packages",
"should",
"probably",
"use",
"this",
"function",
".",
"storage",
".",
"Open",
"is",
"intended",
"for",
"use",
"when",
"supporting",
"more",
"than",
"one",
"database",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/db/storage.go#L71-L79
|
test
|
tsuru/tsuru
|
db/storage.go
|
Apps
|
func (s *Storage) Apps() *storage.Collection {
nameIndex := mgo.Index{Key: []string{"name"}, Unique: true}
c := s.Collection("apps")
c.EnsureIndex(nameIndex)
return c
}
|
go
|
func (s *Storage) Apps() *storage.Collection {
nameIndex := mgo.Index{Key: []string{"name"}, Unique: true}
c := s.Collection("apps")
c.EnsureIndex(nameIndex)
return c
}
|
[
"func",
"(",
"s",
"*",
"Storage",
")",
"Apps",
"(",
")",
"*",
"storage",
".",
"Collection",
"{",
"nameIndex",
":=",
"mgo",
".",
"Index",
"{",
"Key",
":",
"[",
"]",
"string",
"{",
"\"name\"",
"}",
",",
"Unique",
":",
"true",
"}",
"\n",
"c",
":=",
"s",
".",
"Collection",
"(",
"\"apps\"",
")",
"\n",
"c",
".",
"EnsureIndex",
"(",
"nameIndex",
")",
"\n",
"return",
"c",
"\n",
"}"
] |
// Apps returns the apps collection from MongoDB.
|
[
"Apps",
"returns",
"the",
"apps",
"collection",
"from",
"MongoDB",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/db/storage.go#L92-L97
|
test
|
tsuru/tsuru
|
db/storage.go
|
PoolsConstraints
|
func (s *Storage) PoolsConstraints() *storage.Collection {
poolConstraintIndex := mgo.Index{Key: []string{"poolexpr", "field"}, Unique: true}
c := s.Collection("pool_constraints")
c.EnsureIndex(poolConstraintIndex)
return c
}
|
go
|
func (s *Storage) PoolsConstraints() *storage.Collection {
poolConstraintIndex := mgo.Index{Key: []string{"poolexpr", "field"}, Unique: true}
c := s.Collection("pool_constraints")
c.EnsureIndex(poolConstraintIndex)
return c
}
|
[
"func",
"(",
"s",
"*",
"Storage",
")",
"PoolsConstraints",
"(",
")",
"*",
"storage",
".",
"Collection",
"{",
"poolConstraintIndex",
":=",
"mgo",
".",
"Index",
"{",
"Key",
":",
"[",
"]",
"string",
"{",
"\"poolexpr\"",
",",
"\"field\"",
"}",
",",
"Unique",
":",
"true",
"}",
"\n",
"c",
":=",
"s",
".",
"Collection",
"(",
"\"pool_constraints\"",
")",
"\n",
"c",
".",
"EnsureIndex",
"(",
"poolConstraintIndex",
")",
"\n",
"return",
"c",
"\n",
"}"
] |
// PoolsConstraints return the pool constraints collection.
|
[
"PoolsConstraints",
"return",
"the",
"pool",
"constraints",
"collection",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/db/storage.go#L115-L120
|
test
|
tsuru/tsuru
|
db/storage.go
|
Users
|
func (s *Storage) Users() *storage.Collection {
emailIndex := mgo.Index{Key: []string{"email"}, Unique: true}
c := s.Collection("users")
c.EnsureIndex(emailIndex)
return c
}
|
go
|
func (s *Storage) Users() *storage.Collection {
emailIndex := mgo.Index{Key: []string{"email"}, Unique: true}
c := s.Collection("users")
c.EnsureIndex(emailIndex)
return c
}
|
[
"func",
"(",
"s",
"*",
"Storage",
")",
"Users",
"(",
")",
"*",
"storage",
".",
"Collection",
"{",
"emailIndex",
":=",
"mgo",
".",
"Index",
"{",
"Key",
":",
"[",
"]",
"string",
"{",
"\"email\"",
"}",
",",
"Unique",
":",
"true",
"}",
"\n",
"c",
":=",
"s",
".",
"Collection",
"(",
"\"users\"",
")",
"\n",
"c",
".",
"EnsureIndex",
"(",
"emailIndex",
")",
"\n",
"return",
"c",
"\n",
"}"
] |
// Users returns the users collection from MongoDB.
|
[
"Users",
"returns",
"the",
"users",
"collection",
"from",
"MongoDB",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/db/storage.go#L123-L128
|
test
|
tsuru/tsuru
|
db/storage.go
|
SAMLRequests
|
func (s *Storage) SAMLRequests() *storage.Collection {
id := mgo.Index{Key: []string{"id"}}
coll := s.Collection("saml_requests")
coll.EnsureIndex(id)
return coll
}
|
go
|
func (s *Storage) SAMLRequests() *storage.Collection {
id := mgo.Index{Key: []string{"id"}}
coll := s.Collection("saml_requests")
coll.EnsureIndex(id)
return coll
}
|
[
"func",
"(",
"s",
"*",
"Storage",
")",
"SAMLRequests",
"(",
")",
"*",
"storage",
".",
"Collection",
"{",
"id",
":=",
"mgo",
".",
"Index",
"{",
"Key",
":",
"[",
"]",
"string",
"{",
"\"id\"",
"}",
"}",
"\n",
"coll",
":=",
"s",
".",
"Collection",
"(",
"\"saml_requests\"",
")",
"\n",
"coll",
".",
"EnsureIndex",
"(",
"id",
")",
"\n",
"return",
"coll",
"\n",
"}"
] |
// SAMLRequests returns the saml_requests from MongoDB.
|
[
"SAMLRequests",
"returns",
"the",
"saml_requests",
"from",
"MongoDB",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/db/storage.go#L145-L150
|
test
|
tsuru/tsuru
|
db/storage.go
|
AppLogCollection
|
func (s *LogStorage) AppLogCollection(appName string) *storage.Collection {
if appName == "" {
return nil
}
return s.Collection("logs_" + appName)
}
|
go
|
func (s *LogStorage) AppLogCollection(appName string) *storage.Collection {
if appName == "" {
return nil
}
return s.Collection("logs_" + appName)
}
|
[
"func",
"(",
"s",
"*",
"LogStorage",
")",
"AppLogCollection",
"(",
"appName",
"string",
")",
"*",
"storage",
".",
"Collection",
"{",
"if",
"appName",
"==",
"\"\"",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"s",
".",
"Collection",
"(",
"\"logs_\"",
"+",
"appName",
")",
"\n",
"}"
] |
// AppLogCollection returns the logs collection for one app from MongoDB.
|
[
"AppLogCollection",
"returns",
"the",
"logs",
"collection",
"for",
"one",
"app",
"from",
"MongoDB",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/db/storage.go#L159-L164
|
test
|
tsuru/tsuru
|
db/storage.go
|
CreateAppLogCollection
|
func (s *LogStorage) CreateAppLogCollection(appName string) (*storage.Collection, error) {
c := s.AppLogCollection(appName)
err := c.Create(&logCappedInfo)
return c, err
}
|
go
|
func (s *LogStorage) CreateAppLogCollection(appName string) (*storage.Collection, error) {
c := s.AppLogCollection(appName)
err := c.Create(&logCappedInfo)
return c, err
}
|
[
"func",
"(",
"s",
"*",
"LogStorage",
")",
"CreateAppLogCollection",
"(",
"appName",
"string",
")",
"(",
"*",
"storage",
".",
"Collection",
",",
"error",
")",
"{",
"c",
":=",
"s",
".",
"AppLogCollection",
"(",
"appName",
")",
"\n",
"err",
":=",
"c",
".",
"Create",
"(",
"&",
"logCappedInfo",
")",
"\n",
"return",
"c",
",",
"err",
"\n",
"}"
] |
// CreateAppLogCollection creates a new capped collection to store logs for an app.
|
[
"CreateAppLogCollection",
"creates",
"a",
"new",
"capped",
"collection",
"to",
"store",
"logs",
"for",
"an",
"app",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/db/storage.go#L167-L171
|
test
|
tsuru/tsuru
|
db/storage.go
|
LogsCollections
|
func (s *LogStorage) LogsCollections() ([]*storage.Collection, error) {
var names []struct {
Name string
}
conn, err := Conn()
if err != nil {
return nil, err
}
defer conn.Close()
err = conn.Apps().Find(nil).All(&names)
if err != nil {
return nil, err
}
var colls []*storage.Collection
for _, name := range names {
colls = append(colls, s.Collection("logs_"+name.Name))
}
return colls, nil
}
|
go
|
func (s *LogStorage) LogsCollections() ([]*storage.Collection, error) {
var names []struct {
Name string
}
conn, err := Conn()
if err != nil {
return nil, err
}
defer conn.Close()
err = conn.Apps().Find(nil).All(&names)
if err != nil {
return nil, err
}
var colls []*storage.Collection
for _, name := range names {
colls = append(colls, s.Collection("logs_"+name.Name))
}
return colls, nil
}
|
[
"func",
"(",
"s",
"*",
"LogStorage",
")",
"LogsCollections",
"(",
")",
"(",
"[",
"]",
"*",
"storage",
".",
"Collection",
",",
"error",
")",
"{",
"var",
"names",
"[",
"]",
"struct",
"{",
"Name",
"string",
"\n",
"}",
"\n",
"conn",
",",
"err",
":=",
"Conn",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"conn",
".",
"Close",
"(",
")",
"\n",
"err",
"=",
"conn",
".",
"Apps",
"(",
")",
".",
"Find",
"(",
"nil",
")",
".",
"All",
"(",
"&",
"names",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"var",
"colls",
"[",
"]",
"*",
"storage",
".",
"Collection",
"\n",
"for",
"_",
",",
"name",
":=",
"range",
"names",
"{",
"colls",
"=",
"append",
"(",
"colls",
",",
"s",
".",
"Collection",
"(",
"\"logs_\"",
"+",
"name",
".",
"Name",
")",
")",
"\n",
"}",
"\n",
"return",
"colls",
",",
"nil",
"\n",
"}"
] |
// LogsCollections returns logs collections for all apps from MongoDB.
|
[
"LogsCollections",
"returns",
"logs",
"collections",
"for",
"all",
"apps",
"from",
"MongoDB",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/db/storage.go#L174-L192
|
test
|
tsuru/tsuru
|
provision/dockercommon/commands.go
|
ArchiveBuildCmds
|
func ArchiveBuildCmds(app provision.App, archiveURL string) []string {
return buildCmds(app, "build", "archive", archiveURL)
}
|
go
|
func ArchiveBuildCmds(app provision.App, archiveURL string) []string {
return buildCmds(app, "build", "archive", archiveURL)
}
|
[
"func",
"ArchiveBuildCmds",
"(",
"app",
"provision",
".",
"App",
",",
"archiveURL",
"string",
")",
"[",
"]",
"string",
"{",
"return",
"buildCmds",
"(",
"app",
",",
"\"build\"",
",",
"\"archive\"",
",",
"archiveURL",
")",
"\n",
"}"
] |
// ArchiveBuildCmds build a image using the archive method.
|
[
"ArchiveBuildCmds",
"build",
"a",
"image",
"using",
"the",
"archive",
"method",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/provision/dockercommon/commands.go#L17-L19
|
test
|
tsuru/tsuru
|
provision/dockercommon/commands.go
|
ArchiveDeployCmds
|
func ArchiveDeployCmds(app provision.App, archiveURL string) []string {
return buildCmds(app, "deploy", "archive", archiveURL)
}
|
go
|
func ArchiveDeployCmds(app provision.App, archiveURL string) []string {
return buildCmds(app, "deploy", "archive", archiveURL)
}
|
[
"func",
"ArchiveDeployCmds",
"(",
"app",
"provision",
".",
"App",
",",
"archiveURL",
"string",
")",
"[",
"]",
"string",
"{",
"return",
"buildCmds",
"(",
"app",
",",
"\"deploy\"",
",",
"\"archive\"",
",",
"archiveURL",
")",
"\n",
"}"
] |
// ArchiveDeployCmds is a legacy command to deploys an unit using the archive method.
|
[
"ArchiveDeployCmds",
"is",
"a",
"legacy",
"command",
"to",
"deploys",
"an",
"unit",
"using",
"the",
"archive",
"method",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/provision/dockercommon/commands.go#L22-L24
|
test
|
tsuru/tsuru
|
provision/dockercommon/commands.go
|
DeployCmds
|
func DeployCmds(app provision.App) []string {
uaCmds := unitAgentCmds(app)
uaCmds = append(uaCmds, "deploy-only")
finalCmd := strings.Join(uaCmds, " ")
return []string{"/bin/sh", "-lc", finalCmd}
}
|
go
|
func DeployCmds(app provision.App) []string {
uaCmds := unitAgentCmds(app)
uaCmds = append(uaCmds, "deploy-only")
finalCmd := strings.Join(uaCmds, " ")
return []string{"/bin/sh", "-lc", finalCmd}
}
|
[
"func",
"DeployCmds",
"(",
"app",
"provision",
".",
"App",
")",
"[",
"]",
"string",
"{",
"uaCmds",
":=",
"unitAgentCmds",
"(",
"app",
")",
"\n",
"uaCmds",
"=",
"append",
"(",
"uaCmds",
",",
"\"deploy-only\"",
")",
"\n",
"finalCmd",
":=",
"strings",
".",
"Join",
"(",
"uaCmds",
",",
"\" \"",
")",
"\n",
"return",
"[",
"]",
"string",
"{",
"\"/bin/sh\"",
",",
"\"-lc\"",
",",
"finalCmd",
"}",
"\n",
"}"
] |
// DeployCmds deploys an unit builded by tsuru.
|
[
"DeployCmds",
"deploys",
"an",
"unit",
"builded",
"by",
"tsuru",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/provision/dockercommon/commands.go#L27-L32
|
test
|
tsuru/tsuru
|
provision/dockercommon/commands.go
|
runWithAgentCmds
|
func runWithAgentCmds(app provision.App) ([]string, error) {
runCmd, err := config.GetString("docker:run-cmd:bin")
if err != nil {
runCmd = "/var/lib/tsuru/start"
}
host, _ := config.GetString("host")
token := app.Envs()["TSURU_APP_TOKEN"].Value
return []string{"tsuru_unit_agent", host, token, app.GetName(), runCmd}, nil
}
|
go
|
func runWithAgentCmds(app provision.App) ([]string, error) {
runCmd, err := config.GetString("docker:run-cmd:bin")
if err != nil {
runCmd = "/var/lib/tsuru/start"
}
host, _ := config.GetString("host")
token := app.Envs()["TSURU_APP_TOKEN"].Value
return []string{"tsuru_unit_agent", host, token, app.GetName(), runCmd}, nil
}
|
[
"func",
"runWithAgentCmds",
"(",
"app",
"provision",
".",
"App",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"runCmd",
",",
"err",
":=",
"config",
".",
"GetString",
"(",
"\"docker:run-cmd:bin\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"runCmd",
"=",
"\"/var/lib/tsuru/start\"",
"\n",
"}",
"\n",
"host",
",",
"_",
":=",
"config",
".",
"GetString",
"(",
"\"host\"",
")",
"\n",
"token",
":=",
"app",
".",
"Envs",
"(",
")",
"[",
"\"TSURU_APP_TOKEN\"",
"]",
".",
"Value",
"\n",
"return",
"[",
"]",
"string",
"{",
"\"tsuru_unit_agent\"",
",",
"host",
",",
"token",
",",
"app",
".",
"GetName",
"(",
")",
",",
"runCmd",
"}",
",",
"nil",
"\n",
"}"
] |
// runWithAgentCmds returns the list of commands that should be passed when the
// provisioner will run a unit using tsuru_unit_agent to start.
//
// This will only be called for legacy containers that have not been re-
// deployed since the introduction of independent units per 'process' in
// 0.12.0.
|
[
"runWithAgentCmds",
"returns",
"the",
"list",
"of",
"commands",
"that",
"should",
"be",
"passed",
"when",
"the",
"provisioner",
"will",
"run",
"a",
"unit",
"using",
"tsuru_unit_agent",
"to",
"start",
".",
"This",
"will",
"only",
"be",
"called",
"for",
"legacy",
"containers",
"that",
"have",
"not",
"been",
"re",
"-",
"deployed",
"since",
"the",
"introduction",
"of",
"independent",
"units",
"per",
"process",
"in",
"0",
".",
"12",
".",
"0",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/provision/dockercommon/commands.go#L58-L66
|
test
|
tsuru/tsuru
|
provision/kubernetes/pkg/client/clientset/versioned/typed/tsuru/v1/app.go
|
newApps
|
func newApps(c *TsuruV1Client, namespace string) *apps {
return &apps{
client: c.RESTClient(),
ns: namespace,
}
}
|
go
|
func newApps(c *TsuruV1Client, namespace string) *apps {
return &apps{
client: c.RESTClient(),
ns: namespace,
}
}
|
[
"func",
"newApps",
"(",
"c",
"*",
"TsuruV1Client",
",",
"namespace",
"string",
")",
"*",
"apps",
"{",
"return",
"&",
"apps",
"{",
"client",
":",
"c",
".",
"RESTClient",
"(",
")",
",",
"ns",
":",
"namespace",
",",
"}",
"\n",
"}"
] |
// newApps returns a Apps
|
[
"newApps",
"returns",
"a",
"Apps"
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/provision/kubernetes/pkg/client/clientset/versioned/typed/tsuru/v1/app.go#L44-L49
|
test
|
tsuru/tsuru
|
provision/docker/container/container.go
|
Commit
|
func (c *Container) Commit(client provision.BuilderDockerClient, limiter provision.ActionLimiter, writer io.Writer, isDeploy bool) (string, error) {
log.Debugf("committing container %s", c.ID)
repository, tag := image.SplitImageName(c.BuildingImage)
opts := docker.CommitContainerOptions{Container: c.ID, Repository: repository, Tag: tag}
done := limiter.Start(c.HostAddr)
image, err := client.CommitContainer(opts)
done()
if err != nil {
return "", log.WrapError(errors.Wrapf(err, "error in commit container %s", c.ID))
}
tags := []string{tag}
if isDeploy && tag != "latest" {
tags = append(tags, "latest")
err = client.TagImage(fmt.Sprintf("%s:%s", repository, tag), docker.TagImageOptions{
Repo: repository,
Tag: "latest",
Force: true,
})
if err != nil {
return "", log.WrapError(errors.Wrapf(err, "error in tag container %s", c.ID))
}
}
imgHistory, err := client.ImageHistory(c.BuildingImage)
imgSize := ""
if err == nil && len(imgHistory) > 0 {
fullSize := imgHistory[0].Size
if len(imgHistory) > 1 && strings.Contains(imgHistory[1].CreatedBy, "tail -f /dev/null") {
fullSize += imgHistory[1].Size
}
imgSize = fmt.Sprintf("(%.02fMB)", float64(fullSize)/1024/1024)
}
fmt.Fprintf(writer, " ---> Sending image to repository %s\n", imgSize)
log.Debugf("image %s generated from container %s", image.ID, c.ID)
for _, tag := range tags {
maxTry, _ := config.GetInt("docker:registry-max-try")
if maxTry <= 0 {
maxTry = 3
}
for i := 0; i < maxTry; i++ {
err = dockercommon.PushImage(client, repository, tag, dockercommon.RegistryAuthConfig(repository))
if err != nil {
fmt.Fprintf(writer, "Could not send image, trying again. Original error: %s\n", err.Error())
log.Errorf("error in push image %s: %s", c.BuildingImage, err)
time.Sleep(time.Second)
continue
}
break
}
if err != nil {
return "", log.WrapError(errors.Wrapf(err, "error in push image %s", c.BuildingImage))
}
}
return c.BuildingImage, nil
}
|
go
|
func (c *Container) Commit(client provision.BuilderDockerClient, limiter provision.ActionLimiter, writer io.Writer, isDeploy bool) (string, error) {
log.Debugf("committing container %s", c.ID)
repository, tag := image.SplitImageName(c.BuildingImage)
opts := docker.CommitContainerOptions{Container: c.ID, Repository: repository, Tag: tag}
done := limiter.Start(c.HostAddr)
image, err := client.CommitContainer(opts)
done()
if err != nil {
return "", log.WrapError(errors.Wrapf(err, "error in commit container %s", c.ID))
}
tags := []string{tag}
if isDeploy && tag != "latest" {
tags = append(tags, "latest")
err = client.TagImage(fmt.Sprintf("%s:%s", repository, tag), docker.TagImageOptions{
Repo: repository,
Tag: "latest",
Force: true,
})
if err != nil {
return "", log.WrapError(errors.Wrapf(err, "error in tag container %s", c.ID))
}
}
imgHistory, err := client.ImageHistory(c.BuildingImage)
imgSize := ""
if err == nil && len(imgHistory) > 0 {
fullSize := imgHistory[0].Size
if len(imgHistory) > 1 && strings.Contains(imgHistory[1].CreatedBy, "tail -f /dev/null") {
fullSize += imgHistory[1].Size
}
imgSize = fmt.Sprintf("(%.02fMB)", float64(fullSize)/1024/1024)
}
fmt.Fprintf(writer, " ---> Sending image to repository %s\n", imgSize)
log.Debugf("image %s generated from container %s", image.ID, c.ID)
for _, tag := range tags {
maxTry, _ := config.GetInt("docker:registry-max-try")
if maxTry <= 0 {
maxTry = 3
}
for i := 0; i < maxTry; i++ {
err = dockercommon.PushImage(client, repository, tag, dockercommon.RegistryAuthConfig(repository))
if err != nil {
fmt.Fprintf(writer, "Could not send image, trying again. Original error: %s\n", err.Error())
log.Errorf("error in push image %s: %s", c.BuildingImage, err)
time.Sleep(time.Second)
continue
}
break
}
if err != nil {
return "", log.WrapError(errors.Wrapf(err, "error in push image %s", c.BuildingImage))
}
}
return c.BuildingImage, nil
}
|
[
"func",
"(",
"c",
"*",
"Container",
")",
"Commit",
"(",
"client",
"provision",
".",
"BuilderDockerClient",
",",
"limiter",
"provision",
".",
"ActionLimiter",
",",
"writer",
"io",
".",
"Writer",
",",
"isDeploy",
"bool",
")",
"(",
"string",
",",
"error",
")",
"{",
"log",
".",
"Debugf",
"(",
"\"committing container %s\"",
",",
"c",
".",
"ID",
")",
"\n",
"repository",
",",
"tag",
":=",
"image",
".",
"SplitImageName",
"(",
"c",
".",
"BuildingImage",
")",
"\n",
"opts",
":=",
"docker",
".",
"CommitContainerOptions",
"{",
"Container",
":",
"c",
".",
"ID",
",",
"Repository",
":",
"repository",
",",
"Tag",
":",
"tag",
"}",
"\n",
"done",
":=",
"limiter",
".",
"Start",
"(",
"c",
".",
"HostAddr",
")",
"\n",
"image",
",",
"err",
":=",
"client",
".",
"CommitContainer",
"(",
"opts",
")",
"\n",
"done",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"log",
".",
"WrapError",
"(",
"errors",
".",
"Wrapf",
"(",
"err",
",",
"\"error in commit container %s\"",
",",
"c",
".",
"ID",
")",
")",
"\n",
"}",
"\n",
"tags",
":=",
"[",
"]",
"string",
"{",
"tag",
"}",
"\n",
"if",
"isDeploy",
"&&",
"tag",
"!=",
"\"latest\"",
"{",
"tags",
"=",
"append",
"(",
"tags",
",",
"\"latest\"",
")",
"\n",
"err",
"=",
"client",
".",
"TagImage",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"%s:%s\"",
",",
"repository",
",",
"tag",
")",
",",
"docker",
".",
"TagImageOptions",
"{",
"Repo",
":",
"repository",
",",
"Tag",
":",
"\"latest\"",
",",
"Force",
":",
"true",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"log",
".",
"WrapError",
"(",
"errors",
".",
"Wrapf",
"(",
"err",
",",
"\"error in tag container %s\"",
",",
"c",
".",
"ID",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"imgHistory",
",",
"err",
":=",
"client",
".",
"ImageHistory",
"(",
"c",
".",
"BuildingImage",
")",
"\n",
"imgSize",
":=",
"\"\"",
"\n",
"if",
"err",
"==",
"nil",
"&&",
"len",
"(",
"imgHistory",
")",
">",
"0",
"{",
"fullSize",
":=",
"imgHistory",
"[",
"0",
"]",
".",
"Size",
"\n",
"if",
"len",
"(",
"imgHistory",
")",
">",
"1",
"&&",
"strings",
".",
"Contains",
"(",
"imgHistory",
"[",
"1",
"]",
".",
"CreatedBy",
",",
"\"tail -f /dev/null\"",
")",
"{",
"fullSize",
"+=",
"imgHistory",
"[",
"1",
"]",
".",
"Size",
"\n",
"}",
"\n",
"imgSize",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"(%.02fMB)\"",
",",
"float64",
"(",
"fullSize",
")",
"/",
"1024",
"/",
"1024",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Fprintf",
"(",
"writer",
",",
"\" -",
",",
"\\n",
")",
"\n",
"imgSize",
"\n",
"log",
".",
"Debugf",
"(",
"\"image %s generated from container %s\"",
",",
"image",
".",
"ID",
",",
"c",
".",
"ID",
")",
"\n",
"for",
"_",
",",
"tag",
":=",
"range",
"tags",
"{",
"maxTry",
",",
"_",
":=",
"config",
".",
"GetInt",
"(",
"\"docker:registry-max-try\"",
")",
"\n",
"if",
"maxTry",
"<=",
"0",
"{",
"maxTry",
"=",
"3",
"\n",
"}",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"maxTry",
";",
"i",
"++",
"{",
"err",
"=",
"dockercommon",
".",
"PushImage",
"(",
"client",
",",
"repository",
",",
"tag",
",",
"dockercommon",
".",
"RegistryAuthConfig",
"(",
"repository",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Fprintf",
"(",
"writer",
",",
"\"Could not send image, trying again. Original error: %s\\n\"",
",",
"\\n",
")",
"\n",
"err",
".",
"Error",
"(",
")",
"\n",
"log",
".",
"Errorf",
"(",
"\"error in push image %s: %s\"",
",",
"c",
".",
"BuildingImage",
",",
"err",
")",
"\n",
"time",
".",
"Sleep",
"(",
"time",
".",
"Second",
")",
"\n",
"}",
"\n",
"continue",
"\n",
"}",
"\n",
"break",
"\n",
"}",
"\n",
"}"
] |
// Commits commits the container, creating an image in Docker. It then returns
// the image identifier for usage in future container creation.
|
[
"Commits",
"commits",
"the",
"container",
"creating",
"an",
"image",
"in",
"Docker",
".",
"It",
"then",
"returns",
"the",
"image",
"identifier",
"for",
"usage",
"in",
"future",
"container",
"creation",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/provision/docker/container/container.go#L358-L411
|
test
|
tsuru/tsuru
|
auth/team.go
|
processTags
|
func processTags(tags []string) []string {
if tags == nil {
return nil
}
processedTags := []string{}
usedTags := make(map[string]bool)
for _, tag := range tags {
tag = strings.TrimSpace(tag)
if len(tag) > 0 && !usedTags[tag] {
processedTags = append(processedTags, tag)
usedTags[tag] = true
}
}
return processedTags
}
|
go
|
func processTags(tags []string) []string {
if tags == nil {
return nil
}
processedTags := []string{}
usedTags := make(map[string]bool)
for _, tag := range tags {
tag = strings.TrimSpace(tag)
if len(tag) > 0 && !usedTags[tag] {
processedTags = append(processedTags, tag)
usedTags[tag] = true
}
}
return processedTags
}
|
[
"func",
"processTags",
"(",
"tags",
"[",
"]",
"string",
")",
"[",
"]",
"string",
"{",
"if",
"tags",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"processedTags",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"usedTags",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"bool",
")",
"\n",
"for",
"_",
",",
"tag",
":=",
"range",
"tags",
"{",
"tag",
"=",
"strings",
".",
"TrimSpace",
"(",
"tag",
")",
"\n",
"if",
"len",
"(",
"tag",
")",
">",
"0",
"&&",
"!",
"usedTags",
"[",
"tag",
"]",
"{",
"processedTags",
"=",
"append",
"(",
"processedTags",
",",
"tag",
")",
"\n",
"usedTags",
"[",
"tag",
"]",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"processedTags",
"\n",
"}"
] |
// processTags removes duplicates and trims spaces from each tag
|
[
"processTags",
"removes",
"duplicates",
"and",
"trims",
"spaces",
"from",
"each",
"tag"
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/auth/team.go#L118-L132
|
test
|
tsuru/tsuru
|
provision/docker/scheduler.go
|
aggregateContainersBy
|
func (s *segregatedScheduler) aggregateContainersBy(matcher bson.M) (map[string]int, error) {
coll := s.provisioner.Collection()
defer coll.Close()
pipe := coll.Pipe([]bson.M{
matcher,
{"$group": bson.M{"_id": "$hostaddr", "count": bson.M{"$sum": 1}}},
})
var results []nodeAggregate
err := pipe.All(&results)
if err != nil {
return nil, err
}
countMap := make(map[string]int)
for _, result := range results {
countMap[result.HostAddr] = result.Count
}
return countMap, nil
}
|
go
|
func (s *segregatedScheduler) aggregateContainersBy(matcher bson.M) (map[string]int, error) {
coll := s.provisioner.Collection()
defer coll.Close()
pipe := coll.Pipe([]bson.M{
matcher,
{"$group": bson.M{"_id": "$hostaddr", "count": bson.M{"$sum": 1}}},
})
var results []nodeAggregate
err := pipe.All(&results)
if err != nil {
return nil, err
}
countMap := make(map[string]int)
for _, result := range results {
countMap[result.HostAddr] = result.Count
}
return countMap, nil
}
|
[
"func",
"(",
"s",
"*",
"segregatedScheduler",
")",
"aggregateContainersBy",
"(",
"matcher",
"bson",
".",
"M",
")",
"(",
"map",
"[",
"string",
"]",
"int",
",",
"error",
")",
"{",
"coll",
":=",
"s",
".",
"provisioner",
".",
"Collection",
"(",
")",
"\n",
"defer",
"coll",
".",
"Close",
"(",
")",
"\n",
"pipe",
":=",
"coll",
".",
"Pipe",
"(",
"[",
"]",
"bson",
".",
"M",
"{",
"matcher",
",",
"{",
"\"$group\"",
":",
"bson",
".",
"M",
"{",
"\"_id\"",
":",
"\"$hostaddr\"",
",",
"\"count\"",
":",
"bson",
".",
"M",
"{",
"\"$sum\"",
":",
"1",
"}",
"}",
"}",
",",
"}",
")",
"\n",
"var",
"results",
"[",
"]",
"nodeAggregate",
"\n",
"err",
":=",
"pipe",
".",
"All",
"(",
"&",
"results",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"countMap",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"int",
")",
"\n",
"for",
"_",
",",
"result",
":=",
"range",
"results",
"{",
"countMap",
"[",
"result",
".",
"HostAddr",
"]",
"=",
"result",
".",
"Count",
"\n",
"}",
"\n",
"return",
"countMap",
",",
"nil",
"\n",
"}"
] |
// aggregateContainersBy aggregates and counts how many containers
// exist each node that matches received filters
|
[
"aggregateContainersBy",
"aggregates",
"and",
"counts",
"how",
"many",
"containers",
"exist",
"each",
"node",
"that",
"matches",
"received",
"filters"
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/provision/docker/scheduler.go#L183-L200
|
test
|
tsuru/tsuru
|
provision/docker/scheduler.go
|
chooseNodeToAdd
|
func (s *segregatedScheduler) chooseNodeToAdd(nodes []cluster.Node, contName string, appName, process string) (string, error) {
log.Debugf("[scheduler] Possible nodes for container %s: %#v", contName, nodes)
s.hostMutex.Lock()
defer s.hostMutex.Unlock()
chosenNode, _, err := s.minMaxNodes(nodes, appName, process)
if err != nil {
return "", err
}
log.Debugf("[scheduler] Chosen node for container %s: %#v", contName, chosenNode)
if contName != "" {
coll := s.provisioner.Collection()
defer coll.Close()
err = coll.Update(bson.M{"name": contName}, bson.M{"$set": bson.M{"hostaddr": net.URLToHost(chosenNode)}})
}
return chosenNode, err
}
|
go
|
func (s *segregatedScheduler) chooseNodeToAdd(nodes []cluster.Node, contName string, appName, process string) (string, error) {
log.Debugf("[scheduler] Possible nodes for container %s: %#v", contName, nodes)
s.hostMutex.Lock()
defer s.hostMutex.Unlock()
chosenNode, _, err := s.minMaxNodes(nodes, appName, process)
if err != nil {
return "", err
}
log.Debugf("[scheduler] Chosen node for container %s: %#v", contName, chosenNode)
if contName != "" {
coll := s.provisioner.Collection()
defer coll.Close()
err = coll.Update(bson.M{"name": contName}, bson.M{"$set": bson.M{"hostaddr": net.URLToHost(chosenNode)}})
}
return chosenNode, err
}
|
[
"func",
"(",
"s",
"*",
"segregatedScheduler",
")",
"chooseNodeToAdd",
"(",
"nodes",
"[",
"]",
"cluster",
".",
"Node",
",",
"contName",
"string",
",",
"appName",
",",
"process",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"log",
".",
"Debugf",
"(",
"\"[scheduler] Possible nodes for container %s: %#v\"",
",",
"contName",
",",
"nodes",
")",
"\n",
"s",
".",
"hostMutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"hostMutex",
".",
"Unlock",
"(",
")",
"\n",
"chosenNode",
",",
"_",
",",
"err",
":=",
"s",
".",
"minMaxNodes",
"(",
"nodes",
",",
"appName",
",",
"process",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"log",
".",
"Debugf",
"(",
"\"[scheduler] Chosen node for container %s: %#v\"",
",",
"contName",
",",
"chosenNode",
")",
"\n",
"if",
"contName",
"!=",
"\"\"",
"{",
"coll",
":=",
"s",
".",
"provisioner",
".",
"Collection",
"(",
")",
"\n",
"defer",
"coll",
".",
"Close",
"(",
")",
"\n",
"err",
"=",
"coll",
".",
"Update",
"(",
"bson",
".",
"M",
"{",
"\"name\"",
":",
"contName",
"}",
",",
"bson",
".",
"M",
"{",
"\"$set\"",
":",
"bson",
".",
"M",
"{",
"\"hostaddr\"",
":",
"net",
".",
"URLToHost",
"(",
"chosenNode",
")",
"}",
"}",
")",
"\n",
"}",
"\n",
"return",
"chosenNode",
",",
"err",
"\n",
"}"
] |
// chooseNodeToAdd finds which is the node with the minimum number of containers
// and returns it
|
[
"chooseNodeToAdd",
"finds",
"which",
"is",
"the",
"node",
"with",
"the",
"minimum",
"number",
"of",
"containers",
"and",
"returns",
"it"
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/provision/docker/scheduler.go#L283-L298
|
test
|
tsuru/tsuru
|
provision/docker/scheduler.go
|
chooseContainerToRemove
|
func (s *segregatedScheduler) chooseContainerToRemove(nodes []cluster.Node, appName, process string) (string, error) {
_, chosenNode, err := s.minMaxNodes(nodes, appName, process)
if err != nil {
return "", err
}
log.Debugf("[scheduler] Chosen node for remove a container: %#v", chosenNode)
containerID, err := s.getContainerPreferablyFromHost(chosenNode, appName, process)
if err != nil {
return "", err
}
return containerID, err
}
|
go
|
func (s *segregatedScheduler) chooseContainerToRemove(nodes []cluster.Node, appName, process string) (string, error) {
_, chosenNode, err := s.minMaxNodes(nodes, appName, process)
if err != nil {
return "", err
}
log.Debugf("[scheduler] Chosen node for remove a container: %#v", chosenNode)
containerID, err := s.getContainerPreferablyFromHost(chosenNode, appName, process)
if err != nil {
return "", err
}
return containerID, err
}
|
[
"func",
"(",
"s",
"*",
"segregatedScheduler",
")",
"chooseContainerToRemove",
"(",
"nodes",
"[",
"]",
"cluster",
".",
"Node",
",",
"appName",
",",
"process",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"_",
",",
"chosenNode",
",",
"err",
":=",
"s",
".",
"minMaxNodes",
"(",
"nodes",
",",
"appName",
",",
"process",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"log",
".",
"Debugf",
"(",
"\"[scheduler] Chosen node for remove a container: %#v\"",
",",
"chosenNode",
")",
"\n",
"containerID",
",",
"err",
":=",
"s",
".",
"getContainerPreferablyFromHost",
"(",
"chosenNode",
",",
"appName",
",",
"process",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"containerID",
",",
"err",
"\n",
"}"
] |
// chooseContainerToRemove finds a container from the the node with maximum
// number of containers and returns it
|
[
"chooseContainerToRemove",
"finds",
"a",
"container",
"from",
"the",
"the",
"node",
"with",
"maximum",
"number",
"of",
"containers",
"and",
"returns",
"it"
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/provision/docker/scheduler.go#L302-L313
|
test
|
tsuru/tsuru
|
router/router.go
|
Get
|
func Get(name string) (Router, error) {
routerType, prefix, err := Type(name)
if err != nil {
return nil, &ErrRouterNotFound{Name: name}
}
factory, ok := routers[routerType]
if !ok {
return nil, errors.Errorf("unknown router: %q.", routerType)
}
r, err := factory(name, prefix)
if err != nil {
return nil, err
}
return r, nil
}
|
go
|
func Get(name string) (Router, error) {
routerType, prefix, err := Type(name)
if err != nil {
return nil, &ErrRouterNotFound{Name: name}
}
factory, ok := routers[routerType]
if !ok {
return nil, errors.Errorf("unknown router: %q.", routerType)
}
r, err := factory(name, prefix)
if err != nil {
return nil, err
}
return r, nil
}
|
[
"func",
"Get",
"(",
"name",
"string",
")",
"(",
"Router",
",",
"error",
")",
"{",
"routerType",
",",
"prefix",
",",
"err",
":=",
"Type",
"(",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"&",
"ErrRouterNotFound",
"{",
"Name",
":",
"name",
"}",
"\n",
"}",
"\n",
"factory",
",",
"ok",
":=",
"routers",
"[",
"routerType",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"Errorf",
"(",
"\"unknown router: %q.\"",
",",
"routerType",
")",
"\n",
"}",
"\n",
"r",
",",
"err",
":=",
"factory",
"(",
"name",
",",
"prefix",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"r",
",",
"nil",
"\n",
"}"
] |
// Get gets the named router from the registry.
|
[
"Get",
"gets",
"the",
"named",
"router",
"from",
"the",
"registry",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/router/router.go#L75-L89
|
test
|
tsuru/tsuru
|
router/router.go
|
Default
|
func Default() (string, error) {
plans, err := List()
if err != nil {
return "", err
}
if len(plans) == 0 {
return "", ErrDefaultRouterNotFound
}
if len(plans) == 1 {
return plans[0].Name, nil
}
for _, p := range plans {
if p.Default {
return p.Name, nil
}
}
return "", ErrDefaultRouterNotFound
}
|
go
|
func Default() (string, error) {
plans, err := List()
if err != nil {
return "", err
}
if len(plans) == 0 {
return "", ErrDefaultRouterNotFound
}
if len(plans) == 1 {
return plans[0].Name, nil
}
for _, p := range plans {
if p.Default {
return p.Name, nil
}
}
return "", ErrDefaultRouterNotFound
}
|
[
"func",
"Default",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"plans",
",",
"err",
":=",
"List",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"if",
"len",
"(",
"plans",
")",
"==",
"0",
"{",
"return",
"\"\"",
",",
"ErrDefaultRouterNotFound",
"\n",
"}",
"\n",
"if",
"len",
"(",
"plans",
")",
"==",
"1",
"{",
"return",
"plans",
"[",
"0",
"]",
".",
"Name",
",",
"nil",
"\n",
"}",
"\n",
"for",
"_",
",",
"p",
":=",
"range",
"plans",
"{",
"if",
"p",
".",
"Default",
"{",
"return",
"p",
".",
"Name",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\"\"",
",",
"ErrDefaultRouterNotFound",
"\n",
"}"
] |
// Default returns the default router
|
[
"Default",
"returns",
"the",
"default",
"router"
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/router/router.go#L92-L109
|
test
|
tsuru/tsuru
|
router/router.go
|
Store
|
func Store(appName, routerName, kind string) error {
coll, err := collection()
if err != nil {
return err
}
defer coll.Close()
data := routerAppEntry{
App: appName,
Router: routerName,
Kind: kind,
}
_, err = coll.Upsert(bson.M{"app": appName}, data)
return err
}
|
go
|
func Store(appName, routerName, kind string) error {
coll, err := collection()
if err != nil {
return err
}
defer coll.Close()
data := routerAppEntry{
App: appName,
Router: routerName,
Kind: kind,
}
_, err = coll.Upsert(bson.M{"app": appName}, data)
return err
}
|
[
"func",
"Store",
"(",
"appName",
",",
"routerName",
",",
"kind",
"string",
")",
"error",
"{",
"coll",
",",
"err",
":=",
"collection",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"coll",
".",
"Close",
"(",
")",
"\n",
"data",
":=",
"routerAppEntry",
"{",
"App",
":",
"appName",
",",
"Router",
":",
"routerName",
",",
"Kind",
":",
"kind",
",",
"}",
"\n",
"_",
",",
"err",
"=",
"coll",
".",
"Upsert",
"(",
"bson",
".",
"M",
"{",
"\"app\"",
":",
"appName",
"}",
",",
"data",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// Store stores the app name related with the
// router name.
|
[
"Store",
"stores",
"the",
"app",
"name",
"related",
"with",
"the",
"router",
"name",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/router/router.go#L225-L238
|
test
|
tsuru/tsuru
|
provision/kubernetes/pkg/client/clientset/versioned/fake/clientset_generated.go
|
TsuruV1
|
func (c *Clientset) TsuruV1() tsuruv1.TsuruV1Interface {
return &faketsuruv1.FakeTsuruV1{Fake: &c.Fake}
}
|
go
|
func (c *Clientset) TsuruV1() tsuruv1.TsuruV1Interface {
return &faketsuruv1.FakeTsuruV1{Fake: &c.Fake}
}
|
[
"func",
"(",
"c",
"*",
"Clientset",
")",
"TsuruV1",
"(",
")",
"tsuruv1",
".",
"TsuruV1Interface",
"{",
"return",
"&",
"faketsuruv1",
".",
"FakeTsuruV1",
"{",
"Fake",
":",
"&",
"c",
".",
"Fake",
"}",
"\n",
"}"
] |
// TsuruV1 retrieves the TsuruV1Client
|
[
"TsuruV1",
"retrieves",
"the",
"TsuruV1Client"
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/provision/kubernetes/pkg/client/clientset/versioned/fake/clientset_generated.go#L54-L56
|
test
|
tsuru/tsuru
|
provision/kubernetes/pkg/client/clientset/versioned/fake/clientset_generated.go
|
Tsuru
|
func (c *Clientset) Tsuru() tsuruv1.TsuruV1Interface {
return &faketsuruv1.FakeTsuruV1{Fake: &c.Fake}
}
|
go
|
func (c *Clientset) Tsuru() tsuruv1.TsuruV1Interface {
return &faketsuruv1.FakeTsuruV1{Fake: &c.Fake}
}
|
[
"func",
"(",
"c",
"*",
"Clientset",
")",
"Tsuru",
"(",
")",
"tsuruv1",
".",
"TsuruV1Interface",
"{",
"return",
"&",
"faketsuruv1",
".",
"FakeTsuruV1",
"{",
"Fake",
":",
"&",
"c",
".",
"Fake",
"}",
"\n",
"}"
] |
// Tsuru retrieves the TsuruV1Client
|
[
"Tsuru",
"retrieves",
"the",
"TsuruV1Client"
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/provision/kubernetes/pkg/client/clientset/versioned/fake/clientset_generated.go#L59-L61
|
test
|
tsuru/tsuru
|
provision/kubernetes/pkg/client/informers/externalversions/tsuru/v1/app.go
|
NewAppInformer
|
func NewAppInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
return NewFilteredAppInformer(client, namespace, resyncPeriod, indexers, nil)
}
|
go
|
func NewAppInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
return NewFilteredAppInformer(client, namespace, resyncPeriod, indexers, nil)
}
|
[
"func",
"NewAppInformer",
"(",
"client",
"versioned",
".",
"Interface",
",",
"namespace",
"string",
",",
"resyncPeriod",
"time",
".",
"Duration",
",",
"indexers",
"cache",
".",
"Indexers",
")",
"cache",
".",
"SharedIndexInformer",
"{",
"return",
"NewFilteredAppInformer",
"(",
"client",
",",
"namespace",
",",
"resyncPeriod",
",",
"indexers",
",",
"nil",
")",
"\n",
"}"
] |
// NewAppInformer constructs a new informer for App type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
|
[
"NewAppInformer",
"constructs",
"a",
"new",
"informer",
"for",
"App",
"type",
".",
"Always",
"prefer",
"using",
"an",
"informer",
"factory",
"to",
"get",
"a",
"shared",
"informer",
"instead",
"of",
"getting",
"an",
"independent",
"one",
".",
"This",
"reduces",
"memory",
"footprint",
"and",
"number",
"of",
"connections",
"to",
"the",
"server",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/provision/kubernetes/pkg/client/informers/externalversions/tsuru/v1/app.go#L40-L42
|
test
|
tsuru/tsuru
|
provision/kubernetes/pkg/client/informers/externalversions/tsuru/v1/app.go
|
NewFilteredAppInformer
|
func NewFilteredAppInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
return cache.NewSharedIndexInformer(
&cache.ListWatch{
ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.TsuruV1().Apps(namespace).List(options)
},
WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.TsuruV1().Apps(namespace).Watch(options)
},
},
&tsuru_v1.App{},
resyncPeriod,
indexers,
)
}
|
go
|
func NewFilteredAppInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
return cache.NewSharedIndexInformer(
&cache.ListWatch{
ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.TsuruV1().Apps(namespace).List(options)
},
WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.TsuruV1().Apps(namespace).Watch(options)
},
},
&tsuru_v1.App{},
resyncPeriod,
indexers,
)
}
|
[
"func",
"NewFilteredAppInformer",
"(",
"client",
"versioned",
".",
"Interface",
",",
"namespace",
"string",
",",
"resyncPeriod",
"time",
".",
"Duration",
",",
"indexers",
"cache",
".",
"Indexers",
",",
"tweakListOptions",
"internalinterfaces",
".",
"TweakListOptionsFunc",
")",
"cache",
".",
"SharedIndexInformer",
"{",
"return",
"cache",
".",
"NewSharedIndexInformer",
"(",
"&",
"cache",
".",
"ListWatch",
"{",
"ListFunc",
":",
"func",
"(",
"options",
"meta_v1",
".",
"ListOptions",
")",
"(",
"runtime",
".",
"Object",
",",
"error",
")",
"{",
"if",
"tweakListOptions",
"!=",
"nil",
"{",
"tweakListOptions",
"(",
"&",
"options",
")",
"\n",
"}",
"\n",
"return",
"client",
".",
"TsuruV1",
"(",
")",
".",
"Apps",
"(",
"namespace",
")",
".",
"List",
"(",
"options",
")",
"\n",
"}",
",",
"WatchFunc",
":",
"func",
"(",
"options",
"meta_v1",
".",
"ListOptions",
")",
"(",
"watch",
".",
"Interface",
",",
"error",
")",
"{",
"if",
"tweakListOptions",
"!=",
"nil",
"{",
"tweakListOptions",
"(",
"&",
"options",
")",
"\n",
"}",
"\n",
"return",
"client",
".",
"TsuruV1",
"(",
")",
".",
"Apps",
"(",
"namespace",
")",
".",
"Watch",
"(",
"options",
")",
"\n",
"}",
",",
"}",
",",
"&",
"tsuru_v1",
".",
"App",
"{",
"}",
",",
"resyncPeriod",
",",
"indexers",
",",
")",
"\n",
"}"
] |
// NewFilteredAppInformer constructs a new informer for App type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
|
[
"NewFilteredAppInformer",
"constructs",
"a",
"new",
"informer",
"for",
"App",
"type",
".",
"Always",
"prefer",
"using",
"an",
"informer",
"factory",
"to",
"get",
"a",
"shared",
"informer",
"instead",
"of",
"getting",
"an",
"independent",
"one",
".",
"This",
"reduces",
"memory",
"footprint",
"and",
"number",
"of",
"connections",
"to",
"the",
"server",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/provision/kubernetes/pkg/client/informers/externalversions/tsuru/v1/app.go#L47-L67
|
test
|
tsuru/tsuru
|
provision/kubernetes/pkg/client/clientset/versioned/typed/tsuru/v1/fake/fake_app.go
|
Watch
|
func (c *FakeApps) Watch(opts v1.ListOptions) (watch.Interface, error) {
return c.Fake.
InvokesWatch(testing.NewWatchAction(appsResource, c.ns, opts))
}
|
go
|
func (c *FakeApps) Watch(opts v1.ListOptions) (watch.Interface, error) {
return c.Fake.
InvokesWatch(testing.NewWatchAction(appsResource, c.ns, opts))
}
|
[
"func",
"(",
"c",
"*",
"FakeApps",
")",
"Watch",
"(",
"opts",
"v1",
".",
"ListOptions",
")",
"(",
"watch",
".",
"Interface",
",",
"error",
")",
"{",
"return",
"c",
".",
"Fake",
".",
"InvokesWatch",
"(",
"testing",
".",
"NewWatchAction",
"(",
"appsResource",
",",
"c",
".",
"ns",
",",
"opts",
")",
")",
"\n",
"}"
] |
// Watch returns a watch.Interface that watches the requested apps.
|
[
"Watch",
"returns",
"a",
"watch",
".",
"Interface",
"that",
"watches",
"the",
"requested",
"apps",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/provision/kubernetes/pkg/client/clientset/versioned/typed/tsuru/v1/fake/fake_app.go#L63-L67
|
test
|
tsuru/tsuru
|
provision/kubernetes/pkg/client/clientset/versioned/typed/tsuru/v1/fake/fake_app.go
|
Patch
|
func (c *FakeApps) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *tsuru_v1.App, err error) {
obj, err := c.Fake.
Invokes(testing.NewPatchSubresourceAction(appsResource, c.ns, name, data, subresources...), &tsuru_v1.App{})
if obj == nil {
return nil, err
}
return obj.(*tsuru_v1.App), err
}
|
go
|
func (c *FakeApps) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *tsuru_v1.App, err error) {
obj, err := c.Fake.
Invokes(testing.NewPatchSubresourceAction(appsResource, c.ns, name, data, subresources...), &tsuru_v1.App{})
if obj == nil {
return nil, err
}
return obj.(*tsuru_v1.App), err
}
|
[
"func",
"(",
"c",
"*",
"FakeApps",
")",
"Patch",
"(",
"name",
"string",
",",
"pt",
"types",
".",
"PatchType",
",",
"data",
"[",
"]",
"byte",
",",
"subresources",
"...",
"string",
")",
"(",
"result",
"*",
"tsuru_v1",
".",
"App",
",",
"err",
"error",
")",
"{",
"obj",
",",
"err",
":=",
"c",
".",
"Fake",
".",
"Invokes",
"(",
"testing",
".",
"NewPatchSubresourceAction",
"(",
"appsResource",
",",
"c",
".",
"ns",
",",
"name",
",",
"data",
",",
"subresources",
"...",
")",
",",
"&",
"tsuru_v1",
".",
"App",
"{",
"}",
")",
"\n",
"if",
"obj",
"==",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"obj",
".",
"(",
"*",
"tsuru_v1",
".",
"App",
")",
",",
"err",
"\n",
"}"
] |
// Patch applies the patch and returns the patched app.
|
[
"Patch",
"applies",
"the",
"patch",
"and",
"returns",
"the",
"patched",
"app",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/provision/kubernetes/pkg/client/clientset/versioned/typed/tsuru/v1/fake/fake_app.go#L108-L116
|
test
|
tsuru/tsuru
|
provision/kubernetes/pkg/client/informers/externalversions/factory.go
|
NewSharedInformerFactory
|
func NewSharedInformerFactory(client versioned.Interface, defaultResync time.Duration) SharedInformerFactory {
return NewFilteredSharedInformerFactory(client, defaultResync, v1.NamespaceAll, nil)
}
|
go
|
func NewSharedInformerFactory(client versioned.Interface, defaultResync time.Duration) SharedInformerFactory {
return NewFilteredSharedInformerFactory(client, defaultResync, v1.NamespaceAll, nil)
}
|
[
"func",
"NewSharedInformerFactory",
"(",
"client",
"versioned",
".",
"Interface",
",",
"defaultResync",
"time",
".",
"Duration",
")",
"SharedInformerFactory",
"{",
"return",
"NewFilteredSharedInformerFactory",
"(",
"client",
",",
"defaultResync",
",",
"v1",
".",
"NamespaceAll",
",",
"nil",
")",
"\n",
"}"
] |
// NewSharedInformerFactory constructs a new instance of sharedInformerFactory
|
[
"NewSharedInformerFactory",
"constructs",
"a",
"new",
"instance",
"of",
"sharedInformerFactory"
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/provision/kubernetes/pkg/client/informers/externalversions/factory.go#L39-L41
|
test
|
tsuru/tsuru
|
provision/kubernetes/pkg/client/informers/externalversions/factory.go
|
NewFilteredSharedInformerFactory
|
func NewFilteredSharedInformerFactory(client versioned.Interface, defaultResync time.Duration, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) SharedInformerFactory {
return &sharedInformerFactory{
client: client,
namespace: namespace,
tweakListOptions: tweakListOptions,
defaultResync: defaultResync,
informers: make(map[reflect.Type]cache.SharedIndexInformer),
startedInformers: make(map[reflect.Type]bool),
}
}
|
go
|
func NewFilteredSharedInformerFactory(client versioned.Interface, defaultResync time.Duration, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) SharedInformerFactory {
return &sharedInformerFactory{
client: client,
namespace: namespace,
tweakListOptions: tweakListOptions,
defaultResync: defaultResync,
informers: make(map[reflect.Type]cache.SharedIndexInformer),
startedInformers: make(map[reflect.Type]bool),
}
}
|
[
"func",
"NewFilteredSharedInformerFactory",
"(",
"client",
"versioned",
".",
"Interface",
",",
"defaultResync",
"time",
".",
"Duration",
",",
"namespace",
"string",
",",
"tweakListOptions",
"internalinterfaces",
".",
"TweakListOptionsFunc",
")",
"SharedInformerFactory",
"{",
"return",
"&",
"sharedInformerFactory",
"{",
"client",
":",
"client",
",",
"namespace",
":",
"namespace",
",",
"tweakListOptions",
":",
"tweakListOptions",
",",
"defaultResync",
":",
"defaultResync",
",",
"informers",
":",
"make",
"(",
"map",
"[",
"reflect",
".",
"Type",
"]",
"cache",
".",
"SharedIndexInformer",
")",
",",
"startedInformers",
":",
"make",
"(",
"map",
"[",
"reflect",
".",
"Type",
"]",
"bool",
")",
",",
"}",
"\n",
"}"
] |
// NewFilteredSharedInformerFactory constructs a new instance of sharedInformerFactory.
// Listers obtained via this SharedInformerFactory will be subject to the same filters
// as specified here.
|
[
"NewFilteredSharedInformerFactory",
"constructs",
"a",
"new",
"instance",
"of",
"sharedInformerFactory",
".",
"Listers",
"obtained",
"via",
"this",
"SharedInformerFactory",
"will",
"be",
"subject",
"to",
"the",
"same",
"filters",
"as",
"specified",
"here",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/provision/kubernetes/pkg/client/informers/externalversions/factory.go#L46-L55
|
test
|
tsuru/tsuru
|
service/broker.go
|
Proxy
|
func (b *brokerClient) Proxy(path string, evt *event.Event, requestID string, w http.ResponseWriter, r *http.Request) error {
return fmt.Errorf("service proxy is not available for broker services")
}
|
go
|
func (b *brokerClient) Proxy(path string, evt *event.Event, requestID string, w http.ResponseWriter, r *http.Request) error {
return fmt.Errorf("service proxy is not available for broker services")
}
|
[
"func",
"(",
"b",
"*",
"brokerClient",
")",
"Proxy",
"(",
"path",
"string",
",",
"evt",
"*",
"event",
".",
"Event",
",",
"requestID",
"string",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"error",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"service proxy is not available for broker services\"",
")",
"\n",
"}"
] |
// Proxy is not implemented for OSB API implementations
|
[
"Proxy",
"is",
"not",
"implemented",
"for",
"OSB",
"API",
"implementations"
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/service/broker.go#L410-L412
|
test
|
tsuru/tsuru
|
service/broker.go
|
UnbindUnit
|
func (b *brokerClient) UnbindUnit(instance *ServiceInstance, app bind.App, unit bind.Unit) error {
return nil
}
|
go
|
func (b *brokerClient) UnbindUnit(instance *ServiceInstance, app bind.App, unit bind.Unit) error {
return nil
}
|
[
"func",
"(",
"b",
"*",
"brokerClient",
")",
"UnbindUnit",
"(",
"instance",
"*",
"ServiceInstance",
",",
"app",
"bind",
".",
"App",
",",
"unit",
"bind",
".",
"Unit",
")",
"error",
"{",
"return",
"nil",
"\n",
"}"
] |
// UnbindUnit is a no-op for OSB API implementations
|
[
"UnbindUnit",
"is",
"a",
"no",
"-",
"op",
"for",
"OSB",
"API",
"implementations"
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/service/broker.go#L415-L417
|
test
|
tsuru/tsuru
|
app/plan.go
|
Create
|
func (s *planService) Create(plan appTypes.Plan) error {
if plan.Name == "" {
return appTypes.PlanValidationError{Field: "name"}
}
if plan.CpuShare < 2 {
return appTypes.ErrLimitOfCpuShare
}
if plan.Memory > 0 && plan.Memory < 4194304 {
return appTypes.ErrLimitOfMemory
}
return s.storage.Insert(plan)
}
|
go
|
func (s *planService) Create(plan appTypes.Plan) error {
if plan.Name == "" {
return appTypes.PlanValidationError{Field: "name"}
}
if plan.CpuShare < 2 {
return appTypes.ErrLimitOfCpuShare
}
if plan.Memory > 0 && plan.Memory < 4194304 {
return appTypes.ErrLimitOfMemory
}
return s.storage.Insert(plan)
}
|
[
"func",
"(",
"s",
"*",
"planService",
")",
"Create",
"(",
"plan",
"appTypes",
".",
"Plan",
")",
"error",
"{",
"if",
"plan",
".",
"Name",
"==",
"\"\"",
"{",
"return",
"appTypes",
".",
"PlanValidationError",
"{",
"Field",
":",
"\"name\"",
"}",
"\n",
"}",
"\n",
"if",
"plan",
".",
"CpuShare",
"<",
"2",
"{",
"return",
"appTypes",
".",
"ErrLimitOfCpuShare",
"\n",
"}",
"\n",
"if",
"plan",
".",
"Memory",
">",
"0",
"&&",
"plan",
".",
"Memory",
"<",
"4194304",
"{",
"return",
"appTypes",
".",
"ErrLimitOfMemory",
"\n",
"}",
"\n",
"return",
"s",
".",
"storage",
".",
"Insert",
"(",
"plan",
")",
"\n",
"}"
] |
// Create implements Create method of PlanService interface
|
[
"Create",
"implements",
"Create",
"method",
"of",
"PlanService",
"interface"
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/app/plan.go#L36-L47
|
test
|
tsuru/tsuru
|
app/plan.go
|
Remove
|
func (s *planService) Remove(planName string) error {
return s.storage.Delete(appTypes.Plan{Name: planName})
}
|
go
|
func (s *planService) Remove(planName string) error {
return s.storage.Delete(appTypes.Plan{Name: planName})
}
|
[
"func",
"(",
"s",
"*",
"planService",
")",
"Remove",
"(",
"planName",
"string",
")",
"error",
"{",
"return",
"s",
".",
"storage",
".",
"Delete",
"(",
"appTypes",
".",
"Plan",
"{",
"Name",
":",
"planName",
"}",
")",
"\n",
"}"
] |
// Remove implements Remove method of PlanService interface
|
[
"Remove",
"implements",
"Remove",
"method",
"of",
"PlanService",
"interface"
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/app/plan.go#L64-L66
|
test
|
tsuru/tsuru
|
app/plan.go
|
ensureDefault
|
func (s *planService) ensureDefault() error {
plans, err := s.storage.FindAll()
if err != nil {
return err
}
if len(plans) > 0 {
return nil
}
configMemory, _ := config.GetInt("docker:memory")
configSwap, _ := config.GetInt("docker:swap")
dp := appTypes.Plan{
Name: "autogenerated",
Memory: int64(configMemory) * 1024 * 1024,
Swap: int64(configSwap-configMemory) * 1024 * 1024,
CpuShare: 100,
Default: true,
}
return s.storage.Insert(dp)
}
|
go
|
func (s *planService) ensureDefault() error {
plans, err := s.storage.FindAll()
if err != nil {
return err
}
if len(plans) > 0 {
return nil
}
configMemory, _ := config.GetInt("docker:memory")
configSwap, _ := config.GetInt("docker:swap")
dp := appTypes.Plan{
Name: "autogenerated",
Memory: int64(configMemory) * 1024 * 1024,
Swap: int64(configSwap-configMemory) * 1024 * 1024,
CpuShare: 100,
Default: true,
}
return s.storage.Insert(dp)
}
|
[
"func",
"(",
"s",
"*",
"planService",
")",
"ensureDefault",
"(",
")",
"error",
"{",
"plans",
",",
"err",
":=",
"s",
".",
"storage",
".",
"FindAll",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"len",
"(",
"plans",
")",
">",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"configMemory",
",",
"_",
":=",
"config",
".",
"GetInt",
"(",
"\"docker:memory\"",
")",
"\n",
"configSwap",
",",
"_",
":=",
"config",
".",
"GetInt",
"(",
"\"docker:swap\"",
")",
"\n",
"dp",
":=",
"appTypes",
".",
"Plan",
"{",
"Name",
":",
"\"autogenerated\"",
",",
"Memory",
":",
"int64",
"(",
"configMemory",
")",
"*",
"1024",
"*",
"1024",
",",
"Swap",
":",
"int64",
"(",
"configSwap",
"-",
"configMemory",
")",
"*",
"1024",
"*",
"1024",
",",
"CpuShare",
":",
"100",
",",
"Default",
":",
"true",
",",
"}",
"\n",
"return",
"s",
".",
"storage",
".",
"Insert",
"(",
"dp",
")",
"\n",
"}"
] |
// ensureDefault creates and stores an autogenerated plan in case of no plans
// exists.
|
[
"ensureDefault",
"creates",
"and",
"stores",
"an",
"autogenerated",
"plan",
"in",
"case",
"of",
"no",
"plans",
"exists",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/app/plan.go#L70-L88
|
test
|
tsuru/tsuru
|
service/service_instance.go
|
DeleteInstance
|
func DeleteInstance(si *ServiceInstance, evt *event.Event, requestID string) error {
if len(si.Apps) > 0 {
return ErrServiceInstanceBound
}
s, err := Get(si.ServiceName)
if err != nil {
return err
}
endpoint, err := s.getClient("production")
if err == nil {
endpoint.Destroy(si, evt, requestID)
}
conn, err := db.Conn()
if err != nil {
return err
}
defer conn.Close()
return conn.ServiceInstances().Remove(bson.M{"name": si.Name, "service_name": si.ServiceName})
}
|
go
|
func DeleteInstance(si *ServiceInstance, evt *event.Event, requestID string) error {
if len(si.Apps) > 0 {
return ErrServiceInstanceBound
}
s, err := Get(si.ServiceName)
if err != nil {
return err
}
endpoint, err := s.getClient("production")
if err == nil {
endpoint.Destroy(si, evt, requestID)
}
conn, err := db.Conn()
if err != nil {
return err
}
defer conn.Close()
return conn.ServiceInstances().Remove(bson.M{"name": si.Name, "service_name": si.ServiceName})
}
|
[
"func",
"DeleteInstance",
"(",
"si",
"*",
"ServiceInstance",
",",
"evt",
"*",
"event",
".",
"Event",
",",
"requestID",
"string",
")",
"error",
"{",
"if",
"len",
"(",
"si",
".",
"Apps",
")",
">",
"0",
"{",
"return",
"ErrServiceInstanceBound",
"\n",
"}",
"\n",
"s",
",",
"err",
":=",
"Get",
"(",
"si",
".",
"ServiceName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"endpoint",
",",
"err",
":=",
"s",
".",
"getClient",
"(",
"\"production\"",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"endpoint",
".",
"Destroy",
"(",
"si",
",",
"evt",
",",
"requestID",
")",
"\n",
"}",
"\n",
"conn",
",",
"err",
":=",
"db",
".",
"Conn",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"conn",
".",
"Close",
"(",
")",
"\n",
"return",
"conn",
".",
"ServiceInstances",
"(",
")",
".",
"Remove",
"(",
"bson",
".",
"M",
"{",
"\"name\"",
":",
"si",
".",
"Name",
",",
"\"service_name\"",
":",
"si",
".",
"ServiceName",
"}",
")",
"\n",
"}"
] |
// DeleteInstance deletes the service instance from the database.
|
[
"DeleteInstance",
"deletes",
"the",
"service",
"instance",
"from",
"the",
"database",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/service/service_instance.go#L92-L110
|
test
|
tsuru/tsuru
|
service/service_instance.go
|
ToInfo
|
func (si *ServiceInstance) ToInfo() (ServiceInstanceWithInfo, error) {
info, err := si.Info("")
if err != nil {
info = nil
}
return ServiceInstanceWithInfo{
Id: si.Id,
Name: si.Name,
Teams: si.Teams,
PlanName: si.PlanName,
Apps: si.Apps,
ServiceName: si.ServiceName,
Info: info,
TeamOwner: si.TeamOwner,
}, nil
}
|
go
|
func (si *ServiceInstance) ToInfo() (ServiceInstanceWithInfo, error) {
info, err := si.Info("")
if err != nil {
info = nil
}
return ServiceInstanceWithInfo{
Id: si.Id,
Name: si.Name,
Teams: si.Teams,
PlanName: si.PlanName,
Apps: si.Apps,
ServiceName: si.ServiceName,
Info: info,
TeamOwner: si.TeamOwner,
}, nil
}
|
[
"func",
"(",
"si",
"*",
"ServiceInstance",
")",
"ToInfo",
"(",
")",
"(",
"ServiceInstanceWithInfo",
",",
"error",
")",
"{",
"info",
",",
"err",
":=",
"si",
".",
"Info",
"(",
"\"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"info",
"=",
"nil",
"\n",
"}",
"\n",
"return",
"ServiceInstanceWithInfo",
"{",
"Id",
":",
"si",
".",
"Id",
",",
"Name",
":",
"si",
".",
"Name",
",",
"Teams",
":",
"si",
".",
"Teams",
",",
"PlanName",
":",
"si",
".",
"PlanName",
",",
"Apps",
":",
"si",
".",
"Apps",
",",
"ServiceName",
":",
"si",
".",
"ServiceName",
",",
"Info",
":",
"info",
",",
"TeamOwner",
":",
"si",
".",
"TeamOwner",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// ToInfo returns the service instance as a struct compatible with the return
// of the service info api call.
|
[
"ToInfo",
"returns",
"the",
"service",
"instance",
"as",
"a",
"struct",
"compatible",
"with",
"the",
"return",
"of",
"the",
"service",
"info",
"api",
"call",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/service/service_instance.go#L132-L147
|
test
|
tsuru/tsuru
|
service/service_instance.go
|
Update
|
func (si *ServiceInstance) Update(service Service, updateData ServiceInstance, evt *event.Event, requestID string) error {
err := validateServiceInstanceTeamOwner(updateData)
if err != nil {
return err
}
conn, err := db.Conn()
if err != nil {
return err
}
defer conn.Close()
tags := processTags(updateData.Tags)
if tags == nil {
updateData.Tags = si.Tags
} else {
updateData.Tags = tags
}
actions := []*action.Action{&updateServiceInstance, ¬ifyUpdateServiceInstance}
pipeline := action.NewPipeline(actions...)
return pipeline.Execute(service, *si, updateData, evt, requestID)
}
|
go
|
func (si *ServiceInstance) Update(service Service, updateData ServiceInstance, evt *event.Event, requestID string) error {
err := validateServiceInstanceTeamOwner(updateData)
if err != nil {
return err
}
conn, err := db.Conn()
if err != nil {
return err
}
defer conn.Close()
tags := processTags(updateData.Tags)
if tags == nil {
updateData.Tags = si.Tags
} else {
updateData.Tags = tags
}
actions := []*action.Action{&updateServiceInstance, ¬ifyUpdateServiceInstance}
pipeline := action.NewPipeline(actions...)
return pipeline.Execute(service, *si, updateData, evt, requestID)
}
|
[
"func",
"(",
"si",
"*",
"ServiceInstance",
")",
"Update",
"(",
"service",
"Service",
",",
"updateData",
"ServiceInstance",
",",
"evt",
"*",
"event",
".",
"Event",
",",
"requestID",
"string",
")",
"error",
"{",
"err",
":=",
"validateServiceInstanceTeamOwner",
"(",
"updateData",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"conn",
",",
"err",
":=",
"db",
".",
"Conn",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"conn",
".",
"Close",
"(",
")",
"\n",
"tags",
":=",
"processTags",
"(",
"updateData",
".",
"Tags",
")",
"\n",
"if",
"tags",
"==",
"nil",
"{",
"updateData",
".",
"Tags",
"=",
"si",
".",
"Tags",
"\n",
"}",
"else",
"{",
"updateData",
".",
"Tags",
"=",
"tags",
"\n",
"}",
"\n",
"actions",
":=",
"[",
"]",
"*",
"action",
".",
"Action",
"{",
"&",
"updateServiceInstance",
",",
"&",
"notifyUpdateServiceInstance",
"}",
"\n",
"pipeline",
":=",
"action",
".",
"NewPipeline",
"(",
"actions",
"...",
")",
"\n",
"return",
"pipeline",
".",
"Execute",
"(",
"service",
",",
"*",
"si",
",",
"updateData",
",",
"evt",
",",
"requestID",
")",
"\n",
"}"
] |
// Update changes informations of the service instance.
|
[
"Update",
"changes",
"informations",
"of",
"the",
"service",
"instance",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/service/service_instance.go#L181-L200
|
test
|
tsuru/tsuru
|
service/service_instance.go
|
BindApp
|
func (si *ServiceInstance) BindApp(app bind.App, params BindAppParameters, shouldRestart bool, writer io.Writer, evt *event.Event, requestID string) error {
args := bindPipelineArgs{
serviceInstance: si,
app: app,
writer: writer,
shouldRestart: shouldRestart,
params: params,
event: evt,
requestID: requestID,
}
actions := []*action.Action{
bindAppDBAction,
bindAppEndpointAction,
setBoundEnvsAction,
bindUnitsAction,
}
pipeline := action.NewPipeline(actions...)
return pipeline.Execute(&args)
}
|
go
|
func (si *ServiceInstance) BindApp(app bind.App, params BindAppParameters, shouldRestart bool, writer io.Writer, evt *event.Event, requestID string) error {
args := bindPipelineArgs{
serviceInstance: si,
app: app,
writer: writer,
shouldRestart: shouldRestart,
params: params,
event: evt,
requestID: requestID,
}
actions := []*action.Action{
bindAppDBAction,
bindAppEndpointAction,
setBoundEnvsAction,
bindUnitsAction,
}
pipeline := action.NewPipeline(actions...)
return pipeline.Execute(&args)
}
|
[
"func",
"(",
"si",
"*",
"ServiceInstance",
")",
"BindApp",
"(",
"app",
"bind",
".",
"App",
",",
"params",
"BindAppParameters",
",",
"shouldRestart",
"bool",
",",
"writer",
"io",
".",
"Writer",
",",
"evt",
"*",
"event",
".",
"Event",
",",
"requestID",
"string",
")",
"error",
"{",
"args",
":=",
"bindPipelineArgs",
"{",
"serviceInstance",
":",
"si",
",",
"app",
":",
"app",
",",
"writer",
":",
"writer",
",",
"shouldRestart",
":",
"shouldRestart",
",",
"params",
":",
"params",
",",
"event",
":",
"evt",
",",
"requestID",
":",
"requestID",
",",
"}",
"\n",
"actions",
":=",
"[",
"]",
"*",
"action",
".",
"Action",
"{",
"bindAppDBAction",
",",
"bindAppEndpointAction",
",",
"setBoundEnvsAction",
",",
"bindUnitsAction",
",",
"}",
"\n",
"pipeline",
":=",
"action",
".",
"NewPipeline",
"(",
"actions",
"...",
")",
"\n",
"return",
"pipeline",
".",
"Execute",
"(",
"&",
"args",
")",
"\n",
"}"
] |
// BindApp makes the bind between the service instance and an app.
|
[
"BindApp",
"makes",
"the",
"bind",
"between",
"the",
"service",
"instance",
"and",
"an",
"app",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/service/service_instance.go#L212-L230
|
test
|
tsuru/tsuru
|
service/service_instance.go
|
BindUnit
|
func (si *ServiceInstance) BindUnit(app bind.App, unit bind.Unit) error {
s, err := Get(si.ServiceName)
if err != nil {
return err
}
endpoint, err := s.getClient("production")
if err != nil {
return err
}
conn, err := db.Conn()
if err != nil {
return err
}
updateOp := bson.M{
"$addToSet": bson.M{
"bound_units": bson.D([]bson.DocElem{
{Name: "appname", Value: app.GetName()},
{Name: "id", Value: unit.GetID()},
{Name: "ip", Value: unit.GetIp()},
}),
},
}
err = conn.ServiceInstances().Update(bson.M{"name": si.Name, "service_name": si.ServiceName, "bound_units.id": bson.M{"$ne": unit.GetID()}}, updateOp)
conn.Close()
if err != nil {
if err == mgo.ErrNotFound {
return nil
}
return err
}
err = endpoint.BindUnit(si, app, unit)
if err != nil {
updateOp = bson.M{
"$pull": bson.M{
"bound_units": bson.D([]bson.DocElem{
{Name: "appname", Value: app.GetName()},
{Name: "id", Value: unit.GetID()},
{Name: "ip", Value: unit.GetIp()},
}),
},
}
rollbackErr := si.updateData(updateOp)
if rollbackErr != nil {
log.Errorf("[bind unit] could not remove stil unbound unit from db after failure: %s", rollbackErr)
}
return err
}
return nil
}
|
go
|
func (si *ServiceInstance) BindUnit(app bind.App, unit bind.Unit) error {
s, err := Get(si.ServiceName)
if err != nil {
return err
}
endpoint, err := s.getClient("production")
if err != nil {
return err
}
conn, err := db.Conn()
if err != nil {
return err
}
updateOp := bson.M{
"$addToSet": bson.M{
"bound_units": bson.D([]bson.DocElem{
{Name: "appname", Value: app.GetName()},
{Name: "id", Value: unit.GetID()},
{Name: "ip", Value: unit.GetIp()},
}),
},
}
err = conn.ServiceInstances().Update(bson.M{"name": si.Name, "service_name": si.ServiceName, "bound_units.id": bson.M{"$ne": unit.GetID()}}, updateOp)
conn.Close()
if err != nil {
if err == mgo.ErrNotFound {
return nil
}
return err
}
err = endpoint.BindUnit(si, app, unit)
if err != nil {
updateOp = bson.M{
"$pull": bson.M{
"bound_units": bson.D([]bson.DocElem{
{Name: "appname", Value: app.GetName()},
{Name: "id", Value: unit.GetID()},
{Name: "ip", Value: unit.GetIp()},
}),
},
}
rollbackErr := si.updateData(updateOp)
if rollbackErr != nil {
log.Errorf("[bind unit] could not remove stil unbound unit from db after failure: %s", rollbackErr)
}
return err
}
return nil
}
|
[
"func",
"(",
"si",
"*",
"ServiceInstance",
")",
"BindUnit",
"(",
"app",
"bind",
".",
"App",
",",
"unit",
"bind",
".",
"Unit",
")",
"error",
"{",
"s",
",",
"err",
":=",
"Get",
"(",
"si",
".",
"ServiceName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"endpoint",
",",
"err",
":=",
"s",
".",
"getClient",
"(",
"\"production\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"conn",
",",
"err",
":=",
"db",
".",
"Conn",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"updateOp",
":=",
"bson",
".",
"M",
"{",
"\"$addToSet\"",
":",
"bson",
".",
"M",
"{",
"\"bound_units\"",
":",
"bson",
".",
"D",
"(",
"[",
"]",
"bson",
".",
"DocElem",
"{",
"{",
"Name",
":",
"\"appname\"",
",",
"Value",
":",
"app",
".",
"GetName",
"(",
")",
"}",
",",
"{",
"Name",
":",
"\"id\"",
",",
"Value",
":",
"unit",
".",
"GetID",
"(",
")",
"}",
",",
"{",
"Name",
":",
"\"ip\"",
",",
"Value",
":",
"unit",
".",
"GetIp",
"(",
")",
"}",
",",
"}",
")",
",",
"}",
",",
"}",
"\n",
"err",
"=",
"conn",
".",
"ServiceInstances",
"(",
")",
".",
"Update",
"(",
"bson",
".",
"M",
"{",
"\"name\"",
":",
"si",
".",
"Name",
",",
"\"service_name\"",
":",
"si",
".",
"ServiceName",
",",
"\"bound_units.id\"",
":",
"bson",
".",
"M",
"{",
"\"$ne\"",
":",
"unit",
".",
"GetID",
"(",
")",
"}",
"}",
",",
"updateOp",
")",
"\n",
"conn",
".",
"Close",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"mgo",
".",
"ErrNotFound",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"err",
"=",
"endpoint",
".",
"BindUnit",
"(",
"si",
",",
"app",
",",
"unit",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"updateOp",
"=",
"bson",
".",
"M",
"{",
"\"$pull\"",
":",
"bson",
".",
"M",
"{",
"\"bound_units\"",
":",
"bson",
".",
"D",
"(",
"[",
"]",
"bson",
".",
"DocElem",
"{",
"{",
"Name",
":",
"\"appname\"",
",",
"Value",
":",
"app",
".",
"GetName",
"(",
")",
"}",
",",
"{",
"Name",
":",
"\"id\"",
",",
"Value",
":",
"unit",
".",
"GetID",
"(",
")",
"}",
",",
"{",
"Name",
":",
"\"ip\"",
",",
"Value",
":",
"unit",
".",
"GetIp",
"(",
")",
"}",
",",
"}",
")",
",",
"}",
",",
"}",
"\n",
"rollbackErr",
":=",
"si",
".",
"updateData",
"(",
"updateOp",
")",
"\n",
"if",
"rollbackErr",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"[bind unit] could not remove stil unbound unit from db after failure: %s\"",
",",
"rollbackErr",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// BindUnit makes the bind between the binder and an unit.
|
[
"BindUnit",
"makes",
"the",
"bind",
"between",
"the",
"binder",
"and",
"an",
"unit",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/service/service_instance.go#L233-L281
|
test
|
tsuru/tsuru
|
service/service_instance.go
|
UnbindApp
|
func (si *ServiceInstance) UnbindApp(unbindArgs UnbindAppArgs) error {
if si.FindApp(unbindArgs.App.GetName()) == -1 {
return ErrAppNotBound
}
args := bindPipelineArgs{
serviceInstance: si,
app: unbindArgs.App,
writer: unbindArgs.Event,
shouldRestart: unbindArgs.Restart,
event: unbindArgs.Event,
requestID: unbindArgs.RequestID,
forceRemove: unbindArgs.ForceRemove,
}
actions := []*action.Action{
&unbindUnits,
&unbindAppDB,
&unbindAppEndpoint,
&removeBoundEnvs,
}
pipeline := action.NewPipeline(actions...)
return pipeline.Execute(&args)
}
|
go
|
func (si *ServiceInstance) UnbindApp(unbindArgs UnbindAppArgs) error {
if si.FindApp(unbindArgs.App.GetName()) == -1 {
return ErrAppNotBound
}
args := bindPipelineArgs{
serviceInstance: si,
app: unbindArgs.App,
writer: unbindArgs.Event,
shouldRestart: unbindArgs.Restart,
event: unbindArgs.Event,
requestID: unbindArgs.RequestID,
forceRemove: unbindArgs.ForceRemove,
}
actions := []*action.Action{
&unbindUnits,
&unbindAppDB,
&unbindAppEndpoint,
&removeBoundEnvs,
}
pipeline := action.NewPipeline(actions...)
return pipeline.Execute(&args)
}
|
[
"func",
"(",
"si",
"*",
"ServiceInstance",
")",
"UnbindApp",
"(",
"unbindArgs",
"UnbindAppArgs",
")",
"error",
"{",
"if",
"si",
".",
"FindApp",
"(",
"unbindArgs",
".",
"App",
".",
"GetName",
"(",
")",
")",
"==",
"-",
"1",
"{",
"return",
"ErrAppNotBound",
"\n",
"}",
"\n",
"args",
":=",
"bindPipelineArgs",
"{",
"serviceInstance",
":",
"si",
",",
"app",
":",
"unbindArgs",
".",
"App",
",",
"writer",
":",
"unbindArgs",
".",
"Event",
",",
"shouldRestart",
":",
"unbindArgs",
".",
"Restart",
",",
"event",
":",
"unbindArgs",
".",
"Event",
",",
"requestID",
":",
"unbindArgs",
".",
"RequestID",
",",
"forceRemove",
":",
"unbindArgs",
".",
"ForceRemove",
",",
"}",
"\n",
"actions",
":=",
"[",
"]",
"*",
"action",
".",
"Action",
"{",
"&",
"unbindUnits",
",",
"&",
"unbindAppDB",
",",
"&",
"unbindAppEndpoint",
",",
"&",
"removeBoundEnvs",
",",
"}",
"\n",
"pipeline",
":=",
"action",
".",
"NewPipeline",
"(",
"actions",
"...",
")",
"\n",
"return",
"pipeline",
".",
"Execute",
"(",
"&",
"args",
")",
"\n",
"}"
] |
// UnbindApp makes the unbind between the service instance and an app.
|
[
"UnbindApp",
"makes",
"the",
"unbind",
"between",
"the",
"service",
"instance",
"and",
"an",
"app",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/service/service_instance.go#L292-L313
|
test
|
tsuru/tsuru
|
service/service_instance.go
|
Status
|
func (si *ServiceInstance) Status(requestID string) (string, error) {
s, err := Get(si.ServiceName)
if err != nil {
return "", err
}
endpoint, err := s.getClient("production")
if err != nil {
return "", err
}
return endpoint.Status(si, requestID)
}
|
go
|
func (si *ServiceInstance) Status(requestID string) (string, error) {
s, err := Get(si.ServiceName)
if err != nil {
return "", err
}
endpoint, err := s.getClient("production")
if err != nil {
return "", err
}
return endpoint.Status(si, requestID)
}
|
[
"func",
"(",
"si",
"*",
"ServiceInstance",
")",
"Status",
"(",
"requestID",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"s",
",",
"err",
":=",
"Get",
"(",
"si",
".",
"ServiceName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"endpoint",
",",
"err",
":=",
"s",
".",
"getClient",
"(",
"\"production\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"endpoint",
".",
"Status",
"(",
"si",
",",
"requestID",
")",
"\n",
"}"
] |
// Status returns the service instance status.
|
[
"Status",
"returns",
"the",
"service",
"instance",
"status",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/service/service_instance.go#L367-L377
|
test
|
tsuru/tsuru
|
service/service_instance.go
|
ProxyInstance
|
func ProxyInstance(instance *ServiceInstance, path string, evt *event.Event, requestID string, w http.ResponseWriter, r *http.Request) error {
service, err := Get(instance.ServiceName)
if err != nil {
return err
}
endpoint, err := service.getClient("production")
if err != nil {
return err
}
prefix := fmt.Sprintf("/resources/%s/", instance.GetIdentifier())
path = strings.Trim(strings.TrimPrefix(path+"/", prefix), "/")
for _, reserved := range reservedProxyPaths {
if path == reserved && r.Method != "GET" {
return &tsuruErrors.ValidationError{
Message: fmt.Sprintf("proxy request %s %q is forbidden", r.Method, path),
}
}
}
return endpoint.Proxy(fmt.Sprintf("%s%s", prefix, path), evt, requestID, w, r)
}
|
go
|
func ProxyInstance(instance *ServiceInstance, path string, evt *event.Event, requestID string, w http.ResponseWriter, r *http.Request) error {
service, err := Get(instance.ServiceName)
if err != nil {
return err
}
endpoint, err := service.getClient("production")
if err != nil {
return err
}
prefix := fmt.Sprintf("/resources/%s/", instance.GetIdentifier())
path = strings.Trim(strings.TrimPrefix(path+"/", prefix), "/")
for _, reserved := range reservedProxyPaths {
if path == reserved && r.Method != "GET" {
return &tsuruErrors.ValidationError{
Message: fmt.Sprintf("proxy request %s %q is forbidden", r.Method, path),
}
}
}
return endpoint.Proxy(fmt.Sprintf("%s%s", prefix, path), evt, requestID, w, r)
}
|
[
"func",
"ProxyInstance",
"(",
"instance",
"*",
"ServiceInstance",
",",
"path",
"string",
",",
"evt",
"*",
"event",
".",
"Event",
",",
"requestID",
"string",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"error",
"{",
"service",
",",
"err",
":=",
"Get",
"(",
"instance",
".",
"ServiceName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"endpoint",
",",
"err",
":=",
"service",
".",
"getClient",
"(",
"\"production\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"prefix",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"/resources/%s/\"",
",",
"instance",
".",
"GetIdentifier",
"(",
")",
")",
"\n",
"path",
"=",
"strings",
".",
"Trim",
"(",
"strings",
".",
"TrimPrefix",
"(",
"path",
"+",
"\"/\"",
",",
"prefix",
")",
",",
"\"/\"",
")",
"\n",
"for",
"_",
",",
"reserved",
":=",
"range",
"reservedProxyPaths",
"{",
"if",
"path",
"==",
"reserved",
"&&",
"r",
".",
"Method",
"!=",
"\"GET\"",
"{",
"return",
"&",
"tsuruErrors",
".",
"ValidationError",
"{",
"Message",
":",
"fmt",
".",
"Sprintf",
"(",
"\"proxy request %s %q is forbidden\"",
",",
"r",
".",
"Method",
",",
"path",
")",
",",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"endpoint",
".",
"Proxy",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"%s%s\"",
",",
"prefix",
",",
"path",
")",
",",
"evt",
",",
"requestID",
",",
"w",
",",
"r",
")",
"\n",
"}"
] |
// ProxyInstance is a proxy between tsuru and the service instance.
// This method allow customized service instance methods.
|
[
"ProxyInstance",
"is",
"a",
"proxy",
"between",
"tsuru",
"and",
"the",
"service",
"instance",
".",
"This",
"method",
"allow",
"customized",
"service",
"instance",
"methods",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/service/service_instance.go#L562-L581
|
test
|
tsuru/tsuru
|
quota/quota.go
|
Inc
|
func (s *QuotaService) Inc(appName string, quantity int) error {
quota, err := s.Storage.Get(appName)
if err != nil {
return err
}
err = s.checkLimit(quota, quantity)
if err != nil {
return err
}
return s.Storage.Inc(appName, quantity)
}
|
go
|
func (s *QuotaService) Inc(appName string, quantity int) error {
quota, err := s.Storage.Get(appName)
if err != nil {
return err
}
err = s.checkLimit(quota, quantity)
if err != nil {
return err
}
return s.Storage.Inc(appName, quantity)
}
|
[
"func",
"(",
"s",
"*",
"QuotaService",
")",
"Inc",
"(",
"appName",
"string",
",",
"quantity",
"int",
")",
"error",
"{",
"quota",
",",
"err",
":=",
"s",
".",
"Storage",
".",
"Get",
"(",
"appName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"err",
"=",
"s",
".",
"checkLimit",
"(",
"quota",
",",
"quantity",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"s",
".",
"Storage",
".",
"Inc",
"(",
"appName",
",",
"quantity",
")",
"\n",
"}"
] |
// Inc implements Inc method from QuotaService interface
|
[
"Inc",
"implements",
"Inc",
"method",
"from",
"QuotaService",
"interface"
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/quota/quota.go#L16-L26
|
test
|
tsuru/tsuru
|
quota/quota.go
|
SetLimit
|
func (s *QuotaService) SetLimit(appName string, limit int) error {
q, err := s.Storage.Get(appName)
if err != nil {
return err
}
if limit < 0 {
limit = -1
} else if limit < q.InUse {
return quota.ErrLimitLowerThanAllocated
}
return s.Storage.SetLimit(appName, limit)
}
|
go
|
func (s *QuotaService) SetLimit(appName string, limit int) error {
q, err := s.Storage.Get(appName)
if err != nil {
return err
}
if limit < 0 {
limit = -1
} else if limit < q.InUse {
return quota.ErrLimitLowerThanAllocated
}
return s.Storage.SetLimit(appName, limit)
}
|
[
"func",
"(",
"s",
"*",
"QuotaService",
")",
"SetLimit",
"(",
"appName",
"string",
",",
"limit",
"int",
")",
"error",
"{",
"q",
",",
"err",
":=",
"s",
".",
"Storage",
".",
"Get",
"(",
"appName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"limit",
"<",
"0",
"{",
"limit",
"=",
"-",
"1",
"\n",
"}",
"else",
"if",
"limit",
"<",
"q",
".",
"InUse",
"{",
"return",
"quota",
".",
"ErrLimitLowerThanAllocated",
"\n",
"}",
"\n",
"return",
"s",
".",
"Storage",
".",
"SetLimit",
"(",
"appName",
",",
"limit",
")",
"\n",
"}"
] |
// SetLimit redefines the limit of the app. The new limit must be bigger
// than or equal to the current number of units in the app. The new limit may be
// smaller than 0, which means that the app should have an unlimited number of
// units.
// SetLimit implements SetLimit method from QuotaService interface
|
[
"SetLimit",
"redefines",
"the",
"limit",
"of",
"the",
"app",
".",
"The",
"new",
"limit",
"must",
"be",
"bigger",
"than",
"or",
"equal",
"to",
"the",
"current",
"number",
"of",
"units",
"in",
"the",
"app",
".",
"The",
"new",
"limit",
"may",
"be",
"smaller",
"than",
"0",
"which",
"means",
"that",
"the",
"app",
"should",
"have",
"an",
"unlimited",
"number",
"of",
"units",
".",
"SetLimit",
"implements",
"SetLimit",
"method",
"from",
"QuotaService",
"interface"
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/quota/quota.go#L46-L57
|
test
|
tsuru/tsuru
|
quota/quota.go
|
Set
|
func (s *QuotaService) Set(appName string, inUse int) error {
q, err := s.Storage.Get(appName)
if err != nil {
return err
}
if inUse < 0 {
return quota.ErrLessThanZero
}
if !q.IsUnlimited() && inUse > q.Limit {
return "a.QuotaExceededError{
Requested: uint(inUse),
Available: uint(q.Limit),
}
}
return s.Storage.Set(appName, inUse)
}
|
go
|
func (s *QuotaService) Set(appName string, inUse int) error {
q, err := s.Storage.Get(appName)
if err != nil {
return err
}
if inUse < 0 {
return quota.ErrLessThanZero
}
if !q.IsUnlimited() && inUse > q.Limit {
return "a.QuotaExceededError{
Requested: uint(inUse),
Available: uint(q.Limit),
}
}
return s.Storage.Set(appName, inUse)
}
|
[
"func",
"(",
"s",
"*",
"QuotaService",
")",
"Set",
"(",
"appName",
"string",
",",
"inUse",
"int",
")",
"error",
"{",
"q",
",",
"err",
":=",
"s",
".",
"Storage",
".",
"Get",
"(",
"appName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"inUse",
"<",
"0",
"{",
"return",
"quota",
".",
"ErrLessThanZero",
"\n",
"}",
"\n",
"if",
"!",
"q",
".",
"IsUnlimited",
"(",
")",
"&&",
"inUse",
">",
"q",
".",
"Limit",
"{",
"return",
"&",
"quota",
".",
"QuotaExceededError",
"{",
"Requested",
":",
"uint",
"(",
"inUse",
")",
",",
"Available",
":",
"uint",
"(",
"q",
".",
"Limit",
")",
",",
"}",
"\n",
"}",
"\n",
"return",
"s",
".",
"Storage",
".",
"Set",
"(",
"appName",
",",
"inUse",
")",
"\n",
"}"
] |
// Set redefines the inuse units of the app. This new value must be smaller
// than or equal to the current limit of the app. It also must be a non negative number.
// Set implements Set method from QuotaService interface
|
[
"Set",
"redefines",
"the",
"inuse",
"units",
"of",
"the",
"app",
".",
"This",
"new",
"value",
"must",
"be",
"smaller",
"than",
"or",
"equal",
"to",
"the",
"current",
"limit",
"of",
"the",
"app",
".",
"It",
"also",
"must",
"be",
"a",
"non",
"negative",
"number",
".",
"Set",
"implements",
"Set",
"method",
"from",
"QuotaService",
"interface"
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/quota/quota.go#L62-L77
|
test
|
tsuru/tsuru
|
quota/quota.go
|
Get
|
func (s *QuotaService) Get(appName string) (*quota.Quota, error) {
return s.Storage.Get(appName)
}
|
go
|
func (s *QuotaService) Get(appName string) (*quota.Quota, error) {
return s.Storage.Get(appName)
}
|
[
"func",
"(",
"s",
"*",
"QuotaService",
")",
"Get",
"(",
"appName",
"string",
")",
"(",
"*",
"quota",
".",
"Quota",
",",
"error",
")",
"{",
"return",
"s",
".",
"Storage",
".",
"Get",
"(",
"appName",
")",
"\n",
"}"
] |
// Get implements Get method from QuotaService interface
|
[
"Get",
"implements",
"Get",
"method",
"from",
"QuotaService",
"interface"
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/quota/quota.go#L80-L82
|
test
|
tsuru/tsuru
|
registry/registry.go
|
RemoveImage
|
func RemoveImage(imageName string) error {
registry, image, tag := parseImage(imageName)
if registry == "" {
registry, _ = config.GetString("docker:registry")
}
if registry == "" {
// Nothing to do if no registry is set
return nil
}
if image == "" {
return errors.Errorf("empty image after parsing %q", imageName)
}
r := &dockerRegistry{server: registry}
digest, err := r.getDigest(image, tag)
if err != nil {
return errors.Wrapf(err, "failed to get digest for image %s/%s:%s on registry", r.server, image, tag)
}
err = r.removeImage(image, digest)
if err != nil {
return errors.Wrapf(err, "failed to remove image %s/%s:%s/%s on registry", r.server, image, tag, digest)
}
return nil
}
|
go
|
func RemoveImage(imageName string) error {
registry, image, tag := parseImage(imageName)
if registry == "" {
registry, _ = config.GetString("docker:registry")
}
if registry == "" {
// Nothing to do if no registry is set
return nil
}
if image == "" {
return errors.Errorf("empty image after parsing %q", imageName)
}
r := &dockerRegistry{server: registry}
digest, err := r.getDigest(image, tag)
if err != nil {
return errors.Wrapf(err, "failed to get digest for image %s/%s:%s on registry", r.server, image, tag)
}
err = r.removeImage(image, digest)
if err != nil {
return errors.Wrapf(err, "failed to remove image %s/%s:%s/%s on registry", r.server, image, tag, digest)
}
return nil
}
|
[
"func",
"RemoveImage",
"(",
"imageName",
"string",
")",
"error",
"{",
"registry",
",",
"image",
",",
"tag",
":=",
"parseImage",
"(",
"imageName",
")",
"\n",
"if",
"registry",
"==",
"\"\"",
"{",
"registry",
",",
"_",
"=",
"config",
".",
"GetString",
"(",
"\"docker:registry\"",
")",
"\n",
"}",
"\n",
"if",
"registry",
"==",
"\"\"",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"image",
"==",
"\"\"",
"{",
"return",
"errors",
".",
"Errorf",
"(",
"\"empty image after parsing %q\"",
",",
"imageName",
")",
"\n",
"}",
"\n",
"r",
":=",
"&",
"dockerRegistry",
"{",
"server",
":",
"registry",
"}",
"\n",
"digest",
",",
"err",
":=",
"r",
".",
"getDigest",
"(",
"image",
",",
"tag",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Wrapf",
"(",
"err",
",",
"\"failed to get digest for image %s/%s:%s on registry\"",
",",
"r",
".",
"server",
",",
"image",
",",
"tag",
")",
"\n",
"}",
"\n",
"err",
"=",
"r",
".",
"removeImage",
"(",
"image",
",",
"digest",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Wrapf",
"(",
"err",
",",
"\"failed to remove image %s/%s:%s/%s on registry\"",
",",
"r",
".",
"server",
",",
"image",
",",
"tag",
",",
"digest",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// RemoveImage removes an image manifest from a remote registry v2 server, returning an error
// in case of failure.
|
[
"RemoveImage",
"removes",
"an",
"image",
"manifest",
"from",
"a",
"remote",
"registry",
"v2",
"server",
"returning",
"an",
"error",
"in",
"case",
"of",
"failure",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/registry/registry.go#L48-L70
|
test
|
tsuru/tsuru
|
registry/registry.go
|
RemoveAppImages
|
func RemoveAppImages(appName string) error {
registry, _ := config.GetString("docker:registry")
if registry == "" {
// Nothing to do if no registry is set
return nil
}
r := &dockerRegistry{server: registry}
image := fmt.Sprintf("tsuru/app-%s", appName)
tags, err := r.getImageTags(image)
if err != nil {
return err
}
multi := tsuruErrors.NewMultiError()
for _, tag := range tags {
digest, err := r.getDigest(image, tag)
if err != nil {
multi.Add(errors.Wrapf(err, "failed to get digest for image %s/%s:%s on registry", r.server, image, tag))
continue
}
err = r.removeImage(image, digest)
if err != nil {
multi.Add(errors.Wrapf(err, "failed to remove image %s/%s:%s/%s on registry", r.server, image, tag, digest))
if errors.Cause(err) == ErrDeleteDisabled {
break
}
}
}
return multi.ToError()
}
|
go
|
func RemoveAppImages(appName string) error {
registry, _ := config.GetString("docker:registry")
if registry == "" {
// Nothing to do if no registry is set
return nil
}
r := &dockerRegistry{server: registry}
image := fmt.Sprintf("tsuru/app-%s", appName)
tags, err := r.getImageTags(image)
if err != nil {
return err
}
multi := tsuruErrors.NewMultiError()
for _, tag := range tags {
digest, err := r.getDigest(image, tag)
if err != nil {
multi.Add(errors.Wrapf(err, "failed to get digest for image %s/%s:%s on registry", r.server, image, tag))
continue
}
err = r.removeImage(image, digest)
if err != nil {
multi.Add(errors.Wrapf(err, "failed to remove image %s/%s:%s/%s on registry", r.server, image, tag, digest))
if errors.Cause(err) == ErrDeleteDisabled {
break
}
}
}
return multi.ToError()
}
|
[
"func",
"RemoveAppImages",
"(",
"appName",
"string",
")",
"error",
"{",
"registry",
",",
"_",
":=",
"config",
".",
"GetString",
"(",
"\"docker:registry\"",
")",
"\n",
"if",
"registry",
"==",
"\"\"",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"r",
":=",
"&",
"dockerRegistry",
"{",
"server",
":",
"registry",
"}",
"\n",
"image",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"tsuru/app-%s\"",
",",
"appName",
")",
"\n",
"tags",
",",
"err",
":=",
"r",
".",
"getImageTags",
"(",
"image",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"multi",
":=",
"tsuruErrors",
".",
"NewMultiError",
"(",
")",
"\n",
"for",
"_",
",",
"tag",
":=",
"range",
"tags",
"{",
"digest",
",",
"err",
":=",
"r",
".",
"getDigest",
"(",
"image",
",",
"tag",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"multi",
".",
"Add",
"(",
"errors",
".",
"Wrapf",
"(",
"err",
",",
"\"failed to get digest for image %s/%s:%s on registry\"",
",",
"r",
".",
"server",
",",
"image",
",",
"tag",
")",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"err",
"=",
"r",
".",
"removeImage",
"(",
"image",
",",
"digest",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"multi",
".",
"Add",
"(",
"errors",
".",
"Wrapf",
"(",
"err",
",",
"\"failed to remove image %s/%s:%s/%s on registry\"",
",",
"r",
".",
"server",
",",
"image",
",",
"tag",
",",
"digest",
")",
")",
"\n",
"if",
"errors",
".",
"Cause",
"(",
"err",
")",
"==",
"ErrDeleteDisabled",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"multi",
".",
"ToError",
"(",
")",
"\n",
"}"
] |
// RemoveAppImages removes all app images from a remote registry v2 server, returning an error
// in case of failure.
|
[
"RemoveAppImages",
"removes",
"all",
"app",
"images",
"from",
"a",
"remote",
"registry",
"v2",
"server",
"returning",
"an",
"error",
"in",
"case",
"of",
"failure",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/registry/registry.go#L74-L102
|
test
|
tsuru/tsuru
|
app/platform.go
|
Create
|
func (s *platformService) Create(opts appTypes.PlatformOptions) error {
p := appTypes.Platform{Name: opts.Name}
if err := s.validate(p); err != nil {
return err
}
err := s.storage.Insert(p)
if err != nil {
return err
}
opts.ImageName, err = servicemanager.PlatformImage.NewImage(opts.Name)
if err != nil {
return err
}
err = builder.PlatformAdd(opts)
if err != nil {
if imgErr := servicemanager.PlatformImage.DeleteImages(opts.Name); imgErr != nil {
log.Errorf("unable to remove platform images: %s", imgErr)
}
dbErr := s.storage.Delete(p)
if dbErr != nil {
return tsuruErrors.NewMultiError(
errors.Wrapf(dbErr, "unable to rollback platform add"),
errors.Wrapf(err, "original platform add error"),
)
}
return err
}
return servicemanager.PlatformImage.AppendImage(opts.Name, opts.ImageName)
}
|
go
|
func (s *platformService) Create(opts appTypes.PlatformOptions) error {
p := appTypes.Platform{Name: opts.Name}
if err := s.validate(p); err != nil {
return err
}
err := s.storage.Insert(p)
if err != nil {
return err
}
opts.ImageName, err = servicemanager.PlatformImage.NewImage(opts.Name)
if err != nil {
return err
}
err = builder.PlatformAdd(opts)
if err != nil {
if imgErr := servicemanager.PlatformImage.DeleteImages(opts.Name); imgErr != nil {
log.Errorf("unable to remove platform images: %s", imgErr)
}
dbErr := s.storage.Delete(p)
if dbErr != nil {
return tsuruErrors.NewMultiError(
errors.Wrapf(dbErr, "unable to rollback platform add"),
errors.Wrapf(err, "original platform add error"),
)
}
return err
}
return servicemanager.PlatformImage.AppendImage(opts.Name, opts.ImageName)
}
|
[
"func",
"(",
"s",
"*",
"platformService",
")",
"Create",
"(",
"opts",
"appTypes",
".",
"PlatformOptions",
")",
"error",
"{",
"p",
":=",
"appTypes",
".",
"Platform",
"{",
"Name",
":",
"opts",
".",
"Name",
"}",
"\n",
"if",
"err",
":=",
"s",
".",
"validate",
"(",
"p",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"err",
":=",
"s",
".",
"storage",
".",
"Insert",
"(",
"p",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"opts",
".",
"ImageName",
",",
"err",
"=",
"servicemanager",
".",
"PlatformImage",
".",
"NewImage",
"(",
"opts",
".",
"Name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"err",
"=",
"builder",
".",
"PlatformAdd",
"(",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"imgErr",
":=",
"servicemanager",
".",
"PlatformImage",
".",
"DeleteImages",
"(",
"opts",
".",
"Name",
")",
";",
"imgErr",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"unable to remove platform images: %s\"",
",",
"imgErr",
")",
"\n",
"}",
"\n",
"dbErr",
":=",
"s",
".",
"storage",
".",
"Delete",
"(",
"p",
")",
"\n",
"if",
"dbErr",
"!=",
"nil",
"{",
"return",
"tsuruErrors",
".",
"NewMultiError",
"(",
"errors",
".",
"Wrapf",
"(",
"dbErr",
",",
"\"unable to rollback platform add\"",
")",
",",
"errors",
".",
"Wrapf",
"(",
"err",
",",
"\"original platform add error\"",
")",
",",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"return",
"servicemanager",
".",
"PlatformImage",
".",
"AppendImage",
"(",
"opts",
".",
"Name",
",",
"opts",
".",
"ImageName",
")",
"\n",
"}"
] |
// Create implements Create method of PlatformService interface
|
[
"Create",
"implements",
"Create",
"method",
"of",
"PlatformService",
"interface"
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/app/platform.go#L45-L73
|
test
|
tsuru/tsuru
|
app/platform.go
|
List
|
func (s *platformService) List(enabledOnly bool) ([]appTypes.Platform, error) {
if enabledOnly {
return s.storage.FindEnabled()
}
return s.storage.FindAll()
}
|
go
|
func (s *platformService) List(enabledOnly bool) ([]appTypes.Platform, error) {
if enabledOnly {
return s.storage.FindEnabled()
}
return s.storage.FindAll()
}
|
[
"func",
"(",
"s",
"*",
"platformService",
")",
"List",
"(",
"enabledOnly",
"bool",
")",
"(",
"[",
"]",
"appTypes",
".",
"Platform",
",",
"error",
")",
"{",
"if",
"enabledOnly",
"{",
"return",
"s",
".",
"storage",
".",
"FindEnabled",
"(",
")",
"\n",
"}",
"\n",
"return",
"s",
".",
"storage",
".",
"FindAll",
"(",
")",
"\n",
"}"
] |
// List implements List method of PlatformService interface
|
[
"List",
"implements",
"List",
"method",
"of",
"PlatformService",
"interface"
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/app/platform.go#L76-L81
|
test
|
tsuru/tsuru
|
app/platform.go
|
FindByName
|
func (s *platformService) FindByName(name string) (*appTypes.Platform, error) {
p, err := s.storage.FindByName(name)
if err != nil {
return nil, appTypes.ErrInvalidPlatform
}
return p, nil
}
|
go
|
func (s *platformService) FindByName(name string) (*appTypes.Platform, error) {
p, err := s.storage.FindByName(name)
if err != nil {
return nil, appTypes.ErrInvalidPlatform
}
return p, nil
}
|
[
"func",
"(",
"s",
"*",
"platformService",
")",
"FindByName",
"(",
"name",
"string",
")",
"(",
"*",
"appTypes",
".",
"Platform",
",",
"error",
")",
"{",
"p",
",",
"err",
":=",
"s",
".",
"storage",
".",
"FindByName",
"(",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"appTypes",
".",
"ErrInvalidPlatform",
"\n",
"}",
"\n",
"return",
"p",
",",
"nil",
"\n",
"}"
] |
// FindByName implements FindByName method of PlatformService interface
|
[
"FindByName",
"implements",
"FindByName",
"method",
"of",
"PlatformService",
"interface"
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/app/platform.go#L84-L90
|
test
|
tsuru/tsuru
|
app/platform.go
|
Update
|
func (s *platformService) Update(opts appTypes.PlatformOptions) error {
if opts.Name == "" {
return appTypes.ErrPlatformNameMissing
}
conn, err := db.Conn()
if err != nil {
return err
}
defer conn.Close()
_, err = s.FindByName(opts.Name)
if err != nil {
return err
}
if opts.Input != nil {
data, err := ioutil.ReadAll(opts.Input)
if err != nil {
return err
}
if len(data) == 0 {
return appTypes.ErrMissingFileContent
}
opts.Data = data
opts.ImageName, err = servicemanager.PlatformImage.NewImage(opts.Name)
if err != nil {
return err
}
err = builder.PlatformUpdate(opts)
if err != nil {
return err
}
err = servicemanager.PlatformImage.AppendImage(opts.Name, opts.ImageName)
if err != nil {
return err
}
var apps []App
err = conn.Apps().Find(bson.M{"framework": opts.Name}).All(&apps)
if err != nil {
return err
}
for _, app := range apps {
app.SetUpdatePlatform(true)
}
}
if opts.Args["disabled"] != "" {
disableBool, err := strconv.ParseBool(opts.Args["disabled"])
if err != nil {
return err
}
return s.storage.Update(appTypes.Platform{Name: opts.Name, Disabled: disableBool})
}
return nil
}
|
go
|
func (s *platformService) Update(opts appTypes.PlatformOptions) error {
if opts.Name == "" {
return appTypes.ErrPlatformNameMissing
}
conn, err := db.Conn()
if err != nil {
return err
}
defer conn.Close()
_, err = s.FindByName(opts.Name)
if err != nil {
return err
}
if opts.Input != nil {
data, err := ioutil.ReadAll(opts.Input)
if err != nil {
return err
}
if len(data) == 0 {
return appTypes.ErrMissingFileContent
}
opts.Data = data
opts.ImageName, err = servicemanager.PlatformImage.NewImage(opts.Name)
if err != nil {
return err
}
err = builder.PlatformUpdate(opts)
if err != nil {
return err
}
err = servicemanager.PlatformImage.AppendImage(opts.Name, opts.ImageName)
if err != nil {
return err
}
var apps []App
err = conn.Apps().Find(bson.M{"framework": opts.Name}).All(&apps)
if err != nil {
return err
}
for _, app := range apps {
app.SetUpdatePlatform(true)
}
}
if opts.Args["disabled"] != "" {
disableBool, err := strconv.ParseBool(opts.Args["disabled"])
if err != nil {
return err
}
return s.storage.Update(appTypes.Platform{Name: opts.Name, Disabled: disableBool})
}
return nil
}
|
[
"func",
"(",
"s",
"*",
"platformService",
")",
"Update",
"(",
"opts",
"appTypes",
".",
"PlatformOptions",
")",
"error",
"{",
"if",
"opts",
".",
"Name",
"==",
"\"\"",
"{",
"return",
"appTypes",
".",
"ErrPlatformNameMissing",
"\n",
"}",
"\n",
"conn",
",",
"err",
":=",
"db",
".",
"Conn",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"conn",
".",
"Close",
"(",
")",
"\n",
"_",
",",
"err",
"=",
"s",
".",
"FindByName",
"(",
"opts",
".",
"Name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"opts",
".",
"Input",
"!=",
"nil",
"{",
"data",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"opts",
".",
"Input",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"len",
"(",
"data",
")",
"==",
"0",
"{",
"return",
"appTypes",
".",
"ErrMissingFileContent",
"\n",
"}",
"\n",
"opts",
".",
"Data",
"=",
"data",
"\n",
"opts",
".",
"ImageName",
",",
"err",
"=",
"servicemanager",
".",
"PlatformImage",
".",
"NewImage",
"(",
"opts",
".",
"Name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"err",
"=",
"builder",
".",
"PlatformUpdate",
"(",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"err",
"=",
"servicemanager",
".",
"PlatformImage",
".",
"AppendImage",
"(",
"opts",
".",
"Name",
",",
"opts",
".",
"ImageName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"var",
"apps",
"[",
"]",
"App",
"\n",
"err",
"=",
"conn",
".",
"Apps",
"(",
")",
".",
"Find",
"(",
"bson",
".",
"M",
"{",
"\"framework\"",
":",
"opts",
".",
"Name",
"}",
")",
".",
"All",
"(",
"&",
"apps",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"for",
"_",
",",
"app",
":=",
"range",
"apps",
"{",
"app",
".",
"SetUpdatePlatform",
"(",
"true",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"opts",
".",
"Args",
"[",
"\"disabled\"",
"]",
"!=",
"\"\"",
"{",
"disableBool",
",",
"err",
":=",
"strconv",
".",
"ParseBool",
"(",
"opts",
".",
"Args",
"[",
"\"disabled\"",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"s",
".",
"storage",
".",
"Update",
"(",
"appTypes",
".",
"Platform",
"{",
"Name",
":",
"opts",
".",
"Name",
",",
"Disabled",
":",
"disableBool",
"}",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Update implements Update method of PlatformService interface
|
[
"Update",
"implements",
"Update",
"method",
"of",
"PlatformService",
"interface"
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/app/platform.go#L93-L144
|
test
|
tsuru/tsuru
|
app/platform.go
|
Remove
|
func (s *platformService) Remove(name string) error {
if name == "" {
return appTypes.ErrPlatformNameMissing
}
conn, err := db.Conn()
if err != nil {
return err
}
defer conn.Close()
apps, _ := conn.Apps().Find(bson.M{"framework": name}).Count()
if apps > 0 {
return appTypes.ErrDeletePlatformWithApps
}
err = builder.PlatformRemove(name)
if err != nil {
log.Errorf("Failed to remove platform from builder: %s", err)
}
images, err := servicemanager.PlatformImage.ListImagesOrDefault(name)
if err == nil {
for _, img := range images {
if regErr := registry.RemoveImage(img); regErr != nil {
log.Errorf("Failed to remove platform image from registry: %s", regErr)
}
}
} else {
log.Errorf("Failed to retrieve platform images from storage: %s", err)
}
err = servicemanager.PlatformImage.DeleteImages(name)
if err != nil {
log.Errorf("Failed to remove platform images from storage: %s", err)
}
return s.storage.Delete(appTypes.Platform{Name: name})
}
|
go
|
func (s *platformService) Remove(name string) error {
if name == "" {
return appTypes.ErrPlatformNameMissing
}
conn, err := db.Conn()
if err != nil {
return err
}
defer conn.Close()
apps, _ := conn.Apps().Find(bson.M{"framework": name}).Count()
if apps > 0 {
return appTypes.ErrDeletePlatformWithApps
}
err = builder.PlatformRemove(name)
if err != nil {
log.Errorf("Failed to remove platform from builder: %s", err)
}
images, err := servicemanager.PlatformImage.ListImagesOrDefault(name)
if err == nil {
for _, img := range images {
if regErr := registry.RemoveImage(img); regErr != nil {
log.Errorf("Failed to remove platform image from registry: %s", regErr)
}
}
} else {
log.Errorf("Failed to retrieve platform images from storage: %s", err)
}
err = servicemanager.PlatformImage.DeleteImages(name)
if err != nil {
log.Errorf("Failed to remove platform images from storage: %s", err)
}
return s.storage.Delete(appTypes.Platform{Name: name})
}
|
[
"func",
"(",
"s",
"*",
"platformService",
")",
"Remove",
"(",
"name",
"string",
")",
"error",
"{",
"if",
"name",
"==",
"\"\"",
"{",
"return",
"appTypes",
".",
"ErrPlatformNameMissing",
"\n",
"}",
"\n",
"conn",
",",
"err",
":=",
"db",
".",
"Conn",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"conn",
".",
"Close",
"(",
")",
"\n",
"apps",
",",
"_",
":=",
"conn",
".",
"Apps",
"(",
")",
".",
"Find",
"(",
"bson",
".",
"M",
"{",
"\"framework\"",
":",
"name",
"}",
")",
".",
"Count",
"(",
")",
"\n",
"if",
"apps",
">",
"0",
"{",
"return",
"appTypes",
".",
"ErrDeletePlatformWithApps",
"\n",
"}",
"\n",
"err",
"=",
"builder",
".",
"PlatformRemove",
"(",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"Failed to remove platform from builder: %s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"images",
",",
"err",
":=",
"servicemanager",
".",
"PlatformImage",
".",
"ListImagesOrDefault",
"(",
"name",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"for",
"_",
",",
"img",
":=",
"range",
"images",
"{",
"if",
"regErr",
":=",
"registry",
".",
"RemoveImage",
"(",
"img",
")",
";",
"regErr",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"Failed to remove platform image from registry: %s\"",
",",
"regErr",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"else",
"{",
"log",
".",
"Errorf",
"(",
"\"Failed to retrieve platform images from storage: %s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"servicemanager",
".",
"PlatformImage",
".",
"DeleteImages",
"(",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"Failed to remove platform images from storage: %s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"s",
".",
"storage",
".",
"Delete",
"(",
"appTypes",
".",
"Platform",
"{",
"Name",
":",
"name",
"}",
")",
"\n",
"}"
] |
// Remove implements Remove method of PlatformService interface
|
[
"Remove",
"implements",
"Remove",
"method",
"of",
"PlatformService",
"interface"
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/app/platform.go#L147-L179
|
test
|
tsuru/tsuru
|
app/platform.go
|
Rollback
|
func (s *platformService) Rollback(opts appTypes.PlatformOptions) error {
if opts.Name == "" {
return appTypes.ErrPlatformNameMissing
}
if opts.ImageName == "" {
return appTypes.ErrPlatformImageMissing
}
_, err := s.FindByName(opts.Name)
if err != nil {
return err
}
image, err := servicemanager.PlatformImage.FindImage(opts.Name, opts.ImageName)
if err != nil {
return err
}
if image == "" {
return fmt.Errorf("Image %s not found in platform %q", opts.ImageName, opts.Name)
}
opts.Data = []byte("FROM " + image)
opts.ImageName, err = servicemanager.PlatformImage.NewImage(opts.Name)
if err != nil {
return err
}
err = builder.PlatformUpdate(opts)
if err != nil {
return err
}
err = servicemanager.PlatformImage.AppendImage(opts.Name, opts.ImageName)
if err != nil {
return err
}
conn, err := db.Conn()
if err != nil {
return err
}
defer conn.Close()
var apps []App
err = conn.Apps().Find(bson.M{"framework": opts.Name}).All(&apps)
if err != nil {
return err
}
for _, app := range apps {
app.SetUpdatePlatform(true)
}
return nil
}
|
go
|
func (s *platformService) Rollback(opts appTypes.PlatformOptions) error {
if opts.Name == "" {
return appTypes.ErrPlatformNameMissing
}
if opts.ImageName == "" {
return appTypes.ErrPlatformImageMissing
}
_, err := s.FindByName(opts.Name)
if err != nil {
return err
}
image, err := servicemanager.PlatformImage.FindImage(opts.Name, opts.ImageName)
if err != nil {
return err
}
if image == "" {
return fmt.Errorf("Image %s not found in platform %q", opts.ImageName, opts.Name)
}
opts.Data = []byte("FROM " + image)
opts.ImageName, err = servicemanager.PlatformImage.NewImage(opts.Name)
if err != nil {
return err
}
err = builder.PlatformUpdate(opts)
if err != nil {
return err
}
err = servicemanager.PlatformImage.AppendImage(opts.Name, opts.ImageName)
if err != nil {
return err
}
conn, err := db.Conn()
if err != nil {
return err
}
defer conn.Close()
var apps []App
err = conn.Apps().Find(bson.M{"framework": opts.Name}).All(&apps)
if err != nil {
return err
}
for _, app := range apps {
app.SetUpdatePlatform(true)
}
return nil
}
|
[
"func",
"(",
"s",
"*",
"platformService",
")",
"Rollback",
"(",
"opts",
"appTypes",
".",
"PlatformOptions",
")",
"error",
"{",
"if",
"opts",
".",
"Name",
"==",
"\"\"",
"{",
"return",
"appTypes",
".",
"ErrPlatformNameMissing",
"\n",
"}",
"\n",
"if",
"opts",
".",
"ImageName",
"==",
"\"\"",
"{",
"return",
"appTypes",
".",
"ErrPlatformImageMissing",
"\n",
"}",
"\n",
"_",
",",
"err",
":=",
"s",
".",
"FindByName",
"(",
"opts",
".",
"Name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"image",
",",
"err",
":=",
"servicemanager",
".",
"PlatformImage",
".",
"FindImage",
"(",
"opts",
".",
"Name",
",",
"opts",
".",
"ImageName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"image",
"==",
"\"\"",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"Image %s not found in platform %q\"",
",",
"opts",
".",
"ImageName",
",",
"opts",
".",
"Name",
")",
"\n",
"}",
"\n",
"opts",
".",
"Data",
"=",
"[",
"]",
"byte",
"(",
"\"FROM \"",
"+",
"image",
")",
"\n",
"opts",
".",
"ImageName",
",",
"err",
"=",
"servicemanager",
".",
"PlatformImage",
".",
"NewImage",
"(",
"opts",
".",
"Name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"err",
"=",
"builder",
".",
"PlatformUpdate",
"(",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"err",
"=",
"servicemanager",
".",
"PlatformImage",
".",
"AppendImage",
"(",
"opts",
".",
"Name",
",",
"opts",
".",
"ImageName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"conn",
",",
"err",
":=",
"db",
".",
"Conn",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"conn",
".",
"Close",
"(",
")",
"\n",
"var",
"apps",
"[",
"]",
"App",
"\n",
"err",
"=",
"conn",
".",
"Apps",
"(",
")",
".",
"Find",
"(",
"bson",
".",
"M",
"{",
"\"framework\"",
":",
"opts",
".",
"Name",
"}",
")",
".",
"All",
"(",
"&",
"apps",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"for",
"_",
",",
"app",
":=",
"range",
"apps",
"{",
"app",
".",
"SetUpdatePlatform",
"(",
"true",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Rollback implements Rollback method of PlatformService interface
|
[
"Rollback",
"implements",
"Rollback",
"method",
"of",
"PlatformService",
"interface"
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/app/platform.go#L182-L227
|
test
|
tsuru/tsuru
|
provision/pool/pool.go
|
GetPoolByName
|
func GetPoolByName(name string) (*Pool, error) {
conn, err := db.Conn()
if err != nil {
return nil, err
}
defer conn.Close()
var p Pool
err = conn.Pools().FindId(name).One(&p)
if err != nil {
if err == mgo.ErrNotFound {
return nil, ErrPoolNotFound
}
return nil, err
}
return &p, nil
}
|
go
|
func GetPoolByName(name string) (*Pool, error) {
conn, err := db.Conn()
if err != nil {
return nil, err
}
defer conn.Close()
var p Pool
err = conn.Pools().FindId(name).One(&p)
if err != nil {
if err == mgo.ErrNotFound {
return nil, ErrPoolNotFound
}
return nil, err
}
return &p, nil
}
|
[
"func",
"GetPoolByName",
"(",
"name",
"string",
")",
"(",
"*",
"Pool",
",",
"error",
")",
"{",
"conn",
",",
"err",
":=",
"db",
".",
"Conn",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"conn",
".",
"Close",
"(",
")",
"\n",
"var",
"p",
"Pool",
"\n",
"err",
"=",
"conn",
".",
"Pools",
"(",
")",
".",
"FindId",
"(",
"name",
")",
".",
"One",
"(",
"&",
"p",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"mgo",
".",
"ErrNotFound",
"{",
"return",
"nil",
",",
"ErrPoolNotFound",
"\n",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"p",
",",
"nil",
"\n",
"}"
] |
// GetPoolByName finds a pool by name
|
[
"GetPoolByName",
"finds",
"a",
"pool",
"by",
"name"
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/provision/pool/pool.go#L466-L481
|
test
|
tsuru/tsuru
|
repository/repository.go
|
Manager
|
func Manager() RepositoryManager {
managerName, err := config.GetString("repo-manager")
if err != nil {
managerName = defaultManager
}
if _, ok := managers[managerName]; !ok {
managerName = "nop"
}
return managers[managerName]
}
|
go
|
func Manager() RepositoryManager {
managerName, err := config.GetString("repo-manager")
if err != nil {
managerName = defaultManager
}
if _, ok := managers[managerName]; !ok {
managerName = "nop"
}
return managers[managerName]
}
|
[
"func",
"Manager",
"(",
")",
"RepositoryManager",
"{",
"managerName",
",",
"err",
":=",
"config",
".",
"GetString",
"(",
"\"repo-manager\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"managerName",
"=",
"defaultManager",
"\n",
"}",
"\n",
"if",
"_",
",",
"ok",
":=",
"managers",
"[",
"managerName",
"]",
";",
"!",
"ok",
"{",
"managerName",
"=",
"\"nop\"",
"\n",
"}",
"\n",
"return",
"managers",
"[",
"managerName",
"]",
"\n",
"}"
] |
// Manager returns the current configured manager, as defined in the
// configuration file.
|
[
"Manager",
"returns",
"the",
"current",
"configured",
"manager",
"as",
"defined",
"in",
"the",
"configuration",
"file",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/repository/repository.go#L68-L77
|
test
|
tsuru/tsuru
|
repository/repository.go
|
Register
|
func Register(name string, manager RepositoryManager) {
if managers == nil {
managers = make(map[string]RepositoryManager)
}
managers[name] = manager
}
|
go
|
func Register(name string, manager RepositoryManager) {
if managers == nil {
managers = make(map[string]RepositoryManager)
}
managers[name] = manager
}
|
[
"func",
"Register",
"(",
"name",
"string",
",",
"manager",
"RepositoryManager",
")",
"{",
"if",
"managers",
"==",
"nil",
"{",
"managers",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"RepositoryManager",
")",
"\n",
"}",
"\n",
"managers",
"[",
"name",
"]",
"=",
"manager",
"\n",
"}"
] |
// Register registers a new repository manager, that can be later configured
// and used.
|
[
"Register",
"registers",
"a",
"new",
"repository",
"manager",
"that",
"can",
"be",
"later",
"configured",
"and",
"used",
"."
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/repository/repository.go#L81-L86
|
test
|
tsuru/tsuru
|
service/sync.go
|
start
|
func (b *bindSyncer) start() error {
if b.started {
return errors.New("syncer already started")
}
if b.appLister == nil {
return errors.New("must set app lister function")
}
if b.interval == 0 {
b.interval = 5 * time.Minute
}
b.shutdown = make(chan struct{}, 1)
b.done = make(chan struct{})
b.started = true
log.Debugf("[bind-syncer] starting. Running every %s.\n", b.interval)
go func(d time.Duration) {
for {
select {
case <-time.After(d):
start := time.Now()
log.Debug("[bind-syncer] starting run")
apps, err := b.appLister()
if err != nil {
log.Errorf("[bind-syncer] error listing apps: %v. Aborting sync.", err)
syncDuration.Set(time.Since(start).Seconds())
break
}
for _, a := range apps {
err = b.sync(a)
if err != nil {
log.Errorf("[bind-syncer] error syncing app %q: %v", a.GetName(), err)
}
if len(b.shutdown) > 0 {
break
}
}
log.Debugf("[bind-syncer] finished running. Synced %d apps.", len(apps))
d = b.interval
syncDuration.Set(time.Since(start).Seconds())
case <-b.shutdown:
b.done <- struct{}{}
return
}
}
}(time.Millisecond * 100)
return nil
}
|
go
|
func (b *bindSyncer) start() error {
if b.started {
return errors.New("syncer already started")
}
if b.appLister == nil {
return errors.New("must set app lister function")
}
if b.interval == 0 {
b.interval = 5 * time.Minute
}
b.shutdown = make(chan struct{}, 1)
b.done = make(chan struct{})
b.started = true
log.Debugf("[bind-syncer] starting. Running every %s.\n", b.interval)
go func(d time.Duration) {
for {
select {
case <-time.After(d):
start := time.Now()
log.Debug("[bind-syncer] starting run")
apps, err := b.appLister()
if err != nil {
log.Errorf("[bind-syncer] error listing apps: %v. Aborting sync.", err)
syncDuration.Set(time.Since(start).Seconds())
break
}
for _, a := range apps {
err = b.sync(a)
if err != nil {
log.Errorf("[bind-syncer] error syncing app %q: %v", a.GetName(), err)
}
if len(b.shutdown) > 0 {
break
}
}
log.Debugf("[bind-syncer] finished running. Synced %d apps.", len(apps))
d = b.interval
syncDuration.Set(time.Since(start).Seconds())
case <-b.shutdown:
b.done <- struct{}{}
return
}
}
}(time.Millisecond * 100)
return nil
}
|
[
"func",
"(",
"b",
"*",
"bindSyncer",
")",
"start",
"(",
")",
"error",
"{",
"if",
"b",
".",
"started",
"{",
"return",
"errors",
".",
"New",
"(",
"\"syncer already started\"",
")",
"\n",
"}",
"\n",
"if",
"b",
".",
"appLister",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"must set app lister function\"",
")",
"\n",
"}",
"\n",
"if",
"b",
".",
"interval",
"==",
"0",
"{",
"b",
".",
"interval",
"=",
"5",
"*",
"time",
".",
"Minute",
"\n",
"}",
"\n",
"b",
".",
"shutdown",
"=",
"make",
"(",
"chan",
"struct",
"{",
"}",
",",
"1",
")",
"\n",
"b",
".",
"done",
"=",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
"\n",
"b",
".",
"started",
"=",
"true",
"\n",
"log",
".",
"Debugf",
"(",
"\"[bind-syncer] starting. Running every %s.\\n\"",
",",
"\\n",
")",
"\n",
"b",
".",
"interval",
"\n",
"go",
"func",
"(",
"d",
"time",
".",
"Duration",
")",
"{",
"for",
"{",
"select",
"{",
"case",
"<-",
"time",
".",
"After",
"(",
"d",
")",
":",
"start",
":=",
"time",
".",
"Now",
"(",
")",
"\n",
"log",
".",
"Debug",
"(",
"\"[bind-syncer] starting run\"",
")",
"\n",
"apps",
",",
"err",
":=",
"b",
".",
"appLister",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"[bind-syncer] error listing apps: %v. Aborting sync.\"",
",",
"err",
")",
"\n",
"syncDuration",
".",
"Set",
"(",
"time",
".",
"Since",
"(",
"start",
")",
".",
"Seconds",
"(",
")",
")",
"\n",
"break",
"\n",
"}",
"\n",
"for",
"_",
",",
"a",
":=",
"range",
"apps",
"{",
"err",
"=",
"b",
".",
"sync",
"(",
"a",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"[bind-syncer] error syncing app %q: %v\"",
",",
"a",
".",
"GetName",
"(",
")",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"b",
".",
"shutdown",
")",
">",
"0",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"log",
".",
"Debugf",
"(",
"\"[bind-syncer] finished running. Synced %d apps.\"",
",",
"len",
"(",
"apps",
")",
")",
"\n",
"d",
"=",
"b",
".",
"interval",
"\n",
"syncDuration",
".",
"Set",
"(",
"time",
".",
"Since",
"(",
"start",
")",
".",
"Seconds",
"(",
")",
")",
"\n",
"case",
"<-",
"b",
".",
"shutdown",
":",
"b",
".",
"done",
"<-",
"struct",
"{",
"}",
"{",
"}",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
"time",
".",
"Millisecond",
"*",
"100",
")",
"\n",
"}"
] |
// start starts the sync process on a different goroutine
|
[
"start",
"starts",
"the",
"sync",
"process",
"on",
"a",
"different",
"goroutine"
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/service/sync.go#L71-L116
|
test
|
tsuru/tsuru
|
service/sync.go
|
Shutdown
|
func (b *bindSyncer) Shutdown(ctx context.Context) error {
if !b.started {
return nil
}
b.shutdown <- struct{}{}
select {
case <-b.done:
case <-ctx.Done():
}
b.started = false
return ctx.Err()
}
|
go
|
func (b *bindSyncer) Shutdown(ctx context.Context) error {
if !b.started {
return nil
}
b.shutdown <- struct{}{}
select {
case <-b.done:
case <-ctx.Done():
}
b.started = false
return ctx.Err()
}
|
[
"func",
"(",
"b",
"*",
"bindSyncer",
")",
"Shutdown",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"if",
"!",
"b",
".",
"started",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"b",
".",
"shutdown",
"<-",
"struct",
"{",
"}",
"{",
"}",
"\n",
"select",
"{",
"case",
"<-",
"b",
".",
"done",
":",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"}",
"\n",
"b",
".",
"started",
"=",
"false",
"\n",
"return",
"ctx",
".",
"Err",
"(",
")",
"\n",
"}"
] |
// Shutdown shutdowns bindSyncer waiting for the current sync
// to complete
|
[
"Shutdown",
"shutdowns",
"bindSyncer",
"waiting",
"for",
"the",
"current",
"sync",
"to",
"complete"
] |
2f7fd515c5dc25a58aec80f0e497c49e49581b3e
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/service/sync.go#L120-L131
|
test
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.