fix tests and remove subapps

evergreen-ci · May 17, 2018 · 0ce4f5b · 0ce4f5b
1 parent cd9ef7a
commit 0ce4f5b
Show file tree

Hide file tree

Showing 24 changed files with 63 additions and 399 deletions.
diff --git a/.gitignore b/.gitignore
@@ -64,3 +64,4 @@ fabfile.py
 .idea
 evergreen
 test-endpoints.pid
+source-patch-1*
diff --git a/config.go b/config.go
@@ -66,7 +66,6 @@ type Settings struct {
 	KeysNew            util.KeyValuePairSlice    `yaml:"keys_new" bson:"keys_new" json:"keys_new"`
 	LoggerConfig       LoggerConfig              `yaml:"logger_config" bson:"logger_config" json:"logger_config" id:"logger_config"`
 	LogPath            string                    `yaml:"log_path" bson:"log_path" json:"log_path"`
-	NewRelic           NewRelicConfig            `yaml:"new_relic" bson:"new_relic" json:"new_relic" id:"new_relic"`
 	Notify             NotifyConfig              `yaml:"notify" bson:"notify" json:"notify" id:"notify"`
 	Plugins            PluginConfig              `yaml:"plugins" bson:"plugins" json:"plugins"`
 	PluginsNew         util.KeyValuePairSlice    `yaml:"plugins_new" bson:"plugins_new" json:"plugins_new"`

diff --git a/config_db.go b/config_db.go
@@ -47,7 +47,6 @@ var (
 	logPathKey            = bsonutil.MustHaveTag(Settings{}, "LogPath")
 	pprofPortKey          = bsonutil.MustHaveTag(Settings{}, "PprofPort")
 	githubPRCreatorOrgKey = bsonutil.MustHaveTag(Settings{}, "GithubPRCreatorOrg")
-	newRelicKey           = bsonutil.MustHaveTag(Settings{}, "NewRelic")
 
 	// degraded mode flags
 	taskDispatchKey                 = bsonutil.MustHaveTag(ServiceFlags{}, "TaskDispatchDisabled")

diff --git a/config_newrelic.go b/config_newrelic.go
diff --git a/config_registry.go b/config_registry.go
@@ -39,7 +39,6 @@ func resetRegistry() error {
 		&HostInitConfig{},
 		&JiraConfig{},
 		&LoggerConfig{},
-		&NewRelicConfig{},
 		&NotifyConfig{},
 		&RepoTrackerConfig{},
 		&SchedulerConfig{},

diff --git a/config_test.go b/config_test.go
@@ -297,20 +297,6 @@ func (s *AdminSuite) TestJiraConfig() {
 	s.Equal(config, settings.Jira)
 }
 
-func (s *AdminSuite) TestNewRelicConfig() {
-	config := NewRelicConfig{
-		ApplicationName: "new_relic",
-		LicenseKey:      "key",
-	}
-
-	err := config.Set()
-	s.NoError(err)
-	settings, err := GetConfig()
-	s.NoError(err)
-	s.NotNil(settings)
-	s.Equal(config, settings.NewRelic)
-}
-
 func (s *AdminSuite) TestProvidersConfig() {
 	config := CloudProviders{
 		AWS: AWSConfig{

diff --git a/glide.lock b/glide.lock
diff --git a/glide.yaml b/glide.yaml
@@ -51,5 +51,4 @@ import:
   - package: github.com/google/go-github
   - package: github.com/google/go-querystring
   - package: github.com/google/shlex
-  - package: github.com/newrelic/go-agent
   - package: github.com/PuerkitoBio/rehttp
diff --git a/operations/service_web.go b/operations/service_web.go
@@ -15,7 +15,6 @@ import (
 	"github.com/mongodb/grip"
 	"github.com/mongodb/grip/message"
 	"github.com/mongodb/grip/recovery"
-	nrgorilla "github.com/newrelic/go-agent/_integrations/nrgorilla/v1"
 	"github.com/pkg/errors"
 	"github.com/urfave/cli"
 )
@@ -47,30 +46,24 @@ func startWebService() cli.Command {
 			grip.Notice(message.Fields{"build": evergreen.BuildRevision, "process": grip.Name()})
 
 			startSystemCronJobs(ctx, env)
+
+			var (
+				apiServer *http.Server
+				uiServer  *http.Server
+			)
+
 			serviceHandler, err := getServiceRouter(settings, queue)
 			if err != nil {
 				return errors.WithStack(err)
 			}
-
-			apiServer := service.GetServer(settings.Api.HttpListenAddr, serviceHandler)
+			apiServer = service.GetServer(settings.Api.HttpListenAddr, serviceHandler)
 
 			if settings.Ui.CsrfKey != "" {
 				errorHandler := csrf.ErrorHandler(http.HandlerFunc(service.ForbiddenHandler))
-				uiHandler = csrf.Protect([]byte(settings.Ui.CsrfKey), errorHandler)(serviceHandler)
-			}
-			uiServer := service.GetServer(settings.Ui.HttpListenAddr, uiHandler)
-
-			newRelic, err := settings.NewRelic.SetUp()
-			if newRelic == nil || err != nil {
-				grip.Debug(message.WrapError(err, message.Fields{
-					"message": "skipping new relic setup",
-				}))
+				uiHandler := csrf.Protect([]byte(settings.Ui.CsrfKey), errorHandler)(serviceHandler)
+				uiServer = service.GetServer(settings.Ui.HttpListenAddr, uiHandler)
 			} else {
-				grip.Info(message.Fields{
-					"message":          "successfully set up new relic",
-					"application_name": settings.NewRelic.ApplicationName,
-				})
-				nrgorilla.InstrumentRoutes(router, newRelic)
+				uiServer = service.GetServer(settings.Ui.HttpListenAddr, serviceHandler)
 			}
 
 			catcher := grip.NewBasicCatcher()

diff --git a/rest/data/admin_test.go b/rest/data/admin_test.go
@@ -138,7 +138,6 @@ func (s *AdminDataSuite) TestSetAndGetSettings() {
 	s.EqualValues(testSettings.Jira.Username, settingsFromConnector.Jira.Username)
 	s.EqualValues(testSettings.LoggerConfig.DefaultLevel, settingsFromConnector.LoggerConfig.DefaultLevel)
 	s.EqualValues(testSettings.LoggerConfig.Buffer.Count, settingsFromConnector.LoggerConfig.Buffer.Count)
-	s.EqualValues(testSettings.NewRelic.ApplicationName, settingsFromConnector.NewRelic.ApplicationName)
 	s.EqualValues(testSettings.Notify.SMTP.From, settingsFromConnector.Notify.SMTP.From)
 	s.EqualValues(testSettings.Notify.SMTP.Port, settingsFromConnector.Notify.SMTP.Port)
 	s.Equal(len(testSettings.Notify.SMTP.AdminEmail), len(settingsFromConnector.Notify.SMTP.AdminEmail))
@@ -238,7 +237,6 @@ func (s *AdminDataSuite) TestSetAndGetSettings() {
 	s.EqualValues(testSettings.Jira.Username, settingsFromConnector.Jira.Username)
 	s.EqualValues(testSettings.LoggerConfig.DefaultLevel, settingsFromConnector.LoggerConfig.DefaultLevel)
 	s.EqualValues(testSettings.LoggerConfig.Buffer.Count, settingsFromConnector.LoggerConfig.Buffer.Count)
-	s.EqualValues(testSettings.NewRelic.ApplicationName, settingsFromConnector.NewRelic.ApplicationName)
 	s.EqualValues(testSettings.Notify.SMTP.From, settingsFromConnector.Notify.SMTP.From)
 	s.EqualValues(testSettings.Notify.SMTP.Port, settingsFromConnector.Notify.SMTP.Port)
 	s.Equal(len(testSettings.Notify.SMTP.AdminEmail), len(settingsFromConnector.Notify.SMTP.AdminEmail))

diff --git a/rest/model/admin.go b/rest/model/admin.go
@@ -22,7 +22,6 @@ func NewConfigModel() *APIAdminSettings {
 		Jira:         &APIJiraConfig{},
 		Keys:         map[string]string{},
 		LoggerConfig: &APILoggerConfig{},
-		NewRelic:     &APINewRelicConfig{},
 		Notify:       &APINotifyConfig{},
 		Plugins:      map[string]map[string]interface{}{},
 		Providers:    &APICloudProviders{},
@@ -55,7 +54,6 @@ type APIAdminSettings struct {
 	Keys               map[string]string                 `json:"keys,omitempty"`
 	LoggerConfig       *APILoggerConfig                  `json:"logger_config,omitempty"`
 	LogPath            APIString                         `json:"log_path,omitempty"`
-	NewRelic           *APINewRelicConfig                `json:"new_relic,omitempty"`
 	Notify             *APINotifyConfig                  `json:"notify,omitempty"`
 	Plugins            map[string]map[string]interface{} `json:"plugins,omitempty"`
 	PprofPort          APIString                         `json:"pprof_port,omitempty"`
@@ -655,29 +653,6 @@ func (a *APILogBuffering) ToService() (interface{}, error) {
 	}, nil
 }
 
-type APINewRelicConfig struct {
-	ApplicationName APIString `json:"application_name"`
-	LicenseKey      APIString `json:"license_key"`
-}
-
-func (a *APINewRelicConfig) BuildFromService(h interface{}) error {
-	switch v := h.(type) {
-	case evergreen.NewRelicConfig:
-		a.ApplicationName = ToAPIString(v.ApplicationName)
-		a.LicenseKey = ToAPIString(v.LicenseKey)
-	default:
-		return errors.Errorf("%T is not a supported type", h)
-	}
-	return nil
-}
-
-func (a *APINewRelicConfig) ToService() (interface{}, error) {
-	return evergreen.NewRelicConfig{
-		ApplicationName: FromAPIString(a.ApplicationName),
-		LicenseKey:      FromAPIString(a.LicenseKey),
-	}, nil
-}
-
 type APINotifyConfig struct {
 	BufferTargetPerInterval int            `json:"buffer_target_per_interval"`
 	BufferIntervalSeconds   int            `json:"buffer_interval_seconds"`

diff --git a/rest/model/admin_test.go b/rest/model/admin_test.go
@@ -62,7 +62,6 @@ func TestModelConversion(t *testing.T) {
 	assert.EqualValues(testSettings.Jira.Username, FromAPIString(apiSettings.Jira.Username))
 	assert.EqualValues(testSettings.LoggerConfig.DefaultLevel, FromAPIString(apiSettings.LoggerConfig.DefaultLevel))
 	assert.EqualValues(testSettings.LoggerConfig.Buffer.Count, apiSettings.LoggerConfig.Buffer.Count)
-	assert.EqualValues(testSettings.NewRelic.ApplicationName, FromAPIString(apiSettings.NewRelic.ApplicationName))
 	assert.EqualValues(testSettings.Notify.SMTP.From, FromAPIString(apiSettings.Notify.SMTP.From))
 	assert.EqualValues(testSettings.Notify.SMTP.Port, apiSettings.Notify.SMTP.Port)
 	assert.Equal(len(testSettings.Notify.SMTP.AdminEmail), len(apiSettings.Notify.SMTP.AdminEmail))
@@ -97,7 +96,6 @@ func TestModelConversion(t *testing.T) {
 	assert.EqualValues(testSettings.Jira.Username, dbSettings.Jira.Username)
 	assert.EqualValues(testSettings.LoggerConfig.DefaultLevel, dbSettings.LoggerConfig.DefaultLevel)
 	assert.EqualValues(testSettings.LoggerConfig.Buffer.Count, dbSettings.LoggerConfig.Buffer.Count)
-	assert.EqualValues(testSettings.NewRelic.ApplicationName, dbSettings.NewRelic.ApplicationName)
 	assert.EqualValues(testSettings.Notify.SMTP.From, dbSettings.Notify.SMTP.From)
 	assert.EqualValues(testSettings.Notify.SMTP.Port, dbSettings.Notify.SMTP.Port)
 	assert.Equal(len(testSettings.Notify.SMTP.AdminEmail), len(dbSettings.Notify.SMTP.AdminEmail))

diff --git a/rest/route/admin_route_test.go b/rest/route/admin_route_test.go
@@ -99,7 +99,6 @@ func (s *AdminRouteSuite) TestAdminRoute() {
 	s.EqualValues(testSettings.Jira.Username, settings.Jira.Username)
 	s.EqualValues(testSettings.LoggerConfig.DefaultLevel, settings.LoggerConfig.DefaultLevel)
 	s.EqualValues(testSettings.LoggerConfig.Buffer.Count, settings.LoggerConfig.Buffer.Count)
-	s.EqualValues(testSettings.NewRelic.ApplicationName, settings.NewRelic.ApplicationName)
 	s.EqualValues(testSettings.Notify.SMTP.From, settings.Notify.SMTP.From)
 	s.EqualValues(testSettings.Notify.SMTP.Port, settings.Notify.SMTP.Port)
 	s.Equal(len(testSettings.Notify.SMTP.AdminEmail), len(settings.Notify.SMTP.AdminEmail))

diff --git a/service/api_patch.go b/service/api_patch.go
@@ -182,6 +182,7 @@ func (as *APIServer) updatePatchModule(w http.ResponseWriter, r *http.Request) {
 	summaries, err := thirdparty.GetPatchSummaries(patchContent)
 	if err != nil {
 		as.LoggedError(w, r, http.StatusInternalServerError, err)
+		return
 	}
 	repoOwner, repo := module.GetRepoOwnerAndName()
 

diff --git a/service/api_test_utils.go b/service/api_test_utils.go
@@ -10,9 +10,7 @@ import (
 
 	"github.com/evergreen-ci/evergreen"
 	"github.com/evergreen-ci/evergreen/service/testutil"
-	"github.com/gorilla/mux"
 	"github.com/mongodb/grip"
-	"github.com/urfave/negroni"
 )
 
 type TestServer struct {
@@ -31,8 +29,9 @@ func (s *TestServer) Close() {
 }
 
 func CreateTestServer(settings *evergreen.Settings, tlsConfig *tls.Config) (*TestServer, error) {
+	home := evergreen.FindEvergreenHome()
 	port := testutil.NextPort()
-	if err := os.MkdirAll(filepath.Join(evergreen.FindEvergreenHome(), evergreen.ClientDirectory), 0644); err != nil {
+	if err := os.MkdirAll(filepath.Join(home, evergreen.ClientDirectory), 0644); err != nil {
 		return nil, err
 	}
 
@@ -44,17 +43,21 @@ func CreateTestServer(settings *evergreen.Settings, tlsConfig *tls.Config) (*Tes
 	}
 	as.UserManager = testutil.MockUserManager{}
 
+	uis, err := NewUIServer(settings, env.LocalQueue(), home, TemplateFunctionOptions{})
+	if err != nil {
+		return nil, err
+	}
+	uis.UserManager = testutil.MockUserManager{}
+
 	var l net.Listener
 	protocol := "http"
 
-	router := mux.NewRouter()
-	as.AttachRoutes(router)
-	n := negroni.New()
-	n.Use(NewRecoveryLogger())
-	n.Use(negroni.HandlerFunc(UserMiddleware(as.UserManager)))
-	n.UseHandler(router)
+	handler, err := GetRouter(as, uis)
+	if err != nil {
+		return nil, err
+	}
 
-	server := httptest.NewUnstartedServer(n)
+	server := httptest.NewUnstartedServer(handler)
 	server.TLS = tlsConfig
 
 	// We're not running ssl tests with the agent in any cases,

diff --git a/service/rest.go b/service/rest.go
@@ -65,8 +65,8 @@ func MustHaveRESTContext(r *http.Request) *model.Context {
 // AttachRESTHandler attaches a router at the given root that hooks up REST endpoint URIs to be
 // handled by the given restAPIService.
 func GetRESTv1App(evgService restAPIService, um auth.UserManager) (*gimlet.APIApp, error) {
-	rest := &restAPI{evgService}
 	app := gimlet.NewApp()
+	rest := &restAPI{evgService}
 	app.ResetMiddleware()
 	app.SetPrefix(evergreen.RestRoutePrefix)
 	app.AddMiddleware(NewRecoveryLogger())

diff --git a/service/service.go b/service/service.go
@@ -6,13 +6,20 @@ import (
 	"time"
 
 	"github.com/evergreen-ci/evergreen"
-	"github.com/evergreen-ci/gimlet"
 	"github.com/mongodb/grip"
 	"github.com/mongodb/grip/message"
 	"github.com/pkg/errors"
 	"github.com/urfave/negroni"
 )
 
+const (
+	WebRootPath  = "service"
+	Templates    = "templates"
+	Static       = "static"
+	DefaultSkip  = 0
+	DefaultLimit = 10
+)
+
 // GetServer produces an HTTP server instance for a handler.
 func GetServer(addr string, n http.Handler) *http.Server {
 	grip.Notice(message.Fields{
@@ -32,37 +39,33 @@ func GetServer(addr string, n http.Handler) *http.Server {
 }
 
 func GetRouter(as *APIServer, uis *UIServer) (http.Handler, error) {
-	app := gimlet.NewApp()
-
-	restv1, err := GetRESTv1App(as, as.UserManager)
+	// in the future, we'll make the gimlet app here, but we
+	// need/want to access and construct it separately.
+	app, err := GetRESTv1App(as, uis.UserManager)
 	if err != nil {
-		return nil, errors.WithStack(err)
+		return nil, err
 	}
-	app.AddApp(restv1)
 
+	app.AddMiddleware(negroni.NewStatic(http.Dir(filepath.Join(uis.Home, "public"))))
+
+	if err = app.Resolve(); err != nil {
+		return nil, err
+	}
 	// in the future the following functions will be above this
 	// point, and we'll just have the app, but during the legacy
 	// transition, we convert the app to a router and then attach
 	// legacy routes directly.
 
-	legacyApp := gimlet.NewApp()
-	legacyApp.ResetMiddleware()
-	legacyApp.AddMiddleware(NewRecoveryLogger())
-	legacyApp.AddMiddleware(negroni.HandlerFunc(UserMiddleware(as.UserManager)))
-	legacyApp.AddMiddleware(negroni.NewStatic(http.Dir(filepath.Join(uis.Home, "public"))))
-
-	router, err := legacyApp.Router()
+	router, err := app.Router()
 	if err != nil {
 		return nil, errors.WithStack(err)
 	}
 
-	as.AttachRoutes(router)
 	err = uis.AttachRoutes(router)
 	if err != nil {
 		return nil, errors.WithStack(err)
 	}
-
-	app.AddApp(legacyApp)
+	as.AttachRoutes(router)
 
 	return app.Handler()
 }