renames

graph-explorer/pkg/assets/assets.go

@@ -0,0 +1,37 @@
+package assets
+
+import (
+	"net/http"
+	"os"
+
+	"github.com/owncloud/ocis-pkg/v2/log"
+	"github.com/owncloud/ocis/graph-explorer/pkg/config"
+)
+
+//go:generate go run github.com/UnnoTed/fileb0x embed.yml
+
+// assets gets initialized by New and provides the handler.
+type assets struct {
+	logger log.Logger
+	config *config.Config
+}
+
+// Open just implements the HTTP filesystem interface.
+func (a assets) Open(original string) (http.File, error) {
+	return FS.OpenFile(
+		CTX,
+		original,
+		os.O_RDONLY,
+		0644,
+	)
+}
+
+// New returns a new http filesystem to serve assets.
+func New(opts ...Option) http.FileSystem {
+	options := newOptions(opts...)
+
+	return assets{
+		logger: options.Logger,
+		config: options.Config,
+	}
+}

graph-explorer/pkg/assets/dummy.go

@@ -0,0 +1,9 @@
+package assets
+
+import (
+	// Fake the import to make the dep tree happy.
+	_ "golang.org/x/net/context"
+
+	// Fake the import to make the dep tree happy.
+	_ "golang.org/x/net/webdav"
+)

graph-explorer/pkg/assets/embed.yml

@@ -0,0 +1,16 @@
+---
+pkg: "assets"
+dest: "."
+output: "embed.go"
+fmt: true
+noprefix: true
+
+compression:
+  compress: true
+
+custom:
+  - files:
+    - "../../assets/"
+    base: "../../assets/"
+    prefix: ""
+...

graph-explorer/pkg/assets/option.go

@@ -0,0 +1,40 @@
+package assets
+
+import (
+	"github.com/owncloud/ocis-pkg/v2/log"
+	"github.com/owncloud/ocis/graph-explorer/pkg/config"
+)
+
+// Option defines a single option function.
+type Option func(o *Options)
+
+// Options defines the available options for this package.
+type Options struct {
+	Logger log.Logger
+	Config *config.Config
+}
+
+// newOptions initializes the available default options.
+func newOptions(opts ...Option) Options {
+	opt := Options{}
+
+	for _, o := range opts {
+		o(&opt)
+	}
+
+	return opt
+}
+
+// Logger provides a function to set the logger option.
+func Logger(val log.Logger) Option {
+	return func(o *Options) {
+		o.Logger = val
+	}
+}
+
+// Config provides a function to set the config option.
+func Config(val *config.Config) Option {
+	return func(o *Options) {
+		o.Config = val
+	}
+}

graph-explorer/pkg/command/health.go

@@ -0,0 +1,49 @@
+package command
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/micro/cli/v2"
+	"github.com/owncloud/ocis/graph-explorer/pkg/config"
+	"github.com/owncloud/ocis/graph-explorer/pkg/flagset"
+)
+
+// Health is the entrypoint for the health command.
+func Health(cfg *config.Config) *cli.Command {
+	return &cli.Command{
+		Name:  "health",
+		Usage: "Check health status",
+		Flags: flagset.HealthWithConfig(cfg),
+		Action: func(c *cli.Context) error {
+			logger := NewLogger(cfg)
+
+			resp, err := http.Get(
+				fmt.Sprintf(
+					"http://%s/healthz",
+					cfg.Debug.Addr,
+				),
+			)
+
+			if err != nil {
+				logger.Fatal().
+					Err(err).
+					Msg("Failed to request health check")
+			}
+
+			defer resp.Body.Close()
+
+			if resp.StatusCode != 200 {
+				logger.Fatal().
+					Int("code", resp.StatusCode).
+					Msg("Health seems to be in bad state")
+			}
+
+			logger.Debug().
+				Int("code", resp.StatusCode).
+				Msg("Health got a good state")
+
+			return nil
+		},
+	}
+}

graph-explorer/pkg/command/root.go

