#Code commit.

Author: rainbowBPF2

.gitignore

@@ -0,0 +1,10 @@
+*.[oa]
+*~
+*.exe
+.idea
+bin/
+pkg/
+**/_.githooks/
+**/_.git/
+tests
+*.a

src/agent/conf/app.conf

@@ -0,0 +1,14 @@
+#cronjob spec
+schedule=*/10 * * * *
+
+#command type, only FILE and BASH supported.
+type=FILE
+
+#command to be executed. You can use a remote file, or just a command, such as: ls -alh .
+command=http://10.45.11.194:45520/test.sh
+
+#when command type is FILE, file body encrypted or not .
+encrypted=true
+
+#Encrypted salt key, limit to 16 bytes.
+encryptedKey=TestTestTestTest

src/agent/conf/constant.go

@@ -0,0 +1,7 @@
+package conf
+
+var CronSchedule = "schedule"
+var CommandType = "type"
+var Command = "command"
+var Encrypted = "encrypted"
+var EncryptedKey = "encryptedKey"

src/agent/main.go

@@ -0,0 +1,32 @@
+package main
+
+import (
+	"agent/service"
+	"agent/utill"
+	"github.com/robfig/cron"
+	"log"
+	"os"
+)
+
+func main() {
+
+	schedule, commandType, command := utill.ParseLaunchArgs()
+
+	cronJob := cron.New()
+	cronJob.AddFunc(schedule, func() {
+
+		defer func() {
+			if err := recover(); err != nil {
+				log.Print(err)
+				os.Exit(-1)
+			}
+		}()
+
+		service.ExecCommand(commandType, command)
+
+	})
+
+	cronJob.Start()
+
+	select {}
+}

src/agent/service/CronService.go

@@ -0,0 +1,14 @@
+package service
+
+import "log"
+
+func init() {
+
+}
+
+func LaunchCronJob(cronStr string) {
+
+	log.Print("start cronjob")
+
+	log.Print("Cronjob in progress")
+}

src/agent/service/ExecService.go

@@ -0,0 +1,50 @@
+package service
+
+import (
+	"agent/utill"
+	"log"
+	"os/exec"
+	"strings"
+)
+
+func ExecCommand(commandType string, command string) {
+	var cmd *exec.Cmd
+
+	commandType = strings.ToUpper(commandType)
+
+	switch commandType {
+	case "BASH":
+		cmd = exec.Command("sh", "-c", command)
+	case "FILE":
+
+		if strings.HasSuffix(command, ".py") {
+			cmd = exec.Command("python", command)
+		} else if strings.HasSuffix(command, ".sh") {
+
+			if strings.HasPrefix(command, "http") {
+
+				fileBody := utill.GetRemoteFileBody(command)
+
+				cmd = exec.Command("sh", "-c", fileBody)
+
+			} else {
+				cmd = exec.Command("sh", "-c", command)
+
+			}
+
+		} else {
+			panic("Unknown file type! " + command)
+		}
+
+	default:
+		cmd = exec.Command("sh", "-c", "echo 'loop once, no command found!'")
+	}
+
+	out, err := cmd.Output()
+
+	if err != nil {
+		log.Print(err.Error())
+	}
+
+	log.Printf("%s", string(out))
+}

src/agent/startAgent.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+echo
+
+ls -alh
+date

src/agent/test/Aes_Test.go

@@ -0,0 +1,5 @@
+package test
+
+func init() {
+
+}

src/agent/test/fileTest.go

@@ -0,0 +1,36 @@
+package test
+
+import (
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"os/exec"
+)
+
+func main() {
+
+	//executeRemoteFile()
+
+	//ParseAppConf()
+
+}
+func executeRemoteFile() {
+	var url = "http://10.45.11.194:45520/test.sh"
+	resp, err := http.Get(url)
+	if err != nil {
+		log.Print(err.Error())
+	}
+	defer resp.Body.Close()
+	data, _ := ioutil.ReadAll(resp.Body)
+	fmt.Println(string(data))
+	//os
+	//cmd
+	//exec
+	cmd := exec.Command("sh", "-c", string(data))
+	out, err := cmd.Output()
+	if err != nil {
+		fmt.Print(err.Error())
+	}
+	fmt.Print(string(out))
+}

src/agent/utill/aesUtil.go

