// osName returns the name of the OS.
func osName() string {
h, err := host.HostInfo()
if err != nil || h.OS == "" {
return "Linux"
}
return h.OS
}
func main() {
v, _ := mem.VirtualMemory()
// almost every return value is a struct
fmt.Printf("Total: %v, Free:%v, UsedPercent:%f%%\n", v.Total, v.Free, v.UsedPercent)
// convert to JSON. String() is also implemented
fmt.Println(v)
h, err := host.HostInfo()
if err != nil {
fmt.Println("err:", err)
} else {
fmt.Printf("hostname %v", h)
}
c, err := cpu.CPUInfo()
if err != nil {
fmt.Println("err:", err)
}
for _, v := range c {
fmt.Printf("cpu info %v \n ", v)
}
}
func (_ *SystemStats) Gather(acc telegraf.Accumulator) error {
loadavg, err := load.LoadAvg()
if err != nil {
return err
}
hostinfo, err := host.HostInfo()
if err != nil {
return err
}
users, err := host.Users()
if err != nil {
return err
}
fields := map[string]interface{}{
"load1": loadavg.Load1,
"load5": loadavg.Load5,
"load15": loadavg.Load15,
"uptime": hostinfo.Uptime,
"n_users": len(users),
"uptime_format": format_uptime(hostinfo.Uptime),
"n_cpus": runtime.NumCPU(),
}
acc.AddFields("system", fields, nil)
return nil
}
func (f *HostFingerprint) Fingerprint(cfg *config.Config, node *structs.Node) (bool, error) {
hostInfo, err := host.HostInfo()
if err != nil {
f.logger.Println("[WARN] Error retrieving host information: ", err)
return false, err
}
node.Attributes["os.name"] = hostInfo.Platform
node.Attributes["os.version"] = hostInfo.PlatformVersion
node.Attributes["kernel.name"] = runtime.GOOS
node.Attributes["kernel.version"] = ""
if runtime.GOOS != "windows" {
out, err := exec.Command("uname", "-r").Output()
if err != nil {
return false, fmt.Errorf("Failed to run uname: %s", err)
}
node.Attributes["kernel.version"] = strings.Trim(string(out), "\n")
}
node.Attributes["hostname"] = hostInfo.Hostname
return true, nil
}
// osVersion returns the OS version.
func osVersion() string {
h, err := host.HostInfo()
if err != nil || h.PlatformVersion == "" {
return "0.0"
}
return h.PlatformVersion
}
func hostInfo(ctx *gin.Context) {
// For static
info, err := host.HostInfo()
if err != nil {
ctx.AbortWithError(http.StatusInternalServerError, err)
return
}
ctx.JSON(http.StatusOK, info)
}
func handleHostCommand(w http.ResponseWriter) {
var buffer bytes.Buffer
info, _ := host.HostInfo()
buffer.WriteString(fmt.Sprintf("Boottime: %v\n", info.BootTime))
buffer.WriteString(fmt.Sprintf("Hostname: %v\n", info.Hostname))
buffer.WriteString(fmt.Sprintf("Uptime: %v\n", info.Uptime))
io.WriteString(w, buffer.String())
}
// Distro - gets distro info
// {'version': '14.04', 'name': 'Ubuntu'}
func Distro() DistroStruct {
host, _ := pshost.HostInfo()
d := DistroStruct{
Version: host.PlatformVersion,
Name: host.Platform,
}
return d
}
func NewTextDetail(alert string) (*TextDetail, error) {
hostinfo, err := host.HostInfo()
if err != nil {
return nil, err
}
return &TextDetail{
Alert: alert,
HostName: hostinfo.Hostname,
}, nil
}
func main() {
uname, err := getUname()
if err != nil {
fmt.Println("error: ", err)
}
fmt.Println("uname: ", uname)
hostinfo := host.HostInfo()
fmt.Println(hostinfo.String())
}
func ajax(c web.C, w http.ResponseWriter, r *http.Request) {
sys, _ := host.HostInfo()
action := r.FormValue("action")
if action == "time" {
now := time.Now()
past := now.Add(-1 * time.Duration(sys.Uptime) * time.Second)
fmt.Fprintf(w, "%s;%s;%s", now.Format("January 2, 2006"), now.Format("3:04 pm"), past.Format("January 2, 2006"))
}
if action == "uptime" {
uptimeDuration := time.Duration(sys.Uptime) * time.Second
days := int(uptimeDuration.Hours() / 24)
hours := int(uptimeDuration.Hours()) % 24
minutes := int(uptimeDuration.Minutes()) % 60
fmt.Fprintf(w, "%d;%d;%d", days, hours, minutes)
}
if action == "image" {
bingResponse, err := http.Get("http://www.bing.com/HPImageArchive.aspx?format=js&idx=0&n=1&mkt=en-US")
if err != nil {
fmt.Printf("%s", err)
os.Exit(1)
} else {
defer bingResponse.Body.Close()
contents, err := ioutil.ReadAll(bingResponse.Body)
if err != nil {
fmt.Printf("%s", err)
os.Exit(1)
}
var animals BingImage
err = json.Unmarshal(contents, &animals)
if err != nil {
fmt.Println("error:", err)
}
fmt.Fprintf(w, "%s;%s", "https://www.bing.com/"+animals.Images[0].URL, animals.Images[0].Copyright)
}
}
if action == "location" {
ipResponse, err := http.Get("http://icanhazip.com")
if err != nil {
fmt.Printf("%s", err)
os.Exit(1)
} else {
defer ipResponse.Body.Close()
contents, err := ioutil.ReadAll(ipResponse.Body)
if err != nil {
fmt.Printf("%s", err)
os.Exit(1)
}
fmt.Fprintf(w, "%s", string(contents))
}
}
}
func initHostInfo(monitorData *monitoringData) error {
hostInfo, err := host.HostInfo()
if hostInfo != nil {
monitorData.ComputerName = hostInfo.Hostname
monitorData.OperatingSystem = hostInfo.OS
monitorData.Platform = hostInfo.Platform
monitorData.PlatformFamily = hostInfo.PlatformFamily
monitorData.ProcessNumber = hostInfo.Procs
}
return err
}
func home(c web.C, w http.ResponseWriter, r *http.Request) {
p := &Page{Title: "Uptimey"}
sys, _ := host.HostInfo()
now := time.Now()
past := now.Add(-1 * time.Duration(sys.Uptime) * time.Second)
p.StartDate = past
tmpl, err := FSString(false, "/assets/index.html")
if err != nil {
fmt.Println(err.Error())
}
t, _ := template.New("index").Parse(tmpl)
t.Execute(w, p)
}
func printStatus() {
h, err := host.HostInfo()
if err != nil {
log.Println("Could not get host info", err)
}
log.Println(h.String())
procs, err := ps.Processes()
if err != nil {
log.Println("Could not get processes")
}
log.Println(len(procs))
for _, e := range procs {
log.Println(e.Executable(), e.Pid(), e.PPid())
}
}
func (_ *SystemStats) Gather(acc plugins.Accumulator) error {
loadavg, err := load.LoadAvg()
if err != nil {
return err
}
hostinfo, err := host.HostInfo()
if err != nil {
return err
}
acc.Add("load1", loadavg.Load1, nil)
acc.Add("load5", loadavg.Load5, nil)
acc.Add("load15", loadavg.Load15, nil)
acc.Add("uptime", hostinfo.Uptime, nil)
acc.Add("uptime_format", format_uptime(hostinfo.Uptime), nil)
return nil
}
func (_ *SystemStats) Gather(acc inputs.Accumulator) error {
loadavg, err := load.LoadAvg()
if err != nil {
return err
}
hostinfo, err := host.HostInfo()
if err != nil {
return err
}
fields := map[string]interface{}{
"load1": loadavg.Load1,
"load5": loadavg.Load5,
"load15": loadavg.Load15,
"uptime": hostinfo.Uptime,
"uptime_format": format_uptime(hostinfo.Uptime),
}
acc.AddFields("system", fields, nil)
return nil
}
// Run gathers host information from gopsutil.
func (h *HostInfo) Run() error {
data, err := gopsutil_host.HostInfo()
if err != nil {
return err
}
h.Data["Hostname"] = data.Hostname
h.Data["Uptime"] = data.Uptime
h.Data["Procs"] = data.Procs
h.Data["OS"] = data.OS
h.Data["Platform"] = data.Platform
h.Data["PlatformFamily"] = data.PlatformFamily
h.Data["PlatformVersion"] = data.PlatformVersion
h.Data["VirtualizationSystem"] = data.VirtualizationSystem
h.Data["VirtualizationRole"] = data.VirtualizationRole
bootTime, err := gopsutil_host.BootTime()
if err == nil {
h.Data["BootTime"] = bootTime
}
return nil
}
func (c App) Main(admin *models.Admin) revel.Result {
title := "首页--GoCMS管理系统"
UserID := utils.GetSession("UserID", c.Session)
if len(UserID) > 0 {
UserID, err := strconv.ParseInt(UserID, 10, 64)
if err != nil {
revel.WARN.Println(err)
}
admin_info := admin.GetById(UserID)
//判断是否是系统的分隔符
separator := "/"
if os.IsPathSeparator('\\') {
separator = "\\"
} else {
separator = "/"
}
config_file := (revel.BasePath + "/conf/config.conf")
config_file = strings.Replace(config_file, "/", separator, -1)
config_conf, _ := config.ReadDefault(config_file)
system_info := make(map[string]string)
//版本
version, _ := config_conf.String("website", "website.version")
system_info["version"] = version
//前台网站地址
sitedomain, _ := config_conf.String("website", "website.sitedomain")
system_info["sitedomain"] = sitedomain
//操作系统
system_info["os"] = strings.ToUpper(runtime.GOOS + " " + runtime.GOARCH)
//Go版本
system_info["go_varsion"] = strings.ToUpper(runtime.Version())
//Revel版本
system_info["revel_varsion"] = strings.ToUpper("Revel 0.11")
//MySQL版本
system_info["mysql_varsion"] = admin.GetMysqlVer()
//服务器监控
memory_info, _ := mem.VirtualMemory()
system_info["main_server_total_memory"] = utils.FileSize(int(memory_info.Total))
system_info["main_server_free_memory"] = utils.FileSize(int(memory_info.Free))
system_info["main_server_available_memory"] = utils.FileSize(int(memory_info.Available))
system_info["main_server_UsedPercent_memory"] = fmt.Sprintf("%10.2f%%", memory_info.UsedPercent)
host, _ := host.HostInfo()
system_info["main_server_Hostname"] = host.Hostname
system_info["main_server_OS"] = host.OS
system_info["main_server_Platform"] = host.Platform
system_info["main_server_PlatformVersion"] = host.PlatformVersion
system_info["main_server_PlatformFamily"] = host.PlatformFamily
//快捷面板
admin_panel := new(models.Admin_Panel)
panel_list := admin_panel.GetPanelList(admin_info)
c.Render(title, admin_info, system_info, panel_list)
} else {
c.Render(title)
}
return c.RenderTemplate("App/Main.html")
}
func psutilHostDump() {
hostInfo, _ := host.HostInfo()
Println(JsonPretty(*hostInfo))
}
func main() {
// DISK INFO
fmt.Print("\n----Disk Info ----\n\n")
diskInfo, err := disk.DiskPartitions(true)
if err != nil {
panic(err)
}
log.Printf("[DEBUG] %#v\n\n", diskInfo)
for _, diskn := range diskInfo {
fmt.Printf("%s %s\n", diskn.Device, diskn.Mountpoint)
}
// CPU INFO
fmt.Print("\n----CPU Info ----\n\n")
cpuInfo, err := cpu.CPUInfo()
if err != nil {
panic(err)
}
log.Printf("[DEBUG] %#v\n\n", cpuInfo)
var totalCores int32
var frequency float64
var totalCompute float64
var flags string
for _, cpu := range cpuInfo {
totalCores += cpu.Cores
if frequency == 0 {
frequency = cpu.Mhz
} else {
if frequency != cpu.Mhz {
log.Printf("A CPU shows inconsistent frequency with other CPUs: baseline %f, abberant %f", frequency, frequency)
}
}
flags = strings.Join(cpu.Flags, " ")
}
totalCompute = frequency * float64(totalCores)
fmt.Printf("%s %d\n", "cpu.totalcores", totalCores)
fmt.Printf("%s %d\n", "cpu.numcpus", len(cpuInfo))
fmt.Printf("%s %f\n", "cpu.frequency", frequency)
fmt.Printf("%s %f\n", "cpu.totalcompute", totalCompute)
fmt.Printf("%s %s\n", "cpu.flags", flags)
// MEMORY INFO
fmt.Print("\n----Memory Info ----\n\n")
memInfo, err := mem.VirtualMemory()
if err != nil {
panic(err)
}
log.Printf("[DEBUG] %#v\n\n", memInfo)
fmt.Printf("%s %d\n", "memory.totalbytes", memInfo.Total)
// HOST INFO
fmt.Print("\n----Host Info ----\n\n")
hostInfo, err := host.HostInfo()
if err != nil {
panic(err)
}
log.Printf("[DEBUG] %#v\n\n", hostInfo)
fmt.Printf("%s %s\n", "hostInfo.Hostname ", hostInfo.Hostname)
fmt.Printf("%s %s\n", "hostInfo.OS ", hostInfo.OS)
fmt.Printf("%s %s\n", "hostInfo.Platform ", hostInfo.Platform)
fmt.Printf("%s %s\n", "hostInfo.PlatformVersion", hostInfo.PlatformVersion)
fmt.Printf("%s %s\n", "hostInfo.PlatformFamily ", hostInfo.PlatformFamily)
}
// currentState returns the current state of system conforming
// to definitions
func currentState(d Def) State {
s, err := host.HostInfo()
if err != nil {
log.Printf("failed to load host information. (%v)", err.Error())
return State{}
}
state := State{
Host: s.Hostname,
Uptime: s.Uptime,
Ports: []Port{},
Sockets: []Socket{},
Processes: []Process{},
}
pids, err := process.Pids()
if err != nil {
log.Printf("failed to query running processes. (%v)", err.Error())
return State{}
}
for _, i := range pids {
p, err := process.NewProcess(i)
if err != nil {
log.Printf("failed to get handle of process with ID: %v. (%v)", i, err.Error())
continue
}
n, _ := p.Name()
cmd, err := p.Cmdline()
if err != nil {
log.Printf("failed to query the command which started the process with ID: %v. (%v)", i, err.Error())
continue
}
cnt := false
for k := range d.Processes {
if strings.Contains(n, k) {
cnt = true
break
}
}
conn, err := p.Connections()
if err != nil {
log.Printf("failed to query connections made by process with ID: %v. (%v)", i, err.Error())
continue
}
pr := Process{
Name: n,
Command: cmd,
Connections: []Conn{},
}
for _, c := range conn {
ncn := Conn{Local: c.Laddr, Remote: c.Raddr}
pr.Connections = append(pr.Connections, ncn)
if _, match := d.Ports[ncn.Local.Port]; match {
state.Ports = append(state.Ports, Port(ncn.Remote.Port))
}
if cnt {
state.Processes = append(state.Processes, pr)
}
}
}
for k := range d.Sockets {
if _, err := os.Stat(k); err != nil {
state.Sockets = append(state.Sockets, Socket(k))
}
}
return state
}
func PsutilHostDump() {
hostInfo, _ := host.HostInfo()
Println(JsonPretty(*hostInfo))
// Printfln("%#v", ProcessTable())
}
func (st *Stat) stat(t string) string {
checkErr := func(err error) string {
return "系统酱正在食用作死药丸中..."
}
switch t {
case "free":
m, err := mem.VirtualMemory()
checkErr(err)
s, err := mem.SwapMemory()
checkErr(err)
mem := new(runtime.MemStats)
runtime.ReadMemStats(mem)
return fmt.Sprintf(
"全局:\n"+
"Total: %s Free: %s\nUsed: %s %s%%\nCache: %s\n"+
"Swap:\nTotal: %s Free: %s\n Used: %s %s%%\n"+
"群组娘:\n"+
"Allocated: %s\nTotal Allocated: %s\nSystem: %s\n",
helper.HumanByte(m.Total, m.Free, m.Used, m.UsedPercent, m.Cached,
s.Total, s.Free, s.Used, s.UsedPercent,
mem.Alloc, mem.TotalAlloc, mem.Sys)...,
)
case "df":
fs, err := disk.DiskPartitions(false)
checkErr(err)
var buf bytes.Buffer
for k := range fs {
du, err := disk.DiskUsage(fs[k].Mountpoint)
switch {
case err != nil, du.UsedPercent == 0, du.Free == 0:
continue
}
f := fmt.Sprintf("Mountpoint: %s Type: %s \n"+
"Total: %s Free: %s \nUsed: %s %s%%\n",
helper.HumanByte(fs[k].Mountpoint, fs[k].Fstype,
du.Total, du.Free, du.Used, du.UsedPercent)...,
)
buf.WriteString(f)
}
return buf.String()
case "os":
h, err := host.HostInfo()
checkErr(err)
uptime := time.Duration(time.Now().Unix()-int64(h.Uptime)) * time.Second
l, err := load.LoadAvg()
checkErr(err)
c, err := cpu.CPUPercent(time.Second*3, false)
checkErr(err)
return fmt.Sprintf(
"OSRelease: %s\nHostName: %s\nUptime: %s\nLoadAvg: %.2f %.2f %.2f\n"+
"Goroutine: %d\nCPU: %.2f%%",
h.Platform, h.Hostname, uptime.String(), l.Load1, l.Load5, l.Load15,
runtime.NumGoroutine(), c[0],
)
case "redis":
info := conf.Redis.Info().Val()
if info != "" {
infos := strings.Split(info, "\r\n")
infoMap := make(map[string]string)
for k := range infos {
line := strings.Split(infos[k], ":")
if len(line) > 1 {
infoMap[line[0]] = line[1]
}
}
DBSize := conf.Redis.DbSize().Val()
return fmt.Sprintf("Redis Version: %s\nOS: %s\nUsed Memory: %s\n"+
"Used Memory Peak: %s\nDB Size: %d\n",
infoMap["redis_version"], infoMap["os"], infoMap["used_memory_human"],
infoMap["used_memory_peak_human"], DBSize)
}
return ""
default:
return "欢迎来到未知领域(ゝ∀･)"
}
}
func json_hostinfo(w http.ResponseWriter, r *http.Request) {
hostinfo, _ := host.HostInfo()
b, _ := json.Marshal(hostinfo)
w.Header().Set("Content-Type", "application/json")
fmt.Fprintf(w, string(b))
}
func jsonHostInfo() []byte {
hostinfo, _ := host.HostInfo()
jsonHostInfo, _ := json.Marshal(hostinfo)
return jsonHostInfo
}
func main() {
flag.Usage = func() {
fmt.Println(usage)
}
flag.Parse()
for {
// Docker client remote API
endpoint := "unix:///var/run/docker.sock"
dockerClient, _ := docker.NewClient(endpoint)
// Configuration file settings using key-value
viper.SetConfigName("plural")
if *configFlag != "" {
viper.AddConfigPath(*configFlag)
} else {
viper.AddConfigPath("/opt/plural/conf")
}
viperReadConfig := viper.ReadInConfig()
// Default settings if no config file is supplied
viper.SetDefault("elastic_host", "localhost")
viper.SetDefault("elastic_port", "9200")
viper.SetDefault("environment", "dev")
viper.SetDefault("interval", "300")
viper.SetDefault("username", "undef")
viper.SetDefault("password", "undef")
viper.SetDefault("overwrite", "undef")
elastic_host := viper.GetString("elastic_host")
elastic_port := viper.GetString("elastic_port")
environment := viper.GetString("environment")
interval := viper.GetInt("interval")
username := viper.GetString("username")
password := viper.GetString("password")
overwrite := viper.GetString("overwrite")
transport := http.Transport{
Dial: dialTimeout,
}
client := http.Client{
Transport: &transport,
}
cpuCounts, _ := cpu.CPUCounts(true)
v, _ := mem.VirtualMemory()
k, _ := disk.DiskUsage("/")
h, _ := host.HostInfo()
l, _ := load.LoadAvg()
memusedprctConv := strconv.FormatFloat(v.UsedPercent, 'f', 6, 64)
memusedprct := strings.Split(memusedprctConv, ".")[0]
memfree := humanize.Bytes(v.Free)
memtotal := humanize.Bytes(v.Total)
diskusedprctConv := strconv.FormatFloat(k.UsedPercent, 'f', 6, 64)
diskusedprct := strings.Split(diskusedprctConv, ".")[0]
diskfree := humanize.Bytes(k.Free)
disktotal := humanize.Bytes(k.Total)
timeN := time.Now()
dateStamp := fmt.Sprintf("%d-%02d-%02dT%02d:%02d:%02d", timeN.Year(), timeN.Month(), timeN.Day(), timeN.Hour(), timeN.Minute(), timeN.Second())
loadoneConv := strconv.FormatFloat(l.Load1, 'f', 6, 64)
loadone := strings.Split(loadoneConv, ".")[0]
loadfifteenConv := strconv.FormatFloat(l.Load15, 'f', 6, 64)
loadfifteen := strings.Split(loadfifteenConv, ".")[0]
loadfiveConv := strconv.FormatFloat(l.Load5, 'f', 6, 64)
loadfive := strings.Split(loadfiveConv, ".")[0]
ipaddress, err := networkip.ExternalIP()
if err != nil {
fmt.Println(err.Error())
}
// UNIX system commands
dnsfile := exec.Command("ls", "/etc/resolv.conf")
dnsfileout, err := dnsfile.Output()
dnsgrep := exec.Command("grep", "nameserver", "/etc/resolv.conf")
dnsawk := exec.Command("awk", "{print$2}")
dnsgrepOut, err := dnsgrep.StdoutPipe()
dnsgrep.Start()
dnsawk.Stdin = dnsgrepOut
dnsOut, err := dnsawk.Output()
dnsstring := string(dnsOut)
dnsoutputSlice := strings.Split(dnsstring, "\n")
dnsjs, _ := json.Marshal(dnsoutputSlice)
wbin := exec.Command("ls", "/usr/bin/w")
wbinout, err := wbin.Output()
wh := exec.Command("w", "-h")
whawk := exec.Command("awk", "{print$1\"-\"$2}")
whOut, err := wh.StdoutPipe()
wh.Start()
whawk.Stdin = whOut
wOut, err := whawk.Output()
whstring := string(wOut)
whoutputSlice := strings.Split(whstring, "\n")
whjs, _ := json.Marshal(whoutputSlice)
passfile := exec.Command("ls", "/etc/passwd")
passfileout, err := passfile.Output()
passgrep := exec.Command("grep", "-v", "^#", "/etc/passwd")
passgrepOut, err := passgrep.Output()
passstring := string(passgrepOut)
passoutputSlice := strings.Split(passstring, "\n")
passjs, _ := json.Marshal(passoutputSlice)
auditctlbin := exec.Command("ls", "/sbin/auditctl")
auditctlbinout, err := auditctlbin.Output()
auditctl := exec.Command("auditctl", "-l")
auditctlOut, err := auditctl.Output()
auditctlstring := string(auditctlOut)
auditctloutputSlice := strings.Split(auditctlstring, "\n")
auditctljs, _ := json.Marshal(auditctloutputSlice)
rpmbin := exec.Command("ls", "/bin/rpm")
rpmbinout, err := rpmbin.Output()
rpmqa := exec.Command("rpm", "-qa")
rpmsort := exec.Command("sort")
rpmqaOut, err := rpmqa.StdoutPipe()
rpmqa.Start()
rpmsort.Stdin = rpmqaOut
rpmOut, err := rpmsort.Output()
rpmstring := string(rpmOut)
rpmoutputSlice := strings.Split(rpmstring, "\n")
rpmjs, _ := json.Marshal(rpmoutputSlice)
dpkgbin := exec.Command("ls", "/usr/bin/dpkg")
dpkgbinout, err := dpkgbin.Output()
dpkg := exec.Command("dpkg", "-l")
dpkgawk := exec.Command("awk", "/^[a-z]/{print$2\"-\"$3}")
dpkglOut, err := dpkg.StdoutPipe()
dpkg.Start()
dpkgawk.Stdin = dpkglOut
dpkgOut, err := dpkgawk.Output()
dpkgstring := string(dpkgOut)
dpkgoutputSlice := strings.Split(dpkgstring, "\n")
dpkgjs, _ := json.Marshal(dpkgoutputSlice)
iptablesbin := exec.Command("ls", "/sbin/iptables")
iptablesbinout, err := iptablesbin.Output()
iptablesl := exec.Command("iptables", "-L")
iptablesgrep := exec.Command("grep", "-v", "^Chain\\|target\\|^$")
iptableslOut, err := iptablesl.StdoutPipe()
iptablesl.Start()
iptablesgrep.Stdin = iptableslOut
iptablesOut, err := iptablesgrep.Output()
iptablesstring := string(iptablesOut)
iptablesoutputSlice := strings.Split(iptablesstring, "\n")
iptablesjs, _ := json.Marshal(iptablesoutputSlice)
dockerbin := exec.Command("which", "docker")
dockerbinout, err := dockerbin.Output()
pipbin := exec.Command("which", "pip")
pipbinout, err := pipbin.Output()
pipfree := exec.Command("pip", "freeze")
pipsort := exec.Command("sort")
pipfreeOut, err := pipfree.StdoutPipe()
pipfree.Start()
pipsort.Stdin = pipfreeOut
pipOut, err := pipsort.Output()
pipstring := string(pipOut)
pipreplace := strings.Replace(pipstring, "==", "-", -1)
pipoutSlice := strings.Split(pipreplace, "\n")
pipjs, _ := json.Marshal(pipoutSlice)
gembin := exec.Command("which", "gem")
gembinout, err := gembin.Output()
gemlist := exec.Command("gem", "list")
gemgrep := exec.Command("grep", "^[a-zA-Z]")
gemlistOut, err := gemlist.StdoutPipe()
gemlist.Start()
gemgrep.Stdin = gemlistOut
gemOut, err := gemgrep.Output()
gemstring := string(gemOut)
gemreplace := strings.Replace(gemstring, " (", "-", -1)
gemreplace2 := strings.Replace(gemreplace, ")", "", -1)
gemoutSlice := strings.Split(gemreplace2, "\n")
gemjs, _ := json.Marshal(gemoutSlice)
iproutebin := exec.Command("ls", "/sbin/ip")
iproutebinout, err := iproutebin.Output()
iproute := exec.Command("ip", "route")
iprouteOut, err := iproute.Output()
iproutestring := string(iprouteOut)
iprouteoutputSlice := strings.Split(iproutestring, "\n")
iproutejs, _ := json.Marshal(iprouteoutputSlice)
kernelver := exec.Command("uname", "-r")
kernelverout, err := kernelver.Output()
kernelverstring := string(kernelverout)
timezone := exec.Command("date", "+%Z")
timezoneout, err := timezone.Output()
timezonestring := string(timezoneout)
hostname := exec.Command("hostname", "-f")
hostcut := exec.Command("cut", "-d.", "-f", "2-")
hostnameOut, err := hostname.StdoutPipe()
hostname.Start()
hostcut.Stdin = hostnameOut
domainname, err := hostcut.Output()
domainstring := string(domainname)
if err != nil {
fmt.Println(err.Error())
}
// ElasticSearch endpoint
elastic_url := "http://" + elastic_host + ":" + elastic_port + "/" + environment + "/" + h.Hostname
// JSON file name
if *outputFlag != "" {
if string(*outputFlag)[:len(string(*outputFlag))-1] != "/" {
*outputFlag += "/"
}
}
filename := *outputFlag + h.Hostname + ".json"
// Create JSON file
f, err := os.Create(filename)
if err != nil {
fmt.Println(err.Error())
return
}
n, err := io.WriteString(f, "{")
if err != nil {
fmt.Println(n, err)
return
}
if string(auditctlbinout) != "" {
audit_rules := `
"audit_rules": %s,`
auditctlLine := fmt.Sprintf(audit_rules, string(auditctljs))
auditctlReplace := strings.Replace(auditctlLine, ",\"\"]", "]", -1)
writeAuditctl, err := io.WriteString(f, auditctlReplace)
if err != nil {
fmt.Println(writeAuditctl, err)
return
}
}
top := `
"cpu_count": "%v",
"diskfree": "%v",
"disktotal": "%v",
"diskused": "%v",`
topLine := fmt.Sprintf(top, cpuCounts, diskfree, disktotal, diskusedprct)
writeTop, err := io.WriteString(f, topLine)
if err != nil {
fmt.Println(writeTop, err)
return
}
if string(dnsfileout) != "" {
dns_nameserver := `
"dns_nameserver": %s,`
dnsLine := fmt.Sprintf(dns_nameserver, string(dnsjs))
dnsReplace := strings.Replace(dnsLine, ",\"\"]", "]", -1)
writeDns, err := io.WriteString(f, dnsReplace)
if err != nil {
fmt.Println(writeDns, err)
return
}
}
if string(dockerbinout) != "" {
dockerRaw := `
"docker": %s,`
containers, _ := dockerClient.ListContainers(docker.ListContainersOptions{All: false})
dockerString := `[`
for _, container := range containers {
portsRaw := `%v`
portsString := fmt.Sprintf(portsRaw, container.Ports)
portsReplace := strings.Replace(portsString, "{", "", -1)
portsReplace2 := strings.Replace(portsReplace, "}", "", -1)
portsReplace3 := strings.Replace(portsReplace2, "[", "'", -1)
portsReplace4 := strings.Replace(portsReplace3, "]", "'", -1)
containerString := `"%v, %v, %v",`
dockerString += fmt.Sprintf(containerString, container.Image, container.Command, portsReplace4)
}
dockerString += `""]`
dockerLine := fmt.Sprintf(dockerRaw, dockerString)
dockerReplace := strings.Replace(dockerLine, ",\"\"]", "]", -1)
writeDocker, err := io.WriteString(f, dockerReplace)
if err != nil {
fmt.Println(writeDocker, err)
return
}
}
domain := `
"domain": "%s",`
domainLine := fmt.Sprintf(domain, strings.TrimSpace(domainstring))
writeDomain, err := io.WriteString(f, domainLine)
if err != nil {
fmt.Println(writeDomain, err)
return
}
// Local AWS meta-data
awsResponse, err := client.Get("http://169.254.169.254/latest/")
if awsResponse != nil && awsResponse.Status == string("200 OK") {
amiid, err := http.Get("http://169.254.169.254/latest/meta-data/ami-id")
defer amiid.Body.Close()
amiidOut, err := ioutil.ReadAll(amiid.Body)
instanceid, err := http.Get("http://169.254.169.254/latest/meta-data/instance-id")
defer instanceid.Body.Close()
instanceidOut, err := ioutil.ReadAll(instanceid.Body)
instancetype, err := http.Get("http://169.254.169.254/latest/meta-data/instance-type")
defer instancetype.Body.Close()
instancetypeOut, err := ioutil.ReadAll(instancetype.Body)
availabilityzone, err := http.Get("http://169.254.169.254/latest/meta-data/placement/availability-zone")
defer availabilityzone.Body.Close()
availabilityzoneOut, err := ioutil.ReadAll(availabilityzone.Body)
securitygroups, err := http.Get("http://169.254.169.254/latest/meta-data/security-groups")
defer securitygroups.Body.Close()
securitygroupsOut, err := ioutil.ReadAll(securitygroups.Body)
profile, err := http.Get("http://169.254.169.254/latest/meta-data/profile")
defer profile.Body.Close()
profileOut, err := ioutil.ReadAll(profile.Body)
publicip, err := http.Get("http://169.254.169.254/latest/meta-data/public-ipv4")
defer publicip.Body.Close()
publicipOut, err := ioutil.ReadAll(publicip.Body)
if err != nil {
fmt.Println(err.Error())
return
}
aws := `
"ec2_ami_id": "%s",
"ec2_availability_zone": "%s",
"ec2_instance_id": "%s",
"ec2_instance_type": "%s",
"ec2_profile": "%s",
"ec2_public_ip4": "%s",
"ec2_security_groups": "%s",`
awsLine := fmt.Sprintf(aws, amiidOut, availabilityzoneOut, instanceidOut, instancetypeOut, profileOut, publicipOut, securitygroupsOut)
writeAWS, err := io.WriteString(f, awsLine)
if err != nil {
fmt.Println(writeAWS, err)
return
}
}
environmentOut := `
"environment": "%s",`
envLine := fmt.Sprintf(environmentOut, environment)
writeEnv, err := io.WriteString(f, envLine)
if err != nil {
fmt.Println(writeEnv, err)
return
}
if string(gembinout) != "" {
gem := `
"gem": %s,`
gemLine := fmt.Sprintf(gem, string(gemjs))
gemReplace := strings.Replace(gemLine, ",\"\"]", "]", -1)
writeGem, err := io.WriteString(f, gemReplace)
if err != nil {
fmt.Println(writeGem, err)
return
}
}
if string(iptablesbinout) != "" {
iptables := `
"iptables": %s,`
iptablesLine := fmt.Sprintf(iptables, string(iptablesjs))
iptablesReplace := strings.Replace(iptablesLine, ",\"\"]", "]", -1)
writeIptables, err := io.WriteString(f, iptablesReplace)
if err != nil {
fmt.Println(writeIptables, err)
return
}
}
if string(iproutebinout) != "" {
ip_route := `
"ip_route": %s,`
iprouteLine := fmt.Sprintf(ip_route, string(iproutejs))
iprouteReplace := strings.Replace(iprouteLine, ",\"\"]", "]", -1)
writeIproute, err := io.WriteString(f, iprouteReplace)
if err != nil {
fmt.Println(writeIproute, err)
return
}
}
bottom := `
"hostname": "%s",
"ipaddress": "%s",
"kernelversion": "%s",
"lastrun": "%s",
"load15": "%v",
"load1": "%v",
"load5": "%v",
"memoryfree": "%v",
"memorytotal": "%v",
"memoryused": "%v",
"os": "%v",`
bottomLine := fmt.Sprintf(bottom, h.Hostname, ipaddress, strings.TrimSpace(kernelverstring), dateStamp, loadfifteen, loadone, loadfive, memfree, memtotal, memusedprct, h.OS)
writeBottom, err := io.WriteString(f, bottomLine)
if err != nil {
fmt.Println(writeBottom, err)
return
}
if string(rpmbinout) != "" {
packages := `
"packages": %s,`
rpmLine := fmt.Sprintf(packages, string(rpmjs))
rpmReplace := strings.Replace(rpmLine, ",\"\"]", "]", -1)
writeRpm, err := io.WriteString(f, rpmReplace)
if err != nil {
fmt.Println(writeRpm, err)
return
}
}
if string(dpkgbinout) != "" {
packages := `
"packages": %s,`
dpkgLine := fmt.Sprintf(packages, string(dpkgjs))
writeDpkg, err := io.WriteString(f, dpkgLine)
if err != nil {
fmt.Println(writeDpkg, err)
return
}
}
if string(pipbinout) != "" {
pip := `
"pip": %s,`
pipLine := fmt.Sprintf(pip, string(pipjs))
pipReplace := strings.Replace(pipLine, ",\"\"]", "]", -1)
writePip, err := io.WriteString(f, pipReplace)
if err != nil {
fmt.Println(writePip, err)
return
}
}
gonetstat4 := GOnetstat.Tcp()
tcp4String := `[`
for _, nettcp := range gonetstat4 {
if nettcp.State == "LISTEN" {
ip_port := fmt.Sprintf("%v:%v", nettcp.Ip, nettcp.Port)
pid_program := fmt.Sprintf("%v", nettcp.Exe)
ippidString := `"%v %v",`
tcp4String += fmt.Sprintf(ippidString, ip_port, pid_program)
}
}
tcp4String += `""]`
tcp4Replace := strings.Replace(tcp4String, ",\"\"]", "]", -1)
gonetstat6 := GOnetstat.Tcp6()
tcp6String := `[`
for _, nettcp := range gonetstat6 {
if nettcp.State == "LISTEN" {
ip_port := fmt.Sprintf("%v:%v", nettcp.Ip, nettcp.Port)
pid_program := fmt.Sprintf("%v", nettcp.Exe)
ippidString := `"%v %v",`
tcp6String += fmt.Sprintf(ippidString, ip_port, pid_program)
}
}
tcp6String += `""]`
tcp6Replace := strings.Replace(tcp6String, ",\"\"]", "]", -1)
beforeLast := `
"platform": "%v",
"platformfamily": "%v",
"platformverison": "%v",
"tcp4_listen": %v,
"tcp6_listen": %v,`
beforeLastLine := fmt.Sprintf(beforeLast, h.Platform, h.PlatformFamily, h.PlatformVersion, tcp4Replace, tcp6Replace)
writeBeforeLast, err := io.WriteString(f, beforeLastLine)
if err != nil {
fmt.Println(writeBeforeLast, err)
return
}
timezoneLast := `
"timezone": "%s",
"uptime": "%v",`
timezoneLastLine := fmt.Sprintf(timezoneLast, strings.TrimSpace(timezonestring), time.Duration(h.Uptime)*time.Second)
writeTimezoneLast, err := io.WriteString(f, timezoneLastLine)
if err != nil {
fmt.Println(writeTimezoneLast, err)
return
}
if string(passfileout) != "" {
users := `
"users": %s,`
usersLine := fmt.Sprintf(users, string(passjs))
usersReplace := strings.Replace(usersLine, ",\"\"]", "]", -1)
writeUsers, err := io.WriteString(f, usersReplace)
if err != nil {
fmt.Println(writeUsers, err)
return
}
}
if string(wbinout) != "" {
users_loggedin := `
"users_loggedin": %s,`
whLine := fmt.Sprintf(users_loggedin, string(whjs))
whReplace := strings.Replace(whLine, ",\"\"]", "]", -1)
writeWh, err := io.WriteString(f, whReplace)
if err != nil {
fmt.Println(writeWh, err)
return
}
}
last := `
"virtualizationrole": "%v",
"virtualizationsystem": "%v"
}`
lastLine := fmt.Sprintf(last, h.VirtualizationRole, h.VirtualizationSystem)
writeLast, err := io.WriteString(f, lastLine)
if err != nil {
fmt.Println(writeLast, err)
return
}
f.Close()
// Generate SHA256 SUM of JSON file
const filechunk = 8192
file, err := os.Open(filename)
if err != nil {
fmt.Println(err.Error())
return
}
defer file.Close()
info, _ := file.Stat()
filesize := info.Size()
blocks := uint64(math.Ceil(float64(filesize) / float64(filechunk)))
hash := sha256.New()
for i := uint64(0); i < blocks; i++ {
blocksize := int(math.Min(filechunk, float64(filesize-int64(i*filechunk))))
buf := make([]byte, blocksize)
file.Read(buf)
io.WriteString(hash, string(buf))
}
if viperReadConfig != nil {
fmt.Println(dateStamp, h.Hostname, "INFO no config file used, using default configuration")
}
fmt.Printf("%s %s INFO %s SHA256 checksum is %x\n", dateStamp, h.Hostname, file.Name(), hash.Sum(nil))
// Check to see if ElasticSearch server is up
elasticResponse, err := client.Get(elastic_url)
if elasticResponse != nil {
jsonStr, err := ioutil.ReadFile(filename)
if err != nil {
fmt.Println(err.Error())
return
}
fmt.Println(dateStamp, h.Hostname, "INFO elasticsearch endpoint:", elastic_url)
if overwrite == "enable" {
reqDelete, err := http.NewRequest("DELETE", elastic_url, nil)
if username != "undef" {
reqDelete.SetBasicAuth(username, password)
}
respDelete, err := http.DefaultClient.Do(reqDelete)
fmt.Println(dateStamp, h.Hostname, "DELETE elasticsearch type status:", respDelete.Status)
if err != nil {
fmt.Println(err.Error())
}
}
reqPost, err := http.NewRequest("POST", elastic_url, bytes.NewBuffer(jsonStr))
if password != "undef" {
reqPost.SetBasicAuth(username, password)
}
reqPost.Header.Set("Content-Type", "application/json")
clientReq := &http.Client{}
respPost, err := clientReq.Do(reqPost)
if err != nil {
fmt.Println(err.Error())
}
defer respPost.Body.Close()
fmt.Println(dateStamp, h.Hostname, "POST json elasticsearch type status:", respPost.Status)
postBody, _ := ioutil.ReadAll(respPost.Body)
fmt.Println(dateStamp, h.Hostname, "POST response body:", string(postBody))
} else {
fmt.Println(dateStamp, h.Hostname, "FAIL unable to connect to elasticeearch server:", "http://"+elastic_host+":"+elastic_port)
}
if !*daemonFlag {
break
}
// Sleep / interval time for daemon
time.Sleep(time.Duration(interval) * time.Second)
}
}
func main() {
for {
// Docker client remote API
endpoint := "unix:///var/run/docker.sock"
dockerClient, _ := docker.NewClient(endpoint)
// Configuration file settings using key-value
viper.SetConfigName("docker-balancer")
viper.AddConfigPath("/opt/docker-balancer/conf")
err := viper.ReadInConfig()
if err != nil {
fmt.Println("No Configuration File Using DEFAULTS")
}
// Default settings if no config file is supplied
viper.SetDefault("docker_balancer", "localhost")
viper.SetDefault("docker_balancer_port", "8888")
viper.SetDefault("interval", "300")
viper.SetDefault("username", "undef")
viper.SetDefault("password", "undef")
docker_balancer := viper.GetString("docker_balancer")
docker_balancer_port := viper.GetString("docker_balancer_port")
interval := viper.GetInt("interval")
username := viper.GetString("username")
password := viper.GetString("password")
transport := http.Transport{
Dial: dialTimeout,
}
client := http.Client{
Transport: &transport,
}
v, _ := mem.VirtualMemory()
k, _ := disk.DiskUsage("/")
h, _ := host.HostInfo()
memusedprctConv := strconv.FormatFloat(v.UsedPercent, 'f', 6, 64)
memusedprct := strings.Split(memusedprctConv, ".")[0]
diskusedprctConv := strconv.FormatFloat(k.UsedPercent, 'f', 6, 64)
diskusedprct := strings.Split(diskusedprctConv, ".")[0]
timeN := time.Now()
dateStamp := fmt.Sprintf("%d-%02d-%02dT%02d:%02d:%02d", timeN.Year(), timeN.Month(), timeN.Day(), timeN.Hour(), timeN.Minute(), timeN.Second())
if err != nil {
fmt.Println(err.Error())
}
containers, _ := dockerClient.ListContainers(docker.ListContainersOptions{All: false})
dockerCount := 0
for container := range containers {
_ = container
dockerCount += 1
}
dockerConv := strconv.Itoa(dockerCount)
fmt.Sprintf(dockerConv)
// docker-balancer endpoint and request
docker_balancer_url := "http://" + docker_balancer + ":" + docker_balancer_port
docker_balancer_request := "http://" + docker_balancer + ":" + docker_balancer_port + "/api/" + memusedprct + "/" + dockerConv + "/" + diskusedprct
balancerResponse, err := client.Get(docker_balancer_url)
if balancerResponse != nil {
if err != nil {
fmt.Println(err.Error())
return
}
// Check to see if docker-balancer server is up
fmt.Println(dateStamp, h.Hostname, "INFO docker-balancer request:", docker_balancer_request)
reqPost, err := http.NewRequest("POST", docker_balancer_request, nil)
if password != "undef" {
reqPost.SetBasicAuth(username, password)
}
clientReq := &http.Client{}
respPost, err := clientReq.Do(reqPost)
if err != nil {
fmt.Println(err.Error())
}
defer respPost.Body.Close()
fmt.Println(dateStamp, h.Hostname, "POST docker-balancer status:", respPost.Status)
postBody, _ := ioutil.ReadAll(respPost.Body)
fmt.Println(dateStamp, h.Hostname, "POST response body:", string(postBody))
} else {
fmt.Println(dateStamp, h.Hostname, "FAIL unable to connect to docker-balancer endpoint:", "http://"+docker_balancer+":"+docker_balancer_port)
}
// Sleep time for, for loop
time.Sleep(time.Duration(interval) * time.Second)
}
}