@@ -0,0 +1,103 @@
+package command
+
+import (
+	"os"
+	"strings"
+
+	"github.com/micro/cli/v2"
+	"github.com/owncloud/ocis-pkg/v2/log"
+	"github.com/owncloud/ocis/graph-explorer/pkg/config"
+	"github.com/owncloud/ocis/graph-explorer/pkg/flagset"
+	"github.com/owncloud/ocis/graph-explorer/pkg/version"
+	"github.com/spf13/viper"
+)
+
+// Execute is the entry point for the ocis-graph-explorer command.
+func Execute() error {
+	cfg := config.New()
+
+	app := &cli.App{
+		Name:     "graph-explorer",
+		Version:  version.String,
+		Usage:    "Serve Graph-Explorer for oCIS",
+		Compiled: version.Compiled(),
+
+		Authors: []*cli.Author{
+			{
+				Name:  "ownCloud GmbH",
+				Email: "support@owncloud.com",
+			},
+		},
+
+		Flags: flagset.RootWithConfig(cfg),
+
+		Before: func(c *cli.Context) error {
+			logger := NewLogger(cfg)
+
+			viper.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
+			viper.SetEnvPrefix("GRAPH_EXPLORER")
+			viper.AutomaticEnv()
+
+			if c.IsSet("config-file") {
+				viper.SetConfigFile(c.String("config-file"))
+			} else {
+				viper.SetConfigName("graph-explorer")
+
+				viper.AddConfigPath("/etc/ocis")
+				viper.AddConfigPath("$HOME/.ocis")
+				viper.AddConfigPath("./config")
+			}
+
+			if err := viper.ReadInConfig(); err != nil {
+				switch err.(type) {
+				case viper.ConfigFileNotFoundError:
+					logger.Info().
+						Msg("Continue without config")
+				case viper.UnsupportedConfigError:
+					logger.Fatal().
+						Err(err).
+						Msg("Unsupported config type")
+				default:
+					logger.Fatal().
+						Err(err).
+						Msg("Failed to read config")
+				}
+			}
+
+			if err := viper.Unmarshal(&cfg); err != nil {
+				logger.Fatal().
+					Err(err).
+					Msg("Failed to parse config")
+			}
+
+			return nil
+		},
+
+		Commands: []*cli.Command{
+			Server(cfg),
+			Health(cfg),
+		},
+	}
+
+	cli.HelpFlag = &cli.BoolFlag{
+		Name:  "help,h",
+		Usage: "Show the help",
+	}
+
+	cli.VersionFlag = &cli.BoolFlag{
+		Name:  "version,v",
+		Usage: "Print the version",
+	}
+
+	return app.Run(os.Args)
+}
+
+// NewLogger initializes a service-specific logger instance.
+func NewLogger(cfg *config.Config) log.Logger {
+	return log.NewLogger(
+		log.Name("graph-explorer"),
+		log.Level(cfg.Log.Level),
+		log.Pretty(cfg.Log.Pretty),
+		log.Color(cfg.Log.Color),
+	)
+}

graph-explorer/pkg/command/server.go

