arcast/pkg/server/server.go

package server

import (
	"context"
	"crypto/tls"

	"forge.cadoles.com/arcad/arcast/pkg/browser"
	"github.com/pkg/errors"
	"gitlab.com/wpetit/goweb/logger"
)

type Server struct {
	browser browser.Browser

	instanceID string

	address string
	port    int

	tlsAddress string
	tlsPort    int
	tlsCert    *tls.Certificate

	serviceDiscoveryEnabled bool

	appsEnabled bool
	defaultApp  string
	apps        []App

	ctx    context.Context
	cancel context.CancelFunc
}

func (s *Server) Start() error {
	serverCtx, cancelServer := context.WithCancel(context.Background())

	s.cancel = cancelServer
	s.ctx = serverCtx

	webServersCtx, cancelWebServers := context.WithCancel(serverCtx)
	if err := s.startWebServers(webServersCtx); err != nil {
		cancelWebServers()
		return errors.WithStack(err)
	}

	if s.serviceDiscoveryEnabled {
		mdnsServerCtx, cancelMDNSServer := context.WithCancel(serverCtx)
		if err := s.startMDNServer(mdnsServerCtx); err != nil {
			cancelWebServers()
			cancelMDNSServer()
			return errors.WithStack(err)
		}
	} else {
		logger.Info(serverCtx, "service discovery disabled")
	}

	return nil
}

func (s *Server) Stop() error {
	if s.cancel != nil {
		s.cancel()
	}

	return nil
}

func (s *Server) Wait() error {
	<-s.ctx.Done()

	if err := s.ctx.Err(); err != nil {
		return errors.WithStack(err)
	}

	return nil
}

func New(browser browser.Browser, funcs ...OptionFunc) *Server {
	opts := NewOptions(funcs...)

	return &Server{
		browser:                 browser,
		instanceID:              opts.InstanceID,
		address:                 opts.Address,
		tlsAddress:              opts.TLSAddress,
		tlsCert:                 opts.TLSCertificate,
		appsEnabled:             opts.EnableApps,
		defaultApp:              opts.DefaultApp,
		apps:                    opts.Apps,
		serviceDiscoveryEnabled: opts.EnableServiceDiscovery,
	}
}