mirror of
https://github.com/makeplane/plane.git
synced 2026-07-12 13:29:56 +02:00
122 lines
3.4 KiB
Go
122 lines
3.4 KiB
Go
/*
|
|
Copyright © 2024 plane.so engineering@plane.so
|
|
*/
|
|
package cmd
|
|
|
|
import (
|
|
"context"
|
|
"os"
|
|
"os/signal"
|
|
"syscall"
|
|
|
|
prime_api "github.com/makeplane/plane-ee/monitor/lib/api"
|
|
"github.com/makeplane/plane-ee/monitor/lib/feat_flag"
|
|
"github.com/makeplane/plane-ee/monitor/pkg/constants/descriptors"
|
|
"github.com/makeplane/plane-ee/monitor/pkg/db"
|
|
"github.com/makeplane/plane-ee/monitor/pkg/handlers"
|
|
"github.com/makeplane/plane-ee/monitor/pkg/types"
|
|
"github.com/makeplane/plane-ee/monitor/pkg/worker"
|
|
"github.com/spf13/cobra"
|
|
)
|
|
|
|
var StartCmd = &cobra.Command{
|
|
Use: descriptors.CMD_START_USAGE,
|
|
Short: descriptors.CMD_START_USAGE_DESC,
|
|
RunE: func(cmd *cobra.Command, args []string) error {
|
|
healthCheckInterval, err := cmd.Flags().GetInt(descriptors.FLAG_INTERVAL_HEALTHCHECK)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
flagResyncInterval, err := cmd.Flags().GetInt(descriptors.FLAG_INTERVAL_RESYNC)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
|
|
db.Initialize()
|
|
|
|
_, err = feat_flag.ParsePrivateKey(PRIVATE_KEY)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// If we are upgraded, we need to update all the licenses present inside the
|
|
// DB to the current version
|
|
|
|
// Establish signals for catching signal interrupts
|
|
sigs := make(chan os.Signal, 1)
|
|
signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
|
|
|
|
// Initializing cronhandler for cron tasks
|
|
cronHandler := handlers.NewCronHandler(types.Credentials{
|
|
InstanceId: INSTANCE_ID,
|
|
Host: HOST,
|
|
MachineSignature: MACHINE_SIGNATURE,
|
|
AppDomain: APP_DOMAIN,
|
|
AppVersion: APP_VERSION,
|
|
}, CmdLogger)
|
|
|
|
api := prime_api.NewMonitorApi(HOST, MACHINE_SIGNATURE, INSTANCE_ID, APP_VERSION)
|
|
|
|
// Initializing the http handler for addressing requests
|
|
httpHandler := handlers.NewHttpHandler(handlers.HTTPHandlerOptions{
|
|
Host: "0.0.0.0",
|
|
Port: PORT,
|
|
Logger: *CmdLogger,
|
|
PrivateKey: PRIVATE_KEY,
|
|
Api: &api,
|
|
})
|
|
|
|
instanceHandler := handlers.NewInstanceHandler(api)
|
|
|
|
cronHandler.ScheduleCronJobs(handlers.SchedulerOptions{
|
|
HealthCheckInterval: int64(healthCheckInterval),
|
|
ResyncFlagsInterval: int64(flagResyncInterval),
|
|
})
|
|
|
|
/* TODO: If the db has an encrypted cypher then we can instantiate the
|
|
* feature flag engine right away, else we cannot instantiate */
|
|
|
|
// Creating a new instance of the worker
|
|
worker := worker.NewPrimeWorker(CmdLogger)
|
|
|
|
// Notify the channel on interrupt signals (Ctrl+C)
|
|
go func() {
|
|
<-sigs
|
|
err := instanceHandler.Deactivate()
|
|
if err != nil {
|
|
CmdLogger.Error(context.Background(), err.Error())
|
|
}
|
|
worker.Shutdown()
|
|
}()
|
|
|
|
worker.RegisterJob("Prime Scheduler", cronHandler.Start)
|
|
worker.RegisterJob("Prime Monitor Router", httpHandler.StartHttpServer)
|
|
worker.RegisterJob("Activate Current Instance", func(ctx context.Context) {
|
|
err := instanceHandler.Activate()
|
|
if err != nil {
|
|
CmdLogger.Error(ctx, err.Error())
|
|
}
|
|
})
|
|
// Registering the Jobs to the cron handler
|
|
worker.RegisterJob("Resync Instance Licenses", func(ctx context.Context) {
|
|
err := handlers.UpdateFlagsHandler(ctx, api)
|
|
if err != nil {
|
|
CmdLogger.Error(ctx, err.Error())
|
|
}
|
|
})
|
|
|
|
// Starting the Jobs in background
|
|
worker.StartJobsInBackground()
|
|
worker.Wait()
|
|
|
|
return nil
|
|
},
|
|
}
|
|
|
|
func init() {
|
|
StartCmd.Flags().Int(descriptors.FLAG_INTERVAL_HEALTHCHECK, 5, descriptors.FLAG_INTERVAL_HEALTHCHECK_USE)
|
|
StartCmd.Flags().Int(descriptors.FLAG_INTERVAL_RESYNC, 300, descriptors.FLAG_INTERVAL_RESYNC_USE)
|
|
rootCmd.AddCommand(StartCmd)
|
|
}
|