@@ -0,0 +1,227 @@
+package command
+
+import (
+	"context"
+	"os"
+	"os/signal"
+	"strings"
+	"time"
+
+	"contrib.go.opencensus.io/exporter/jaeger"
+	"contrib.go.opencensus.io/exporter/ocagent"
+	"contrib.go.opencensus.io/exporter/zipkin"
+	"github.com/micro/cli/v2"
+	"github.com/oklog/run"
+	openzipkin "github.com/openzipkin/zipkin-go"
+	zipkinhttp "github.com/openzipkin/zipkin-go/reporter/http"
+	"github.com/owncloud/ocis/graph-explorer/pkg/config"
+	"github.com/owncloud/ocis/graph-explorer/pkg/flagset"
+	"github.com/owncloud/ocis/graph-explorer/pkg/metrics"
+	"github.com/owncloud/ocis/graph-explorer/pkg/server/debug"
+	"github.com/owncloud/ocis/graph-explorer/pkg/server/http"
+	"go.opencensus.io/stats/view"
+	"go.opencensus.io/trace"
+)
+
+// Server is the entrypoint for the server command.
+func Server(cfg *config.Config) *cli.Command {
+	return &cli.Command{
+		Name:  "server",
+		Usage: "Start integrated server",
+		Flags: flagset.ServerWithConfig(cfg),
+		Before: func(c *cli.Context) error {
+			if cfg.HTTP.Root != "/" {
+				cfg.HTTP.Root = strings.TrimSuffix(cfg.HTTP.Root, "/")
+			}
+
+			return nil
+		},
+		Action: func(c *cli.Context) error {
+			logger := NewLogger(cfg)
+
+			if cfg.Tracing.Enabled {
+				switch t := cfg.Tracing.Type; t {
+				case "agent":
+					exporter, err := ocagent.NewExporter(
+						ocagent.WithReconnectionPeriod(5*time.Second),
+						ocagent.WithAddress(cfg.Tracing.Endpoint),
+						ocagent.WithServiceName(cfg.Tracing.Service),
+					)
+
+					if err != nil {
+						logger.Error().
+							Err(err).
+							Str("endpoint", cfg.Tracing.Endpoint).
+							Str("collector", cfg.Tracing.Collector).
+							Msg("Failed to create agent tracing")
+
+						return err
+					}
+
+					trace.RegisterExporter(exporter)
+					view.RegisterExporter(exporter)
+
+				case "jaeger":
+					exporter, err := jaeger.NewExporter(
+						jaeger.Options{
+							AgentEndpoint:     cfg.Tracing.Endpoint,
+							CollectorEndpoint: cfg.Tracing.Collector,
+							ServiceName:       cfg.Tracing.Service,
+						},
+					)
+
+					if err != nil {
+						logger.Error().
+							Err(err).
+							Str("endpoint", cfg.Tracing.Endpoint).
+							Str("collector", cfg.Tracing.Collector).
+							Msg("Failed to create jaeger tracing")
+
+						return err
+					}
+
+					trace.RegisterExporter(exporter)
+
+				case "zipkin":
+					endpoint, err := openzipkin.NewEndpoint(
+						cfg.Tracing.Service,
+						cfg.Tracing.Endpoint,
+					)
+
+					if err != nil {
+						logger.Error().
+							Err(err).
+							Str("endpoint", cfg.Tracing.Endpoint).
+							Str("collector", cfg.Tracing.Collector).
+							Msg("Failed to create zipkin tracing")
+
+						return err
+					}
+
+					exporter := zipkin.NewExporter(
+						zipkinhttp.NewReporter(
+							cfg.Tracing.Collector,
+						),
+						endpoint,
+					)
+
+					trace.RegisterExporter(exporter)
+
+				default:
+					logger.Warn().
+						Str("type", t).
+						Msg("Unknown tracing backend")
+				}
+
+				trace.ApplyConfig(
+					trace.Config{
+						DefaultSampler: trace.AlwaysSample(),
+					},
+				)
+			} else {
+				logger.Debug().
+					Msg("Tracing is not enabled")
+			}
+
+			var (
+				gr          = run.Group{}
+				ctx, cancel = context.WithCancel(context.Background())
+				metrics     = metrics.New()
+			)
+
+			defer cancel()
+
+			{
+				server, err := http.Server(
+					http.Logger(logger),
+					http.Context(ctx),
+					http.Namespace(cfg.HTTP.Namespace),
+					http.Config(cfg),
+					http.Metrics(metrics),
+					http.Flags(flagset.RootWithConfig(cfg)),
+					http.Flags(flagset.ServerWithConfig(cfg)),
+				)
+
+				if err != nil {
+					logger.Info().
+						Err(err).
+						Str("transport", "http").
+						Msg("Failed to initialize server")
+
+					return err
+				}
+
+				gr.Add(func() error {
+					err := server.Run()
+					if err != nil {
+						logger.Error().
+							Err(err).
+							Str("transport", "http").
+							Msg("Failed to start server")
+					}
+					return err
+				}, func(_ error) {
+					logger.Info().
+						Str("transport", "http").
+						Msg("Shutting down server")
+
+					cancel()
+				})
+			}
+
+			{
+				server, err := debug.Server(
+					debug.Logger(logger),
+					debug.Context(ctx),
+					debug.Config(cfg),
+				)
+
+				if err != nil {
+					logger.Info().
+						Err(err).
+						Str("transport", "debug").
+						Msg("Failed to initialize server")
+
+					return err
+				}
+
+				gr.Add(func() error {
+					return server.ListenAndServe()
+				}, func(_ error) {
+					ctx, timeout := context.WithTimeout(ctx, 5*time.Second)
+
+					defer timeout()
+					defer cancel()
+
+					if err := server.Shutdown(ctx); err != nil {
+						logger.Info().
+							Err(err).
+							Str("transport", "debug").
+							Msg("Failed to shutdown server")
+					} else {
+						logger.Info().
+							Str("transport", "debug").
+							Msg("Shutting down server")
+					}
+				})
+			}
+
+			{
+				stop := make(chan os.Signal, 1)
+
+				gr.Add(func() error {
+					signal.Notify(stop, os.Interrupt)
+
+					<-stop
+
+					return nil
+				}, func(err error) {
+					close(stop)
+					cancel()
+				})
+			}
+
+			return gr.Run()
+		},
+	}
+}

