|
1 | 1 | package main |
2 | 2 |
|
3 | 3 | import ( |
| 4 | + "bytes" |
4 | 5 | "context" |
| 6 | + "encoding/json" |
| 7 | + "net/http" |
5 | 8 | "os" |
6 | 9 | "os/signal" |
7 | 10 | "sync" |
8 | 11 | "syscall" |
9 | 12 | "time" |
10 | 13 |
|
11 | | - _ "github.com/go-sql-driver/mysql" // MySQL / MariaDB driver |
12 | | - _ "github.com/lib/pq" // PostgreSQL driver |
| 14 | + "github.com/go-chi/chi/v5" |
| 15 | + "github.com/retail-ai-inc/sync/pkg/api" |
13 | 16 | "github.com/retail-ai-inc/sync/pkg/config" |
14 | 17 | "github.com/retail-ai-inc/sync/pkg/logger" |
15 | 18 | "github.com/retail-ai-inc/sync/pkg/syncer" |
16 | 19 | "github.com/retail-ai-inc/sync/pkg/utils" |
| 20 | + "github.com/sirupsen/logrus" |
17 | 21 | ) |
18 | 22 |
|
19 | | -// Interval for row count monitoring every minute |
20 | 23 | const monitorInterval = time.Second * 60 |
21 | 24 |
|
22 | 25 | func main() { |
23 | | - // Initialize context |
| 26 | + cfg := config.NewConfig() |
| 27 | + log := logger.InitLogger(cfg.LogLevel) |
| 28 | + |
| 29 | + if _, err := os.Stat("ui/dist"); os.IsNotExist(err) { |
| 30 | + log.Info("ui/dist directory does not exist, extracting ui/dist.zip...") |
| 31 | + if err := utils.UnzipDistFile("ui/dist.zip", "ui/"); err != nil { |
| 32 | + log.Errorf("Error unzipping dist.zip: %v", err) |
| 33 | + return |
| 34 | + } |
| 35 | + log.Info("ui/dist directory extracted successfully.") |
| 36 | + } |
| 37 | + |
24 | 38 | ctx, cancel := context.WithCancel(context.Background()) |
25 | 39 | defer cancel() |
26 | | - |
27 | | - // Capture system interrupt signal |
28 | | - c := make(chan os.Signal, 1) |
29 | | - signal.Notify(c, os.Interrupt, syscall.SIGTERM) |
| 40 | + sigs := make(chan os.Signal, 1) |
| 41 | + signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM) |
30 | 42 | go func() { |
31 | | - <-c |
32 | | - logger.Log.Info("Received interrupt signal, exiting...") |
| 43 | + <-sigs |
33 | 44 | cancel() |
34 | 45 | }() |
35 | 46 |
|
36 | | - // Load configuration |
37 | | - cfg := config.NewConfig() |
38 | | - log := logger.InitLogger(cfg.LogLevel) |
| 47 | + if cfg.EnableTableRowCountMonitoring { |
| 48 | + utils.StartRowCountMonitoring(ctx, cfg, log, monitorInterval) |
| 49 | + } |
| 50 | + |
| 51 | + router := chi.NewRouter() |
| 52 | + router.Mount("/api", api.NewRouter()) |
| 53 | + router.Handle("/*", http.StripPrefix("/", http.FileServer(http.Dir("ui/dist")))) |
| 54 | + |
| 55 | + server := &http.Server{ |
| 56 | + Addr: ":8080", |
| 57 | + Handler: router, |
| 58 | + } |
| 59 | + go func() { |
| 60 | + log.Info("UI is running at http://localhost:8080") |
| 61 | + if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed { |
| 62 | + log.Errorf("HTTP server error: %v", err) |
| 63 | + cancel() |
| 64 | + } |
| 65 | + }() |
| 66 | + |
| 67 | + go runSyncTasks(ctx, log, cfg) |
39 | 68 |
|
40 | | - // Start backend synchronization |
| 69 | + <-ctx.Done() |
| 70 | + shutdownCtx, shutdownCancel := context.WithTimeout(context.Background(), 10*time.Second) |
| 71 | + defer shutdownCancel() |
| 72 | + if err := server.Shutdown(shutdownCtx); err != nil { |
| 73 | + log.Errorf("HTTP server Shutdown error: %v", err) |
| 74 | + } else { |
| 75 | + log.Info("HTTP server gracefully stopped") |
| 76 | + } |
| 77 | + |
| 78 | + time.Sleep(2 * time.Second) |
| 79 | + log.Info("Program exited") |
| 80 | +} |
| 81 | + |
| 82 | +func runSyncTasks(parentCtx context.Context, log *logrus.Logger, cfg *config.Config) { |
| 83 | + configReloadInterval := 10 * time.Second |
| 84 | + currentConfig := cfg |
41 | 85 | var wg sync.WaitGroup |
| 86 | + syncCtx, syncCancel := context.WithCancel(parentCtx) |
| 87 | + startSyncTasks(syncCtx, currentConfig, &wg, log) |
| 88 | + ticker := time.NewTicker(configReloadInterval) |
| 89 | + defer ticker.Stop() |
| 90 | + |
| 91 | + // Monitor for config changes and restart row count monitoring if needed |
| 92 | + var rowCountMonitorCancel context.CancelFunc |
| 93 | + var rowCountMonitorCtx context.Context // Declare the context variable here |
| 94 | + |
| 95 | + for { |
| 96 | + select { |
| 97 | + case <-parentCtx.Done(): |
| 98 | + syncCancel() |
| 99 | + wg.Wait() |
| 100 | + if rowCountMonitorCancel != nil { |
| 101 | + rowCountMonitorCancel() |
| 102 | + } |
| 103 | + return |
| 104 | + case <-ticker.C: |
| 105 | + newConfig := config.NewConfig() |
| 106 | + if !configsEqual(currentConfig, newConfig) { |
| 107 | + log.Info("Config change detected, restarting sync tasks and row count monitoring...") |
| 108 | + syncCancel() |
| 109 | + wg.Wait() |
| 110 | + |
| 111 | + // Stop the row count monitoring if it was started |
| 112 | + if rowCountMonitorCancel != nil { |
| 113 | + rowCountMonitorCancel() |
| 114 | + } |
| 115 | + |
| 116 | + currentConfig = newConfig |
| 117 | + syncCtx, syncCancel = context.WithCancel(parentCtx) |
| 118 | + wg = sync.WaitGroup{} |
| 119 | + startSyncTasks(syncCtx, currentConfig, &wg, log) |
| 120 | + |
| 121 | + // Restart row count monitoring if needed |
| 122 | + if currentConfig.EnableTableRowCountMonitoring { |
| 123 | + // Cancel the previous row count monitoring context (if any) |
| 124 | + if rowCountMonitorCancel != nil { |
| 125 | + rowCountMonitorCancel() |
| 126 | + } |
| 127 | + // Start a new row count monitoring with a fresh context |
| 128 | + rowCountMonitorCtx, rowCountMonitorCancel = context.WithCancel(parentCtx) |
| 129 | + utils.StartRowCountMonitoring(rowCountMonitorCtx, currentConfig, log, monitorInterval) |
| 130 | + } |
| 131 | + } |
| 132 | + } |
| 133 | + } |
| 134 | +} |
| 135 | + |
| 136 | +func startSyncTasks(ctx context.Context, cfg *config.Config, wg *sync.WaitGroup, log *logrus.Logger) { |
42 | 137 | for _, syncCfg := range cfg.SyncConfigs { |
43 | 138 | if !syncCfg.Enable { |
44 | 139 | continue |
45 | 140 | } |
46 | 141 | wg.Add(1) |
47 | 142 | switch syncCfg.Type { |
48 | 143 | case "mongodb": |
49 | | - go func(syncCfg config.SyncConfig) { |
| 144 | + go func(sc config.SyncConfig) { |
50 | 145 | defer wg.Done() |
51 | | - syncer := syncer.NewMongoDBSyncer(syncCfg, log) |
52 | | - syncer.Start(ctx) |
| 146 | + syncer.NewMongoDBSyncer(sc, log).Start(ctx) |
53 | 147 | }(syncCfg) |
54 | | - case "mysql": |
55 | | - go func(syncCfg config.SyncConfig) { |
| 148 | + case "mysql", "mariadb": |
| 149 | + go func(sc config.SyncConfig) { |
56 | 150 | defer wg.Done() |
57 | | - syncer := syncer.NewMySQLSyncer(syncCfg, log) |
58 | | - syncer.Start(ctx) |
59 | | - }(syncCfg) |
60 | | - case "mariadb": |
61 | | - go func(syncCfg config.SyncConfig) { |
62 | | - defer wg.Done() |
63 | | - syncer := syncer.NewMariaDBSyncer(syncCfg, log) |
64 | | - syncer.Start(ctx) |
| 151 | + syncer.NewMySQLSyncer(sc, log).Start(ctx) |
65 | 152 | }(syncCfg) |
66 | 153 | case "postgresql": |
67 | | - go func(syncCfg config.SyncConfig) { |
| 154 | + go func(sc config.SyncConfig) { |
68 | 155 | defer wg.Done() |
69 | | - syncer := syncer.NewPostgreSQLSyncer(syncCfg, log) |
70 | | - syncer.Start(ctx) |
| 156 | + syncer.NewPostgreSQLSyncer(sc, log).Start(ctx) |
71 | 157 | }(syncCfg) |
72 | 158 | case "redis": |
73 | | - go func(syncCfg config.SyncConfig) { |
| 159 | + go func(sc config.SyncConfig) { |
74 | 160 | defer wg.Done() |
75 | | - syncer := syncer.NewRedisSyncer(syncCfg, log) |
76 | | - syncer.Start(ctx) |
| 161 | + syncer.NewRedisSyncer(sc, log).Start(ctx) |
77 | 162 | }(syncCfg) |
78 | 163 | default: |
79 | 164 | log.Errorf("Unknown sync type: %s", syncCfg.Type) |
80 | 165 | wg.Done() |
81 | 166 | } |
82 | 167 | } |
| 168 | +} |
83 | 169 |
|
84 | | - // Start monitoring goroutine: output row counts every minute for each mapped table (source/target) |
85 | | - if cfg.EnableTableRowCountMonitoring { |
86 | | - utils.StartRowCountMonitoring(ctx, cfg, log, monitorInterval) |
| 170 | +func configsEqual(c1, c2 *config.Config) bool { |
| 171 | + b1, err1 := json.Marshal(c1.SyncConfigs) |
| 172 | + b2, err2 := json.Marshal(c2.SyncConfigs) |
| 173 | + if err1 != nil || err2 != nil { |
| 174 | + return false |
87 | 175 | } |
88 | | - |
89 | | - // Wait for all sync to complete |
90 | | - wg.Wait() |
91 | | - logger.Log.Info("All synchronization tasks have completed.") |
92 | | - |
93 | | - // Wait for program to end |
94 | | - <-ctx.Done() |
95 | | - logger.Log.Info("Program has exited") |
| 176 | + return bytes.Equal(b1, b2) |
96 | 177 | } |
0 commit comments