Example #1
0
func (app *App) handleServersData(w http.ResponseWriter, r *http.Request) {
	if r.Method != "GET" {
		http.Error(w, "I only respond to GETs", http.StatusNotImplemented)
		return
	}
	tx, err := app.db.Begin()
	if err != nil {
		app.dbError(w, r, err)
		return
	}
	defer tx.Rollback()
	workers, err := db.Workers(tx)
	if err != nil {
		app.dbError(w, r, err)
		return
	}
	sort.Sort(workersById(workers))
	app.writeJson(w, workers)
}
Example #2
0
func NewApp(config *AppConfig) (*App, error) {

	if config.ModelReplication < 1 {
		return nil, fmt.Errorf("model replication level cannot be less than 1")
	}
	var accessLog io.Writer
	if config.AccessLog == "" {
		accessLog = os.Stderr
	} else {
		flags := os.O_WRONLY | os.O_APPEND | os.O_CREATE
		file, err := os.OpenFile(config.AccessLog, flags, 0644)
		if err != nil {
			return nil, err
		}
		log.Println("using access log:", config.AccessLog)
		accessLog = file
	}

	appDB, err := sqlutil.NewReconnectingDB("mysql", config.DBConnStr)
	if err != nil {
		return nil, fmt.Errorf("could not connect to database: %v", err)
	}

	// do the static directories exist?
	for _, dir := range []string{"css", "js", "fonts", "img", "model"} {
		d := filepath.Join(config.StaticDir, dir)
		_, err := os.Stat(d)
		if err != nil {
			return nil, fmt.Errorf("directory %s doesn't exist", d)
		}
	}

	serveDir := func(dirName string) http.Handler {
		d := filepath.Join(config.StaticDir, dirName)
		return http.StripPrefix("/"+dirName, http.FileServer(http.Dir(d)))
	}

	store := sessions.NewCookieStore([]byte(config.SecretSessionKey))

	client, err := tlsconfig.NewClient(config.CertDir)
	if err != nil {
		return nil, fmt.Errorf("certificate loading failed: %v", err)
	}

	app := App{
		store:            store,
		db:               appDB,
		staticDir:        config.StaticDir,
		bundleDir:        config.BundleDir,
		modelLogsDir:     config.ModelLogs,
		modelReplication: config.ModelReplication,
		isdev:            config.IsDev,
		serviceName:      config.ServiceName,
		sharingDisabled:  config.DisableSharing,
	}

	tx, err := app.db.Begin()
	if err != nil {
		return nil, err
	}
	workers, err := db.Workers(tx)
	if err != nil {
		return nil, err
	}
	deploymentReqs, err := db.DeploymentRequests(tx)
	if err != nil {
		return nil, err
	}
	tx.Rollback()
	c := alb.SupervisorConfig{
		Storage:       &storage{new(sync.Mutex), &app},
		TLSHandshaker: client,
		Workers:       workers,
		Deployments:   deploymentReqs,
	}
	app.sup, err = alb.NewSupervisor(c)
	if err != nil {
		return nil, fmt.Errorf("failed to initialize communcation with MPSs: %v", err)
	}
	app.sup.Logger = log.New(os.Stderr, "supervisor: ", log.LstdFlags)

	r := mux.NewRouter()
	r.PathPrefix("/css/").Handler(serveDir("css"))
	r.PathPrefix("/js/").Handler(serveDir("js"))
	r.PathPrefix("/fonts/").Handler(serveDir("fonts"))
	r.PathPrefix("/img/").Handler(serveDir("img"))

	r.HandleFunc("/login", app.handleLogin)
	r.HandleFunc("/register", app.handleRegister)
	r.HandleFunc("/verify-password", app.handleVerifyPassword)
	r.HandleFunc("/logout", app.handleLogout)

	r.Handle("/favicon.ico", app.serveFile("favicon.ico"))

	// deployment routes
	r.PathPrefix("/deployer").HandlerFunc(app.handleDeployment)
	r.HandleFunc("/verify", app.handleOldVerify)

	authedRouter := mux.NewRouter()
	authedRouter.NotFoundHandler = app.serveFile("404.html")

	authedRouter.PathPrefix("/model/").Handler(serveDir("model"))
	authedRouter.Handle("/", app.serveFile("index.html"))
	authedRouter.Handle("/account", app.serveFile("account.html"))
	authedRouter.HandleFunc("/user.json", app.handleUser)
	authedRouter.HandleFunc("/users/{name}", app.handleUserByName)

	// apikey stuff
	authedRouter.HandleFunc("/apikey", app.handleApikey)

	// model specific pages
	authedRouter.Handle("/models/{name}", app.serveFile("model/index.html"))
	authedRouter.HandleFunc("/models/{name}/json", app.handleModel)
	authedRouter.Handle("/models/{name}/scoring", app.serveFile("model/scoring.html"))
	authedRouter.Handle("/models/{name}/versions", app.serveFile("model/versions.html"))
	authedRouter.HandleFunc("/models/{name}/versions.json", app.handleModelVersions)
	authedRouter.Handle("/models/{name}/logs", app.serveFile("model/logs.html"))
	authedRouter.HandleFunc("/models/{name}/logs/json", app.handleModelLogs)
	authedRouter.Handle("/models/{name}/settings", app.serveFile("model/settings.html"))
	authedRouter.Handle("/models/{name}/form-builder", app.serveFile("model/form-builder.html"))
	authedRouter.HandleFunc("/models/{name}/redeploy/{version}", app.handleModelRedeploy)
	authedRouter.HandleFunc("/models/{name}/shared", app.handleModelSharedUsers)
	authedRouter.HandleFunc("/models/{name}/startshare/{user}", app.handleModelStartSharing)
	authedRouter.HandleFunc("/models/{name}/stopshare/{user}", app.handleModelStopSharing)
	authedRouter.HandleFunc("/models/{name}/example", app.handleModelExample)

	// model actions
	authedRouter.HandleFunc("/models/{name}/action/{action}", app.handleModelStateChange)

	authedRouter.HandleFunc("/models", app.handleUserModels)
	authedRouter.HandleFunc("/shared", app.handleSharedModels)
	authedRouter.HandleFunc("/whoami", app.handleWhoami)

	adminRouter := mux.NewRouter()
	authedRouter.PathPrefix("/admin").Handler(app.restrictAdmin(adminRouter))

	adminRouter.Handle("/admin", app.serveFile("admin/index.html"))
	adminRouter.Handle("/admin/users", app.serveFile("admin/users.html"))
	adminRouter.HandleFunc("/admin/users.json", app.handleUsersData)
	adminRouter.HandleFunc("/admin/users/create", app.handleUsersCreate)
	adminRouter.HandleFunc("/admin/users/delete", app.handleUserDelete)
	adminRouter.HandleFunc("/admin/users/makeadmin", app.handleUserMakeAdmin)
	adminRouter.HandleFunc("/admin/users/unmakeadmin", app.handleUserUnmakeAdmin)
	adminRouter.HandleFunc("/admin/users/setpass", app.handleUserSetPass)

	adminRouter.Handle("/admin/models", app.serveFile("admin/models.html"))
	adminRouter.HandleFunc("/admin/models.json", app.handleAllUserModels)

	adminRouter.HandleFunc("/admin/servers", app.handleServers)
	adminRouter.HandleFunc("/admin/servers.json", app.handleServersData)
	adminRouter.HandleFunc("/admin/servers/remove", app.handleServersRemove)

	// get initial authentication for models
	auth, err := func() (*db.PredictionAuth, error) {
		tx, err := app.db.Begin()
		if err != nil {
			return nil, err
		}
		defer tx.Rollback()
		return db.GetAuth(tx)
	}()
	if err != nil {
		return nil, err
	}

	// must enforce no caching for jsx pages
	noCaching := func(handler http.Handler) http.Handler {
		hf := func(w http.ResponseWriter, r *http.Request) {
			// see: http://goo.gl/itaIDo
			w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
			w.Header().Set("Pragma", "no-cache")
			w.Header().Set("Expires", "0")

			handler.ServeHTTP(w, r)
		}
		return http.HandlerFunc(hf)
	}

	h := handlers.LoggingHandler(accessLog, noCaching(app.restrict(authedRouter)))
	r.NotFoundHandler = h

	predRouter := alb.NewPredictionRouter(r, app.sup, auth)

	// TODO: add api routes

	app.router = predRouter

	return &app, nil
}