@@ -0,0 +1,60 @@
+package utill
+
+import (
+	"agent/conf"
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/rand"
+	"encoding/hex"
+	"errors"
+	"io"
+	"log"
+)
+
+// salt key length should limit to 8 char.
+var saltKey []byte
+
+func init() {
+	saltKey = []byte("saltDataSaltData")
+	cMap := ParseAppConf()
+
+	if cMap != nil && cMap[conf.Encrypted] == "true" {
+		saltKey = []byte(cMap[conf.EncryptedKey])
+	}
+}
+
+// Encrypt data using AES algorithm
+func EncryptAesData(textData string) (string, error) {
+	block, err := aes.NewCipher(saltKey)
+
+	if err != nil {
+		log.Fatal(err.Error())
+		return "", err
+	}
+
+	cipherText := make([]byte, aes.BlockSize+len(textData))
+	initVector := cipherText[:aes.BlockSize]
+	if _, err := io.ReadFull(rand.Reader, initVector); err != nil {
+		return "", err
+	}
+	cipher.NewCFBEncrypter(block, initVector).XORKeyStream(cipherText[aes.BlockSize:], []byte(textData))
+	return hex.EncodeToString(cipherText), nil
+
+}
+
+// Decrypt data using AES algorithm.
+func DecryptAesData(encryptData string) (string, error) {
+	cipherText, _ := hex.DecodeString(encryptData)
+
+	block, err := aes.NewCipher(saltKey)
+	if err != nil {
+		return "", err
+	}
+	if len(cipherText) < aes.BlockSize {
+		return "", errors.New("cipherText too short")
+	}
+	initVector := cipherText[:aes.BlockSize]
+	cipherText = cipherText[aes.BlockSize:]
+	cipher.NewCFBDecrypter(block, initVector).XORKeyStream(cipherText, cipherText)
+	return string(cipherText), nil
+}

src/agent/utill/argUtil.go

@@ -0,0 +1,48 @@
+package utill
+
+import (
+	"agent/conf"
+	"fmt"
+	"log"
+	"os"
+)
+
+var defaultSchedule = "*/5 * * * *"
+var defaultType = "FILE"
+var defaultCommand = "startAgent.sh"
+
+func Help() {
+	fmt.Println("************ Ops Monitor Agent ************\n")
+	fmt.Printf("\t%s\t%s\n", "-s", " cronjob schedule. Such as -s=*/5 * * * * , execute for each 5 seconds.")
+	fmt.Printf("\t%s\t%s\n", "-t", " cronjob command type. Such as FILE, BASH.")
+	fmt.Printf("\t%s\t%s\n", "-c", " command to be execute, such as date, ls, mv, test.sh.")
+	fmt.Printf("\t%s\t%s\n", "-h", " ops agent, help tips.")
+}
+
+func ParseLaunchArgs() (schedule string, commandType string, command string) {
+
+	args := os.Args
+
+	if len(args) > 1 && (args[1] == "-h" || args[1] == "--help") {
+		Help()
+		return
+	}
+
+	log.Print("****** Launch ops-monitor agent ******")
+
+	configMap := ParseAppConf()
+
+	if configMap[conf.CronSchedule] != "" {
+		defaultSchedule = configMap[conf.CronSchedule]
+	}
+
+	if configMap[conf.CommandType] != "" {
+		defaultType = configMap[conf.CommandType]
+	}
+
+	if configMap[conf.Command] != "" {
+		defaultCommand = configMap[conf.Command]
+	}
+
+	return defaultSchedule, defaultType, defaultCommand
+}

src/agent/utill/fileUtil.go

@@ -0,0 +1,90 @@
+package utill
+
+import (
+	"agent/conf"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+)
+
+var cMap = make(map[string]string)
+var mutex = sync.Mutex{}
+
+func GetRemoteFileBody(filePath string) string {
+
+	log.Print("begin download file:", filePath)
+	resp, err := http.Get(filePath)
+
+	if err != nil {
+		panic(err.Error())
+	}
+
+	defer resp.Body.Close()
+	data, _ := ioutil.ReadAll(resp.Body)
+
+	fileBody := string(data)
+
+	conMap := ParseAppConf()
+	if conMap[conf.Encrypted] == "true" {
+
+		fileBody = strings.Replace(fileBody, "\n", "", -1)
+		fileBody = strings.Replace(fileBody, "\r", "", -1)
+		fileBody, _ = DecryptAesData(fileBody)
+	}
+
+	return fileBody
+}
+
+func ParseAppConf() map[string]string {
+
+	var configPath string
+
+	mutex.Lock()
+	defer mutex.Unlock()
+
+	if len(cMap) != 0 {
+		return cMap
+	}
+
+	home, _ := os.Getwd()
+	configPath = filepath.Join(home, "src/agent/conf", "app.conf")
+
+	if !FileExists(configPath) {
+		configPath = filepath.Join(home, "conf", "app.conf")
+
+		if !FileExists(configPath) {
+			panic("app.conf not found!" + configPath)
+		}
+	}
+
+	cFile, _ := os.Open(configPath)
+	fileBytes, _ := ioutil.ReadAll(cFile)
+	fileBody := string(fileBytes)
+
+	fileBody = strings.Replace(fileBody, "\r", "", -1)
+	bodyArr := strings.Split(fileBody, "\n")
+
+	for _, body := range bodyArr {
+		if body != "" && !strings.HasPrefix(body, "#") {
+			arrV := strings.Split(body, "=")
+			if len(arrV) == 2 {
+				cMap[arrV[0]] = arrV[1]
+			}
+		}
+	}
+
+	return cMap
+}
+
+func FileExists(name string) bool {
+	if _, err := os.Stat(name); err != nil {
+		if os.IsNotExist(err) {
+			return false
+		}
+	}
+	return true
+}

src/github.com/robfig/cron

@@ -0,0 +1 @@
+Subproject commit b41be1df696709bb6395fe435af20370037c0b4c