_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q178700 | RemoveImage | test | 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", ima... | go | {
"resource": ""
} |
q178701 | RemoveAppImages | test | 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 {
ret... | go | {
"resource": ""
} |
q178702 | Create | test | 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 {
... | go | {
"resource": ""
} |
q178703 | List | test | func (s *platformService) List(enabledOnly bool) ([]appTypes.Platform, error) {
if enabledOnly {
return s.storage.FindEnabled()
}
return s.storage.FindAll()
} | go | {
"resource": ""
} |
q178704 | FindByName | test | 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 | {
"resource": ""
} |
q178705 | Update | test | 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 :=... | go | {
"resource": ""
} |
q178706 | Remove | test | 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
}
e... | go | {
"resource": ""
} |
q178707 | Rollback | test | 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.PlatformIm... | go | {
"resource": ""
} |
q178708 | GetPoolByName | test | 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 | {
"resource": ""
} |
q178709 | Manager | test | 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 | {
"resource": ""
} |
q178710 | Register | test | func Register(name string, manager RepositoryManager) {
if managers == nil {
managers = make(map[string]RepositoryManager)
}
managers[name] = manager
} | go | {
"resource": ""
} |
q178711 | start | test | 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 = tr... | go | {
"resource": ""
} |
q178712 | Shutdown | test | 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 | {
"resource": ""
} |
q178713 | GetForProvisioner | test | func GetForProvisioner(p provision.Provisioner) (Builder, error) {
builder, err := get(p.GetName())
if err != nil {
if _, ok := p.(provision.BuilderDeployDockerClient); ok {
return get("docker")
} else if _, ok := p.(provision.BuilderDeployKubeClient); ok {
return get("kubernetes")
}
}
return builder, e... | go | {
"resource": ""
} |
q178714 | get | test | func get(name string) (Builder, error) {
b, ok := builders[name]
if !ok {
return nil, errors.Errorf("unknown builder: %q", name)
}
return b, nil
} | go | {
"resource": ""
} |
q178715 | Registry | test | func Registry() ([]Builder, error) {
registry := make([]Builder, 0, len(builders))
for _, b := range builders {
registry = append(registry, b)
}
return registry, nil
} | go | {
"resource": ""
} |
q178716 | RegisterQueueTask | test | func RegisterQueueTask(p DockerProvisioner) error {
q, err := queue.Queue()
if err != nil {
return err
}
return q.RegisterTask(&runBs{provisioner: p})
} | go | {
"resource": ""
} |
q178717 | Apps | test | func (v *version) Apps() AppInformer {
return &appInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
} | go | {
"resource": ""
} |
q178718 | DeepCopy | test | func (in *App) DeepCopy() *App {
if in == nil {
return nil
}
out := new(App)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q178719 | DeepCopy | test | func (in *AppList) DeepCopy() *AppList {
if in == nil {
return nil
}
out := new(AppList)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q178720 | DeepCopy | test | func (in *AppSpec) DeepCopy() *AppSpec {
if in == nil {
return nil
}
out := new(AppSpec)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q178721 | Write | test | func (w *LogWriter) Write(data []byte) (int, error) {
w.finLk.RLock()
defer w.finLk.RUnlock()
if w.closed {
return len(data), nil
}
if w.msgCh == nil {
return len(data), w.write(data)
}
copied := make([]byte, len(data))
copy(copied, data)
w.msgCh <- copied
return len(data), nil
} | go | {
"resource": ""
} |
q178722 | ResetPassword | test | func (s NativeScheme) ResetPassword(user *auth.User, resetToken string) error {
if resetToken == "" {
return auth.ErrInvalidToken
}
conn, err := db.Conn()
if err != nil {
return err
}
defer conn.Close()
passToken, err := getPasswordToken(resetToken)
if err != nil {
return err
}
if passToken.UserEmail !=... | go | {
"resource": ""
} |
q178723 | addKnownTypes | test | func addKnownTypes(scheme *runtime.Scheme) error {
scheme.AddKnownTypes(SchemeGroupVersion,
&App{},
&AppList{},
)
scheme.AddKnownTypes(SchemeGroupVersion,
&metav1.Status{},
)
metav1.AddToGroupVersion(scheme, SchemeGroupVersion)
return nil
} | go | {
"resource": ""
} |
q178724 | Register | test | func Register(s Shutdownable) {
lock.Lock()
defer lock.Unlock()
registered = append(registered, s)
} | go | {
"resource": ""
} |
q178725 | Do | test | func Do(ctx context.Context, w io.Writer) error {
lock.Lock()
defer lock.Unlock()
done := make(chan bool)
wg := sync.WaitGroup{}
for _, h := range registered {
wg.Add(1)
go func(h Shutdownable) {
defer wg.Done()
var name string
if _, ok := h.(fmt.Stringer); ok {
name = fmt.Sprintf("%s", h)
} el... | go | {
"resource": ""
} |
q178726 | ListImagesOrDefault | test | func (s *platformImageService) ListImagesOrDefault(platformName string) ([]string, error) {
imgs, err := s.ListImages(platformName)
if err != nil && err == imageTypes.ErrPlatformImageNotFound {
return []string{platformBasicImageName(platformName)}, nil
}
return imgs, err
} | go | {
"resource": ""
} |
q178727 | MigrateAppsCRDs | test | func MigrateAppsCRDs() error {
config.Set("kubernetes:use-pool-namespaces", false)
defer config.Unset("kubernetes:use-pool-namespaces")
prov := kubernetes.GetProvisioner()
pools, err := pool.ListAllPools()
if err != nil {
return errors.Wrap(err, "failed to list pools")
}
var kubePools []string
for _, p := ran... | go | {
"resource": ""
} |
q178728 | Register | test | func Register(name string, fn MigrateFunc) error {
return register(name, false, fn)
} | go | {
"resource": ""
} |
q178729 | RegisterOptional | test | func RegisterOptional(name string, fn MigrateFunc) error {
return register(name, true, fn)
} | go | {
"resource": ""
} |
q178730 | Run | test | func Run(args RunArgs) error {
if args.Name != "" {
return runOptional(args)
}
if args.Force {
return ErrCannotForceMandatory
}
return run(args)
} | go | {
"resource": ""
} |
q178731 | Units | test | func (app *App) Units() ([]provision.Unit, error) {
prov, err := app.getProvisioner()
if err != nil {
return []provision.Unit{}, err
}
units, err := prov.Units(app)
if units == nil {
// This is unusual but was done because previously this method didn't
// return an error. This ensures we always return an emp... | go | {
"resource": ""
} |
q178732 | MarshalJSON | test | func (app *App) MarshalJSON() ([]byte, error) {
repo, _ := repository.Manager().GetRepository(app.Name)
result := make(map[string]interface{})
result["name"] = app.Name
result["platform"] = app.Platform
if version := app.GetPlatformVersion(); version != "latest" {
result["platform"] = fmt.Sprintf("%s:%s", app.Pl... | go | {
"resource": ""
} |
q178733 | AcquireApplicationLockWait | test | func AcquireApplicationLockWait(appName string, owner string, reason string, timeout time.Duration) (bool, error) {
timeoutChan := time.After(timeout)
for {
appLock := appTypes.AppLock{
Locked: true,
Reason: reason,
Owner: owner,
AcquireDate: time.Now().In(time.UTC),
}
conn, err := d... | go | {
"resource": ""
} |
q178734 | ReleaseApplicationLock | test | func ReleaseApplicationLock(appName string) {
var err error
retries := 3
for i := 0; i < retries; i++ {
err = releaseApplicationLockOnce(appName)
if err == nil {
return
}
time.Sleep(time.Second * time.Duration(i+1))
}
log.Error(err)
} | go | {
"resource": ""
} |
q178735 | GetByName | test | func GetByName(name string) (*App, error) {
var app App
conn, err := db.Conn()
if err != nil {
return nil, err
}
defer conn.Close()
err = conn.Apps().Find(bson.M{"name": name}).One(&app)
if err == mgo.ErrNotFound {
return nil, appTypes.ErrAppNotFound
}
return &app, err
} | go | {
"resource": ""
} |
q178736 | AddUnits | test | func (app *App) AddUnits(n uint, process string, w io.Writer) error {
if n == 0 {
return errors.New("Cannot add zero units.")
}
units, err := app.Units()
if err != nil {
return err
}
for _, u := range units {
if (u.Status == provision.StatusAsleep) || (u.Status == provision.StatusStopped) {
return errors... | go | {
"resource": ""
} |
q178737 | SetUnitStatus | test | func (app *App) SetUnitStatus(unitName string, status provision.Status) error {
units, err := app.Units()
if err != nil {
return err
}
for _, unit := range units {
if strings.HasPrefix(unit.ID, unitName) {
prov, err := app.getProvisioner()
if err != nil {
return err
}
unitProv, ok := prov.(provi... | go | {
"resource": ""
} |
q178738 | UpdateNodeStatus | test | func UpdateNodeStatus(nodeData provision.NodeStatusData) ([]UpdateUnitsResult, error) {
node, findNodeErr := findNodeForNodeData(nodeData)
var nodeAddresses []string
if findNodeErr == nil {
nodeAddresses = []string{node.Address()}
} else {
nodeAddresses = nodeData.Addrs
}
if healer.HealerInstance != nil {
e... | go | {
"resource": ""
} |
q178739 | available | test | func (app *App) available() bool {
units, err := app.Units()
if err != nil {
return false
}
for _, unit := range units {
if unit.Available() {
return true
}
}
return false
} | go | {
"resource": ""
} |
q178740 | Grant | test | func (app *App) Grant(team *authTypes.Team) error {
if _, found := app.findTeam(team); found {
return ErrAlreadyHaveAccess
}
app.Teams = append(app.Teams, team.Name)
conn, err := db.Conn()
if err != nil {
return err
}
defer conn.Close()
err = conn.Apps().Update(bson.M{"name": app.Name}, bson.M{"$addToSet": ... | go | {
"resource": ""
} |
q178741 | Revoke | test | func (app *App) Revoke(team *authTypes.Team) error {
if len(app.Teams) == 1 {
return ErrCannotOrphanApp
}
index, found := app.findTeam(team)
if !found {
return ErrNoAccess
}
last := len(app.Teams) - 1
app.Teams[index] = app.Teams[last]
app.Teams = app.Teams[:last]
conn, err := db.Conn()
if err != nil {
... | go | {
"resource": ""
} |
q178742 | GetTeams | test | func (app *App) GetTeams() []authTypes.Team {
t, _ := servicemanager.Team.FindByNames(app.Teams)
return t
} | go | {
"resource": ""
} |
q178743 | setEnv | test | func (app *App) setEnv(env bind.EnvVar) {
if app.Env == nil {
app.Env = make(map[string]bind.EnvVar)
}
app.Env[env.Name] = env
if env.Public {
app.Log(fmt.Sprintf("setting env %s with value %s", env.Name, env.Value), "tsuru", "api")
}
} | go | {
"resource": ""
} |
q178744 | getEnv | test | func (app *App) getEnv(name string) (bind.EnvVar, error) {
if env, ok := app.Env[name]; ok {
return env, nil
}
return bind.EnvVar{}, errors.New("Environment variable not declared for this app.")
} | go | {
"resource": ""
} |
q178745 | validateNew | test | func (app *App) validateNew() error {
if app.Name == InternalAppName || !validation.ValidateName(app.Name) {
msg := "Invalid app name, your app should have at most 40 " +
"characters, containing only lower case letters, numbers or dashes, " +
"starting with a letter."
return &tsuruErrors.ValidationError{Mess... | go | {
"resource": ""
} |
q178746 | validate | test | func (app *App) validate() error {
err := app.validatePool()
if err != nil {
return err
}
return app.validatePlan()
} | go | {
"resource": ""
} |
q178747 | InstanceEnvs | test | func (app *App) InstanceEnvs(serviceName, instanceName string) map[string]bind.EnvVar {
envs := make(map[string]bind.EnvVar)
for _, env := range app.ServiceEnvs {
if env.ServiceName == serviceName && env.InstanceName == instanceName {
envs[env.Name] = env.EnvVar
}
}
return envs
} | go | {
"resource": ""
} |
q178748 | Run | test | func (app *App) Run(cmd string, w io.Writer, args provision.RunArgs) error {
if !args.Isolated && !app.available() {
return errors.New("App must be available to run non-isolated commands")
}
app.Log(fmt.Sprintf("running '%s'", cmd), "tsuru", "api")
logWriter := LogWriter{App: app, Source: "app-run"}
logWriter.As... | go | {
"resource": ""
} |
q178749 | GetUnits | test | func (app *App) GetUnits() ([]bind.Unit, error) {
provUnits, err := app.Units()
if err != nil {
return nil, err
}
units := make([]bind.Unit, len(provUnits))
for i := range provUnits {
units[i] = &provUnits[i]
}
return units, nil
} | go | {
"resource": ""
} |
q178750 | GetUUID | test | func (app *App) GetUUID() (string, error) {
if app.UUID != "" {
return app.UUID, nil
}
uuidV4, err := uuid.NewV4()
if err != nil {
return "", errors.WithMessage(err, "failed to generate uuid v4")
}
conn, err := db.Conn()
if err != nil {
return "", err
}
defer conn.Close()
err = conn.Apps().Update(bson.M... | go | {
"resource": ""
} |
q178751 | Envs | test | func (app *App) Envs() map[string]bind.EnvVar {
mergedEnvs := make(map[string]bind.EnvVar, len(app.Env)+len(app.ServiceEnvs)+1)
for _, e := range app.Env {
mergedEnvs[e.Name] = e
}
for _, e := range app.ServiceEnvs {
mergedEnvs[e.Name] = e.EnvVar
}
mergedEnvs[TsuruServicesEnvVar] = serviceEnvsFromEnvVars(app.... | go | {
"resource": ""
} |
q178752 | SetEnvs | test | func (app *App) SetEnvs(setEnvs bind.SetEnvArgs) error {
if len(setEnvs.Envs) == 0 {
return nil
}
for _, env := range setEnvs.Envs {
err := validateEnv(env.Name)
if err != nil {
return err
}
}
if setEnvs.Writer != nil {
fmt.Fprintf(setEnvs.Writer, "---- Setting %d new environment variables ----\n", le... | go | {
"resource": ""
} |
q178753 | UnsetEnvs | test | func (app *App) UnsetEnvs(unsetEnvs bind.UnsetEnvArgs) error {
if len(unsetEnvs.VariableNames) == 0 {
return nil
}
if unsetEnvs.Writer != nil {
fmt.Fprintf(unsetEnvs.Writer, "---- Unsetting %d environment variables ----\n", len(unsetEnvs.VariableNames))
}
for _, name := range unsetEnvs.VariableNames {
delete... | go | {
"resource": ""
} |
q178754 | AddCName | test | func (app *App) AddCName(cnames ...string) error {
actions := []*action.Action{
&validateNewCNames,
&setNewCNamesToProvisioner,
&saveCNames,
&updateApp,
}
err := action.NewPipeline(actions...).Execute(app, cnames)
rebuild.RoutesRebuildOrEnqueue(app.Name)
return err
} | go | {
"resource": ""
} |
q178755 | Log | test | func (app *App) Log(message, source, unit string) error {
messages := strings.Split(message, "\n")
logs := make([]interface{}, 0, len(messages))
for _, msg := range messages {
if msg != "" {
l := Applog{
Date: time.Now().In(time.UTC),
Message: msg,
Source: source,
AppName: app.Name,
Unit... | go | {
"resource": ""
} |
q178756 | LastLogs | test | func (app *App) LastLogs(lines int, filterLog Applog) ([]Applog, error) {
return app.lastLogs(lines, filterLog, false)
} | go | {
"resource": ""
} |
q178757 | List | test | func List(filter *Filter) ([]App, error) {
apps := []App{}
query := filter.Query()
conn, err := db.Conn()
if err != nil {
return nil, err
}
err = conn.Apps().Find(query).All(&apps)
conn.Close()
if err != nil {
return nil, err
}
if filter != nil && len(filter.Statuses) > 0 {
appsProvisionerMap := make(ma... | go | {
"resource": ""
} |
q178758 | Swap | test | func Swap(app1, app2 *App, cnameOnly bool) error {
a1Routers := app1.GetRouters()
a2Routers := app2.GetRouters()
if len(a1Routers) != 1 || len(a2Routers) != 1 {
return errors.New("swapping apps with multiple routers is not supported")
}
r1, err := router.Get(a1Routers[0].Name)
if err != nil {
return err
}
r... | go | {
"resource": ""
} |
q178759 | Start | test | func (app *App) Start(w io.Writer, process string) error {
w = app.withLogWriter(w)
msg := fmt.Sprintf("\n ---> Starting the process %q", process)
if process == "" {
msg = fmt.Sprintf("\n ---> Starting the app %q", app.Name)
}
fmt.Fprintf(w, "%s\n", msg)
prov, err := app.getProvisioner()
if err != nil {
retu... | go | {
"resource": ""
} |
q178760 | GetDbDriver | test | func GetDbDriver(name string) (*DbDriver, error) {
driver, ok := dbDrivers[name]
if !ok {
return nil, errors.Errorf("Unknown database driver: %q.", name)
}
return &driver, nil
} | go | {
"resource": ""
} |
q178761 | GetCurrentDbDriver | test | func GetCurrentDbDriver() (*DbDriver, error) {
driverLock.RLock()
if currentDbDriver != nil {
driverLock.RUnlock()
return currentDbDriver, nil
}
driverLock.RUnlock()
driverLock.Lock()
defer driverLock.Unlock()
if currentDbDriver != nil {
return currentDbDriver, nil
}
dbDriverName, err := config.GetString... | go | {
"resource": ""
} |
q178762 | NewForConfig | test | func NewForConfig(c *rest.Config) (*Clientset, error) {
configShallowCopy := *c
if configShallowCopy.RateLimiter == nil && configShallowCopy.QPS > 0 {
configShallowCopy.RateLimiter = flowcontrol.NewTokenBucketRateLimiter(configShallowCopy.QPS, configShallowCopy.Burst)
}
var cs Clientset
var err error
cs.tsuruV1... | go | {
"resource": ""
} |
q178763 | GetAppFromUnitID | test | func (p *dockerProvisioner) GetAppFromUnitID(unitID string) (provision.App, error) {
cnt, err := p.GetContainer(unitID)
if err != nil {
return nil, err
}
a, err := app.GetByName(cnt.AppName)
if err != nil {
return nil, err
}
return a, nil
} | go | {
"resource": ""
} |
q178764 | NewPipeline | test | func NewPipeline(actions ...*Action) *Pipeline {
// Actions are usually global functions, copying them
// guarantees each copy has an isolated Result.
newActions := make([]*Action, len(actions))
for i, action := range actions {
newAction := &Action{
Name: action.Name,
Forward: action.Forward,
Back... | go | {
"resource": ""
} |
q178765 | Result | test | func (p *Pipeline) Result() Result {
action := p.actions[len(p.actions)-1]
action.rMutex.Lock()
defer action.rMutex.Unlock()
return action.result
} | go | {
"resource": ""
} |
q178766 | DecodeJsonPayload | test | func (r *Request) DecodeJsonPayload(v interface{}) error {
content, err := ioutil.ReadAll(r.Body)
r.Body.Close()
if err != nil {
return err
}
if len(content) == 0 {
return ErrJsonPayloadEmpty
}
err = json.Unmarshal(content, v)
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q178767 | UrlFor | test | func (r *Request) UrlFor(path string, queryParams map[string][]string) *url.URL {
baseUrl := r.BaseUrl()
baseUrl.Path = path
if queryParams != nil {
query := url.Values{}
for k, v := range queryParams {
for _, vv := range v {
query.Add(k, vv)
}
}
baseUrl.RawQuery = query.Encode()
}
return baseUrl... | go | {
"resource": ""
} |
q178768 | GetCorsInfo | test | func (r *Request) GetCorsInfo() *CorsInfo {
origin := r.Header.Get("Origin")
var originUrl *url.URL
var isCors bool
if origin == "" {
isCors = false
} else if origin == "null" {
isCors = true
} else {
var err error
originUrl, err = url.ParseRequestURI(origin)
isCors = err == nil && r.Host != originUr... | go | {
"resource": ""
} |
q178769 | MiddlewareFunc | test | func (mw *CorsMiddleware) MiddlewareFunc(handler HandlerFunc) HandlerFunc {
// precompute as much as possible at init time
mw.allowedMethods = map[string]bool{}
normedMethods := []string{}
for _, allowedMethod := range mw.AllowedMethods {
normed := strings.ToUpper(allowedMethod)
mw.allowedMethods[normed] = tr... | go | {
"resource": ""
} |
q178770 | MiddlewareFunc | test | func (mw *RecorderMiddleware) MiddlewareFunc(h HandlerFunc) HandlerFunc {
return func(w ResponseWriter, r *Request) {
writer := &recorderResponseWriter{w, 0, false, 0}
// call the handler
h(writer, r)
r.Env["STATUS_CODE"] = writer.statusCode
r.Env["BYTES_WRITTEN"] = writer.bytesWritten
}
} | go | {
"resource": ""
} |
q178771 | WriteHeader | test | func (w *recorderResponseWriter) WriteHeader(code int) {
w.ResponseWriter.WriteHeader(code)
if w.wroteHeader {
return
}
w.statusCode = code
w.wroteHeader = true
} | go | {
"resource": ""
} |
q178772 | MakeRouter | test | func MakeRouter(routes ...*Route) (App, error) {
r := &router{
Routes: routes,
}
err := r.start()
if err != nil {
return nil, err
}
return r, nil
} | go | {
"resource": ""
} |
q178773 | AppFunc | test | func (rt *router) AppFunc() HandlerFunc {
return func(writer ResponseWriter, request *Request) {
// find the route
route, params, pathMatched := rt.findRouteFromURL(request.Method, request.URL)
if route == nil {
if pathMatched {
// no route found, but path was matched: 405 Method Not Allowed
Error(w... | go | {
"resource": ""
} |
q178774 | escapedPath | test | func escapedPath(urlObj *url.URL) string {
// the escape method of url.URL should be public
// that would avoid this split.
parts := strings.SplitN(urlObj.RequestURI(), "?", 2)
return parts[0]
} | go | {
"resource": ""
} |
q178775 | escapedPathExp | test | func escapedPathExp(pathExp string) (string, error) {
// PathExp validation
if pathExp == "" {
return "", errors.New("empty PathExp")
}
if pathExp[0] != '/' {
return "", errors.New("PathExp must start with /")
}
if strings.Contains(pathExp, "?") {
return "", errors.New("PathExp must not contain the query s... | go | {
"resource": ""
} |
q178776 | start | test | func (rt *router) start() error {
rt.trie = trie.New()
rt.index = map[*Route]int{}
for i, route := range rt.Routes {
// work with the PathExp urlencoded.
pathExp, err := escapedPathExp(route.PathExp)
if err != nil {
return err
}
// insert in the Trie
err = rt.trie.AddRoute(
strings.ToUpper(rout... | go | {
"resource": ""
} |
q178777 | ofFirstDefinedRoute | test | func (rt *router) ofFirstDefinedRoute(matches []*trie.Match) *trie.Match {
minIndex := -1
var bestMatch *trie.Match
for _, result := range matches {
route := result.Route.(*Route)
routeIndex := rt.index[route]
if minIndex == -1 || routeIndex < minIndex {
minIndex = routeIndex
bestMatch = result
}
}
... | go | {
"resource": ""
} |
q178778 | findRouteFromURL | test | func (rt *router) findRouteFromURL(httpMethod string, urlObj *url.URL) (*Route, map[string]string, bool) {
// lookup the routes in the Trie
matches, pathMatched := rt.trie.FindRoutesAndPathMatched(
strings.ToUpper(httpMethod), // work with the httpMethod in uppercase
escapedPath(urlObj), // work with the... | go | {
"resource": ""
} |
q178779 | MiddlewareFunc | test | func (mw *ContentTypeCheckerMiddleware) MiddlewareFunc(handler HandlerFunc) HandlerFunc {
return func(w ResponseWriter, r *Request) {
mediatype, params, _ := mime.ParseMediaType(r.Header.Get("Content-Type"))
charset, ok := params["charset"]
if !ok {
charset = "UTF-8"
}
// per net/http doc, means that t... | go | {
"resource": ""
} |
q178780 | CloseNotify | test | func (w *responseWriter) CloseNotify() <-chan bool {
notifier := w.ResponseWriter.(http.CloseNotifier)
return notifier.CloseNotify()
} | go | {
"resource": ""
} |
q178781 | MiddlewareFunc | test | func (mw *AccessLogApacheMiddleware) MiddlewareFunc(h HandlerFunc) HandlerFunc {
// set the default Logger
if mw.Logger == nil {
mw.Logger = log.New(os.Stderr, "", 0)
}
// set default format
if mw.Format == "" {
mw.Format = DefaultLogFormat
}
mw.convertFormat()
return func(w ResponseWriter, r *Request) ... | go | {
"resource": ""
} |
q178782 | executeTextTemplate | test | func (mw *AccessLogApacheMiddleware) executeTextTemplate(util *accessLogUtil) string {
buf := bytes.NewBufferString("")
err := mw.textTemplate.Execute(buf, util)
if err != nil {
panic(err)
}
return buf.String()
} | go | {
"resource": ""
} |
q178783 | RemoteUser | test | func (u *accessLogUtil) RemoteUser() string {
if u.R.Env["REMOTE_USER"] != nil {
return u.R.Env["REMOTE_USER"].(string)
}
return ""
} | go | {
"resource": ""
} |
q178784 | ApacheQueryString | test | func (u *accessLogUtil) ApacheQueryString() string {
if u.R.URL.RawQuery != "" {
return "?" + u.R.URL.RawQuery
}
return ""
} | go | {
"resource": ""
} |
q178785 | StartTime | test | func (u *accessLogUtil) StartTime() *time.Time {
if u.R.Env["START_TIME"] != nil {
return u.R.Env["START_TIME"].(*time.Time)
}
return nil
} | go | {
"resource": ""
} |
q178786 | ApacheRemoteAddr | test | func (u *accessLogUtil) ApacheRemoteAddr() string {
remoteAddr := u.R.RemoteAddr
if remoteAddr != "" {
if ip, _, err := net.SplitHostPort(remoteAddr); err == nil {
return ip
}
}
return ""
} | go | {
"resource": ""
} |
q178787 | ResponseTime | test | func (u *accessLogUtil) ResponseTime() *time.Duration {
if u.R.Env["ELAPSED_TIME"] != nil {
return u.R.Env["ELAPSED_TIME"].(*time.Duration)
}
return nil
} | go | {
"resource": ""
} |
q178788 | MiddlewareFunc | test | func (mw *JsonIndentMiddleware) MiddlewareFunc(handler HandlerFunc) HandlerFunc {
if mw.Indent == "" {
mw.Indent = " "
}
return func(w ResponseWriter, r *Request) {
writer := &jsonIndentResponseWriter{w, false, mw.Prefix, mw.Indent}
// call the wrapped handler
handler(writer, r)
}
} | go | {
"resource": ""
} |
q178789 | EncodeJson | test | func (w *jsonIndentResponseWriter) EncodeJson(v interface{}) ([]byte, error) {
b, err := json.MarshalIndent(v, w.prefix, w.indent)
if err != nil {
return nil, err
}
return b, nil
} | go | {
"resource": ""
} |
q178790 | WriteHeader | test | func (w *jsonIndentResponseWriter) WriteHeader(code int) {
w.ResponseWriter.WriteHeader(code)
w.wroteHeader = true
} | go | {
"resource": ""
} |
q178791 | MakePath | test | func (route *Route) MakePath(pathParams map[string]string) string {
path := route.PathExp
for paramName, paramValue := range pathParams {
paramPlaceholder := ":" + paramName
relaxedPlaceholder := "#" + paramName
splatPlaceholder := "*" + paramName
r := strings.NewReplacer(paramPlaceholder, paramValue, splatPl... | go | {
"resource": ""
} |
q178792 | MiddlewareFunc | test | func (mw *RecoverMiddleware) MiddlewareFunc(h HandlerFunc) HandlerFunc {
// set the default Logger
if mw.Logger == nil {
mw.Logger = log.New(os.Stderr, "", 0)
}
return func(w ResponseWriter, r *Request) {
// catch user code's panic, and convert to http response
defer func() {
if reco := recover(); reco ... | go | {
"resource": ""
} |
q178793 | WrapMiddlewares | test | func WrapMiddlewares(middlewares []Middleware, handler HandlerFunc) HandlerFunc {
wrapped := handler
for i := len(middlewares) - 1; i >= 0; i-- {
wrapped = middlewares[i].MiddlewareFunc(wrapped)
}
return wrapped
} | go | {
"resource": ""
} |
q178794 | MiddlewareFunc | test | func (mw *GzipMiddleware) MiddlewareFunc(h HandlerFunc) HandlerFunc {
return func(w ResponseWriter, r *Request) {
// gzip support enabled
canGzip := strings.Contains(r.Header.Get("Accept-Encoding"), "gzip")
// client accepts gzip ?
writer := &gzipResponseWriter{w, false, canGzip, nil}
defer func() {
// ne... | go | {
"resource": ""
} |
q178795 | WriteHeader | test | func (w *gzipResponseWriter) WriteHeader(code int) {
// Always set the Vary header, even if this particular request
// is not gzipped.
w.Header().Add("Vary", "Accept-Encoding")
if w.canGzip {
w.Header().Set("Content-Encoding", "gzip")
}
w.ResponseWriter.WriteHeader(code)
w.wroteHeader = true
} | go | {
"resource": ""
} |
q178796 | Hijack | test | func (w *gzipResponseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
hijacker := w.ResponseWriter.(http.Hijacker)
return hijacker.Hijack()
} | go | {
"resource": ""
} |
q178797 | Write | test | func (w *gzipResponseWriter) Write(b []byte) (int, error) {
if !w.wroteHeader {
w.WriteHeader(http.StatusOK)
}
writer := w.ResponseWriter.(http.ResponseWriter)
if w.canGzip {
// Write can be called multiple times for a given response.
// (see the streaming example:
// https://github.com/ant0ine/go-json-r... | go | {
"resource": ""
} |
q178798 | MiddlewareFunc | test | func (mw *AuthBasicMiddleware) MiddlewareFunc(handler HandlerFunc) HandlerFunc {
if mw.Realm == "" {
log.Fatal("Realm is required")
}
if mw.Authenticator == nil {
log.Fatal("Authenticator is required")
}
if mw.Authorizator == nil {
mw.Authorizator = func(userId string, request *Request) bool {
return t... | go | {
"resource": ""
} |
q178799 | printDebug | test | func (n *node) printDebug(level int) {
level++
// *splat branch
if n.SplatChild != nil {
printFPadding(level, "*splat\n")
n.SplatChild.printDebug(level)
}
// :param branch
if n.ParamChild != nil {
printFPadding(level, ":param\n")
n.ParamChild.printDebug(level)
}
// #param branch
if n.RelaxedChild != ni... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.