271 lines
6.4 KiB
Go
271 lines
6.4 KiB
Go
package service
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"os"
|
|
"path"
|
|
"reflect"
|
|
"compress/gzip"
|
|
|
|
cda "git.loafle.net/commons/di-go/annotation"
|
|
cdr "git.loafle.net/commons/di-go/registry"
|
|
"git.loafle.net/commons/logging-go"
|
|
occp "git.loafle.net/overflow/commons-go/config/probe"
|
|
ocmsc "git.loafle.net/overflow/commons-go/model/sensorconfig"
|
|
ocsp "git.loafle.net/overflow/commons-go/service/probe"
|
|
"git.loafle.net/overflow/probe/config"
|
|
|
|
// For annotation
|
|
_ "git.loafle.net/overflow/commons-go/core/annotation"
|
|
"crypto/cipher"
|
|
"crypto/des"
|
|
"bytes"
|
|
)
|
|
|
|
var SensorConfigServiceType = reflect.TypeOf((*SensorConfigService)(nil))
|
|
|
|
func init() {
|
|
cdr.RegisterType(SensorConfigServiceType)
|
|
}
|
|
|
|
type SensorConfigService struct {
|
|
ocsp.SensorConfigService
|
|
cda.TypeAnnotation `annotation:"@overflow:RPCService()"`
|
|
|
|
ContainerService *ContainerService `annotation:"@Inject()"`
|
|
ProbeClientService *ProbeClientService `annotation:"@Inject()"`
|
|
|
|
sensorConfigs map[string]*ocmsc.SensorConfig
|
|
sensorConfigsPerContainer map[occp.ContainerType][]*ocmsc.SensorConfig
|
|
}
|
|
|
|
func (s *SensorConfigService) InitService() error {
|
|
s.sensorConfigs = make(map[string]*ocmsc.SensorConfig)
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *SensorConfigService) StartService() error {
|
|
if err := s.loadConfigAll(); nil != err {
|
|
return fmt.Errorf("SensorConfigService: StartService failed %v", err)
|
|
}
|
|
|
|
if nil != s.sensorConfigs || 0 < len(s.sensorConfigs) {
|
|
s.sortSensorConfigPerContainer()
|
|
|
|
for containerType := range s.sensorConfigsPerContainer {
|
|
s.ContainerService.RunContainer(containerType)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *SensorConfigService) StopService() {
|
|
|
|
}
|
|
|
|
func (s *SensorConfigService) DestroyService() {
|
|
|
|
}
|
|
|
|
func (s *SensorConfigService) SendInitConfig(containerType occp.ContainerType) error {
|
|
configs, ok := s.sensorConfigsPerContainer[containerType]
|
|
if !ok {
|
|
return nil
|
|
}
|
|
|
|
if err := s.ContainerService.Send(containerType, "SensorConfigService.InitConfig", configs); nil != err {
|
|
return fmt.Errorf("SensorConfigService: StartService failed %v", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *SensorConfigService) AddConfig(tempFilePath string) error {
|
|
//sc, buf, err := s.loadConfigFile(tempFilePath)
|
|
|
|
sc, buf, err := s.loadConfigFile1(tempFilePath)
|
|
if nil != err {
|
|
return err
|
|
}
|
|
|
|
targetPath := config.SensorConfigFilePath(sc)
|
|
ioutil.WriteFile(targetPath, buf, 0644)
|
|
|
|
// tempfile remove
|
|
err = os.Remove(tempFilePath)
|
|
if nil != err {
|
|
return err
|
|
}
|
|
|
|
//s.sensorConfigs[sc.ID.String()] = sc
|
|
//s.sortSensorConfigPerContainer()
|
|
//
|
|
//if err := s.ContainerService.Send(occp.ToContainerType(sc.Crawler.Container), "SensorConfigService.AddConfig", sc); nil != err {
|
|
// return err
|
|
//}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *SensorConfigService) UpdateConfig(tempFilePath string) error {
|
|
sc, buf, err := s.loadConfigFile(tempFilePath)
|
|
if nil != err {
|
|
return err
|
|
}
|
|
|
|
targetPath := config.SensorConfigFilePath(sc)
|
|
ioutil.WriteFile(targetPath, buf, 0644)
|
|
|
|
// tempfile remove
|
|
err = os.Remove(tempFilePath)
|
|
if nil != err {
|
|
return err
|
|
}
|
|
|
|
//delete(s.sensorConfigs, sc.ConfigID)
|
|
//s.sensorConfigs[sc.ID.String()] = sc
|
|
//s.sortSensorConfigPerContainer()
|
|
//
|
|
//if err := s.ContainerService.Send(occp.ToContainerType(sc.Crawler.Container), "SensorConfigService.UpdateConfig", sc); nil != err {
|
|
// return err
|
|
//}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *SensorConfigService) RemoveConfig(sensorConfigID string) error {
|
|
sc, ok := s.sensorConfigs[sensorConfigID]
|
|
if !ok {
|
|
return fmt.Errorf("SensorConfig[%s] is not exist", sensorConfigID)
|
|
}
|
|
|
|
targetPath := config.SensorConfigFilePath(sc)
|
|
err := os.Remove(targetPath)
|
|
if nil != err {
|
|
return err
|
|
}
|
|
|
|
delete(s.sensorConfigs, sensorConfigID)
|
|
s.sortSensorConfigPerContainer()
|
|
|
|
//if err := s.ContainerService.Send(occp.ToContainerType(sc.Crawler.Container), "SensorConfigService.RemoveConfig", sensorConfigID); nil != err {
|
|
// return err
|
|
//}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *SensorConfigService) loadConfigAll() error {
|
|
configDirPath := config.ConfigDir()
|
|
files, err := ioutil.ReadDir(configDirPath)
|
|
if nil != err {
|
|
return err
|
|
}
|
|
|
|
for _, file := range files {
|
|
if file.IsDir() == true {
|
|
if err := s.loadConfigDir(path.Join(configDirPath, file.Name())); nil != err {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *SensorConfigService) loadConfigDir(dirPath string) error {
|
|
files, err := ioutil.ReadDir(dirPath)
|
|
if nil != err {
|
|
return err
|
|
}
|
|
|
|
for _, file := range files {
|
|
filePath := path.Join(dirPath, file.Name())
|
|
|
|
if file.IsDir() == true {
|
|
if err := s.loadConfigDir(filePath); nil != err {
|
|
return err
|
|
}
|
|
} else {
|
|
sc, _, err := s.loadConfigFile(filePath)
|
|
if nil != err {
|
|
return err
|
|
}
|
|
s.sensorConfigs[file.Name()] = sc
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *SensorConfigService) loadConfigFile(filePath string) (*ocmsc.SensorConfig, []byte, error) {
|
|
logging.Logger().Debugf("filePath: %s", filePath)
|
|
buf, err := ioutil.ReadFile(filePath)
|
|
|
|
if nil != err {
|
|
return nil, nil, err
|
|
}
|
|
|
|
// probe ecncreiption key decode
|
|
// gzip decode
|
|
|
|
var m = &ocmsc.SensorConfig{}
|
|
if err := json.Unmarshal(buf, m); nil != err {
|
|
return nil, nil, err
|
|
}
|
|
|
|
return m, buf, nil
|
|
}
|
|
|
|
func (s *SensorConfigService) loadConfigFile1(decodeStr string) (*ocmsc.SensorConfig, []byte, error) {
|
|
//keyStr := s.ProbeClientService.EncryptionKey
|
|
keyStr := "$2a$10$rPZYValfYvsVb8oDDz7gkuuf1FpqVnG8xbxQa.NhKdH7WDi.H2UD."
|
|
key := []byte(keyStr)
|
|
iv := []byte(keyStr)
|
|
block, err := des.NewCipher(key)
|
|
|
|
if nil != err {
|
|
return nil, nil, err
|
|
}
|
|
blockMode := cipher.NewCBCDecrypter(block, iv)
|
|
origData := make([]byte, len(decodeStr))
|
|
blockMode.CryptBlocks(origData, []byte(decodeStr))
|
|
origData = s.PKCS5UnPadding(origData)
|
|
|
|
gr, err := gzip.NewReader(bytes.NewBuffer(origData))
|
|
defer gr.Close()
|
|
data, err := ioutil.ReadAll(gr)
|
|
|
|
var m = &ocmsc.SensorConfig{}
|
|
if err := json.Unmarshal(data, m); nil != err {
|
|
return nil, nil, err
|
|
}
|
|
|
|
fmt.Println(string(data))
|
|
return m, data, nil
|
|
}
|
|
|
|
func (s *SensorConfigService) PKCS5UnPadding(src []byte) []byte {
|
|
length := len(src)
|
|
unpadding := int(src[length-1])
|
|
return src[:(length - unpadding)]
|
|
}
|
|
|
|
func (s *SensorConfigService) sortSensorConfigPerContainer() {
|
|
if nil == s.sensorConfigs || 0 == len(s.sensorConfigs) {
|
|
return
|
|
}
|
|
|
|
s.sensorConfigsPerContainer = nil
|
|
s.sensorConfigsPerContainer = make(map[occp.ContainerType][]*ocmsc.SensorConfig)
|
|
|
|
//for _, sensorConfig := range s.sensorConfigs {
|
|
// containerType := occp.ToContainerType(sensorConfig.Crawler.Container)
|
|
// s.sensorConfigsPerContainer[containerType] = append(s.sensorConfigsPerContainer[containerType], sensorConfig)
|
|
//}
|
|
}
|