370 lines
11 KiB
Go
370 lines
11 KiB
Go
package a_init
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"github.com/spf13/viper"
|
|
"gopkg.in/yaml.v3"
|
|
"io/ioutil"
|
|
"reflect"
|
|
"strings"
|
|
"time"
|
|
"wdd.io/agent-common/logger"
|
|
"wdd.io/agent-go/a_agent"
|
|
"wdd.io/agent-go/a_executor"
|
|
"wdd.io/agent-go/a_status"
|
|
"wdd.io/agent-go/g"
|
|
"wdd.io/agent-go/rabbitmq"
|
|
)
|
|
|
|
var initOmType = g.InitOmType
|
|
var P = g.G.P
|
|
|
|
var log = logger.Log
|
|
|
|
func INIT(octopusAgentConfigFileName string, agentServerInfoConf string) chan bool {
|
|
|
|
// 获取系统的环境变量
|
|
agentServerInfo := parseAgentServerInfo(agentServerInfoConf)
|
|
// todo totally get from a_status module
|
|
|
|
// re-get agentInfo from status module
|
|
agentInfo := a_status.ReportAgentInfo()
|
|
refreshAgentInfoByStatusInfo(agentInfo, agentServerInfo)
|
|
|
|
// build operator cache
|
|
BuildAgentOsOperator(agentInfo, agentServerInfo)
|
|
|
|
// 缓存此内容
|
|
a_agent.AgentServerInfoCache = agentServerInfo
|
|
|
|
// 初始化Nacos的连接配置
|
|
agentConfig := ParseConfiguration(octopusAgentConfigFileName)
|
|
a_agent.AgentConfig = agentConfig
|
|
|
|
// build for octopus tcp connect info struct
|
|
rabbitTCPConnectInfo := BuildOctopusTCPConnect(agentConfig)
|
|
|
|
initToServerProp := &rabbitmq.ConnectProperty{
|
|
ExchangeName: agentConfig.GetString("octopus.message.init_exchange"),
|
|
QueueName: agentConfig.GetString("octopus.message.init_to_server"),
|
|
ExchangeType: g.QueueDirect,
|
|
TopicKey: agentConfig.GetString("octopus.message.init_to_server_key"),
|
|
}
|
|
|
|
initFromServerProp := &rabbitmq.ConnectProperty{
|
|
ExchangeName: agentConfig.GetString("octopus.message.init_exchange"),
|
|
QueueName: agentConfig.GetString("octopus.message.init_from_server"),
|
|
ExchangeType: g.QueueDirect,
|
|
TopicKey: agentConfig.GetString("octopus.message.init_from_server_key"),
|
|
}
|
|
|
|
// 建立RabbitMQ的连接
|
|
initToServerQueue := &rabbitmq.RabbitQueue{
|
|
RabbitProp: initToServerProp,
|
|
RabbitConnectInfo: rabbitTCPConnectInfo,
|
|
}
|
|
//defer initToServerQueue.Close()
|
|
|
|
// 建立连接
|
|
initToServerQueue.Connect()
|
|
|
|
// 监听初始化连接中的信息
|
|
initFromServerQueue := &rabbitmq.RabbitQueue{
|
|
RabbitProp: initFromServerProp,
|
|
RabbitConnectInfo: rabbitTCPConnectInfo,
|
|
}
|
|
//defer initFromServerQueue.Close()
|
|
|
|
// 建立连接
|
|
initFromServerQueue.Connect()
|
|
|
|
initFromServerQueue.Handle()
|
|
|
|
buildAndSendInitMsgToServer(agentServerInfo, initToServerQueue)
|
|
|
|
// receive from server
|
|
for g.G.AgentHasRegister == false {
|
|
select {
|
|
case initFromServerMsg := <-initFromServerQueue.ReceiveChan.InitRChan:
|
|
if handleInitMsgFromServer(initFromServerMsg, initToServerQueue, agentServerInfo) {
|
|
break
|
|
}
|
|
default:
|
|
log.Debug("agent init not received from server ! start to waiting !")
|
|
time.Sleep(time.Second * 10)
|
|
}
|
|
}
|
|
|
|
//<-initForeverHandle
|
|
//close(initFromServerQueue.ReceiveChan.InitRChan)
|
|
|
|
// 建立 运行时 RabbitMQ连接
|
|
runtimeConnectorQueue := buildAndStartBusinessRuntimeQueue(a_agent.AgentServerInfoCache.TopicName)
|
|
|
|
// 激活子模块
|
|
activatedOctopusAgentModules()
|
|
|
|
return runtimeConnectorQueue
|
|
}
|
|
|
|
func buildAndStartBusinessRuntimeQueue(agentTopicName string) chan bool {
|
|
|
|
// 建立 业务消息 接收队列
|
|
// agentTopicName为名称的队列
|
|
agentConfig := a_agent.AgentConfig
|
|
|
|
octopusExchangeName := agentConfig.GetString("octopus.message.octopus_exchange")
|
|
|
|
octopusConnectProp := &rabbitmq.ConnectProperty{
|
|
ExchangeName: octopusExchangeName,
|
|
QueueName: agentTopicName,
|
|
ExchangeType: g.QueueTopic,
|
|
TopicKey: agentTopicName + "*",
|
|
}
|
|
|
|
octopusMsgQueue := &rabbitmq.RabbitQueue{
|
|
RabbitProp: octopusConnectProp,
|
|
}
|
|
octopusMsgQueue.Connect()
|
|
|
|
// 建立 业务消息 返回队列
|
|
// 统一为 OctopusToServer
|
|
octopusToServerQueueName := agentConfig.GetString("octopus.message.octopus_to_server")
|
|
|
|
octopusToServerProp := &rabbitmq.ConnectProperty{
|
|
ExchangeName: octopusExchangeName,
|
|
QueueName: octopusToServerQueueName,
|
|
ExchangeType: g.QueueTopic,
|
|
TopicKey: octopusToServerQueueName,
|
|
}
|
|
|
|
octopusToServerQueue := &rabbitmq.RabbitQueue{
|
|
RabbitProp: octopusToServerProp,
|
|
}
|
|
|
|
// 开启运行时消息返回队列
|
|
octopusToServerQueue.Connect()
|
|
|
|
log.InfoF("Octopus Message Business Runtime Queue is established ! => %v", octopusToServerQueue)
|
|
|
|
// 开始处理Runtime的OM消息
|
|
businessForeverChan := octopusMsgQueue.Handle()
|
|
|
|
// cache it
|
|
rabbitmq.BusinessRuntimeQueue = octopusMsgQueue
|
|
|
|
return businessForeverChan
|
|
}
|
|
|
|
// activatedOctopusAgentModules 激活Octopus Agent的所有子模块
|
|
func activatedOctopusAgentModules() {
|
|
|
|
// Agent
|
|
err := P.Submit(func() {
|
|
a_agent.Activate()
|
|
})
|
|
if err != nil {
|
|
return
|
|
}
|
|
// Executor
|
|
_ = P.Submit(func() {
|
|
a_executor.Activate()
|
|
})
|
|
// Status
|
|
_ = P.Submit(func() {
|
|
a_status.Activate()
|
|
})
|
|
}
|
|
|
|
func buildAndSendInitMsgToServer(agentServerInfo *a_agent.AgentServerInfo, initToServerQueue *rabbitmq.RabbitQueue) {
|
|
// 组装OctopusMessage
|
|
var octopusMsg *rabbitmq.OctopusMessage
|
|
octopusMsg = octopusMsg.Build(
|
|
initOmType,
|
|
agentServerInfo,
|
|
)
|
|
msgBytes, err := json.Marshal(octopusMsg)
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("octopus message convert to json is wrong! msg is => %v", octopusMsg))
|
|
}
|
|
|
|
// 发送OM至MQ中
|
|
P.Submit(
|
|
func() {
|
|
for g.G.AgentHasRegister == false {
|
|
|
|
log.Debug(fmt.Sprintf("Send init message to server! ==> %s", string(msgBytes)))
|
|
|
|
//如果agent存活 而Server不存活 那么需要持续不断的向Server中发送消息
|
|
initToServerQueue.Send(
|
|
msgBytes,
|
|
)
|
|
// 休眠
|
|
time.Sleep(10 * time.Minute)
|
|
}
|
|
})
|
|
}
|
|
|
|
func BuildOctopusTCPConnect(agentConfig *viper.Viper) *rabbitmq.RabbitTCPConnectInfo {
|
|
host := agentConfig.GetString("spring.rabbitmq.host")
|
|
port := agentConfig.GetString("spring.rabbitmq.port")
|
|
username := agentConfig.GetString("spring.rabbitmq.username")
|
|
password := agentConfig.GetString("spring.rabbitmq.password")
|
|
virtualHost := agentConfig.GetString("spring.rabbitmq.virtual-host")
|
|
|
|
//todo
|
|
return &rabbitmq.RabbitTCPConnectInfo{
|
|
UserName: username,
|
|
Password: password,
|
|
Host: host,
|
|
Port: port,
|
|
VirtualHost: virtualHost,
|
|
}
|
|
}
|
|
|
|
func refreshAgentInfoByStatusInfo(agentInfo *a_status.AgentInfo, agentServerInfo *a_agent.AgentServerInfo) {
|
|
|
|
agentServerInfo.Platform = agentInfo.HostInfo.Platform
|
|
agentServerInfo.PlatformFamily = agentInfo.HostInfo.PlatformFamily
|
|
agentServerInfo.PlatformVersion = agentInfo.HostInfo.PlatformVersion
|
|
agentServerInfo.KernelVersion = agentInfo.HostInfo.KernelVersion
|
|
agentServerInfo.KernelArch = agentInfo.HostInfo.KernelArch
|
|
|
|
log.DebugF("[refreshAgentInfoByStatusInfo] - ok !")
|
|
}
|
|
|
|
// handleInitMsgFromServer 处理从Server接收的 注册信息
|
|
func handleInitMsgFromServer(initFromServerMsg *rabbitmq.OctopusMessage, initToServerQueue *rabbitmq.RabbitQueue, agentServerInfo *a_agent.AgentServerInfo) bool {
|
|
|
|
//initOctopusMessageDeliveries := initFromServerQueue.Read(false)
|
|
|
|
log.DebugF("message received from server is %s", initFromServerMsg)
|
|
|
|
var serverInfo a_agent.AgentServerInfo
|
|
|
|
s, er := initFromServerMsg.Content.(string)
|
|
if !er {
|
|
log.ErrorF("convet to string error! => %v", er)
|
|
}
|
|
cc := json.Unmarshal([]byte(s), &serverInfo)
|
|
if cc != nil {
|
|
log.Error(fmt.Sprintf("parse init message from server wroong, message is => %v ", cc))
|
|
}
|
|
serverName := serverInfo.ServerName
|
|
|
|
// 处理OM信息
|
|
if strings.HasPrefix(initFromServerMsg.OctopusMessageType, g.InitOmType) && strings.HasPrefix(serverName, agentServerInfo.ServerName) {
|
|
// 是本机的注册回复信息
|
|
log.InfoF("OctopusMessage INIT from server is this agent !")
|
|
|
|
// 手动确认信息
|
|
//delivery.Ack(false)
|
|
|
|
// 修改系统参数
|
|
g.G.AgentHasRegister = true
|
|
|
|
// 保存真实的AgentTopicName
|
|
a_agent.AgentServerInfoCache.TopicName = serverInfo.TopicName
|
|
|
|
// 手动关闭 注册队列的连接
|
|
//shutdownRegisterQueueConnection(initFromServerQueue, initToServerQueue)
|
|
|
|
} else {
|
|
// 不是自身的 注册回复信息 -- 拒绝 2023年6月19日 此处存在错误！ 会死循环Nack 导致异常
|
|
log.Warn(fmt.Sprintf("OctopusMessage INIT from server not this agent ! => %v, ", &initFromServerMsg))
|
|
|
|
// 需要休眠等待不再获取相应的信息
|
|
P.Submit(func() {
|
|
time.Sleep(time.Second * 5)
|
|
initToServerQueue.SendOMsg(initFromServerMsg)
|
|
})
|
|
}
|
|
|
|
return g.G.AgentHasRegister
|
|
}
|
|
|
|
// shutdownRegisterQueueConnection 关闭初始化连接的两个队列
|
|
func shutdownRegisterQueueConnection(initFromServerQueue *rabbitmq.RabbitQueue, initToServerQueue *rabbitmq.RabbitQueue) {
|
|
|
|
initFromServerQueue.Close()
|
|
initToServerQueue.Close()
|
|
|
|
log.InfoF("Pretend to Shutdown register queue connection !")
|
|
}
|
|
|
|
func parseAgentServerInfo(agentServerInfoConf string) *a_agent.AgentServerInfo {
|
|
|
|
// 约定文件地址为 /octopus-agent/octopus-agent.conf
|
|
var agentServerInfo *a_agent.AgentServerInfo
|
|
yamlFile, err := ioutil.ReadFile(agentServerInfoConf)
|
|
|
|
if err != nil {
|
|
panic(fmt.Errorf("failed to read YAML file: %v", err))
|
|
}
|
|
|
|
err = yaml.Unmarshal(yamlFile, &agentServerInfo)
|
|
if err != nil {
|
|
panic(fmt.Errorf("failed to unmarshal YAML: %v", err))
|
|
}
|
|
|
|
// uniform agent server info
|
|
UniformAgentServerInfo(agentServerInfo)
|
|
|
|
jsonFormat, err := json.Marshal(&agentServerInfo)
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("agent server info convert error ! agentserverinfo is %v", agentServerInfo))
|
|
panic(err)
|
|
}
|
|
log.Info(fmt.Sprintf("agent server info is %v", string(jsonFormat)))
|
|
|
|
return agentServerInfo
|
|
}
|
|
|
|
// UniformAgentServerInfo uniform deal with ip
|
|
func UniformAgentServerInfo(agentServerInfo *a_agent.AgentServerInfo) {
|
|
|
|
// reflect to iterator all field
|
|
log.Info("[Initialization] - UniformAgentServerInfo !")
|
|
value := reflect.ValueOf(agentServerInfo).Elem()
|
|
|
|
for i := 0; i < value.NumField(); i++ {
|
|
field := value.Field(i)
|
|
if field.Kind() == reflect.String && field.CanSet() {
|
|
field.SetString(strings.TrimSpace(field.String()))
|
|
}
|
|
}
|
|
|
|
log.Debug("[Initialization] - uniform ip address !")
|
|
if strings.Contains(agentServerInfo.ServerIPInV4, "/") {
|
|
agentServerInfo.ServerIPInV4 = strings.Split(agentServerInfo.ServerIPInV4, "/")[0]
|
|
}
|
|
|
|
if strings.Contains(agentServerInfo.ServerIPInV6, "/") {
|
|
agentServerInfo.ServerIPInV6 = strings.Split(agentServerInfo.ServerIPInV6, "/")[0]
|
|
}
|
|
|
|
}
|
|
|
|
func BuildAgentOsOperator(agentInfo *a_status.AgentInfo, agentServerInfo *a_agent.AgentServerInfo) {
|
|
|
|
// 2023年8月4日 pass through some key information
|
|
ossOfflinePrefix := "http://bastion.io"
|
|
if a_agent.AgentConfig != nil {
|
|
ossOfflinePrefix := a_agent.AgentConfig.GetString("octopus.agent.executor.ossOfflinePrefix")
|
|
if !strings.HasSuffix(ossOfflinePrefix, "/") {
|
|
ossOfflinePrefix += "/"
|
|
}
|
|
}
|
|
|
|
// call the init exec function
|
|
agentOsOperator := a_executor.BuildAgentOsOperator(agentInfo, ossOfflinePrefix)
|
|
|
|
// assign the agentServerInfo
|
|
agentOsOperator.AgentServerInfo = agentServerInfo
|
|
|
|
// debug
|
|
marshal, _ := json.Marshal(agentOsOperator)
|
|
log.DebugF("[Agent INIT] cached agent operator is %s", marshal)
|
|
}
|