orion/cmd/server/main.go

package main

import (
	"fmt"
	"log"
	"net/http"
	"net/rpc"

	"github.com/gorilla/sessions"

	"forge.cadoles.com/wpetit/goweb/static"

	"forge.cadoles.com/wpetit/goweb/session/gorilla"
	"forge.cadoles.com/wpetit/goweb/template/html"

	"github.com/go-chi/chi/middleware"

	goweb "forge.cadoles.com/wpetit/goweb/middleware"
	"forge.cadoles.com/wpetit/goweb/service/session"
	"forge.cadoles.com/wpetit/goweb/service/template"

	"forge.cadoles.com/Pyxis/orion/cmd/server/jsonrpc"
	"forge.cadoles.com/wpetit/goweb/service"
	"github.com/go-chi/chi"
)

var (
	conf = newDefaultConfig()
)

func main() {

	if err := overwriteFromEnv(conf); err != nil {
		log.Fatal(err)
	}

	// Create service container
	container := service.NewContainer()
	container.Provide(jsonrpc.ServiceName, getJSONRPCServiceProvider())
	container.Provide(template.ServiceName, getTemplateServiceProvider(conf.TemplateDir))
	container.Provide(session.ServiceName, getSessionServiceProvider())

	router := chi.NewRouter()

	router.Use(middleware.Recoverer)
	router.Use(middleware.RequestID)
	router.Use(middleware.Logger)
	router.Use(goweb.ServiceContainer(container))

	// Define routes
	router.Get("/", serveHomepage)
	router.Post("/rpc", handleJSONRPC)
	router.Get("/**", static.Dir(conf.AssetDir, "", router.NotFoundHandler()))

	hostStr := fmt.Sprintf("%s:%s", conf.HTTPHost, conf.HTTPPort)

	log.Printf("listening on http://%s", hostStr)
	if err := http.ListenAndServe(hostStr, router); err != nil {
		log.Fatal(err)
	}

}

func getJSONRPCServiceProvider() service.Provider {
	jsonrpc := rpc.NewServer()
	return func(c *service.Container) (interface{}, error) {
		return jsonrpc, nil
	}
}

func getTemplateServiceProvider(templateDir string) service.Provider {

	// Create templateService at application startup
	templateService := html.NewTemplateService()

	// Load templates and keep error in cache
	err := templateService.LoadTemplates(templateDir)

	return func(c *service.Container) (interface{}, error) {

		// If an error occured during the templates loading
		// return the error
		if err != nil {
			return nil, err
		}
		return templateService, nil
	}
}

func getSessionServiceProvider() service.Provider {

	// Create a new encrypted/authenticated cookie store for the session
	cookieStore, err := gorilla.CreateCookieSessionStore(32, 64)

	var sessionService session.Service
	if err == nil {
		sessionService = gorilla.NewSessionService(
			"orion",
			cookieStore,
			&sessions.Options{
				HttpOnly: true,
			},
		)
	}

	return func(c *service.Container) (interface{}, error) {
		if err != nil {
			return nil, err
		}
		return sessionService, nil
	}

}