a
/
agola
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
agola/internal/services/gateway/gateway.go

368 lines
17 KiB
Go
Raw Permalink Normal View History

gateway: initial implementation
2019-02-21 16:58:25 +00:00
// Copyright 2019 Sorint.lab
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied
// See the License for the specific language governing permissions and
// limitations under the License.
package gateway
import (
"context"
"crypto/tls"
"io/ioutil"
"net/http"
*: use vanity url use agola.io domain
2019-07-01 09:40:20 +00:00
scommon "agola.io/agola/internal/common"
*: use new errors handling library Implement a new error handling library based on pkg/errors. It provides stack saving on wrapping and exports some function to add stack saving also to external errors. It also implements custom zerolog error formatting without adding too much verbosity by just printing the chain error file:line without a full stack trace of every error. * Add a --detailed-errors options to print error with they full chain * Wrap all error returns. Use errors.WithStack to wrap without adding a new messsage and error.Wrap[f] to add a message. * Add golangci-lint wrapcheck to check that external packages errors are wrapped. This won't check that internal packages error are wrapped. But we want also to ensure this case so we'll have to find something else to check also these.
2022-02-22 14:01:29 +00:00
"agola.io/agola/internal/errors"
*: use vanity url use agola.io domain
2019-07-01 09:40:20 +00:00
"agola.io/agola/internal/objectstorage"
"agola.io/agola/internal/services/common"
"agola.io/agola/internal/services/config"
"agola.io/agola/internal/services/gateway/action"
"agola.io/agola/internal/services/gateway/api"
"agola.io/agola/internal/services/gateway/handlers"
"agola.io/agola/internal/util"
*: export clients and related types Export clients and related packages. The main rule is to not import internal packages from exported packages. The gateway client and related types are totally decoupled from the gateway service (not shared types between the client and the server). Instead the configstore and the runservice client currently share many types that are now exported (decoupling them will require that a lot of types must be duplicated and the need of functions to convert between them, this will be done in future when the APIs will be declared as stable).
2019-07-31 13:39:07 +00:00
csclient "agola.io/agola/services/configstore/client"
rsclient "agola.io/agola/services/runservice/client"
gateway: initial implementation
2019-02-21 16:58:25 +00:00
*: migrate to golang-jwt/jwt Migrate to the new community maintained version of github.com/dgrijalva/jwt-go
2021-09-10 10:33:59 +00:00
"github.com/golang-jwt/jwt/v4"
gateway: initial implementation
2019-02-21 16:58:25 +00:00
ghandlers "github.com/gorilla/handlers"
"github.com/gorilla/mux"
*: use zerolog for logging Replace zap with zerolog. zerolog has a cleaner interface and can be easily configured with custom error chain printing using a new error handling library that will be implemented in another PR.
2022-02-21 17:07:58 +00:00
"github.com/rs/zerolog"
"github.com/rs/zerolog/log"
gateway: initial implementation
2019-02-21 16:58:25 +00:00
)
gateway: limit requests to a predefined max size
2019-04-03 14:59:17 +00:00
const (
maxRequestSize = 1024 * 1024
)
gateway: initial implementation
2019-02-21 16:58:25 +00:00
type Gateway struct {
*: use zerolog for logging Replace zap with zerolog. zerolog has a cleaner interface and can be easily configured with custom error chain printing using a new error handling library that will be implemented in another PR.
2022-02-21 17:07:58 +00:00
log zerolog.Logger
c *config.Gateway
gateway: initial implementation
2019-02-21 16:58:25 +00:00
*: rename "lts" to "ost" `lts` was choosen to reflect a "long term storage" but currently it's just an object storage implementation. So use this term and "ost" as its abbreviation (to not clash with "os").
2019-04-27 13:16:48 +00:00
ost *objectstorage.ObjStorage
*: export clients and related types Export clients and related packages. The main rule is to not import internal packages from exported packages. The gateway client and related types are totally decoupled from the gateway service (not shared types between the client and the server). Instead the configstore and the runservice client currently share many types that are now exported (decoupling them will require that a lot of types must be duplicated and the need of functions to convert between them, this will be done in future when the APIs will be declared as stable).
2019-07-31 13:39:07 +00:00
runserviceClient *rsclient.Client
configstoreClient *csclient.Client
gateway: rename command(handler) to action(handler) Since we're going to migrate all actions (also queries that now are implemented in the api handlers) there
2019-05-03 21:48:49 +00:00
ah *action.ActionHandler
gateway: initial implementation
2019-02-21 16:58:25 +00:00
sd *common.TokenSigningData
}
*: use zerolog for logging Replace zap with zerolog. zerolog has a cleaner interface and can be easily configured with custom error chain printing using a new error handling library that will be implemented in another PR.
2022-02-21 17:07:58 +00:00
func NewGateway(ctx context.Context, log zerolog.Logger, gc *config.Config) (*Gateway, error) {
gateway: use agola ID in gitsource tokenname
2019-04-30 10:13:12 +00:00
c := &gc.Gateway
tests: improve services logging During tests provide a zaptest Logger so all services output will be redirected to golang testing logger. When multiple services of the same type are provided add a unique name field to distinguish them.
2020-01-15 11:01:46 +00:00
gateway: initial implementation
2019-02-21 16:58:25 +00:00
if c.Debug {
*: use zerolog for logging Replace zap with zerolog. zerolog has a cleaner interface and can be easily configured with custom error chain printing using a new error handling library that will be implemented in another PR.
2022-02-21 17:07:58 +00:00
log = log.Level(zerolog.DebugLevel)
gateway: initial implementation
2019-02-21 16:58:25 +00:00
}
if c.Web.ListenAddress == "" {
return nil, errors.Errorf("listen address undefined")
}
if c.Web.TLS {
if c.Web.TLSKeyFile == "" {
return nil, errors.Errorf("no tls key file specified")
}
if c.Web.TLSCertFile == "" {
return nil, errors.Errorf("no tls cert file specified")
}
}
sd := &common.TokenSigningData{Duration: c.TokenSigning.Duration}
switch c.TokenSigning.Method {
case "hmac":
sd.Method = jwt.SigningMethodHS256
if c.TokenSigning.Key == "" {
return nil, errors.Errorf("empty token signing key for hmac method")
}
sd.Key = []byte(c.TokenSigning.Key)
case "rsa":
if c.TokenSigning.PrivateKeyPath == "" {
return nil, errors.Errorf("token signing private key file for rsa method not defined")
}
if c.TokenSigning.PublicKeyPath == "" {
return nil, errors.Errorf("token signing public key file for rsa method not defined")
}
sd.Method = jwt.SigningMethodRS256
privateKeyData, err := ioutil.ReadFile(c.TokenSigning.PrivateKeyPath)
if err != nil {
*: use new errors handling library Implement a new error handling library based on pkg/errors. It provides stack saving on wrapping and exports some function to add stack saving also to external errors. It also implements custom zerolog error formatting without adding too much verbosity by just printing the chain error file:line without a full stack trace of every error. * Add a --detailed-errors options to print error with they full chain * Wrap all error returns. Use errors.WithStack to wrap without adding a new messsage and error.Wrap[f] to add a message. * Add golangci-lint wrapcheck to check that external packages errors are wrapped. This won't check that internal packages error are wrapped. But we want also to ensure this case so we'll have to find something else to check also these.
2022-02-22 14:01:29 +00:00
return nil, errors.Wrapf(err, "error reading token signing private key")
gateway: initial implementation
2019-02-21 16:58:25 +00:00
}
sd.PrivateKey, err = jwt.ParseRSAPrivateKeyFromPEM(privateKeyData)
if err != nil {
*: use new errors handling library Implement a new error handling library based on pkg/errors. It provides stack saving on wrapping and exports some function to add stack saving also to external errors. It also implements custom zerolog error formatting without adding too much verbosity by just printing the chain error file:line without a full stack trace of every error. * Add a --detailed-errors options to print error with they full chain * Wrap all error returns. Use errors.WithStack to wrap without adding a new messsage and error.Wrap[f] to add a message. * Add golangci-lint wrapcheck to check that external packages errors are wrapped. This won't check that internal packages error are wrapped. But we want also to ensure this case so we'll have to find something else to check also these.
2022-02-22 14:01:29 +00:00
return nil, errors.Wrapf(err, "error parsing token signing private key")
gateway: initial implementation
2019-02-21 16:58:25 +00:00
}
publicKeyData, err := ioutil.ReadFile(c.TokenSigning.PublicKeyPath)
if err != nil {
*: use new errors handling library Implement a new error handling library based on pkg/errors. It provides stack saving on wrapping and exports some function to add stack saving also to external errors. It also implements custom zerolog error formatting without adding too much verbosity by just printing the chain error file:line without a full stack trace of every error. * Add a --detailed-errors options to print error with they full chain * Wrap all error returns. Use errors.WithStack to wrap without adding a new messsage and error.Wrap[f] to add a message. * Add golangci-lint wrapcheck to check that external packages errors are wrapped. This won't check that internal packages error are wrapped. But we want also to ensure this case so we'll have to find something else to check also these.
2022-02-22 14:01:29 +00:00
return nil, errors.Wrapf(err, "error reading token signing public key")
gateway: initial implementation
2019-02-21 16:58:25 +00:00
}
sd.PublicKey, err = jwt.ParseRSAPublicKeyFromPEM(publicKeyData)
if err != nil {
*: use new errors handling library Implement a new error handling library based on pkg/errors. It provides stack saving on wrapping and exports some function to add stack saving also to external errors. It also implements custom zerolog error formatting without adding too much verbosity by just printing the chain error file:line without a full stack trace of every error. * Add a --detailed-errors options to print error with they full chain * Wrap all error returns. Use errors.WithStack to wrap without adding a new messsage and error.Wrap[f] to add a message. * Add golangci-lint wrapcheck to check that external packages errors are wrapped. This won't check that internal packages error are wrapped. But we want also to ensure this case so we'll have to find something else to check also these.
2022-02-22 14:01:29 +00:00
return nil, errors.Wrapf(err, "error parsing token signing public key")
gateway: initial implementation
2019-02-21 16:58:25 +00:00
}
case "":
return nil, errors.Errorf("missing token signing method")
default:
return nil, errors.Errorf("unknown token signing method: %q", c.TokenSigning.Method)
}
*: rename "lts" to "ost" `lts` was choosen to reflect a "long term storage" but currently it's just an object storage implementation. So use this term and "ost" as its abbreviation (to not clash with "os").
2019-04-27 13:16:48 +00:00
ost, err := scommon.NewObjectStorage(&c.ObjectStorage)
gateway: initial implementation
2019-02-21 16:58:25 +00:00
if err != nil {
*: use new errors handling library Implement a new error handling library based on pkg/errors. It provides stack saving on wrapping and exports some function to add stack saving also to external errors. It also implements custom zerolog error formatting without adding too much verbosity by just printing the chain error file:line without a full stack trace of every error. * Add a --detailed-errors options to print error with they full chain * Wrap all error returns. Use errors.WithStack to wrap without adding a new messsage and error.Wrap[f] to add a message. * Add golangci-lint wrapcheck to check that external packages errors are wrapped. This won't check that internal packages error are wrapped. But we want also to ensure this case so we'll have to find something else to check also these.
2022-02-22 14:01:29 +00:00
return nil, errors.WithStack(err)
gateway: initial implementation
2019-02-21 16:58:25 +00:00
}
*: export clients and related types Export clients and related packages. The main rule is to not import internal packages from exported packages. The gateway client and related types are totally decoupled from the gateway service (not shared types between the client and the server). Instead the configstore and the runservice client currently share many types that are now exported (decoupling them will require that a lot of types must be duplicated and the need of functions to convert between them, this will be done in future when the APIs will be declared as stable).
2019-07-31 13:39:07 +00:00
configstoreClient := csclient.NewClient(c.ConfigstoreURL)
runserviceClient := rsclient.NewClient(c.RunserviceURL)
gateway: initial implementation
2019-02-21 16:58:25 +00:00
*: use zerolog for logging Replace zap with zerolog. zerolog has a cleaner interface and can be easily configured with custom error chain printing using a new error handling library that will be implemented in another PR.
2022-02-21 17:07:58 +00:00
ah := action.NewActionHandler(log, sd, configstoreClient, runserviceClient, gc.ID, c.APIExposedURL, c.WebExposedURL)
gateway: initial implementation
2019-02-21 16:58:25 +00:00
return &Gateway{
*: use zerolog for logging Replace zap with zerolog. zerolog has a cleaner interface and can be easily configured with custom error chain printing using a new error handling library that will be implemented in another PR.
2022-02-21 17:07:58 +00:00
log: log,
gateway: initial implementation
2019-02-21 16:58:25 +00:00
c: c,
*: rename "lts" to "ost" `lts` was choosen to reflect a "long term storage" but currently it's just an object storage implementation. So use this term and "ost" as its abbreviation (to not clash with "os").
2019-04-27 13:16:48 +00:00
ost: ost,
gateway: move run logic from api to actions
2019-05-05 22:00:45 +00:00
runserviceClient: runserviceClient,
gateway: initial implementation
2019-02-21 16:58:25 +00:00
configstoreClient: configstoreClient,
gateway: rename command(handler) to action(handler) Since we're going to migrate all actions (also queries that now are implemented in the api handlers) there
2019-05-03 21:48:49 +00:00
ah: ah,
gateway: initial implementation
2019-02-21 16:58:25 +00:00
sd: sd,
}, nil
}
func (g *Gateway) Run(ctx context.Context) error {
service: handle cors config and use it only on gateway * Don't make cors enabled on all (*) by default. * Handle related web.allowedOrigins options * Only the gateway api should be called by a browser so setup the cors handler only on it
2019-07-13 21:15:00 +00:00
// noop coors handler
corsHandler := func(h http.Handler) http.Handler {
return h
}
db: use context functions Use the go sql context functions (ExecContext, QueryContext etc...) The context is saved inside Tx so the library users should only pass it one time to the db.Do function.
2019-07-25 08:46:02 +00:00
if len(g.c.Web.AllowedOrigins) > 0 {
corsAllowedMethodsOptions := ghandlers.AllowedMethods([]string{"GET", "HEAD", "POST", "PUT", "DELETE"})
corsAllowedHeadersOptions := ghandlers.AllowedHeaders([]string{"Accept", "Accept-Encoding", "Authorization", "Content-Length", "Content-Type", "X-CSRF-Token", "Authorization"})
corsAllowedOriginsOptions := ghandlers.AllowedOrigins(g.c.Web.AllowedOrigins)
corsHandler = ghandlers.CORS(corsAllowedMethodsOptions, corsAllowedHeadersOptions, corsAllowedOriginsOptions)
}
gateway: initial implementation
2019-02-21 16:58:25 +00:00
*: use zerolog for logging Replace zap with zerolog. zerolog has a cleaner interface and can be easily configured with custom error chain printing using a new error handling library that will be implemented in another PR.
2022-02-21 17:07:58 +00:00
webhooksHandler := api.NewWebhooksHandler(g.log, g.ah, g.configstoreClient, g.runserviceClient, g.c.APIExposedURL)
projectGroupHandler := api.NewProjectGroupHandler(g.log, g.ah)
projectGroupSubgroupsHandler := api.NewProjectGroupSubgroupsHandler(g.log, g.ah)
projectGroupProjectsHandler := api.NewProjectGroupProjectsHandler(g.log, g.ah)
createProjectGroupHandler := api.NewCreateProjectGroupHandler(g.log, g.ah)
updateProjectGroupHandler := api.NewUpdateProjectGroupHandler(g.log, g.ah)
deleteProjectGroupHandler := api.NewDeleteProjectGroupHandler(g.log, g.ah)
projectHandler := api.NewProjectHandler(g.log, g.ah)
createProjectHandler := api.NewCreateProjectHandler(g.log, g.ah)
updateProjectHandler := api.NewUpdateProjectHandler(g.log, g.ah)
deleteProjectHandler := api.NewDeleteProjectHandler(g.log, g.ah)
projectReconfigHandler := api.NewProjectReconfigHandler(g.log, g.ah)
projectUpdateRepoLinkedAccountHandler := api.NewProjectUpdateRepoLinkedAccountHandler(g.log, g.ah)
projectCreateRunHandler := api.NewProjectCreateRunHandler(g.log, g.ah)
secretHandler := api.NewSecretHandler(g.log, g.ah)
createSecretHandler := api.NewCreateSecretHandler(g.log, g.ah)
updateSecretHandler := api.NewUpdateSecretHandler(g.log, g.ah)
deleteSecretHandler := api.NewDeleteSecretHandler(g.log, g.ah)
variableHandler := api.NewVariableHandler(g.log, g.ah)
createVariableHandler := api.NewCreateVariableHandler(g.log, g.ah)
updateVariableHandler := api.NewUpdateVariableHandler(g.log, g.ah)
deleteVariableHandler := api.NewDeleteVariableHandler(g.log, g.ah)
currentUserHandler := api.NewCurrentUserHandler(g.log, g.ah)
userHandler := api.NewUserHandler(g.log, g.ah)
usersHandler := api.NewUsersHandler(g.log, g.ah)
createUserHandler := api.NewCreateUserHandler(g.log, g.ah)
deleteUserHandler := api.NewDeleteUserHandler(g.log, g.ah)
userCreateRunHandler := api.NewUserCreateRunHandler(g.log, g.ah)
userOrgsHandler := api.NewUserOrgsHandler(g.log, g.ah)
createUserLAHandler := api.NewCreateUserLAHandler(g.log, g.ah)
deleteUserLAHandler := api.NewDeleteUserLAHandler(g.log, g.ah)
createUserTokenHandler := api.NewCreateUserTokenHandler(g.log, g.ah)
deleteUserTokenHandler := api.NewDeleteUserTokenHandler(g.log, g.ah)
remoteSourceHandler := api.NewRemoteSourceHandler(g.log, g.ah)
createRemoteSourceHandler := api.NewCreateRemoteSourceHandler(g.log, g.ah)
updateRemoteSourceHandler := api.NewUpdateRemoteSourceHandler(g.log, g.ah)
remoteSourcesHandler := api.NewRemoteSourcesHandler(g.log, g.ah)
deleteRemoteSourceHandler := api.NewDeleteRemoteSourceHandler(g.log, g.ah)
orgHandler := api.NewOrgHandler(g.log, g.ah)
orgsHandler := api.NewOrgsHandler(g.log, g.ah)
createOrgHandler := api.NewCreateOrgHandler(g.log, g.ah)
deleteOrgHandler := api.NewDeleteOrgHandler(g.log, g.ah)
orgMembersHandler := api.NewOrgMembersHandler(g.log, g.ah)
addOrgMemberHandler := api.NewAddOrgMemberHandler(g.log, g.ah)
removeOrgMemberHandler := api.NewRemoveOrgMemberHandler(g.log, g.ah)
runHandler := api.NewRunHandler(g.log, g.ah)
runsHandler := api.NewRunsHandler(g.log, g.ah)
runtaskHandler := api.NewRuntaskHandler(g.log, g.ah)
runActionsHandler := api.NewRunActionsHandler(g.log, g.ah)
runTaskActionsHandler := api.NewRunTaskActionsHandler(g.log, g.ah)
logsHandler := api.NewLogsHandler(g.log, g.ah)
logsDeleteHandler := api.NewLogsDeleteHandler(g.log, g.ah)
userRemoteReposHandler := api.NewUserRemoteReposHandler(g.log, g.ah, g.configstoreClient)
badgeHandler := api.NewBadgeHandler(g.log, g.ah)
versionHandler := api.NewVersionHandler(g.log, g.ah)
reposHandler := api.NewReposHandler(g.log, g.c.GitserverURL)
loginUserHandler := api.NewLoginUserHandler(g.log, g.ah)
authorizeHandler := api.NewAuthorizeHandler(g.log, g.ah)
registerHandler := api.NewRegisterUserHandler(g.log, g.ah)
oauth2callbackHandler := api.NewOAuth2CallbackHandler(g.log, g.ah)
gateway: initial implementation
2019-02-21 16:58:25 +00:00
router := mux.NewRouter()
gateway: don't use maxBytesHandler in gitserver proxy handler a git object could much be greater than 1MiB.
2019-06-08 14:26:22 +00:00
reposRouter := mux.NewRouter()
gateway: initial implementation
2019-02-21 16:58:25 +00:00
initial project group impl and related api updated
2019-03-14 13:36:18 +00:00
apirouter := mux.NewRouter().PathPrefix("/api/v1alpha").Subrouter().UseEncodedPath()
gateway: initial implementation
2019-02-21 16:58:25 +00:00
*: use zerolog for logging Replace zap with zerolog. zerolog has a cleaner interface and can be easily configured with custom error chain printing using a new error handling library that will be implemented in another PR.
2022-02-21 17:07:58 +00:00
authForcedHandler := handlers.NewAuthHandler(g.log, g.configstoreClient, g.c.AdminToken, g.sd, true)
authOptionalHandler := handlers.NewAuthHandler(g.log, g.configstoreClient, g.c.AdminToken, g.sd, false)
gateway: initial implementation
2019-02-21 16:58:25 +00:00
router.PathPrefix("/api/v1alpha").Handler(apirouter)
gateway: use authOptionalHandle with logHandler or it'll fail when fetching logs on user runs since the logged in userid is not set in the context
2019-05-11 22:28:50 +00:00
apirouter.Handle("/logs", authOptionalHandler(logsHandler)).Methods("GET")
gateway/runservice: add api to delete step logs
2019-11-09 10:18:00 +00:00
apirouter.Handle("/logs", authForcedHandler(logsDeleteHandler)).Methods("DELETE")
gateway: initial implementation
2019-02-21 16:58:25 +00:00
initial project group impl and related api updated
2019-03-14 13:36:18 +00:00
//apirouter.Handle("/projectgroups", authForcedHandler(projectsHandler)).Methods("GET")
gateway: rename projectid to projectref
2019-04-08 07:04:55 +00:00
apirouter.Handle("/projectgroups/{projectgroupref}", authForcedHandler(projectGroupHandler)).Methods("GET")
apirouter.Handle("/projectgroups/{projectgroupref}/subgroups", authForcedHandler(projectGroupSubgroupsHandler)).Methods("GET")
apirouter.Handle("/projectgroups/{projectgroupref}/projects", authForcedHandler(projectGroupProjectsHandler)).Methods("GET")
*: fix rest methods * use POST instead of PUT for resource creation * use PUT instead of POST for resource special actions
2019-04-08 06:54:45 +00:00
apirouter.Handle("/projectgroups", authForcedHandler(createProjectGroupHandler)).Methods("POST")
*: implement update projectgroup
2019-05-14 15:53:48 +00:00
apirouter.Handle("/projectgroups/{projectgroupref}", authForcedHandler(updateProjectGroupHandler)).Methods("PUT")
gateway: implement projectgroup delete
2019-05-12 22:24:16 +00:00
apirouter.Handle("/projectgroups/{projectgroupref}", authForcedHandler(deleteProjectGroupHandler)).Methods("DELETE")
initial project group impl and related api updated
2019-03-14 13:36:18 +00:00
gateway: return project if the project is public If the project is public don't require the user to be logged in to show the project.
2019-07-12 21:41:34 +00:00
apirouter.Handle("/projects/{projectref}", authOptionalHandler(projectHandler)).Methods("GET")
*: fix rest methods * use POST instead of PUT for resource creation * use PUT instead of POST for resource special actions
2019-04-08 06:54:45 +00:00
apirouter.Handle("/projects", authForcedHandler(createProjectHandler)).Methods("POST")
gateway: implement updateProject Update project currently handles updating project name and visibility. In future we'll add additional update logic.
2019-05-12 21:22:18 +00:00
apirouter.Handle("/projects/{projectref}", authForcedHandler(updateProjectHandler)).Methods("PUT")
gateway: rename projectid to projectref
2019-04-08 07:04:55 +00:00
apirouter.Handle("/projects/{projectref}", authForcedHandler(deleteProjectHandler)).Methods("DELETE")
apirouter.Handle("/projects/{projectref}/reconfig", authForcedHandler(projectReconfigHandler)).Methods("PUT")
gateway: add project update repo linked account api Change the project repo linked account to the one of the current user
2019-05-09 13:36:47 +00:00
apirouter.Handle("/projects/{projectref}/updaterepolinkedaccount", authForcedHandler(projectUpdateRepoLinkedAccountHandler)).Methods("PUT")
gateway: fix project create run http method Make it a POST instead of a PUT.
2019-10-22 07:47:11 +00:00
apirouter.Handle("/projects/{projectref}/createrun", authForcedHandler(projectCreateRunHandler)).Methods("POST")
gateway: initial implementation
2019-02-21 16:58:25 +00:00
initial secret and variables impl
2019-03-14 13:36:18 +00:00
apirouter.Handle("/projectgroups/{projectgroupref}/secrets", authForcedHandler(secretHandler)).Methods("GET")
apirouter.Handle("/projects/{projectref}/secrets", authForcedHandler(secretHandler)).Methods("GET")
*: fix rest methods * use POST instead of PUT for resource creation * use PUT instead of POST for resource special actions
2019-04-08 06:54:45 +00:00
apirouter.Handle("/projectgroups/{projectgroupref}/secrets", authForcedHandler(createSecretHandler)).Methods("POST")
apirouter.Handle("/projects/{projectref}/secrets", authForcedHandler(createSecretHandler)).Methods("POST")
gateway: implement secret update
2019-07-08 08:32:45 +00:00
apirouter.Handle("/projectgroups/{projectgroupref}/secrets/{secretname}", authForcedHandler(updateSecretHandler)).Methods("PUT")
apirouter.Handle("/projects/{projectref}/secrets/{secretname}", authForcedHandler(updateSecretHandler)).Methods("PUT")
initial secret and variables impl
2019-03-14 13:36:18 +00:00
apirouter.Handle("/projectgroups/{projectgroupref}/secrets/{secretname}", authForcedHandler(deleteSecretHandler)).Methods("DELETE")
apirouter.Handle("/projects/{projectref}/secrets/{secretname}", authForcedHandler(deleteSecretHandler)).Methods("DELETE")
apirouter.Handle("/projectgroups/{projectgroupref}/variables", authForcedHandler(variableHandler)).Methods("GET")
apirouter.Handle("/projects/{projectref}/variables", authForcedHandler(variableHandler)).Methods("GET")
*: fix rest methods * use POST instead of PUT for resource creation * use PUT instead of POST for resource special actions
2019-04-08 06:54:45 +00:00
apirouter.Handle("/projectgroups/{projectgroupref}/variables", authForcedHandler(createVariableHandler)).Methods("POST")
apirouter.Handle("/projects/{projectref}/variables", authForcedHandler(createVariableHandler)).Methods("POST")
gateway: implement variable update
2019-07-06 13:25:45 +00:00
apirouter.Handle("/projectgroups/{projectgroupref}/variables/{variablename}", authForcedHandler(updateVariableHandler)).Methods("PUT")
apirouter.Handle("/projects/{projectref}/variables/{variablename}", authForcedHandler(updateVariableHandler)).Methods("PUT")
initial secret and variables impl
2019-03-14 13:36:18 +00:00
apirouter.Handle("/projectgroups/{projectgroupref}/variables/{variablename}", authForcedHandler(deleteVariableHandler)).Methods("DELETE")
apirouter.Handle("/projects/{projectref}/variables/{variablename}", authForcedHandler(deleteVariableHandler)).Methods("DELETE")
gateway: initial implementation
2019-02-21 16:58:25 +00:00
apirouter.Handle("/user", authForcedHandler(currentUserHandler)).Methods("GET")
* api: accept both ids or names in the same endpoint Simplify api to accept both ids or names in the same endpoint
2019-05-03 09:07:53 +00:00
apirouter.Handle("/users/{userref}", authForcedHandler(userHandler)).Methods("GET")
gateway: initial implementation
2019-02-21 16:58:25 +00:00
apirouter.Handle("/users", authForcedHandler(usersHandler)).Methods("GET")
*: fix rest methods * use POST instead of PUT for resource creation * use PUT instead of POST for resource special actions
2019-04-08 06:54:45 +00:00
apirouter.Handle("/users", authForcedHandler(createUserHandler)).Methods("POST")
* api: accept both ids or names in the same endpoint Simplify api to accept both ids or names in the same endpoint
2019-05-03 09:07:53 +00:00
apirouter.Handle("/users/{userref}", authForcedHandler(deleteUserHandler)).Methods("DELETE")
gateway: add UserCreateRun api and related action add an api to execute a user direct run. This method will replace the current custom webhook way to create a direct run.
2019-06-11 13:09:41 +00:00
apirouter.Handle("/user/createrun", authForcedHandler(userCreateRunHandler)).Methods("POST")
gateway: add api to get authenticated user organizations gateway: add api to get authenticated user organizations gateway: add api to get authenticated user organizations
2022-01-26 15:52:10 +00:00
apirouter.Handle("/user/orgs", authForcedHandler(userOrgsHandler)).Methods("GET")
gateway: initial implementation
2019-02-21 16:58:25 +00:00
* api: accept both ids or names in the same endpoint Simplify api to accept both ids or names in the same endpoint
2019-05-03 09:07:53 +00:00
apirouter.Handle("/users/{userref}/linkedaccounts", authForcedHandler(createUserLAHandler)).Methods("POST")
apirouter.Handle("/users/{userref}/linkedaccounts/{laid}", authForcedHandler(deleteUserLAHandler)).Methods("DELETE")
apirouter.Handle("/users/{userref}/tokens", authForcedHandler(createUserTokenHandler)).Methods("POST")
apirouter.Handle("/users/{userref}/tokens/{tokenname}", authForcedHandler(deleteUserTokenHandler)).Methods("DELETE")
gateway: initial implementation
2019-02-21 16:58:25 +00:00
* api: accept both ids or names in the same endpoint Simplify api to accept both ids or names in the same endpoint
2019-05-03 09:07:53 +00:00
apirouter.Handle("/remotesources/{remotesourceref}", authForcedHandler(remoteSourceHandler)).Methods("GET")
*: fix rest methods * use POST instead of PUT for resource creation * use PUT instead of POST for resource special actions
2019-04-08 06:54:45 +00:00
apirouter.Handle("/remotesources", authForcedHandler(createRemoteSourceHandler)).Methods("POST")
*: implement remote source update
2019-05-23 08:29:03 +00:00
apirouter.Handle("/remotesources/{remotesourceref}", authForcedHandler(updateRemoteSourceHandler)).Methods("PUT")
gateway: initial implementation
2019-02-21 16:58:25 +00:00
apirouter.Handle("/remotesources", authOptionalHandler(remoteSourcesHandler)).Methods("GET")
gateway: add delete remote source handler
2019-05-09 22:03:03 +00:00
apirouter.Handle("/remotesources/{remotesourceref}", authForcedHandler(deleteRemoteSourceHandler)).Methods("DELETE")
gateway: initial implementation
2019-02-21 16:58:25 +00:00
* api: accept both ids or names in the same endpoint Simplify api to accept both ids or names in the same endpoint
2019-05-03 09:07:53 +00:00
apirouter.Handle("/orgs/{orgref}", authForcedHandler(orgHandler)).Methods("GET")
*: add organizations
2019-02-28 14:52:35 +00:00
apirouter.Handle("/orgs", authForcedHandler(orgsHandler)).Methods("GET")
*: fix rest methods * use POST instead of PUT for resource creation * use PUT instead of POST for resource special actions
2019-04-08 06:54:45 +00:00
apirouter.Handle("/orgs", authForcedHandler(createOrgHandler)).Methods("POST")
* api: accept both ids or names in the same endpoint Simplify api to accept both ids or names in the same endpoint
2019-05-03 09:07:53 +00:00
apirouter.Handle("/orgs/{orgref}", authForcedHandler(deleteOrgHandler)).Methods("DELETE")
gateway: add get org members api/action
2019-05-14 10:58:29 +00:00
apirouter.Handle("/orgs/{orgref}/members", authForcedHandler(orgMembersHandler)).Methods("GET")
*: implement add/update org member
2019-05-09 14:47:22 +00:00
apirouter.Handle("/orgs/{orgref}/members/{userref}", authForcedHandler(addOrgMemberHandler)).Methods("PUT")
*: rename deleteOrgMember to removeOrgMember
2019-05-14 09:20:09 +00:00
apirouter.Handle("/orgs/{orgref}/members/{userref}", authForcedHandler(removeOrgMemberHandler)).Methods("DELETE")
*: add organizations
2019-02-28 14:52:35 +00:00
gateway: show run/tasks/steps if the project is public If the project is public don't require the user to be logged in to show the run/tasks/logs
2019-07-01 14:40:02 +00:00
apirouter.Handle("/runs/{runid}", authOptionalHandler(runHandler)).Methods("GET")
gateway: fix runs url to plural
2019-04-08 14:11:19 +00:00
apirouter.Handle("/runs/{runid}/actions", authForcedHandler(runActionsHandler)).Methods("PUT")
gateway: show run/tasks/steps if the project is public If the project is public don't require the user to be logged in to show the run/tasks/logs
2019-07-01 14:40:02 +00:00
apirouter.Handle("/runs/{runid}/tasks/{taskid}", authOptionalHandler(runtaskHandler)).Methods("GET")
*: rework run approval and annotations * runservice: use generic task annotations instead of approval annotations * runservice: add method to set task annotations * gateway: when an user call the run task approval action, it will set in the task annotations the approval users ids. The task won't be approved. * scheduler: when the number of approvers meets the required minimum number (currently 1) call the runservice to approve the task In this way we could easily implement some approval features like requiring a minimum number of approvers (saved in the task annotations) before marking the run as approved in the runservice.
2019-05-06 13:19:29 +00:00
apirouter.Handle("/runs/{runid}/tasks/{taskid}/actions", authForcedHandler(runTaskActionsHandler)).Methods("PUT")
gateway: initial implementation
2019-02-21 16:58:25 +00:00
apirouter.Handle("/runs", authForcedHandler(runsHandler)).Methods("GET")
gateway: add badges endpoint Currently we generate badges only for projects branches. In future this could be extended to also generate badges for tags and PRs
2019-05-10 09:08:24 +00:00
apirouter.Handle("/user/remoterepos/{remotesourceref}", authForcedHandler(userRemoteReposHandler)).Methods("GET")
apirouter.Handle("/badges/{projectref}", badgeHandler).Methods("GET")
cmd: add version command
2019-10-04 09:32:07 +00:00
apirouter.Handle("/version", versionHandler).Methods("GET")
gateway: move authentication apis to /api/v1alpha/auth Move the various authentication apis to /api/v1alpha/auth since they should be versioned like other apis.
2020-02-19 09:03:13 +00:00
apirouter.Handle("/auth/login", loginUserHandler).Methods("POST")
apirouter.Handle("/auth/authorize", authorizeHandler).Methods("POST")
apirouter.Handle("/auth/register", registerHandler).Methods("POST")
apirouter.Handle("/auth/oauth2/callback", oauth2callbackHandler).Methods("GET")
* api: accept both ids or names in the same endpoint Simplify api to accept both ids or names in the same endpoint
2019-05-03 09:07:53 +00:00
// TODO(sgotti) add auth to these requests
gateway: don't use maxBytesHandler in gitserver proxy handler a git object could much be greater than 1MiB.
2019-06-08 14:26:22 +00:00
reposRouter.Handle("/repos/{rest:.*}", reposHandler).Methods("GET", "POST")
gateway: add user remote repos API
2019-05-02 22:11:11 +00:00
gateway: initial implementation
2019-02-21 16:58:25 +00:00
router.Handle("/webhooks", webhooksHandler).Methods("POST")
router.PathPrefix("/").HandlerFunc(handlers.NewWebBundleHandlerFunc(g.c.APIExposedURL))
gateway: fix linter errors Fix errors reported by default golangci-lint linters
2019-07-02 13:35:14 +00:00
maxBytesHandler := handlers.NewMaxBytesHandler(router, maxRequestSize)
gateway: limit requests to a predefined max size
2019-04-03 14:59:17 +00:00
gateway: initial implementation
2019-02-21 16:58:25 +00:00
mainrouter := mux.NewRouter()
gateway: don't use maxBytesHandler in gitserver proxy handler a git object could much be greater than 1MiB.
2019-06-08 14:26:22 +00:00
mainrouter.PathPrefix("/repos/").Handler(corsHandler(reposRouter))
gateway: limit requests to a predefined max size
2019-04-03 14:59:17 +00:00
mainrouter.PathPrefix("/").Handler(corsHandler(maxBytesHandler))
gateway: initial implementation
2019-02-21 16:58:25 +00:00
var tlsConfig *tls.Config
if g.c.Web.TLS {
var err error
tlsConfig, err = util.NewTLSConfig(g.c.Web.TLSCertFile, g.c.Web.TLSKeyFile, "", false)
if err != nil {
*: use zerolog for logging Replace zap with zerolog. zerolog has a cleaner interface and can be easily configured with custom error chain printing using a new error handling library that will be implemented in another PR.
2022-02-21 17:07:58 +00:00
g.log.Err(err).Send()
*: use new errors handling library Implement a new error handling library based on pkg/errors. It provides stack saving on wrapping and exports some function to add stack saving also to external errors. It also implements custom zerolog error formatting without adding too much verbosity by just printing the chain error file:line without a full stack trace of every error. * Add a --detailed-errors options to print error with they full chain * Wrap all error returns. Use errors.WithStack to wrap without adding a new messsage and error.Wrap[f] to add a message. * Add golangci-lint wrapcheck to check that external packages errors are wrapped. This won't check that internal packages error are wrapped. But we want also to ensure this case so we'll have to find something else to check also these.
2022-02-22 14:01:29 +00:00
return errors.WithStack(err)
gateway: initial implementation
2019-02-21 16:58:25 +00:00
}
}
httpServer := http.Server{
Addr: g.c.Web.ListenAddress,
Handler: mainrouter,
TLSConfig: tlsConfig,
}
lerrCh := make(chan error)
go func() {
*: call ListenAndServeTLS when tls is enabled in config
2021-03-19 09:52:32 +00:00
if !g.c.Web.TLS {
lerrCh <- httpServer.ListenAndServe()
} else {
lerrCh <- httpServer.ListenAndServeTLS("", "")
}
gateway: initial implementation
2019-02-21 16:58:25 +00:00
}()
select {
case <-ctx.Done():
*: use zerolog for logging Replace zap with zerolog. zerolog has a cleaner interface and can be easily configured with custom error chain printing using a new error handling library that will be implemented in another PR.
2022-02-21 17:07:58 +00:00
log.Info().Msgf("configstore exiting")
gateway: initial implementation
2019-02-21 16:58:25 +00:00
httpServer.Close()
case err := <-lerrCh:
service/*: log error only if nil
2019-07-04 13:50:37 +00:00
if err != nil {
*: use zerolog for logging Replace zap with zerolog. zerolog has a cleaner interface and can be easily configured with custom error chain printing using a new error handling library that will be implemented in another PR.
2022-02-21 17:07:58 +00:00
log.Err(err).Msgf("http server listen error")
*: use new errors handling library Implement a new error handling library based on pkg/errors. It provides stack saving on wrapping and exports some function to add stack saving also to external errors. It also implements custom zerolog error formatting without adding too much verbosity by just printing the chain error file:line without a full stack trace of every error. * Add a --detailed-errors options to print error with they full chain * Wrap all error returns. Use errors.WithStack to wrap without adding a new messsage and error.Wrap[f] to add a message. * Add golangci-lint wrapcheck to check that external packages errors are wrapped. This won't check that internal packages error are wrapped. But we want also to ensure this case so we'll have to find something else to check also these.
2022-02-22 14:01:29 +00:00
return errors.WithStack(err)
service/*: log error only if nil
2019-07-04 13:50:37 +00:00
}
gateway: initial implementation
2019-02-21 16:58:25 +00:00
}
service/*: log error only if nil
2019-07-04 13:50:37 +00:00
return nil
gateway: initial implementation
2019-02-21 16:58:25 +00:00
}