graph-explorer/pkg/config/config.go

@@ -0,0 +1,54 @@
+package config
+
+// Log defines the available logging configuration.
+type Log struct {
+	Level  string
+	Pretty bool
+	Color  bool
+}
+
+// Debug defines the available debug configuration.
+type Debug struct {
+	Addr   string
+	Token  string
+	Pprof  bool
+	Zpages bool
+}
+
+// HTTP defines the available http configuration.
+type HTTP struct {
+	Addr      string
+	Root      string
+	Namespace string
+}
+
+// Tracing defines the available tracing configuration.
+type Tracing struct {
+	Enabled   bool
+	Type      string
+	Endpoint  string
+	Collector string
+	Service   string
+}
+
+// GraphExplorer defines the available graph-explorer configuration.
+type GraphExplorer struct {
+	ClientID string
+	Issuer   string
+	GraphURL string
+}
+
+// Config combines all available configuration parts.
+type Config struct {
+	File          string
+	Log           Log
+	Debug         Debug
+	HTTP          HTTP
+	Tracing       Tracing
+	GraphExplorer GraphExplorer
+}
+
+// New initializes a new configuration with or without defaults.
+func New() *Config {
+	return &Config{}
+}

graph-explorer/pkg/flagset/flagset.go

@@ -0,0 +1,154 @@
+package flagset
+
+import (
+	"github.com/micro/cli/v2"
+	"github.com/owncloud/ocis/graph-explorer/pkg/config"
+)
+
+// RootWithConfig applies cfg to the root flagset
+func RootWithConfig(cfg *config.Config) []cli.Flag {
+	return []cli.Flag{
+		&cli.StringFlag{
+			Name:        "log-level",
+			Value:       "info",
+			Usage:       "Set logging level",
+			EnvVars:     []string{"GRAPH_EXPLORER_LOG_LEVEL"},
+			Destination: &cfg.Log.Level,
+		},
+		&cli.BoolFlag{
+			Value:       true,
+			Name:        "log-pretty",
+			Usage:       "Enable pretty logging",
+			EnvVars:     []string{"GRAPH_EXPLORER_LOG_PRETTY"},
+			Destination: &cfg.Log.Pretty,
+		},
+		&cli.BoolFlag{
+			Value:       true,
+			Name:        "log-color",
+			Usage:       "Enable colored logging",
+			EnvVars:     []string{"GRAPH_EXPLORER_LOG_COLOR"},
+			Destination: &cfg.Log.Color,
+		},
+	}
+}
+
+// HealthWithConfig applies cfg to the root flagset
+func HealthWithConfig(cfg *config.Config) []cli.Flag {
+	return []cli.Flag{
+		&cli.StringFlag{
+			Name:        "debug-addr",
+			Value:       "0.0.0.0:9136",
+			Usage:       "Address to debug endpoint",
+			EnvVars:     []string{"GRAPH_EXPLORER_DEBUG_ADDR"},
+			Destination: &cfg.Debug.Addr,
+		},
+	}
+}
+
+// ServerWithConfig applies cfg to the root flagset
+func ServerWithConfig(cfg *config.Config) []cli.Flag {
+	return []cli.Flag{
+		&cli.BoolFlag{
+			Name:        "tracing-enabled",
+			Usage:       "Enable sending traces",
+			EnvVars:     []string{"GRAPH_EXPLORER_TRACING_ENABLED"},
+			Destination: &cfg.Tracing.Enabled,
+		},
+		&cli.StringFlag{
+			Name:        "tracing-type",
+			Value:       "jaeger",
+			Usage:       "Tracing backend type",
+			EnvVars:     []string{"GRAPH_EXPLORER_TRACING_TYPE"},
+			Destination: &cfg.Tracing.Type,
+		},
+		&cli.StringFlag{
+			Name:        "tracing-endpoint",
+			Value:       "",
+			Usage:       "Endpoint for the agent",
+			EnvVars:     []string{"GRAPH_EXPLORER_TRACING_ENDPOINT"},
+			Destination: &cfg.Tracing.Endpoint,
+		},
+		&cli.StringFlag{
+			Name:        "tracing-collector",
+			Value:       "",
+			Usage:       "Endpoint for the collector",
+			EnvVars:     []string{"GRAPH_EXPLORER_TRACING_COLLECTOR"},
+			Destination: &cfg.Tracing.Collector,
+		},
+		&cli.StringFlag{
+			Name:        "tracing-service",
+			Value:       "graph-explorer",
+			Usage:       "Service name for tracing",
+			EnvVars:     []string{"GRAPH_EXPLORER_TRACING_SERVICE"},
+			Destination: &cfg.Tracing.Service,
+		},
+		&cli.StringFlag{
+			Name:        "debug-addr",
+			Value:       "0.0.0.0:9136",
+			Usage:       "Address to bind debug server",
+			EnvVars:     []string{"GRAPH_EXPLORER_DEBUG_ADDR"},
+			Destination: &cfg.Debug.Addr,
+		},
+		&cli.StringFlag{
+			Name:        "debug-token",
+			Value:       "",
+			Usage:       "Token to grant metrics access",
+			EnvVars:     []string{"GRAPH_EXPLORER_DEBUG_TOKEN"},
+			Destination: &cfg.Debug.Token,
+		},
+		&cli.BoolFlag{
+			Name:        "debug-pprof",
+			Usage:       "Enable pprof debugging",
+			EnvVars:     []string{"GRAPH_EXPLORER_DEBUG_PPROF"},
+			Destination: &cfg.Debug.Pprof,
+		},
+		&cli.BoolFlag{
+			Name:        "debug-zpages",
+			Usage:       "Enable zpages debugging",
+			EnvVars:     []string{"GRAPH_EXPLORER_DEBUG_ZPAGES"},
+			Destination: &cfg.Debug.Zpages,
+		},
+		&cli.StringFlag{
+			Name:        "http-addr",
+			Value:       "0.0.0.0:9135",
+			Usage:       "Address to bind http server",
+			EnvVars:     []string{"GRAPH_EXPLORER_HTTP_ADDR"},
+			Destination: &cfg.HTTP.Addr,
+		},
+		&cli.StringFlag{
+			Name:        "http-root",
+			Value:       "/",
+			Usage:       "Root path of http server",
+			EnvVars:     []string{"GRAPH_EXPLORER_HTTP_ROOT"},
+			Destination: &cfg.HTTP.Root,
+		},
+		&cli.StringFlag{
+			Name:        "http-namespace",
+			Value:       "com.owncloud.web",
+			Usage:       "Set the base namespace for the http namespace",
+			EnvVars:     []string{"GRAPH_EXPLORER_NAMESPACE"},
+			Destination: &cfg.HTTP.Namespace,
+		},
+		&cli.StringFlag{
+			Name:        "issuer",
+			Value:       "https://localhost:9130",
+			Usage:       "Set the OpenID Connect Provider",
+			EnvVars:     []string{"GRAPH_EXPLORER_ISSUER"},
+			Destination: &cfg.GraphExplorer.Issuer,
+		},
+		&cli.StringFlag{
+			Name:        "client-id",
+			Value:       "ocis-explorer.js",
+			Usage:       "Set the OpenID Client ID to send to the issuer",
+			EnvVars:     []string{"GRAPH_EXPLORER_CLIENT_ID"},
+			Destination: &cfg.GraphExplorer.ClientID,
+		},
+		&cli.StringFlag{
+			Name:        "graph-url",
+			Value:       "http://localhost:9120",
+			Usage:       "Set the url to the graph api service",
+			EnvVars:     []string{"GRAPH_EXPLORER_GRAPH_URL"},
+			Destination: &cfg.GraphExplorer.GraphURL,
+		},
+	}
+}

