metricator/internal/application/application.go

80 lines
2.1 KiB
Go
Raw Normal View History

package application
import (
"context"
"net/http"
"sync"
"go.dev.pztrn.name/metricator/internal/common"
2020-12-23 16:28:57 +05:00
"go.dev.pztrn.name/metricator/internal/logger"
"go.dev.pztrn.name/metricator/internal/storage"
"go.dev.pztrn.name/metricator/internal/storage/memory"
)
// Application is a thing that responsible for all application-related
// actions like data fetching, storing, etc. on higher level.
type Application struct {
2020-12-23 19:31:09 +05:00
ctx context.Context
storage storage.Metrics
config *Config
doneChan chan struct{}
logger *logger.Logger
storageDone chan struct{}
httpClient *http.Client
name string
fetchIsRunningMutex sync.RWMutex
2020-12-23 19:31:09 +05:00
fetchIsRunning bool
}
// NewApplication creates new application.
2020-12-23 16:28:57 +05:00
func NewApplication(ctx context.Context, name string, config *Config, logger *logger.Logger) *Application {
2021-11-21 14:45:09 +05:00
// Some variables are initialized in initialize() function.
// nolint:exhaustivestruct
app := &Application{
config: config,
ctx: ctx,
doneChan: make(chan struct{}),
2020-12-23 16:28:57 +05:00
logger: logger,
name: name,
}
2021-11-21 14:45:09 +05:00
app.initialize()
2021-11-21 14:45:09 +05:00
return app
}
// GetDoneChan returns a channel which should be used to block execution until
// application's routines are completed.
func (a *Application) GetDoneChan() chan struct{} {
return a.doneChan
}
// GetHandler returns HTTP requests handling function.
func (a *Application) GetHandler() common.HTTPHandlerFunc {
return a.respond
}
// Initializes internal things like storage, HTTP client, etc.
func (a *Application) initialize() {
2020-12-23 16:28:57 +05:00
a.storage, a.storageDone = memory.NewStorage(a.ctx, a.name+" storage", a.logger)
2020-12-23 16:28:57 +05:00
a.logger.Debugf("Application '%s' initialized with configuration: %+v\n", a.name, a.config)
}
// Start starts asynchronous things like data fetching, storage cleanup, etc.
func (a *Application) Start() {
a.storage.Start()
go a.startFetcher()
// The Context Listening Goroutine.
go func() {
<-a.ctx.Done()
// We should wait until storage routines are also stopped.
<-a.storage.GetDoneChan()
2020-12-23 16:28:57 +05:00
a.logger.Infoln("Application", a.name, "stopped")
a.doneChan <- struct{}{}
}()
}