zhangzengfei
2023-09-04 e8e536d1cb52d2126c8c7ce2ba1c7a76f7208678
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
package main
 
import (
    "context"
    "flag"
    "fmt"
    "os"
    "os/signal"
    "sync"
    "syscall"
 
    "vamicro/config"
    "vamicro/version-control/api"
    "vamicro/version-control/controller"
    "vamicro/version-control/service"
 
    "basic.com/valib/bhomeclient.git"
    "basic.com/valib/bhomedbapi.git"
    "basic.com/valib/logger.git"
    "basic.com/valib/version.git"
)
 
var (
    env      = flag.String("e", "pro", "")
    procName = service.ProcName
    proc     = &bhomeclient.ProcInfo{
        Name: procName, //进程名称
        ID:   procName, //进程id
        Info: "",       //进程的描述信息,用于区分同一进程名称下多个进程
    }
)
 
func init() {
    flag.Parse()
    vaversion.Usage()
 
    config.Init(*env)
 
    // 日志初始化
    var logFile = config.LogConf.Path + "vamicro-" + procName + ".log"
    logger.InitLogger(logFile, config.LogConf.Level, config.LogConf.MaxSize, config.LogConf.MaxBackups, config.LogConf.MaxAge)
    logger.Info("log init success !")
}
 
func main() {
    //防止多进程运行
    lockFile := "/tmp/run/version-control.lock"
    var lock *os.File
    lock, err := os.Create(lockFile)
    if err != nil {
        fmt.Println("create lock file error", err)
        os.Exit(1)
    }
 
    defer os.Remove(lockFile)
    defer lock.Close()
 
    err = syscall.Flock(int(lock.Fd()), syscall.LOCK_EX|syscall.LOCK_NB)
    if err != nil {
        fmt.Println("report service is running ")
        os.Exit(1)
    }
 
    defer syscall.Flock(int(lock.Fd()), syscall.LOCK_UN)
 
    wg := &sync.WaitGroup{}
    q := make(chan os.Signal, 1)
    signal.Notify(q, os.Interrupt, os.Kill, syscall.SIGTERM)
 
    fm, pubTopics := initFuncMap()
    ctx, cancel := context.WithCancel(context.Background())
 
    var reg = &bhomeclient.RegisterInfo{
        Proc:     *proc,
        Channel:  nil,
        PubTopic: pubTopics,
        SubTopic: []string{},
    }
    ms, err := bhomeclient.NewMicroNode(ctx, q, config.Server.AnalyServerId, reg, nil)
    if err != nil {
        return
    }
    bhomedbapi.InitGetNetNode(ms.GetLocalNetNodeByTopic)
    bhomedbapi.InitDoReq(ms.RequestOnly)
    bhomedbapi.InitLog(logger.Debug)
 
    server := api.InitRouter(wg, ms)
 
    go ms.StartServer(fm)
 
    go service.SelfUpdateStart(ctx, ms) //自动更新
 
    go service.NoticeTick(ctx) //更新提醒
 
    go service.AuthorizationUpdate(ctx, ms) //更新授权
 
    go service.BakSchedule(ctx)
 
    <-q
    logger.Info("user signalled...")
 
    // shutdown http service gracefully
    if err := server.Shutdown(ctx); nil != err {
        logger.Fatal("server shutdown failed, err:", err)
    }
 
    cancel()
    wg.Wait()
    logger.Info("all sub threads exited...")
 
    //upgrade.CheckVersion()
 
    //fmt.Println("appver.BuildTime:", appver.BuildTime, "IvyTest:", IvyTest)
    //ctx, cancel := context.WithCancel(context.Background())
}
 
const urlPrefix = "/data/api-v"
 
func initFuncMap() (map[string]bhomeclient.MicroFunc, []string) {
    funcMap := make(map[string]bhomeclient.MicroFunc)
    vController := new(controller.VersionController)
 
    funcMap[urlPrefix+"/version/check"] = vController.VersionCheck
    funcMap[urlPrefix+"/version/upgrade"] = vController.UpgradeVersion
    funcMap[urlPrefix+"/version/snBus"] = vController.SnWithBus
 
    var pubTopics []string
    for key, _ := range funcMap {
        pubTopics = append(pubTopics, key)
    }
    return funcMap, pubTopics
}