id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c178700 | 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
} | |
c178701 | 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()
} | |
c178702 |
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)
} | |
c178703 | s.storage.FindEnabled()
}
return s.storage.FindAll()
} | |
c178704 | nil {
return nil, appTypes.ErrInvalidPlatform
}
return p, nil
} | |
c178705 | 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
} | |
c178706 | 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})
} | |
c178707 | = 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
} | |
c178708 | == mgo.ErrNotFound {
return nil, ErrPoolNotFound
}
return nil, err
}
return &p, nil
} | |
c178709 | nil {
managerName = defaultManager
}
if _, ok := managers[managerName]; !ok {
managerName = "nop"
}
return managers[managerName]
} | |
c178710 | == nil {
managers = make(map[string]RepositoryManager)
}
managers[name] = manager
} | |
c178711 | 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
} | |
c178712 | {
case <-b.done:
case <-ctx.Done():
}
b.started = false
return ctx.Err()
} | |
c178713 | ok {
return get("docker")
} else if _, ok := p.(provision.BuilderDeployKubeClient); ok {
return get("kubernetes")
}
}
return builder, err
} | |
c178714 |
if !ok {
return nil, errors.Errorf("unknown builder: %q", name)
}
return b, nil
} | |
c178715 | registry = append(registry, b)
}
return registry, nil
} | |
c178716 | err
}
return q.RegisterTask(&runBs{provisioner: p})
} | |
c178717 | v.namespace, tweakListOptions: v.tweakListOptions}
} | |
c178718 | := new(App)
in.DeepCopyInto(out)
return out
} | |
c178719 | := new(AppList)
in.DeepCopyInto(out)
return out
} | |
c178720 | := new(AppSpec)
in.DeepCopyInto(out)
return out
} | |
c178721 | copied := make([]byte, len(data))
copy(copied, data)
w.msgCh <- copied
return len(data), nil
} | |
c178722 |
return auth.ErrInvalidToken
}
password := generatePassword(12)
user.Password = password
hashPassword(user)
go sendNewPassword(user, password)
passToken.Used = true
conn.PasswordTokens().UpdateId(passToken.Token, passToken)
return user.Update()
} | |
c178723 | &metav1.Status{},
)
metav1.AddToGroupVersion(scheme, SchemeGroupVersion)
return nil
} | |
c178724 | registered = append(registered, s)
} | |
c178725 | if err != nil {
fmt.Fprintf(w, "[shutdown] running shutdown for %s. ERROED: %v", name, err)
return
}
fmt.Fprintf(w, "[shutdown] running shutdown for %s. DONE.\n", name)
}(h)
}
go func() {
wg.Wait()
close(done)
}()
select {
case <-ctx.Done():
return ctx.Err()
case <-done:
}
return nil
} | |
c178726 | {
return []string{platformBasicImageName(platformName)}, nil
}
return imgs, err
} | |
c178727 | err != nil {
return errors.Wrap(err, "failed to list apps")
}
multiErr := tsuruerrors.NewMultiError()
for _, a := range apps {
errProv := prov.Provision(&a)
if errProv != nil {
multiErr.Add(errProv)
}
}
return multiErr.ToError()
} | |
c178728 | register(name, false, fn)
} | |
c178729 | return register(name, true, fn)
} | |
c178730 | ErrCannotForceMandatory
}
return run(args)
} | |
c178731 | // return an error. This ensures we always return an empty list instead
// of nil to preserve compatibility with old clients.
units = []provision.Unit{}
}
return units, err
} | |
c178732 | result["router"] = routers[0].Name
result["routeropts"] = routers[0].Opts
}
result["cname"] = app.CName
result["owner"] = app.Owner
result["pool"] = app.Pool
result["description"] = app.Description
result["deploys"] = app.Deploys
result["teamowner"] = app.TeamOwner
result["plan"] = plan
result["lock"] = app.Lock
result["tags"] = app.Tags
result["routers"] = routers
if len(errMsgs) > 0 {
result["error"] = strings.Join(errMsgs, "\n")
}
return json.Marshal(&result)
} | |
c178733 | bson.M{"lock": appLock}})
conn.Close()
if err == nil {
return true, nil
}
if err != mgo.ErrNotFound {
return false, err
}
select {
case <-timeoutChan:
return false, nil
case <-time.After(300 * time.Millisecond):
}
}
} | |
c178734 | {
err = releaseApplicationLockOnce(appName)
if err == nil {
return
}
time.Sleep(time.Second * time.Duration(i+1))
}
log.Error(err)
} | |
c178735 | name}).One(&app)
if err == mgo.ErrNotFound {
return nil, appTypes.ErrAppNotFound
}
return &app, err
} | |
c178736 | &reserveUnitsToAdd,
&provisionAddUnits,
).Execute(app, n, w, process)
rebuild.RoutesRebuildOrEnqueue(app.Name)
quotaErr := app.fixQuota()
if err != nil {
return err
}
return quotaErr
} | |
c178737 |
prov, err := app.getProvisioner()
if err != nil {
return err
}
unitProv, ok := prov.(provision.UnitStatusProvisioner)
if !ok {
return nil
}
return unitProv.SetUnitStatus(unit, status)
}
}
return &provision.UnitNotFoundError{ID: unitName}
} | |
c178738 | not found with nodedata: %#v", nodeData)
result := make([]UpdateUnitsResult, len(nodeData.Units))
for i, unitData := range nodeData.Units {
result[i] = UpdateUnitsResult{ID: unitData.ID, Found: false}
}
return result, nil
}
if findNodeErr != nil {
return nil, findNodeErr
}
unitProv, ok := node.Provisioner().(provision.UnitStatusProvisioner)
if !ok {
return []UpdateUnitsResult{}, nil
}
result := make([]UpdateUnitsResult, len(nodeData.Units))
for i, unitData := range nodeData.Units {
unit := provision.Unit{ID: unitData.ID, Name: unitData.Name}
err := unitProv.SetUnitStatus(unit, unitData.Status)
_, isNotFound := err.(*provision.UnitNotFoundError)
if err != nil && !isNotFound {
return nil, err
}
result[i] = UpdateUnitsResult{ID: unitData.ID, Found: !isNotFound}
}
return result, nil
} | |
c178739 | unit.Available() {
return true
}
}
return false
} | |
c178740 | err
}
users, err := auth.ListUsersWithPermissions(permission.Permission{
Scheme: permission.PermAppDeploy,
Context: permission.Context(permTypes.CtxTeam, team.Name),
})
if err != nil {
conn.Apps().Update(bson.M{"name": app.Name}, bson.M{"$pull": bson.M{"teams": team.Name}})
return err
}
for _, user := range users {
err = repository.Manager().GrantAccess(app.Name, user.Email)
if err != nil {
conn.Apps().Update(bson.M{"name": app.Name}, bson.M{"$pull": bson.M{"teams": team.Name}})
return err
}
}
return nil
} | |
c178741 |
if err != nil {
conn.Apps().Update(bson.M{"name": app.Name}, bson.M{"$addToSet": bson.M{"teams": team.Name}})
return err
}
for _, user := range users {
perms, err := user.Permissions()
if err != nil {
conn.Apps().Update(bson.M{"name": app.Name}, bson.M{"$addToSet": bson.M{"teams": team.Name}})
return err
}
canDeploy := permission.CheckFromPermList(perms, permission.PermAppDeploy,
append(permission.Contexts(permTypes.CtxTeam, app.Teams),
permission.Context(permTypes.CtxApp, app.Name),
permission.Context(permTypes.CtxPool, app.Pool),
)...,
)
if canDeploy {
continue
}
err = repository.Manager().RevokeAccess(app.Name, user.Email)
if err != nil {
conn.Apps().Update(bson.M{"name": app.Name}, bson.M{"$addToSet": bson.M{"teams": team.Name}})
return err
}
}
return nil
} | |
c178742 | := servicemanager.Team.FindByNames(app.Teams)
return t
} | |
c178743 | {
app.Log(fmt.Sprintf("setting env %s with value %s", env.Name, env.Value), "tsuru", "api")
}
} | |
c178744 |
return bind.EnvVar{}, errors.New("Environment variable not declared for this app.")
} | |
c178745 | or dashes, " +
"starting with a letter."
return &tsuruErrors.ValidationError{Message: msg}
}
return app.validate()
} | |
c178746 |
if err != nil {
return err
}
return app.validatePlan()
} | |
c178747 | for _, env := range app.ServiceEnvs {
if env.ServiceName == serviceName && env.InstanceName == instanceName {
envs[env.Name] = env.EnvVar
}
}
return envs
} | |
c178748 | commands")
}
app.Log(fmt.Sprintf("running '%s'", cmd), "tsuru", "api")
logWriter := LogWriter{App: app, Source: "app-run"}
logWriter.Async()
defer logWriter.Close()
return app.run(cmd, io.MultiWriter(w, &logWriter), args)
} | |
c178749 | := make([]bind.Unit, len(provUnits))
for i := range provUnits {
units[i] = &provUnits[i]
}
return units, nil
} | |
c178750 | "", err
}
defer conn.Close()
err = conn.Apps().Update(bson.M{"name": app.Name}, bson.M{"$set": bson.M{"uuid": uuidV4.String()}})
if err != nil {
return "", err
}
app.UUID = uuidV4.String()
return app.UUID, nil
} | |
c178751 |
mergedEnvs[e.Name] = e.EnvVar
}
mergedEnvs[TsuruServicesEnvVar] = serviceEnvsFromEnvVars(app.ServiceEnvs)
return mergedEnvs
} | |
c178752 |
}
defer conn.Close()
err = conn.Apps().Update(bson.M{"name": app.Name}, bson.M{"$set": bson.M{"env": app.Env}})
if err != nil {
return err
}
if setEnvs.ShouldRestart {
return app.restartIfUnits(setEnvs.Writer)
}
return nil
} | |
c178753 |
err = conn.Apps().Update(bson.M{"name": app.Name}, bson.M{"$set": bson.M{"env": app.Env}})
if err != nil {
return err
}
if unsetEnvs.ShouldRestart {
return app.restartIfUnits(unsetEnvs.Writer)
}
return nil
} | |
c178754 | err := action.NewPipeline(actions...).Execute(app, cnames)
rebuild.RoutesRebuildOrEnqueue(app.Name)
return err
} | |
c178755 |
logs = append(logs, l)
}
}
if len(logs) > 0 {
conn, err := db.LogConn()
if err != nil {
return err
}
defer conn.Close()
return conn.AppLogCollection(app.Name).Insert(logs...)
}
return nil
} | |
c178756 | return app.lastLogs(lines, filterLog, false)
} | |
c178757 | }
appsProvisionerMap[prov.GetName()] = append(appsProvisionerMap[prov.GetName()], a)
}
var provisionApps []provision.App
for provName, apps := range appsProvisionerMap {
prov, err = provision.Get(provName)
if err != nil {
return nil, err
}
if filterProv, ok := prov.(provision.AppFilterProvisioner); ok {
apps, err = filterProv.FilterAppsByUnitStatus(apps, filter.Statuses)
if err != nil {
return nil, err
}
}
provisionApps = append(provisionApps, apps...)
}
for i := range provisionApps {
apps[i] = *(provisionApps[i].(*App))
}
apps = apps[:len(provisionApps)]
}
err = loadCachedAddrsInApps(apps)
if err != nil {
return nil, err
}
return apps, nil
} | |
c178758 | err := db.Conn()
if err != nil {
return err
}
defer conn.Close()
app1.CName, app2.CName = app2.CName, app1.CName
updateCName := func(app *App, r router.Router) error {
return conn.Apps().Update(
bson.M{"name": app.Name},
bson.M{"$set": bson.M{"cname": app.CName}},
)
}
err = updateCName(app1, r1)
if err != nil {
return err
}
return updateCName(app2, r2)
} | |
c178759 | app.Name)
}
fmt.Fprintf(w, "%s\n", msg)
prov, err := app.getProvisioner()
if err != nil {
return err
}
err = prov.Start(app, process)
if err != nil {
log.Errorf("[start] error on start the app %s - %s", app.Name, err)
return err
}
rebuild.RoutesRebuildOrEnqueue(app.Name)
return err
} | |
c178760 | database driver: %q.", name)
}
return &driver, nil
} | |
c178761 |
if err != nil || dbDriverName == "" {
dbDriverName = DefaultDbDriverName
}
currentDbDriver, err = GetDbDriver(dbDriverName)
if err != nil {
return nil, err
}
return currentDbDriver, nil
} | |
c178762 | }
var cs Clientset
var err error
cs.tsuruV1, err = tsuruv1.NewForConfig(&configShallowCopy)
if err != nil {
return nil, err
}
cs.DiscoveryClient, err = discovery.NewDiscoveryClientForConfig(&configShallowCopy)
if err != nil {
glog.Errorf("failed to create the DiscoveryClient: %v", err)
return nil, err
}
return &cs, nil
} | |
c178763 | if err != nil {
return nil, err
}
a, err := app.GetByName(cnt.AppName)
if err != nil {
return nil, err
}
return a, nil
} | |
c178764 | i, action := range actions {
newAction := &Action{
Name: action.Name,
Forward: action.Forward,
Backward: action.Backward,
MinParams: action.MinParams,
OnError: action.OnError,
}
newActions[i] = newAction
}
return &Pipeline{actions: newActions}
} | |
c178765 | action.rMutex.Unlock()
return action.result
} | |
c178766 |
return ErrJsonPayloadEmpty
}
err = json.Unmarshal(content, v)
if err != nil {
return err
}
return nil
} | |
c178767 |
for _, vv := range v {
query.Add(k, vv)
}
}
baseUrl.RawQuery = query.Encode()
}
return baseUrl
} | |
c178768 | for _, reqHeader := range strings.Split(rawReqHeader, ",") {
reqHeaders = append(reqHeaders, http.CanonicalHeaderKey(strings.TrimSpace(reqHeader)))
}
}
isPreflight := isCors && r.Method == "OPTIONS" && reqMethod != ""
return &CorsInfo{
IsCors: isCors,
IsPreflight: isPreflight,
Origin: origin,
OriginUrl: originUrl,
AccessControlRequestMethod: strings.ToUpper(reqMethod),
AccessControlRequestHeaders: reqHeaders,
}
} | |
c178769 |
// Validate the Origin
if mw.OriginValidator(corsInfo.Origin, request) == false {
Error(writer, "Invalid Origin", http.StatusForbidden)
return
}
if corsInfo.IsPreflight {
// check the request methods
if mw.allowedMethods[corsInfo.AccessControlRequestMethod] == false {
Error(writer, "Invalid Preflight Request", http.StatusForbidden)
return
}
// check the request headers
for _, requestedHeader := range corsInfo.AccessControlRequestHeaders {
if mw.allowedHeaders[requestedHeader] == false {
Error(writer, "Invalid Preflight Request", http.StatusForbidden)
return
}
}
writer.Header().Set("Access-Control-Allow-Methods", mw.allowedMethodsCsv)
writer.Header().Set("Access-Control-Allow-Headers", mw.allowedHeadersCsv)
writer.Header().Set("Access-Control-Allow-Origin", corsInfo.Origin)
if mw.AccessControlAllowCredentials == true {
writer.Header().Set("Access-Control-Allow-Credentials", "true")
}
writer.Header().Set("Access-Control-Max-Age", strconv.Itoa(mw.AccessControlMaxAge))
writer.WriteHeader(http.StatusOK)
return
}
// Non-preflight requests
for _, exposed := range mw.AccessControlExposeHeaders {
writer.Header().Add("Access-Control-Expose-Headers", exposed)
}
writer.Header().Set("Access-Control-Allow-Origin", corsInfo.Origin)
if mw.AccessControlAllowCredentials == true {
writer.Header().Set("Access-Control-Allow-Credentials", "true")
}
// continure, execute the wrapped middleware
handler(writer, request)
return
}
} | |
c178770 | r.Env["STATUS_CODE"] = writer.statusCode
r.Env["BYTES_WRITTEN"] = writer.bytesWritten
}
} | |
c178771 |
return
}
w.statusCode = code
w.wroteHeader = true
} | |
c178772 | r.start()
if err != nil {
return nil, err
}
return r, nil
} | |
c178773 | was not matched: 404 Not Found
NotFound(writer, request)
return
}
// a route was found, set the PathParams
request.PathParams = params
// run the user code
handler := route.Func
handler(writer, request)
}
} | |
c178774 |
parts := strings.SplitN(urlObj.RequestURI(), "?", 2)
return parts[0]
} | |
c178775 | err := url.Parse(pathExp)
if err != nil {
return "", err
}
// get the same escaping as find requests
pathExp = urlObj.RequestURI()
pathExp = postEscape.Replace(pathExp)
return pathExp, nil
} | |
c178776 | pathExp,
route,
)
if err != nil {
return err
}
// index
rt.index[route] = i
}
if rt.disableTrieCompression == false {
rt.trie.Compress()
}
return nil
} | |
c178777 | -1 || routeIndex < minIndex {
minIndex = routeIndex
bestMatch = result
}
}
return bestMatch
} | |
c178778 | nil, nil, pathMatched
}
if len(matches) == 1 {
// one route found
return matches[0].Route.(*Route), matches[0].Params, pathMatched
}
// multiple routes found, pick the first defined
result := rt.ofFirstDefinedRoute(matches)
return result.Route.(*Route), result.Params, pathMatched
} | |
c178779 | "application/json" && strings.ToUpper(charset) == "UTF-8") {
Error(w,
"Bad Content-Type or charset, expected 'application/json'",
http.StatusUnsupportedMediaType,
)
return
}
// call the wrapped handler
handler(w, r)
}
} | |
c178780 | := w.ResponseWriter.(http.CloseNotifier)
return notifier.CloseNotify()
} | |
c178781 |
mw.convertFormat()
return func(w ResponseWriter, r *Request) {
// call the handler
h(w, r)
util := &accessLogUtil{w, r}
mw.Logger.Print(mw.executeTextTemplate(util))
}
} | |
c178782 | err := mw.textTemplate.Execute(buf, util)
if err != nil {
panic(err)
}
return buf.String()
} | |
c178783 | return u.R.Env["REMOTE_USER"].(string)
}
return ""
} | |
c178784 | "?" + u.R.URL.RawQuery
}
return ""
} | |
c178785 | return u.R.Env["START_TIME"].(*time.Time)
}
return nil
} | |
c178786 | ip, _, err := net.SplitHostPort(remoteAddr); err == nil {
return ip
}
}
return ""
} | |
c178787 | return u.R.Env["ELAPSED_TIME"].(*time.Duration)
}
return nil
} | |
c178788 | "
}
return func(w ResponseWriter, r *Request) {
writer := &jsonIndentResponseWriter{w, false, mw.Prefix, mw.Indent}
// call the wrapped handler
handler(writer, r)
}
} | |
c178789 | {
b, err := json.MarshalIndent(v, w.prefix, w.indent)
if err != nil {
return nil, err
}
return b, nil
} | |
c178790 | int) {
w.ResponseWriter.WriteHeader(code)
w.wroteHeader = true
} | |
c178791 | := strings.NewReplacer(paramPlaceholder, paramValue, splatPlaceholder, paramValue, relaxedPlaceholder, paramValue)
path = r.Replace(path)
}
return path
} | |
c178792 | trace)
mw.logError(message)
// write error response
if mw.EnableResponseStackTrace {
Error(w, message, http.StatusInternalServerError)
} else {
Error(w, "Internal Server Error", http.StatusInternalServerError)
}
}
}()
// call the handler
h(w, r)
}
} | |
c178793 | handler
for i := len(middlewares) - 1; i >= 0; i-- {
wrapped = middlewares[i].MiddlewareFunc(wrapped)
}
return wrapped
} | |
c178794 | defer func() {
// need to close gzip writer
if writer.gzipWriter != nil {
writer.gzipWriter.Close()
}
}()
// call the handler with the wrapped writer
h(writer, r)
}
} | |
c178795 | {
w.Header().Set("Content-Encoding", "gzip")
}
w.ResponseWriter.WriteHeader(code)
w.wroteHeader = true
} | |
c178796 | := w.ResponseWriter.(http.Hijacker)
return hijacker.Hijack()
} | |
c178797 | if w.gzipWriter == nil {
w.gzipWriter = gzip.NewWriter(writer)
}
count, errW := w.gzipWriter.Write(b)
errF := w.gzipWriter.Flush()
if errW != nil {
return count, errW
}
if errF != nil {
return count, errF
}
return count, nil
}
return writer.Write(b)
} | |
c178798 | if err != nil {
Error(writer, "Invalid authentication", http.StatusBadRequest)
return
}
if !mw.Authenticator(providedUserId, providedPassword) {
mw.unauthorized(writer)
return
}
if !mw.Authorizator(providedUserId, request) {
mw.unauthorized(writer)
return
}
request.Env["REMOTE_USER"] = providedUserId
handler(writer, request)
}
} | |
c178799 | printFPadding(level, "#relaxed\n")
n.RelaxedChild.printDebug(level)
}
// main branch
for key, node := range n.Children {
printFPadding(level, "\"%s\"\n", key)
node.printDebug(level)
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.