graph-explorer/pkg/metrics/metrics.go

@@ -0,0 +1,32 @@
+package metrics
+
+var (
+	// Namespace defines the namespace for the defines metrics.
+	Namespace = "ocis"
+
+	// Subsystem defines the subsystem for the defines metrics.
+	Subsystem = "graph-explorer"
+)
+
+// Metrics defines the available metrics of this service.
+type Metrics struct {
+	// Counter  *prometheus.CounterVec
+}
+
+// New initializes the available metrics.
+func New() *Metrics {
+	m := &Metrics{
+		// Counter: prometheus.NewCounterVec(prometheus.CounterOpts{
+		// 	Namespace: Namespace,
+		// 	Subsystem: Subsystem,
+		// 	Name:      "greet_total",
+		// 	Help:      "How many greeting requests processed",
+		// }, []string{}),
+	}
+
+	// prometheus.Register(
+	// 	m.Counter,
+	// )
+
+	return m
+}

graph-explorer/pkg/server/debug/option.go

@@ -0,0 +1,50 @@
+package debug
+
+import (
+	"context"
+
+	"github.com/owncloud/ocis-pkg/v2/log"
+	"github.com/owncloud/ocis/graph-explorer/pkg/config"
+)
+
+// Option defines a single option function.
+type Option func(o *Options)
+
+// Options defines the available options for this package.
+type Options struct {
+	Logger  log.Logger
+	Context context.Context
+	Config  *config.Config
+}
+
+// newOptions initializes the available default options.
+func newOptions(opts ...Option) Options {
+	opt := Options{}
+
+	for _, o := range opts {
+		o(&opt)
+	}
+
+	return opt
+}
+
+// Logger provides a function to set the logger option.
+func Logger(val log.Logger) Option {
+	return func(o *Options) {
+		o.Logger = val
+	}
+}
+
+// Context provides a function to set the context option.
+func Context(val context.Context) Option {
+	return func(o *Options) {
+		o.Context = val
+	}
+}
+
+// Config provides a function to set the config option.
+func Config(val *config.Config) Option {
+	return func(o *Options) {
+		o.Config = val
+	}
+}

