_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q178600 | VerifyMimeType | test | func VerifyMimeType(mimeType string) http.HandlerFunc {
return func(w http.ResponseWriter, req *http.Request) {
Expect(strings.Split(req.Header.Get("Content-Type"), ";")[0]).Should(Equal(mimeType))
}
} | go | {
"resource": ""
} |
q178601 | VerifyBasicAuth | test | func VerifyBasicAuth(username string, password string) http.HandlerFunc {
return func(w http.ResponseWriter, req *http.Request) {
auth := req.Header.Get("Authorization")
Expect(auth).ShouldNot(Equal(""), "Authorization header must be specified")
decoded, err := base64.StdEncoding.DecodeString(auth[6:])
Expect... | go | {
"resource": ""
} |
q178602 | VerifyJSONRepresenting | test | func VerifyJSONRepresenting(object interface{}) http.HandlerFunc {
data, err := json.Marshal(object)
Expect(err).ShouldNot(HaveOccurred())
return CombineHandlers(
VerifyContentType("application/json"),
VerifyJSON(string(data)),
)
} | go | {
"resource": ""
} |
q178603 | VerifyFormKV | test | func VerifyFormKV(key string, values ...string) http.HandlerFunc {
return VerifyForm(url.Values{key: values})
} | go | {
"resource": ""
} |
q178604 | RespondWithProto | test | func RespondWithProto(statusCode int, message proto.Message, optionalHeader ...http.Header) http.HandlerFunc {
return func(w http.ResponseWriter, req *http.Request) {
data, err := proto.Marshal(message)
Expect(err).ShouldNot(HaveOccurred())
var headers http.Header
if len(optionalHeader) == 1 {
headers = op... | go | {
"resource": ""
} |
q178605 | RegisterFailHandlerWithT | test | func RegisterFailHandlerWithT(t types.TWithHelper, handler types.GomegaFailHandler) {
if handler == nil {
globalFailWrapper = nil
return
}
globalFailWrapper = &types.GomegaFailWrapper{
Fail: handler,
TWithHelper: t,
}
} | go | {
"resource": ""
} |
q178606 | EventuallyWithOffset | test | func EventuallyWithOffset(offset int, actual interface{}, intervals ...interface{}) AsyncAssertion {
if globalFailWrapper == nil {
panic(nilFailHandlerPanic)
}
timeoutInterval := defaultEventuallyTimeout
pollingInterval := defaultEventuallyPollingInterval
if len(intervals) > 0 {
timeoutInterval = toDuration(in... | go | {
"resource": ""
} |
q178607 | ConsistentlyWithOffset | test | func ConsistentlyWithOffset(offset int, actual interface{}, intervals ...interface{}) AsyncAssertion {
if globalFailWrapper == nil {
panic(nilFailHandlerPanic)
}
timeoutInterval := defaultConsistentlyDuration
pollingInterval := defaultConsistentlyPollingInterval
if len(intervals) > 0 {
timeoutInterval = toDura... | go | {
"resource": ""
} |
q178608 | Expect | test | func (g *WithT) Expect(actual interface{}, extra ...interface{}) Assertion {
return assertion.New(actual, testingtsupport.BuildTestingTGomegaFailWrapper(g.t), 0, extra...)
} | go | {
"resource": ""
} |
q178609 | Eventually | test | func (g *WithT) Eventually(actual interface{}, intervals ...interface{}) AsyncAssertion {
timeoutInterval := defaultEventuallyTimeout
pollingInterval := defaultEventuallyPollingInterval
if len(intervals) > 0 {
timeoutInterval = toDuration(intervals[0])
}
if len(intervals) > 1 {
pollingInterval = toDuration(int... | go | {
"resource": ""
} |
q178610 | Consistently | test | func (g *WithT) Consistently(actual interface{}, intervals ...interface{}) AsyncAssertion {
timeoutInterval := defaultConsistentlyDuration
pollingInterval := defaultConsistentlyPollingInterval
if len(intervals) > 0 {
timeoutInterval = toDuration(intervals[0])
}
if len(intervals) > 1 {
pollingInterval = toDurat... | go | {
"resource": ""
} |
q178611 | TimeoutCloser | test | func TimeoutCloser(c io.Closer, timeout time.Duration) io.Closer {
return timeoutReaderWriterCloser{c: c, d: timeout}
} | go | {
"resource": ""
} |
q178612 | TimeoutReader | test | func TimeoutReader(r io.Reader, timeout time.Duration) io.Reader {
return timeoutReaderWriterCloser{r: r, d: timeout}
} | go | {
"resource": ""
} |
q178613 | TimeoutWriter | test | func TimeoutWriter(w io.Writer, timeout time.Duration) io.Writer {
return timeoutReaderWriterCloser{w: w, d: timeout}
} | go | {
"resource": ""
} |
q178614 | Nest | test | 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 &NestedE... | go | {
"resource": ""
} |
q178615 | SetMockService | test | 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{}
... | go | {
"resource": ""
} |
q178616 | FindMachineByIdOrAddress | test | 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)
... | go | {
"resource": ""
} |
q178617 | Write | test | 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 ... | go | {
"resource": ""
} |
q178618 | Hijack | test | 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 | {
"resource": ""
} |
q178619 | ListDeploys | test | 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.Tar... | go | {
"resource": ""
} |
q178620 | AddAll | test | func (r *DelayedRouter) AddAll(version, path string, h http.Handler) *mux.Route {
return r.addRoute(version, path, h, "GET", "POST", "PUT", "DELETE")
} | go | {
"resource": ""
} |
q178621 | samlRequestTimeout | test | func samlRequestTimeout(schemeData map[string]string) int {
p := schemeData["request_timeout"]
timeout, _ := strconv.Atoi(p)
return timeout
} | go | {
"resource": ""
} |
q178622 | RegisterHandler | test | func RegisterHandler(path string, method string, h http.Handler) {
RegisterHandlerVersion("1.0", path, method, h)
} | go | {
"resource": ""
} |
q178623 | RegisterHandlerVersion | test | 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 | {
"resource": ""
} |
q178624 | Check | test | 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 &&... | go | {
"resource": ""
} |
q178625 | DiscoverRepositoryPath | test | 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, "..", "..",... | go | {
"resource": ""
} |
q178626 | OpenRepository | test | 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, E... | go | {
"resource": ""
} |
q178627 | RemoteURL | test | 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 scan... | go | {
"resource": ""
} |
q178628 | List | test | 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 | {
"resource": ""
} |
q178629 | Apps | test | func (s *appLister) Apps(namespace string) AppNamespaceLister {
return appNamespaceLister{indexer: s.indexer, namespace: namespace}
} | go | {
"resource": ""
} |
q178630 | List | test | 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 | {
"resource": ""
} |
q178631 | StreamJSONResponse | test | 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 er... | go | {
"resource": ""
} |
q178632 | DropDatabase | test | func (s *Storage) DropDatabase(name string) error {
return s.session.DB(name).DropDatabase()
} | go | {
"resource": ""
} |
q178633 | Collection | test | func (s *Storage) Collection(name string) *Collection {
return &Collection{Collection: s.session.DB(s.dbname).C(name)}
} | go | {
"resource": ""
} |
q178634 | SetLogger | test | func (t *Target) SetLogger(l Logger) {
t.mut.Lock()
defer t.mut.Unlock()
t.logger = l
} | go | {
"resource": ""
} |
q178635 | Error | test | func (t *Target) Error(v error) {
t.mut.RLock()
defer t.mut.RUnlock()
if t.logger != nil {
t.logger.Errorf("%+v", v)
}
} | go | {
"resource": ""
} |
q178636 | Errorf | test | 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 | {
"resource": ""
} |
q178637 | Fatal | test | func (t *Target) Fatal(v string) {
t.mut.RLock()
defer t.mut.RUnlock()
if t.logger != nil {
t.logger.Fatal(v)
}
} | go | {
"resource": ""
} |
q178638 | Debugf | test | 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 | {
"resource": ""
} |
q178639 | GetStdLogger | test | func (t *Target) GetStdLogger() *log.Logger {
t.mut.RLock()
defer t.mut.RUnlock()
if t.logger != nil {
return t.logger.GetStdLogger()
}
return nil
} | go | {
"resource": ""
} |
q178640 | Namespace | test | func (c *ClusterClient) Namespace() string {
if c.CustomData != nil && c.CustomData[namespaceClusterKey] != "" {
return c.CustomData[namespaceClusterKey]
}
return "tsuru"
} | go | {
"resource": ""
} |
q178641 | recreateContainers | test | func recreateContainers(p DockerProvisioner, w io.Writer, nodes ...cluster.Node) error {
return ensureContainersStarted(p, w, true, nil, nodes...)
} | go | {
"resource": ""
} |
q178642 | checkProvisioner | test | func checkProvisioner() error {
if value, _ := config.Get("provisioner"); value == defaultProvisionerName || value == "" {
return checkDocker()
}
return nil
} | go | {
"resource": ""
} |
q178643 | checkDocker | test | 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
... | go | {
"resource": ""
} |
q178644 | checkScheduler | test | 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 er... | go | {
"resource": ""
} |
q178645 | checkRouter | test | 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 !=... | go | {
"resource": ""
} |
q178646 | Available | test | func (u *Unit) Available() bool {
return u.Status == StatusStarted ||
u.Status == StatusStarting ||
u.Status == StatusError
} | go | {
"resource": ""
} |
q178647 | Get | test | func Get(name string) (Provisioner, error) {
pFunc, ok := provisioners[name]
if !ok {
return nil, errors.Errorf("unknown provisioner: %q", name)
}
return pFunc()
} | go | {
"resource": ""
} |
q178648 | Registry | test | 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 | {
"resource": ""
} |
q178649 | Error | test | 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 | {
"resource": ""
} |
q178650 | validateVersion | test | 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 | {
"resource": ""
} |
q178651 | ReadTarget | test | 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(targetPat... | go | {
"resource": ""
} |
q178652 | WriteTarget | test | 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 != ni... | go | {
"resource": ""
} |
q178653 | WriteOnTargetList | test | 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 := JoinWithUserDi... | go | {
"resource": ""
} |
q178654 | Conn | test | func Conn() (*Storage, error) {
var (
strg Storage
err error
)
url, dbname := DbConfig("")
strg.Storage, err = storage.Open(url, dbname)
return &strg, err
} | go | {
"resource": ""
} |
q178655 | Apps | test | func (s *Storage) Apps() *storage.Collection {
nameIndex := mgo.Index{Key: []string{"name"}, Unique: true}
c := s.Collection("apps")
c.EnsureIndex(nameIndex)
return c
} | go | {
"resource": ""
} |
q178656 | PoolsConstraints | test | 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 | {
"resource": ""
} |
q178657 | Users | test | func (s *Storage) Users() *storage.Collection {
emailIndex := mgo.Index{Key: []string{"email"}, Unique: true}
c := s.Collection("users")
c.EnsureIndex(emailIndex)
return c
} | go | {
"resource": ""
} |
q178658 | SAMLRequests | test | func (s *Storage) SAMLRequests() *storage.Collection {
id := mgo.Index{Key: []string{"id"}}
coll := s.Collection("saml_requests")
coll.EnsureIndex(id)
return coll
} | go | {
"resource": ""
} |
q178659 | AppLogCollection | test | func (s *LogStorage) AppLogCollection(appName string) *storage.Collection {
if appName == "" {
return nil
}
return s.Collection("logs_" + appName)
} | go | {
"resource": ""
} |
q178660 | CreateAppLogCollection | test | func (s *LogStorage) CreateAppLogCollection(appName string) (*storage.Collection, error) {
c := s.AppLogCollection(appName)
err := c.Create(&logCappedInfo)
return c, err
} | go | {
"resource": ""
} |
q178661 | LogsCollections | test | 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 := ra... | go | {
"resource": ""
} |
q178662 | ArchiveBuildCmds | test | func ArchiveBuildCmds(app provision.App, archiveURL string) []string {
return buildCmds(app, "build", "archive", archiveURL)
} | go | {
"resource": ""
} |
q178663 | ArchiveDeployCmds | test | func ArchiveDeployCmds(app provision.App, archiveURL string) []string {
return buildCmds(app, "deploy", "archive", archiveURL)
} | go | {
"resource": ""
} |
q178664 | DeployCmds | test | 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 | {
"resource": ""
} |
q178665 | runWithAgentCmds | test | 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(), ru... | go | {
"resource": ""
} |
q178666 | newApps | test | func newApps(c *TsuruV1Client, namespace string) *apps {
return &apps{
client: c.RESTClient(),
ns: namespace,
}
} | go | {
"resource": ""
} |
q178667 | Commit | test | 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: ... | go | {
"resource": ""
} |
q178668 | processTags | test | 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
}
}
retu... | go | {
"resource": ""
} |
q178669 | aggregateContainersBy | test | 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)
... | go | {
"resource": ""
} |
q178670 | chooseNodeToAdd | test | 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)
... | go | {
"resource": ""
} |
q178671 | chooseContainerToRemove | test | 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.... | go | {
"resource": ""
} |
q178672 | Get | test | 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, ... | go | {
"resource": ""
} |
q178673 | Default | test | 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 | {
"resource": ""
} |
q178674 | Store | test | 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 | {
"resource": ""
} |
q178675 | TsuruV1 | test | func (c *Clientset) TsuruV1() tsuruv1.TsuruV1Interface {
return &faketsuruv1.FakeTsuruV1{Fake: &c.Fake}
} | go | {
"resource": ""
} |
q178676 | Tsuru | test | func (c *Clientset) Tsuru() tsuruv1.TsuruV1Interface {
return &faketsuruv1.FakeTsuruV1{Fake: &c.Fake}
} | go | {
"resource": ""
} |
q178677 | NewAppInformer | test | func NewAppInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
return NewFilteredAppInformer(client, namespace, resyncPeriod, indexers, nil)
} | go | {
"resource": ""
} |
q178678 | NewFilteredAppInformer | test | 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) (r... | go | {
"resource": ""
} |
q178679 | Watch | test | func (c *FakeApps) Watch(opts v1.ListOptions) (watch.Interface, error) {
return c.Fake.
InvokesWatch(testing.NewWatchAction(appsResource, c.ns, opts))
} | go | {
"resource": ""
} |
q178680 | Patch | test | 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.(*tsur... | go | {
"resource": ""
} |
q178681 | NewSharedInformerFactory | test | func NewSharedInformerFactory(client versioned.Interface, defaultResync time.Duration) SharedInformerFactory {
return NewFilteredSharedInformerFactory(client, defaultResync, v1.NamespaceAll, nil)
} | go | {
"resource": ""
} |
q178682 | NewFilteredSharedInformerFactory | test | func NewFilteredSharedInformerFactory(client versioned.Interface, defaultResync time.Duration, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) SharedInformerFactory {
return &sharedInformerFactory{
client: client,
namespace: namespace,
tweakListOptions: tweakListOptio... | go | {
"resource": ""
} |
q178683 | Proxy | test | 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 | {
"resource": ""
} |
q178684 | UnbindUnit | test | func (b *brokerClient) UnbindUnit(instance *ServiceInstance, app bind.App, unit bind.Unit) error {
return nil
} | go | {
"resource": ""
} |
q178685 | Create | test | 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 | {
"resource": ""
} |
q178686 | Remove | test | func (s *planService) Remove(planName string) error {
return s.storage.Delete(appTypes.Plan{Name: planName})
} | go | {
"resource": ""
} |
q178687 | ensureDefault | test | 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(co... | go | {
"resource": ""
} |
q178688 | DeleteInstance | test | 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, er... | go | {
"resource": ""
} |
q178689 | ToInfo | test | 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,
I... | go | {
"resource": ""
} |
q178690 | Update | test | 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.Ta... | go | {
"resource": ""
} |
q178691 | BindApp | test | 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,
... | go | {
"resource": ""
} |
q178692 | BindUnit | test | 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{
"... | go | {
"resource": ""
} |
q178693 | UnbindApp | test | 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: ... | go | {
"resource": ""
} |
q178694 | Status | test | 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 | {
"resource": ""
} |
q178695 | ProxyInstance | test | 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.Spr... | go | {
"resource": ""
} |
q178696 | Inc | test | 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 | {
"resource": ""
} |
q178697 | SetLimit | test | 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 | {
"resource": ""
} |
q178698 | Set | test | 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),
}
}
... | go | {
"resource": ""
} |
q178699 | Get | test | func (s *QuotaService) Get(appName string) (*quota.Quota, error) {
return s.Storage.Get(appName)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.