Build Status MIT License made-with-Go made-with-Go GitHub go.mod Go version of a Go module GitHub Release

An extensible monitoring tool for user defined services and protocols, all wrote in GoLang and VueJS 3, made with BigBro core.

• This project is in BETA stage
• Go version : 1.15
• Vue version : 3.0
• BigBro core version: GitHub Release

BigBro is a lightweight monitoring software tool that offers a lightweight User Interface to monitor the services and protocols defined by users.

The software also can be used only via CLI interface

The entire software is based on one configuration file where it is possible define a list of services that would be monitor.

BigBro was compiled and tested on Debian and RHEL Linux distribution families.

BigBro was develop to run in any kind of computer or embedded system and was tested on:

• General Personal Computer (x86_64)
• Raspberry 3 B+
• Orange Pi Zero

The default protocols are based on default protocols from BigBro Core, nevertheless new or custom protocols can be implemented in BigBro as in BigBro Core.

• http
• https (with ssl)
• icmp
• icmp6

In the configuration file will must be defined all services and protocol to be monitor. The format type of the file is YAML as follows:

services:
 - name: Facebook (ssl)
 protocols:
 - type: https
 port: 443
 server: facebook.com
 interval : 1000
 - name: Google
 protocols:
 - type: http
 server: google.com
 interval : 1000
 - name: Google DNS
 protocols:
 - type: icmp
 server: 8.8.8.8
 interval : 1000
 - name: Google DNS6
 protocols:
 - type: icmp6
 server: 2a00:1450:400a:804::2004
 interval : 5000
 - type: ftp
 server: 1.1.1.1
 interval : 1000
 customs :
 user : uss
 password : passwd
 ...

• name : Name of the service
• protocols: List of protocols that would be monitored
  • type: name of registered protocol
  • server: IP or dns of service
  • interval: interval time between check (in milliseconds)
  • port: (optional) port of service
  • customs: (optional) list of custom filed for custom implementation of protocols

Basically BigBro can be downloaded from releases section with a pre-compiled binary file.

Releases Page | Last release:

GitHub Release

• Debian or RHEL Linux distribution family
• NodeJS >= v12.10.1 (it is used to compile the user interface)
• Go Version >= v1.15 (developed with this version)
• $GOPATH variable set and included in $PATH ( export PATH=$PATH:$GO:$GOPATH/bin )
• Git installed

Firstly, before the usage of this library you must clone this repository:

git clone github.com/bigbroproject/bigbro

Secondly, the installation of libraries and dependencies is required:

cd bigbro && make install-dep

After the installation of dependencies, you can proceed to build BigBro:

make build #for your architecture
make build-x64 #for 64 bit architecture
make build-x86 #for 32 bit architecture
make build-arm #for ARM 7 architecture
make build-arm5 #for ARM 5 architecture
make build-all #to build all solutions

Before the build phase you can edit the main code, registering new protocols or handlers:

package main
import (
	"github.com/bigbroproject/bigbrocore/core"
	"github.com/bigbroproject/bigbrocore/protocols"
	"github.com/bigbroproject/bigbrocore/responsehandlers"
)
func main() {
	//log.SetFlags(log.LstdFlags | log.Lshortfile)
	system.PrintSystemInfo()
	ws := webserver.NewWebServer("config/serverconfig.yml")
	ws.Start()
	regProtocolInterfaces, regResponseHandlerInterfaces := core.Initialize("config/config.yml")
	// Register custom protocols
	//protocols.RegisterProtocolInterface(&regProtocolInterfaces, "ftp", protocols.FTP{})
	// Register Response Handlers
	responsehandlers.RegisterResponseHandlerInterface(&regResponseHandlerInterfaces, "webServerHandler", responsehandler.WebServerRespHandler{OutputChannel: ws.InputChannel})
 // Register custom handlers
	//responsehandlers.RegisterResponseHandlerInterface(&regResponseHandlerInterfaces, "console", responsehandlers.ConsoleHandler{})
	responsehandlers.RegisterResponseHandlerInterface(&regResponseHandlerInterfaces, "consoleMemory", responsehandlers.ConsoleHandlerWithMemory{})
	// Start monitoring
	core.Start(regProtocolInterfaces, regResponseHandlerInterfaces)
}

In this example we Initialize the entire module with a given configuration file path (you can manage this as a first input in your command line, for instance). Secondly, you must define and register a ResponseHandler to manage the Responses from service checks (otherwise you cannot log or see anything) and then register a custom protocol, if needed.

Finally, you can over your project main with the Start of the module.

For more information about the implementation of new protocols and handlers read the documentation of BigBro core.

Made with ❤️ by Asdrubbalo, filirnd and fedyfausto