graph-explorer/pkg/server/debug/server.go

@@ -0,0 +1,51 @@
+package debug
+
+import (
+	"io"
+	"net/http"
+
+	"github.com/owncloud/ocis-pkg/v2/service/debug"
+	"github.com/owncloud/ocis/graph-explorer/pkg/config"
+	"github.com/owncloud/ocis/graph-explorer/pkg/version"
+)
+
+// Server initializes the debug service and server.
+func Server(opts ...Option) (*http.Server, error) {
+	options := newOptions(opts...)
+
+	return debug.NewService(
+		debug.Logger(options.Logger),
+		debug.Name("graph-explorer"),
+		debug.Version(version.String),
+		debug.Address(options.Config.Debug.Addr),
+		debug.Token(options.Config.Debug.Token),
+		debug.Pprof(options.Config.Debug.Pprof),
+		debug.Zpages(options.Config.Debug.Zpages),
+		debug.Health(health(options.Config)),
+		debug.Ready(ready(options.Config)),
+	), nil
+}
+
+// health implements the health check.
+func health(cfg *config.Config) func(http.ResponseWriter, *http.Request) {
+	return func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "text/plain")
+		w.WriteHeader(http.StatusOK)
+
+		// TODO(tboerger): check if services are up and running
+
+		io.WriteString(w, http.StatusText(http.StatusOK))
+	}
+}
+
+// ready implements the ready check.
+func ready(cfg *config.Config) func(http.ResponseWriter, *http.Request) {
+	return func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "text/plain")
+		w.WriteHeader(http.StatusOK)
+
+		// TODO(tboerger): check if services are up and running
+
+		io.WriteString(w, http.StatusText(http.StatusOK))
+	}
+}

graph-explorer/pkg/server/http/option.go

@@ -0,0 +1,76 @@
+package http
+
+import (
+	"context"
+
+	"github.com/micro/cli/v2"
+	"github.com/owncloud/ocis-pkg/v2/log"
+	"github.com/owncloud/ocis/graph-explorer/pkg/config"
+	"github.com/owncloud/ocis/graph-explorer/pkg/metrics"
+)
+
+// Option defines a single option function.
+type Option func(o *Options)
+
+// Options defines the available options for this package.
+type Options struct {
+	Logger    log.Logger
+	Context   context.Context
+	Config    *config.Config
+	Metrics   *metrics.Metrics
+	Flags     []cli.Flag
+	Namespace string
+}
+
+// newOptions initializes the available default options.
+func newOptions(opts ...Option) Options {
+	opt := Options{}
+
+	for _, o := range opts {
+		o(&opt)
+	}
+
+	return opt
+}
+
+// Logger provides a function to set the logger option.
+func Logger(val log.Logger) Option {
+	return func(o *Options) {
+		o.Logger = val
+	}
+}
+
+// Context provides a function to set the context option.
+func Context(val context.Context) Option {
+	return func(o *Options) {
+		o.Context = val
+	}
+}
+
+// Config provides a function to set the config option.
+func Config(val *config.Config) Option {
+	return func(o *Options) {
+		o.Config = val
+	}
+}
+
+// Metrics provides a function to set the metrics option.
+func Metrics(val *metrics.Metrics) Option {
+	return func(o *Options) {
+		o.Metrics = val
+	}
+}
+
+// Flags provides a function to set the flags option.
+func Flags(val []cli.Flag) Option {
+	return func(o *Options) {
+		o.Flags = append(o.Flags, val...)
+	}
+}
+
+// Namespace provides a function to set the Namespace option.
+func Namespace(val string) Option {
+	return func(o *Options) {
+		o.Namespace = val
+	}
+}

