153 lines
3.7 KiB
Go
153 lines
3.7 KiB
Go
package apiimp
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/go-chi/chi/v5"
|
|
"github.com/tech/sendico/notification/interface/api"
|
|
"github.com/tech/sendico/notification/interface/api/localizer"
|
|
"github.com/tech/sendico/notification/interface/services/amplitude"
|
|
"github.com/tech/sendico/notification/interface/services/notification"
|
|
"github.com/tech/sendico/pkg/db"
|
|
"github.com/tech/sendico/pkg/domainprovider"
|
|
"github.com/tech/sendico/pkg/messaging"
|
|
"github.com/tech/sendico/pkg/mlogger"
|
|
"github.com/tech/sendico/pkg/mservice"
|
|
"go.uber.org/zap"
|
|
)
|
|
|
|
type Microservices = []mservice.MicroService
|
|
|
|
type APIImp struct {
|
|
logger mlogger.Logger
|
|
db db.Factory
|
|
localizer localizer.Localizer
|
|
domain domainprovider.DomainProvider
|
|
config *api.Config
|
|
services Microservices
|
|
debug bool
|
|
mw *Middleware
|
|
router *chi.Mux
|
|
}
|
|
|
|
func (a *APIImp) installMicroservice(srv mservice.MicroService) {
|
|
a.services = append(a.services, srv)
|
|
a.logger.Info("Microservice installed", zap.String("service", srv.Name()))
|
|
}
|
|
|
|
func (a *APIImp) addMicroservice(srvf api.MicroServiceFactoryT) error {
|
|
srv, err := srvf(a)
|
|
if err != nil {
|
|
a.logger.Error("Failed to install a microservice", zap.Error(err))
|
|
return err
|
|
}
|
|
|
|
a.installMicroservice(srv)
|
|
return nil
|
|
}
|
|
|
|
func (a *APIImp) Logger() mlogger.Logger {
|
|
return a.logger
|
|
}
|
|
|
|
func (a *APIImp) Config() *api.Config {
|
|
return a.config
|
|
}
|
|
|
|
func (a *APIImp) Localizer() localizer.Localizer {
|
|
return a.localizer
|
|
}
|
|
|
|
func (a *APIImp) DBFactory() db.Factory {
|
|
return a.db
|
|
}
|
|
|
|
func (a *APIImp) DomainProvider() domainprovider.DomainProvider {
|
|
return a.domain
|
|
}
|
|
|
|
func (a *APIImp) Register() messaging.Register {
|
|
return a.mw
|
|
}
|
|
|
|
func (a *APIImp) Router() *chi.Mux {
|
|
return a.router
|
|
}
|
|
|
|
func (a *APIImp) installServices() error {
|
|
srvf := make([]api.MicroServiceFactoryT, 0)
|
|
|
|
srvf = append(srvf, amplitude.Create)
|
|
srvf = append(srvf, notification.Create)
|
|
|
|
for _, v := range srvf {
|
|
err := a.addMicroservice(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
a.mw.SetStatus("ok")
|
|
return nil
|
|
}
|
|
|
|
func (a *APIImp) Finish(ctx context.Context) error {
|
|
a.mw.SetStatus("deactivating")
|
|
a.mw.Finish()
|
|
var lastError error
|
|
// stop services in the reverse order
|
|
for i := len(a.services) - 1; i >= 0; i-- {
|
|
err := (a.services[i]).Finish(ctx)
|
|
if err != nil {
|
|
lastError = err
|
|
a.logger.Warn("Error occurred when finishing service",
|
|
zap.Error(err),
|
|
zap.String("service_name", (a.services[i]).Name()))
|
|
} else {
|
|
a.logger.Info("Microservice is down",
|
|
zap.String("service_name", (a.services[i]).Name()))
|
|
}
|
|
}
|
|
return lastError
|
|
}
|
|
|
|
func (a *APIImp) Name() string {
|
|
return "api"
|
|
}
|
|
|
|
func CreateAPI(logger mlogger.Logger, config *api.Config, l localizer.Localizer, db db.Factory, router *chi.Mux, debug bool) (mservice.MicroService, error) {
|
|
p := new(APIImp)
|
|
p.logger = logger.Named("api")
|
|
p.debug = debug
|
|
p.config = config
|
|
p.db = db
|
|
p.localizer = l
|
|
p.router = router
|
|
|
|
var err error
|
|
if p.domain, err = domainprovider.CreateDomainProvider(p.logger, config.Mw.DomainEnv, config.Mw.APIProtocolEnv, config.Mw.EndPointEnv); err != nil {
|
|
p.logger.Error("Failed to initizlize domain provider")
|
|
return nil, err
|
|
}
|
|
odb, err := db.NewOrganizationDB()
|
|
if err != nil {
|
|
p.logger.Warn("Failed to create organization database", zap.Error(err))
|
|
return nil, err
|
|
}
|
|
|
|
if p.mw, err = CreateMiddleware(logger, odb, router, config.Mw, debug); err != nil {
|
|
p.logger.Warn("Failed to create middleware", zap.Error(err))
|
|
return nil, err
|
|
}
|
|
|
|
p.logger.Info("Installing microservices...")
|
|
if err := p.installServices(); err != nil {
|
|
p.logger.Error("Failed to install a microservice", zap.Error(err))
|
|
return nil, err
|
|
}
|
|
|
|
p.logger.Info("Microservices installation complete", zap.Int("microservices", len(p.services)))
|
|
|
|
return p, nil
|
|
}
|