KDOC 55: giteaのコードを読んだメモ

$(EXECUTABLE): $(GO_SOURCES) \((TAGS_PREREQ) CGO_CFLAGS="\)(CGO_CFLAGS)“ $(GO) build $(GOFLAGS) \((EXTRA_GOFLAGS) -tags '\)(TAGS)’ -ldflags ‘-s -w $(LDFLAGS)’ -o $@

webRoutes := routers.NormalRoutes()

// Database holds the database settings Database = struct {

func loadDBSetting(rootCfg ConfigProvider) { sec := rootCfg.Section(“database”) Database.Type = DatabaseType(sec.Key(“DB_TYPE”).String())

Database.Host = sec.Key(“HOST”).String() Database.Name = sec.Key(“NAME”).String() Database.User = sec.Key(“USER”).String()

// InitEngine initializes the xorm.Engine and sets it as db.DefaultContext func InitEngine(ctx context.Context) error {

xormEngine, err := newXORMEngine()

// SetDefaultEngine sets the default engine for db func SetDefaultEngine(ctx context.Context, eng *xorm.Engine) { x = eng DefaultContext = &Context{ Context: ctx, e: x, } }

mustInitCtx(ctx, common.InitDBEngine)

// SetDefaultEngine sets the default engine for db func SetDefaultEngine(ctx context.Context, eng *xorm.Engine) { x = eng DefaultContext = &Context{ Context: ctx, e: x, } }

// APIContext is a specific context for API service type APIContext struct { *Base

Cache cache.Cache

Doer *user_model.User // current signed-in user IsSigned bool IsBasicAuth bool

ContextUser *user_model.User // the user which is being visited, in most cases it differs from Doer

Repo *Repository Org *APIOrganization Package *Package }

type Base struct { originCtx context.Context contextValues []contextValuePair

Resp ResponseWriter Req *http.Request

/ Data is prepared by ContextDataStore middleware, this field only refers to the pre-created/prepared ContextData. / Although it’s mainly used for MVC templates, sometimes it’s also used to pass data between middlewares/handler Data middleware.ContextData

// Locale is mainly for Web context, although the API context also uses it in some cases: message response, form validation Locale translation.Locale }

// APIContexter returns apicontext as middleware func APIContexter() func(http.Handler) http.Handler { return func(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { base, baseCleanUp := NewBaseContext(w, req) ctx := &APIContext{ Base: base, Cache: mc.GetCache(), Repo: &Repository{PullRequest: &PullRequest{}}, Org: &APIOrganization{}, }

has, err := db.GetEngine(ctx).ID(task.RepoID).Get(&repo)

// Context represents a db context type Context struct { context.Context e Engine transaction bool }

/ DefaultContext is the default context to run xorm queries in / will be overwritten by Init with HammerContext var DefaultContext context.Context

// Engined structs provide an Engine type Engined interface { Engine() Engine }

// GetEngine will get a db Engine from this context or return an Engine restricted to this context func GetEngine(ctx context.Context) Engine { if e := getEngine(ctx); e != nil { return e } return x.Context(ctx) }

// getEngine will get a db Engine from this context or return nil func getEngine(ctx context.Context) Engine { if engined, ok := ctx.(Engined); ok { return engined.Engine() } enginedInterface := ctx.Value(enginedContextKey) if enginedInterface != nil { return enginedInterface.(Engined).Engine() } return nil }

// Engine returns db engine func (ctx *Context) Engine() Engine { return ctx.e }

engine, err = xorm.NewEngine(“postgresschema”, connStr)

assert.NoError(t, unittest.PrepareTestDatabase()) token := unittest.AssertExistsAndLoadBean(t, &ActionRunnerToken{ID: 3}) expectedToken, err := GetLatestRunnerToken(db.DefaultContext, 1, 0)

// APIContexter returns apicontext as middleware func APIContexter() func(http.Handler) http.Handler { return func(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { base, baseCleanUp := NewBaseContext(w, req) ctx := &APIContext{ Base: base, Cache: mc.GetCache(), Repo: &Repository{PullRequest: &PullRequest{}}, Org: &APIOrganization{}, } defer baseCleanUp()

ctx.Base.AppendContextValue(apiContextKey, ctx) ctx.Base.AppendContextValueFunc(git.RepositoryContextKey, func() any { return ctx.Repo.GitRepo })

// If request sends files, parse them here otherwise the Query() can’t be parsed and the CsrfToken will be invalid. if ctx.Req.Method = "POST" && strings.Contains(ctx.Req.Header.Get("Content-Type"), "multipart/form-data") { if err : ctx.Req.ParseMultipartForm(setting.Attachment.MaxSize << 20); err != nil && !strings.Contains(err.Error(), “EOF”) { // 32MB max size ctx.InternalServerError(err) return } }

httpcache.SetCacheControlInHeader(ctx.Resp.Header(), 0, “no-transform”) ctx.Resp.Header().Set(`X-Frame-Options`, setting.CORSConfig.XFrameOptions)

next.ServeHTTP(ctx.Resp, ctx.Req) }) } }

m.Use(context.APIContexter())

func runMigrate(ctx *cli.Context) error {

func MainTest(m *testing.M, testOpts …*TestOptions) {