graph-explorer/pkg/server/http/server.go

@@ -0,0 +1,56 @@
+package http
+
+import (
+	"github.com/owncloud/ocis-pkg/v2/middleware"
+	"github.com/owncloud/ocis-pkg/v2/service/http"
+	svc "github.com/owncloud/ocis/graph-explorer/pkg/service/v0"
+	"github.com/owncloud/ocis/graph-explorer/pkg/version"
+)
+
+// Server initializes the http service and server.
+func Server(opts ...Option) (http.Service, error) {
+	options := newOptions(opts...)
+
+	service := http.NewService(
+		http.Logger(options.Logger),
+		http.Namespace(options.Namespace),
+		http.Name("graph-explorer"),
+		http.Version(version.String),
+		http.Address(options.Config.HTTP.Addr),
+		http.Context(options.Context),
+		http.Flags(options.Flags...),
+	)
+
+	handle := svc.NewService(
+		svc.Logger(options.Logger),
+		svc.Config(options.Config),
+		svc.Middleware(
+			middleware.RealIP,
+			middleware.RequestID,
+			middleware.Cache,
+			middleware.Cors,
+			middleware.Secure,
+			middleware.Version(
+				"graph-explorer",
+				version.String,
+			),
+			middleware.Logger(
+				options.Logger,
+			),
+		),
+	)
+
+	{
+		handle = svc.NewInstrument(handle, options.Metrics)
+		handle = svc.NewLogging(handle, options.Logger)
+		handle = svc.NewTracing(handle)
+	}
+
+	service.Handle(
+		"/",
+		handle,
+	)
+
+	service.Init()
+	return service, nil
+}

graph-explorer/pkg/service/v0/instrument.go

@@ -0,0 +1,30 @@
+package svc
+
+import (
+	"net/http"
+
+	"github.com/owncloud/ocis/graph-explorer/pkg/metrics"
+)
+
+// NewInstrument returns a service that instruments metrics.
+func NewInstrument(next Service, metrics *metrics.Metrics) Service {
+	return instrument{
+		next:    next,
+		metrics: metrics,
+	}
+}
+
+type instrument struct {
+	next    Service
+	metrics *metrics.Metrics
+}
+
+// ServeHTTP implements the Service interface.
+func (i instrument) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	i.next.ServeHTTP(w, r)
+}
+
+// ConfigJs implements the Service interface.
+func (i instrument) ConfigJs(w http.ResponseWriter, r *http.Request) {
+	i.next.ConfigJs(w, r)
+}

graph-explorer/pkg/service/v0/logging.go

@@ -0,0 +1,30 @@
+package svc
+
+import (
+	"net/http"
+
+	"github.com/owncloud/ocis-pkg/v2/log"
+)
+
+// NewLogging returns a service that logs messages.
+func NewLogging(next Service, logger log.Logger) Service {
+	return logging{
+		next:   next,
+		logger: logger,
+	}
+}
+
+type logging struct {
+	next   Service
+	logger log.Logger
+}
+
+// ServeHTTP implements the Service interface.
+func (l logging) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	l.next.ServeHTTP(w, r)
+}
+
+// ConfigJs implements the Service interface.
+func (l logging) ConfigJs(w http.ResponseWriter, r *http.Request) {
+	l.next.ConfigJs(w, r)
+}

graph-explorer/pkg/service/v0/option.go

@@ -0,0 +1,50 @@
+package svc
+
+import (
+	"net/http"
+
+	"github.com/owncloud/ocis-pkg/v2/log"
+	"github.com/owncloud/ocis/graph-explorer/pkg/config"
+)
+
+// Option defines a single option function.
+type Option func(o *Options)
+
+// Options defines the available options for this package.
+type Options struct {
+	Logger     log.Logger
+	Config     *config.Config
+	Middleware []func(http.Handler) http.Handler
+}
+
+// newOptions initializes the available default options.
+func newOptions(opts ...Option) Options {
+	opt := Options{}
+
+	for _, o := range opts {
+		o(&opt)
+	}
+
+	return opt
+}
+
+// Logger provides a function to set the logger option.
+func Logger(val log.Logger) Option {
+	return func(o *Options) {
+		o.Logger = val
+	}
+}
+
+// Config provides a function to set the config option.
+func Config(val *config.Config) Option {
+	return func(o *Options) {
+		o.Config = val
+	}
+}
+
+// Middleware provides a function to set the middleware option.
+func Middleware(val ...func(http.Handler) http.Handler) Option {
+	return func(o *Options) {
+		o.Middleware = val
+	}
+}

