// The SetupSuite method will run before the tests in the suite are run.
// It sets up a database connection for all the tests in this suite without polluting global space.
func (s *workItemLinkSuite) SetupSuite() {
var err error
if err = configuration.Setup(""); err != nil {
panic(fmt.Errorf("Failed to setup the configuration: %s", err.Error()))
}
s.db, err = gorm.Open("postgres", configuration.GetPostgresConfigString())
if err != nil {
panic("Failed to connect database: " + err.Error())
}
// Make sure the database is populated with the correct types (e.g. bug etc.)
if err := models.Transactional(DB, func(tx *gorm.DB) error {
return migration.PopulateCommonTypes(context.Background(), tx, workitem.NewWorkItemTypeRepository(tx))
}); err != nil {
panic(err.Error())
}
require.Nil(s.T(), err)
priv, err := almtoken.ParsePrivateKey([]byte(almtoken.RSAPrivateKey))
require.Nil(s.T(), err)
svc := goa.New("TestWorkItemLinkType-Service")
require.NotNil(s.T(), svc)
s.workItemLinkTypeCtrl = NewWorkItemLinkTypeController(svc, gormapplication.NewGormDB(DB))
require.NotNil(s.T(), s.workItemLinkTypeCtrl)
svc = goa.New("TestWorkItemLinkCategory-Service")
require.NotNil(s.T(), svc)
s.workItemLinkCategoryCtrl = NewWorkItemLinkCategoryController(svc, gormapplication.NewGormDB(DB))
require.NotNil(s.T(), s.workItemLinkCategoryCtrl)
svc = goa.New("TestWorkItemLink-Service")
require.NotNil(s.T(), svc)
s.workItemLinkCtrl = NewWorkItemLinkController(svc, gormapplication.NewGormDB(DB))
require.NotNil(s.T(), s.workItemLinkCtrl)
svc = goa.New("TestWorkItemRelationshipsLinks-Service")
require.NotNil(s.T(), svc)
s.workItemRelsLinksCtrl = NewWorkItemRelationshipsLinksController(svc, gormapplication.NewGormDB(DB))
require.NotNil(s.T(), s.workItemRelsLinksCtrl)
s.workItemSvc = testsupport.ServiceAsUser("TestWorkItem-Service", almtoken.NewManagerWithPrivateKey(priv), testsupport.TestIdentity)
require.NotNil(s.T(), s.workItemSvc)
s.workItemCtrl = NewWorkitemController(svc, gormapplication.NewGormDB(DB))
require.NotNil(s.T(), s.workItemCtrl)
}
func createControler(t *testing.T) (*UsersController, application.DB) {
svc := goa.New("test")
app := gormapplication.NewGormDB(DB)
controller := NewUsersController(svc, app)
assert.NotNil(t, controller)
return controller, app
}
func TestKeycloakAuthorizationRedirect(t *testing.T) {
resource.Require(t, resource.UnitTest)
rw := httptest.NewRecorder()
u := &url.URL{
Path: fmt.Sprintf("/api/login/authorize"),
}
req, err := http.NewRequest("GET", u.String(), nil)
if err != nil {
panic("invalid test " + err.Error()) // bug
}
// The user clicks login while on ALM UI.
// Therefore the referer would be an ALM URL.
refererUrl := "https://alm-url.example.org/path"
req.Header.Add("referer", refererUrl)
prms := url.Values{}
ctx := context.Background()
goaCtx := goa.NewContext(goa.WithAction(ctx, "LoginTest"), rw, req, prms)
authorizeCtx, err := app.NewAuthorizeLoginContext(goaCtx, goa.New("LoginService"))
if err != nil {
panic("invalid test data " + err.Error()) // bug
}
err = loginService.Perform(authorizeCtx)
assert.Equal(t, 307, rw.Code)
assert.Contains(t, rw.Header().Get("Location"), configuration.GetKeycloakEndpointAuth())
}
func TestNewWorkitemController(t *testing.T) {
t.Parallel()
resource.Require(t, resource.UnitTest)
assert.Panics(t, func() {
NewWorkitemController(goa.New("Test service"), nil)
})
}
func main() {
// Configure logger
logger := log15.New()
logger.SetHandler(log15.StreamHandler(os.Stderr, log15.LogfmtFormat()))
// Create service
service := goa.New("goa Swagger service")
service.WithLogger(goalog15.New(logger))
// Setup middleware
service.Use(middleware.RequestID())
service.Use(middleware.LogRequest(true))
service.Use(middleware.ErrorHandler(service, true))
service.Use(middleware.Recover())
// Mount "spec" controller
c := NewSpecController(service)
app.MountSpecController(service, c)
// Mount "ae" controller
h := NewAeController(service)
app.MountAeController(service, h)
// Start service, listen on port 8080
if err := service.ListenAndServe(":8080"); err != nil {
service.LogError(err.Error())
}
logger.Info("Exiting...")
}
// The SetupSuite method will run before the tests in the suite are run.
// It sets up a database connection for all the tests in this suite without polluting global space.
func (s *workItemLinkTypeSuite) SetupSuite() {
var err error
if err = configuration.Setup(""); err != nil {
panic(fmt.Errorf("Failed to setup the configuration: %s", err.Error()))
}
s.db, err = gorm.Open("postgres", configuration.GetPostgresConfigString())
if err != nil {
panic("Failed to connect database: " + err.Error())
}
// Make sure the database is populated with the correct types (e.g. bug etc.)
if err := models.Transactional(DB, func(tx *gorm.DB) error {
return migration.PopulateCommonTypes(context.Background(), tx, workitem.NewWorkItemTypeRepository(tx))
}); err != nil {
panic(err.Error())
}
svc := goa.New("workItemLinkTypeSuite-Service")
require.NotNil(s.T(), svc)
s.linkTypeCtrl = NewWorkItemLinkTypeController(svc, gormapplication.NewGormDB(DB))
require.NotNil(s.T(), s.linkTypeCtrl)
s.linkCatCtrl = NewWorkItemLinkCategoryController(svc, gormapplication.NewGormDB(DB))
require.NotNil(s.T(), s.linkCatCtrl)
// s.typeCtrl = NewWorkitemtypeController(svc, gormapplication.NewGormDB(DB))
// require.NotNil(s.T(), s.typeCtrl)
}
// Helper that sets up a "working" service
func newService(logger goa.LogAdapter) *goa.Service {
service := goa.New("test")
service.Encoder.Register(goa.NewJSONEncoder, "*/*")
service.Decoder.Register(goa.NewJSONDecoder, "*/*")
service.WithLogger(logger)
return service
}
func TestSpacesSearchOK(t *testing.T) {
resource.Require(t, resource.Database)
tester := TestSearchSpaces{}
tester.db = gormapplication.NewGormDB(DB)
tester.clean = cleaner.DeleteCreatedEntities(DB)
idents, err := tester.createTestData()
if err != nil {
t.Fatal(err)
}
defer tester.cleanTestData()
tests := []okScenario{
{"With uppercase fullname query", args{offset("0"), limit(10), "TEST_AB"}, expects{totalCount(1)}},
{"With lowercase fullname query", args{offset("0"), limit(10), "TEST_AB"}, expects{totalCount(1)}},
{"With uppercase description query", args{offset("0"), limit(10), "DESCRIPTION FOR TEST_AB"}, expects{totalCount(1)}},
{"With lowercase description query", args{offset("0"), limit(10), "description for test_ab"}, expects{totalCount(1)}},
{"with special chars", args{offset("0"), limit(10), "&:\n!#%?*"}, expects{totalCount(0)}},
{"with * to list all", args{offset("0"), limit(10), "*"}, expects{totalCountAtLeast(len(idents))}},
{"with multi page", args{offset("0"), limit(10), "TEST"}, expects{hasLinks("Next")}},
{"with last page", args{offset(strconv.Itoa(len(idents) - 1)), limit(10), "TEST"}, expects{hasNoLinks("Next"), hasLinks("Prev")}},
{"with different values", args{offset("0"), limit(10), "TEST"}, expects{differentValues()}},
}
service := goa.New("TestSpacesSearch-Service")
controller := NewSearchController(service, tester.db)
for _, tt := range tests {
_, result := test.SpacesSearchOK(t, context.Background(), service, controller, tt.args.pageLimit, tt.args.pageOffset, tt.args.q)
for _, expect := range tt.expects {
expect(t, tt, result)
}
}
}
func TestInvalidState(t *testing.T) {
resource.Require(t, resource.UnitTest)
// Setup request context
rw := httptest.NewRecorder()
u := &url.URL{
Path: fmt.Sprintf("/api/login/authorize"),
}
req, err := http.NewRequest("GET", u.String(), nil)
if err != nil {
panic("invalid test " + err.Error()) // bug
}
// The OAuth 'state' is sent as a query parameter by calling /api/login/authorize?code=_SOME_CODE_&state=_SOME_STATE_
// The request originates from Keycloak after a valid authorization by the end user.
// This is not where the redirection should happen on failure.
refererKeyclaokUrl := "https://keycloak-url.example.org/path-of-login"
req.Header.Add("referer", refererKeyclaokUrl)
prms := url.Values{
"state": {},
"code": {"doesnt_matter_what_is_here"},
}
ctx := context.Background()
goaCtx := goa.NewContext(goa.WithAction(ctx, "LoginTest"), rw, req, prms)
authorizeCtx, err := app.NewAuthorizeLoginContext(goaCtx, goa.New("LoginService"))
if err != nil {
panic("invalid test data " + err.Error()) // bug
}
err = loginService.Perform(authorizeCtx)
assert.Equal(t, 401, rw.Code)
}
func createControler(t *testing.T) (*goa.Service, *LoginController) {
svc := goa.New("test")
loginService := newTestKeycloakOAuthProvider()
controller := NewLoginController(svc, loginService, loginService.TokenManager)
// assert.NotNil(t, controller)
return svc, controller
}
// This test case will check authorized access to Create/Update/Delete APIs
func (s *workItemLinkSuite) TestUnauthorizeWorkItemLinkCUD() {
UnauthorizeCreateUpdateDeleteTest(s.T(), getWorkItemLinkTestData, func() *goa.Service {
return goa.New("TestUnauthorizedCreateWorkItemLink-Service")
}, func(service *goa.Service) error {
controller := NewWorkItemLinkController(service, gormapplication.NewGormDB(DB))
app.MountWorkItemLinkController(service, controller)
return nil
})
}
// This test case will check authorized access to Create/Update/Delete APIs
func TestUnauthorizeTrackerCUD(t *testing.T) {
UnauthorizeCreateUpdateDeleteTest(t, getTrackerTestData, func() *goa.Service {
return goa.New("TestUnauthorizedTracker-Service")
}, func(service *goa.Service) error {
controller := NewTrackerController(service, gormapplication.NewGormDB(DB), RwiScheduler)
app.MountTrackerController(service, controller)
return nil
})
}
// This test case will check authorized access to Create/Update/Delete APIs
func TestUnauthorizeWorkItemTypeCreate(t *testing.T) {
UnauthorizeCreateUpdateDeleteTest(t, getWorkItemTypeTestData, func() *goa.Service {
return goa.New("TestUnauthorizedCreateWIT-Service")
}, func(service *goa.Service) error {
controller := NewWorkitemtypeController(service, gormapplication.NewGormDB(DB))
app.MountWorkitemtypeController(service, controller)
return nil
})
}
// The SetupTest method will be run before every test in the suite.
func (s *workItemTypeSuite) SetupTest() {
svc := goa.New("workItemTypeSuite-Service")
assert.NotNil(s.T(), svc)
s.typeCtrl = NewWorkitemtypeController(svc, gormapplication.NewGormDB(s.DB))
assert.NotNil(s.T(), s.typeCtrl)
s.linkTypeCtrl = NewWorkItemLinkTypeController(svc, gormapplication.NewGormDB(DB))
require.NotNil(s.T(), s.linkTypeCtrl)
s.linkCatCtrl = NewWorkItemLinkCategoryController(svc, gormapplication.NewGormDB(DB))
require.NotNil(s.T(), s.linkCatCtrl)
}
func (s *workItemLinkSuite) TestUnauthorizeWorkItemRelationshipsLinksCUD() {
wiID := strconv.FormatUint(s.bug1ID, 10)
UnauthorizeCreateUpdateDeleteTest(s.T(), getWorkItemRelationshipLinksTestData(s.T(), wiID), func() *goa.Service {
return goa.New("TestUnauthorizedCreateWorkItemRelationshipsLinks-Service")
}, func(service *goa.Service) error {
controller := NewWorkItemRelationshipsLinksController(service, gormapplication.NewGormDB(DB))
app.MountWorkItemRelationshipsLinksController(service, controller)
return nil
})
}
func TestListIdentities(t *testing.T) {
resource.Require(t, resource.Database)
defer cleaner.DeleteCreatedEntities(DB)()
service := goa.New("Test-Identities")
app := gormapplication.NewGormDB(DB)
identityController := NewIdentityController(service, app)
_, ic := test.ListIdentityOK(t, service.Context, service, identityController)
require.NotNil(t, ic)
numberOfCurrentIdent := len(ic.Data)
ctx := context.Background()
identityRepo := app.Identities()
identity := account.Identity{
Username: "******",
Provider: "test-idp",
ID: uuid.NewV4(),
}
err := identityRepo.Create(ctx, &identity)
if err != nil {
t.Fatal(err)
}
_, ic2 := test.ListIdentityOK(t, service.Context, service, identityController)
require.NotNil(t, ic2)
assert.Equal(t, numberOfCurrentIdent+1, len(ic2.Data))
assertIdent(t, identity, findIdent(identity.ID, ic2.Data))
identity2 := account.Identity{
Username: "******",
Provider: "test-idp",
ID: uuid.NewV4(),
}
err = identityRepo.Create(ctx, &identity2)
if err != nil {
t.Fatal(err)
}
_, ic3 := test.ListIdentityOK(t, service.Context, service, identityController)
require.NotNil(t, ic3)
assert.Equal(t, numberOfCurrentIdent+2, len(ic3.Data))
assertIdent(t, identity, findIdent(identity.ID, ic3.Data))
assertIdent(t, identity2, findIdent(identity2.ID, ic3.Data))
}
// Service provide a general goa.Service used for testing purposes
func Service(logBuf *bytes.Buffer, respSetter ResponseSetterFunc) *goa.Service {
s := goa.New("test")
logger := log.New(logBuf, "", log.Ltime)
s.WithLogger(goa.NewLogger(logger))
s.Use(middleware.LogRequest(true))
s.Use(middleware.LogResponse())
newEncoder := func(io.Writer) goa.Encoder {
return respSetter
}
s.Decoder.Register(goa.NewJSONDecoder, "*/*")
s.Encoder.Register(newEncoder, "*/*")
return s
}
func main() {
// Create service
service := goa.New("cellar")
// Mount middleware
service.Use(middleware.RequestID())
service.Use(middleware.LogRequest(true))
service.Use(middleware.ErrorHandler(service, true))
service.Use(middleware.Recover())
// Mount "bottle" controller
c := NewBottleController(service)
app.MountBottleController(service, c)
// Start service
if err := service.ListenAndServe(":8080"); err != nil {
service.LogError("startup", "err", err)
}
}
func main() {
// Create service
service := goa.New("API")
logger := log15.New()
goa.Log = goalog15.New(logger)
// Setup middleware
service.Use(middleware.RequestID())
service.Use(middleware.LogRequest(true))
service.Use(middleware.Recover())
cspec, err := cors.New(func() {
cors.Origin("*", func() {
cors.Resource("/*", func() {
cors.Headers("Accept", "Content-Type", "Origin", "Authorization")
cors.Methods("GET", "POST", "PUT", "DELETE", "OPTIONS")
cors.MaxAge(600)
cors.Credentials(true)
cors.Vary("Http-Origin")
})
})
})
if err != nil {
panic(err)
}
// mount the cors controller
service.Use(cors.Middleware(cspec))
cors.MountPreflightController(service, cspec)
// Mount "authentication" controller
c := NewAuthenticationController(service)
app.MountAuthenticationController(service, c)
// Mount "operands" controller
c2 := NewOperandsController(service)
app.MountOperandsController(service, c2)
// Mount "ui" controller
ui.MountController(service)
// Mount Swagger spec provider controller
swagger.MountController(service)
// Start service, listen on port 8080
service.ListenAndServe(":8080")
fmt.Println("a ...interface{}")
}
func TestCreateTrackerQueryREST(t *testing.T) {
resource.Require(t, resource.Database)
privatekey, err := jwt.ParseRSAPrivateKeyFromPEM([]byte(almtoken.RSAPrivateKey))
if err != nil {
t.Fatal("Could not parse Key ", err)
}
service := goa.New("API")
controller := NewTrackerController(service, gormapplication.NewGormDB(DB), RwiScheduler)
payload := app.CreateTrackerAlternatePayload{
URL: "http://api.github.com",
Type: "github",
}
_, tracker := test.CreateTrackerCreated(t, nil, nil, controller, &payload)
jwtMiddleware := goajwt.New(&privatekey.PublicKey, nil, app.NewJWTSecurity())
app.UseJWTMiddleware(service, jwtMiddleware)
controller2 := NewTrackerqueryController(service, gormapplication.NewGormDB(DB), RwiScheduler)
app.MountTrackerqueryController(service, controller2)
server := httptest.NewServer(service.Mux)
tqPayload := fmt.Sprintf(`{"query": "abcdefgh", "schedule": "1 1 * * * *", "trackerID": "%s"}`, tracker.ID)
trackerQueryCreateURL := "/api/trackerqueries"
req, _ := http.NewRequest("POST", server.URL+trackerQueryCreateURL, strings.NewReader(tqPayload))
jwtToken := getValidAuthHeader(t, privatekey)
req.Header.Set("Authorization", jwtToken)
client := http.Client{}
res, err := client.Do(req)
if err != nil {
t.Fatalf("Server error %s", err)
}
if res.StatusCode != http.StatusCreated {
t.Fatalf("Expected a 201 Created response, got %d", res.StatusCode)
}
server.Close()
}
func (rest *TestSpaceAreaREST) UnSecuredController() (*goa.Service, *SpaceAreasController) {
svc := goa.New("Area-Service")
return svc, NewSpaceAreasController(svc, rest.db)
}
"strings"
"github.com/goadesign/goa"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"golang.org/x/net/context"
"gopkg.in/inconshreveable/log15.v2"
)
var _ = Describe("Context", func() {
var logger log15.Logger
var ctx *goa.Context
BeforeEach(func() {
gctx := context.Background()
ctx = goa.NewContext(gctx, goa.New("test"), nil, nil, nil)
ctx.Logger = logger
})
Describe("SetValue", func() {
key := "answer"
val := 42
BeforeEach(func() {
ctx.SetValue(key, val)
})
It("sets the value in the context.Context", func() {
v := ctx.Value(key)
Ω(v).Should(Equal(val))
})
func (rest *TestSpaceIterationREST) UnSecuredController() (*goa.Service, *SpaceIterationsController) {
svc := goa.New("Iteration-Service")
return svc, NewSpaceIterationsController(svc, rest.db)
}
"io/ioutil"
"net/http"
"net/url"
"github.com/goadesign/goa"
"github.com/goadesign/middleware"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("Application", func() {
const appName = "foo"
var s goa.Service
BeforeEach(func() {
s = goa.New(appName)
s.SetDecoder(goa.JSONDecoderFactory(), true, "*/*")
s.SetEncoder(goa.JSONEncoderFactory(), true, "*/*")
})
Describe("New", func() {
It("creates an application", func() {
Ω(s).ShouldNot(BeNil())
})
It("initializes the application fields", func() {
Ω(s.Name()).Should(Equal(appName))
Ω(s).Should(BeAssignableToTypeOf(&goa.Application{}))
app, _ := s.(*goa.Application)
Ω(app.Name()).Should(Equal(appName))
Ω(app.Logger).ShouldNot(BeNil())
goaMiddlewareFunc = func(h goa.Handler) goa.Handler { return h }
input = goaMiddlewareFunc
})
It("returns the middleware", func() {
Ω(fmt.Sprintf("%#v", middleware)).Should(Equal(fmt.Sprintf("%#v", goa.Middleware(goaMiddlewareFunc))))
Ω(mErr).ShouldNot(HaveOccurred())
})
})
Context("with a context", func() {
var service goa.Service
var ctx *goa.Context
BeforeEach(func() {
service = goa.New("test")
req, err := http.NewRequest("GET", "/goo", nil)
Ω(err).ShouldNot(HaveOccurred())
rw := new(testResponseWriter)
params := url.Values{"foo": []string{"bar"}}
ctx = goa.NewContext(nil, service, req, rw, params)
Ω(ctx.ResponseStatus()).Should(Equal(0))
})
Context("using a goa handler", func() {
BeforeEach(func() {
var goaHandler goa.Handler = func(ctx *goa.Context) error {
ctx.Respond(200, "ok")
return nil
}
input = goaHandler
// ServiceAsUser creates a new service and fill the context with input Identity
func ServiceAsUser(serviceName string, tm token.Manager, u account.Identity) *goa.Service {
svc := goa.New(serviceName)
svc.Context = WithIdentity(svc.Context, u)
svc.Context = login.ContextWithTokenManager(svc.Context, tm)
return svc
}
})
It("returns the middleware", func() {
Ω(fmt.Sprintf("%#v", middleware)).Should(Equal(fmt.Sprintf("%#v", goa.Middleware(goaMiddlewareFunc))))
Ω(mErr).ShouldNot(HaveOccurred())
})
})
Context("with a context", func() {
var service *goa.Service
var req *http.Request
var rw http.ResponseWriter
var ctx context.Context
BeforeEach(func() {
service = goa.New("test")
var err error
req, err = http.NewRequest("GET", "/goo", nil)
Ω(err).ShouldNot(HaveOccurred())
rw = new(TestResponseWriter)
ctx = goa.NewContext(nil, service, rw, req, nil)
Ω(goa.Response(ctx).Status).Should(Equal(0))
})
Context("using a goa handler", func() {
BeforeEach(func() {
var goaHandler goa.Handler = func(ctx context.Context, rw http.ResponseWriter, req *http.Request) error {
goa.Response(ctx).Send(ctx, 200, "ok")
return nil
}
input = goaHandler
var ctx *goa.Context
var req *http.Request
var rw *TestResponseWriter
params := url.Values{"param": []string{"value"}}
payload := map[string]interface{}{"payload": 42}
BeforeEach(func() {
var err error
req, err = http.NewRequest("POST", "/foo/bar", strings.NewReader(`{"payload":42}`))
req.Header.Set("Accept-Encoding", "gzip")
Ω(err).ShouldNot(HaveOccurred())
rw = &TestResponseWriter{
ParentHeader: http.Header{},
}
ctx = goa.NewContext(nil, goa.New("test"), req, rw, params)
ctx.SetPayload(payload)
handler = new(testHandler)
logger := log15.New("test", "test")
logger.SetHandler(handler)
ctx.Logger = logger
})
It("encodes response using gzip", func() {
h := func(ctx *goa.Context) error {
ctx.Write([]byte("gzip me!"))
ctx.WriteHeader(http.StatusOK)
return nil
}
t := gzm.Middleware(gzip.BestCompression)(h)
err := t(ctx)
return errors.New("failed")
}
handler := func(ctx *goa.Context) error {
ctx.Respond(200, "ok")
return nil
}
BeforeEach(func() {
req, err = http.NewRequest("GET", "/goo", nil)
Ω(err).ShouldNot(HaveOccurred())
rw = new(TestResponseWriter)
rw.ParentHeader = make(http.Header)
s := goa.New("test")
s.SetEncoder(goa.JSONEncoderFactory(), true, "*/*")
ctx = goa.NewContext(nil, s, req, rw, nil)
spec = &httpauth.Specification{
ValidationProvider: validFunc,
}
})
It("handles valid credentials", func() {
req.Header.Add("Authorization", authString)
auth := httpauth.BasicMiddleware(spec)(handler)
Ω(auth(ctx)).ShouldNot(HaveOccurred())
Ω(ctx.ResponseStatus()).Should(Equal(http.StatusOK))
Ω(rw.Body).Should(Equal([]byte("\"ok\"\n")))
func main() {
// --------------------------------------------------------------------
// Parse flags
// --------------------------------------------------------------------
var configFilePath string
var printConfig bool
var migrateDB bool
var scheduler *remoteworkitem.Scheduler
flag.StringVar(&configFilePath, "config", "", "Path to the config file to read")
flag.BoolVar(&printConfig, "printConfig", false, "Prints the config (including merged environment variables) and exits")
flag.BoolVar(&migrateDB, "migrateDatabase", false, "Migrates the database to the newest version and exits.")
flag.Parse()
// Override default -config switch with environment variable only if -config switch was
// not explicitly given via the command line.
configSwitchIsSet := false
flag.Visit(func(f *flag.Flag) {
if f.Name == "config" {
configSwitchIsSet = true
}
})
if !configSwitchIsSet {
if envConfigPath, ok := os.LookupEnv("ALMIGHTY_CONFIG_FILE_PATH"); ok {
configFilePath = envConfigPath
}
}
var err error
if err = configuration.Setup(configFilePath); err != nil {
logrus.Panic(nil, map[string]interface{}{
"configFilePath": configFilePath,
"err": err,
}, "failed to setup the configuration")
}
if printConfig {
os.Exit(0)
}
// Initialized developer mode flag for the logger
log.InitializeLogger(configuration.IsPostgresDeveloperModeEnabled())
printUserInfo()
var db *gorm.DB
for {
db, err = gorm.Open("postgres", configuration.GetPostgresConfigString())
if err != nil {
db.Close()
log.Logger().Errorf("ERROR: Unable to open connection to database %v\n", err)
log.Logger().Infof("Retrying to connect in %v...\n", configuration.GetPostgresConnectionRetrySleep())
time.Sleep(configuration.GetPostgresConnectionRetrySleep())
} else {
defer db.Close()
break
}
}
if configuration.IsPostgresDeveloperModeEnabled() {
db = db.Debug()
}
// Migrate the schema
err = migration.Migrate(db.DB())
if err != nil {
log.Panic(nil, map[string]interface{}{
"err": fmt.Sprintf("%+v", err),
}, "failed migration")
}
// Nothing to here except exit, since the migration is already performed.
if migrateDB {
os.Exit(0)
}
// Make sure the database is populated with the correct types (e.g. bug etc.)
if configuration.GetPopulateCommonTypes() {
// set a random request ID for the context
ctx, req_id := client.ContextWithRequestID(context.Background())
log.Debug(ctx, nil, "Initializing the population of the database... Request ID: %v", req_id)
if err := models.Transactional(db, func(tx *gorm.DB) error {
return migration.PopulateCommonTypes(ctx, tx, workitem.NewWorkItemTypeRepository(tx))
}); err != nil {
log.Panic(ctx, map[string]interface{}{
"err": fmt.Sprintf("%+v", err),
}, "failed to populate common types")
}
if err := models.Transactional(db, func(tx *gorm.DB) error {
return migration.BootstrapWorkItemLinking(ctx, link.NewWorkItemLinkCategoryRepository(tx), link.NewWorkItemLinkTypeRepository(tx))
}); err != nil {
log.Panic(ctx, map[string]interface{}{
"err": fmt.Sprintf("%+v", err),
}, "failed to bootstap work item linking")
}
}
// Scheduler to fetch and import remote tracker items
scheduler = remoteworkitem.NewScheduler(db)
defer scheduler.Stop()
scheduler.ScheduleAllQueries()
// Create service
service := goa.New("alm")
// Mount middleware
service.Use(middleware.RequestID())
service.Use(middleware.LogRequest(configuration.IsPostgresDeveloperModeEnabled()))
service.Use(gzip.Middleware(9))
service.Use(jsonapi.ErrorHandler(service, true))
service.Use(middleware.Recover())
service.WithLogger(goalogrus.New(log.Logger()))
publicKey, err := token.ParsePublicKey(configuration.GetTokenPublicKey())
if err != nil {
log.Panic(nil, map[string]interface{}{
"err": fmt.Sprintf("%+v", err),
}, "failed to parse public token")
}
// Setup Account/Login/Security
identityRepository := account.NewIdentityRepository(db)
userRepository := account.NewUserRepository(db)
tokenManager := token.NewManager(publicKey)
app.UseJWTMiddleware(service, jwt.New(publicKey, nil, app.NewJWTSecurity()))
service.Use(login.InjectTokenManager(tokenManager))
// Mount "login" controller
oauth := &oauth2.Config{
ClientID: configuration.GetKeycloakClientID(),
ClientSecret: configuration.GetKeycloakSecret(),
Scopes: []string{"user:email"},
Endpoint: oauth2.Endpoint{
AuthURL: configuration.GetKeycloakEndpointAuth(),
TokenURL: configuration.GetKeycloakEndpointToken(),
},
}
appDB := gormapplication.NewGormDB(db)
loginService := login.NewKeycloakOAuthProvider(oauth, identityRepository, userRepository, tokenManager, appDB)
loginCtrl := NewLoginController(service, loginService, tokenManager)
app.MountLoginController(service, loginCtrl)
// Mount "status" controller
statusCtrl := NewStatusController(service, db)
app.MountStatusController(service, statusCtrl)
// Mount "workitem" controller
workitemCtrl := NewWorkitemController(service, appDB)
app.MountWorkitemController(service, workitemCtrl)
// Mount "workitemtype" controller
workitemtypeCtrl := NewWorkitemtypeController(service, appDB)
app.MountWorkitemtypeController(service, workitemtypeCtrl)
// Mount "work item link category" controller
workItemLinkCategoryCtrl := NewWorkItemLinkCategoryController(service, appDB)
app.MountWorkItemLinkCategoryController(service, workItemLinkCategoryCtrl)
// Mount "work item link type" controller
workItemLinkTypeCtrl := NewWorkItemLinkTypeController(service, appDB)
app.MountWorkItemLinkTypeController(service, workItemLinkTypeCtrl)
// Mount "work item link" controller
workItemLinkCtrl := NewWorkItemLinkController(service, appDB)
app.MountWorkItemLinkController(service, workItemLinkCtrl)
// Mount "work item comments" controller
workItemCommentsCtrl := NewWorkItemCommentsController(service, appDB)
app.MountWorkItemCommentsController(service, workItemCommentsCtrl)
// Mount "work item relationships links" controller
workItemRelationshipsLinksCtrl := NewWorkItemRelationshipsLinksController(service, appDB)
app.MountWorkItemRelationshipsLinksController(service, workItemRelationshipsLinksCtrl)
// Mount "comments" controller
commentsCtrl := NewCommentsController(service, appDB)
app.MountCommentsController(service, commentsCtrl)
// Mount "tracker" controller
c5 := NewTrackerController(service, appDB, scheduler)
app.MountTrackerController(service, c5)
// Mount "trackerquery" controller
c6 := NewTrackerqueryController(service, appDB, scheduler)
app.MountTrackerqueryController(service, c6)
// Mount "space" controller
spaceCtrl := NewSpaceController(service, appDB)
app.MountSpaceController(service, spaceCtrl)
// Mount "user" controller
userCtrl := NewUserController(service, appDB, tokenManager)
app.MountUserController(service, userCtrl)
// Mount "search" controller
searchCtrl := NewSearchController(service, appDB)
app.MountSearchController(service, searchCtrl)
// Mount "indentity" controller
identityCtrl := NewIdentityController(service, appDB)
app.MountIdentityController(service, identityCtrl)
// Mount "users" controller
usersCtrl := NewUsersController(service, appDB)
app.MountUsersController(service, usersCtrl)
// Mount "iterations" controller
iterationCtrl := NewIterationController(service, appDB)
app.MountIterationController(service, iterationCtrl)
// Mount "spaceiterations" controller
spaceIterationCtrl := NewSpaceIterationsController(service, appDB)
app.MountSpaceIterationsController(service, spaceIterationCtrl)
// Mount "userspace" controller
userspaceCtrl := NewUserspaceController(service, db)
app.MountUserspaceController(service, userspaceCtrl)
// Mount "render" controller
renderCtrl := NewRenderController(service)
app.MountRenderController(service, renderCtrl)
// Mount "areas" controller
areaCtrl := NewAreaController(service, appDB)
app.MountAreaController(service, areaCtrl)
spaceAreaCtrl := NewSpaceAreasController(service, appDB)
app.MountSpaceAreasController(service, spaceAreaCtrl)
log.Logger().Infoln("Git Commit SHA: ", Commit)
log.Logger().Infoln("UTC Build Time: ", BuildTime)
log.Logger().Infoln("UTC Start Time: ", StartTime)
log.Logger().Infoln("Dev mode: ", configuration.IsPostgresDeveloperModeEnabled())
http.Handle("/api/", service.Mux)
http.Handle("/", http.FileServer(assetFS()))
http.Handle("/favicon.ico", http.NotFoundHandler())
// Start http
if err := http.ListenAndServe(configuration.GetHTTPAddress(), nil); err != nil {
log.Error(nil, map[string]interface{}{
"addr": configuration.GetHTTPAddress(),
"err": err,
}, "unable to connect to server")
service.LogError("startup", "err", err)
}
}