graph-explorer/pkg/service/v0/service.go

@@ -0,0 +1,104 @@
+package svc
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+
+	"github.com/go-chi/chi"
+	"github.com/owncloud/ocis-pkg/v2/log"
+	"github.com/owncloud/ocis/graph-explorer/pkg/assets"
+	"github.com/owncloud/ocis/graph-explorer/pkg/config"
+)
+
+// Service defines the extension handlers.
+type Service interface {
+	ServeHTTP(http.ResponseWriter, *http.Request)
+	ConfigJs(http.ResponseWriter, *http.Request)
+}
+
+// NewService returns a service implementation for Service.
+func NewService(opts ...Option) Service {
+	options := newOptions(opts...)
+
+	m := chi.NewMux()
+	m.Use(options.Middleware...)
+
+	svc := GraphExplorer{
+		logger: options.Logger,
+		config: options.Config,
+		mux:    m,
+	}
+
+	m.Route(options.Config.HTTP.Root, func(r chi.Router) {
+		r.Get("/config.js", svc.ConfigJs)
+		r.Mount("/", svc.Static())
+	})
+
+	return svc
+}
+
+// GraphExplorer defines implements the business logic for Service.
+type GraphExplorer struct {
+	logger log.Logger
+	config *config.Config
+	mux    *chi.Mux
+}
+
+// ServeHTTP implements the Service interface.
+func (p GraphExplorer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	p.mux.ServeHTTP(w, r)
+}
+
+// ConfigJs implements the Service interface.
+func (p GraphExplorer) ConfigJs(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "application/javascript")
+	w.WriteHeader(http.StatusOK)
+	io.WriteString(w, fmt.Sprintf("window.ClientId = \"%v\";", p.config.GraphExplorer.ClientID))
+	io.WriteString(w, fmt.Sprintf("window.Iss = \"%v\";", p.config.GraphExplorer.Issuer))
+	io.WriteString(w, fmt.Sprintf("window.GraphUrl = \"%v\";", p.config.GraphExplorer.GraphURL))
+}
+
+// Static simply serves all static files.
+func (p GraphExplorer) Static() http.HandlerFunc {
+	rootWithSlash := p.config.HTTP.Root
+
+	if !strings.HasSuffix(rootWithSlash, "/") {
+		rootWithSlash = rootWithSlash + "/"
+	}
+
+	static := http.StripPrefix(
+		rootWithSlash,
+		http.FileServer(
+			assets.New(
+				assets.Logger(p.logger),
+				assets.Config(p.config),
+			),
+		),
+	)
+
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if rootWithSlash != "/" && r.URL.Path == p.config.HTTP.Root {
+			http.Redirect(
+				w,
+				r,
+				rootWithSlash,
+				http.StatusMovedPermanently,
+			)
+
+			return
+		}
+
+		if r.URL.Path != rootWithSlash && strings.HasSuffix(r.URL.Path, "/") {
+			http.NotFound(
+				w,
+				r,
+			)
+
+			return
+		}
+
+		static.ServeHTTP(w, r)
+	})
+}

graph-explorer/pkg/service/v0/tracing.go

@@ -0,0 +1,26 @@
+package svc
+
+import (
+	"net/http"
+)
+
+// NewTracing returns a service that instruments traces.
+func NewTracing(next Service) Service {
+	return tracing{
+		next: next,
+	}
+}
+
+type tracing struct {
+	next Service
+}
+
+// ServeHTTP implements the Service interface.
+func (t tracing) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	t.next.ServeHTTP(w, r)
+}
+
+// ConfigJs implements the Service interface.
+func (t tracing) ConfigJs(w http.ResponseWriter, r *http.Request) {
+	t.next.ConfigJs(w, r)
+}

graph-explorer/pkg/version/version.go

@@ -0,0 +1,19 @@
+package version
+
+import (
+	"time"
+)
+
+var (
+	// String gets defined by the build system.
+	String = "0.0.0"
+
+	// Date indicates the build date.
+	Date = "00000000"
+)
+
+// Compiled returns the compile time of this service.
+func Compiled() time.Time {
+	t, _ := time.Parse("20060102", Date)
+	return t
+}