2021-03-01 16:08:40 +00:00
|
|
|
// The structure of how to add new method types to the system.
|
|
|
|
// -----------------------------------------------------------
|
|
|
|
// All methods need 3 things:
|
|
|
|
// - A type definition
|
|
|
|
// - The type needs a getKind method
|
|
|
|
// - The type needs a handler method
|
|
|
|
// Overall structure example shown below.
|
|
|
|
//
|
|
|
|
// ---
|
|
|
|
// type methodCommandCLICommand struct {
|
|
|
|
// commandOrEvent CommandOrEvent
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// func (m methodCommandCLICommand) getKind() CommandOrEvent {
|
|
|
|
// return m.commandOrEvent
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// func (m methodCommandCLICommand) handler(s *server, message Message, node string) ([]byte, error) {
|
|
|
|
// ...
|
|
|
|
// ...
|
|
|
|
// outMsg := []byte(fmt.Sprintf("confirmed from node: %v: messageID: %v\n---\n%s---", node, message.ID, out))
|
|
|
|
// return outMsg, nil
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// ---
|
|
|
|
// You also need to make a constant for the Method, and add
|
|
|
|
// that constant as the key in the map, where the value is
|
|
|
|
// the actual type you want to map it to with a handler method.
|
|
|
|
// You also specify if it is a Command or Event, and if it is
|
|
|
|
// ACK or NACK.
|
|
|
|
// Check out the existing code below for more examples.
|
2021-02-11 14:39:19 +00:00
|
|
|
|
|
|
|
package steward
|
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
|
|
|
"log"
|
2021-03-02 12:46:02 +00:00
|
|
|
"os"
|
2021-02-11 14:39:19 +00:00
|
|
|
"os/exec"
|
2021-03-02 12:46:02 +00:00
|
|
|
"path/filepath"
|
2021-02-11 14:39:19 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
// ------------------------------------------------------------
|
2021-03-01 16:08:40 +00:00
|
|
|
// The constants that will be used throughout the system for
|
|
|
|
// when specifying what kind of Method to send or work with.
|
|
|
|
const (
|
|
|
|
// Shell command to be executed via f.ex. bash
|
|
|
|
CLICommand Method = "CLICommand"
|
|
|
|
// Send text logging to some host
|
|
|
|
TextLogging Method = "TextLogging"
|
|
|
|
// Send Hello I'm here message
|
|
|
|
SayHello Method = "SayHello"
|
|
|
|
// Error log methods to centralError
|
|
|
|
ErrorLog Method = "ErrorLog"
|
|
|
|
)
|
2021-02-11 14:39:19 +00:00
|
|
|
|
|
|
|
// Method is used to specify the actual function/method that
|
|
|
|
// is represented in a typed manner.
|
|
|
|
type Method string
|
|
|
|
|
2021-03-01 16:08:40 +00:00
|
|
|
// The mapping of all the method constants specified, what type
|
|
|
|
// it references, and the kind if it is an Event or Command, and
|
|
|
|
// if it is ACK or NACK.
|
|
|
|
// Allowed values for the commandOrEvent field are:
|
|
|
|
// - CommandACK
|
|
|
|
// - CommandNACK
|
|
|
|
// - EventACK
|
|
|
|
// - EventNack
|
2021-02-11 14:39:19 +00:00
|
|
|
func (m Method) GetMethodsAvailable() MethodsAvailable {
|
|
|
|
ma := MethodsAvailable{
|
2021-03-05 12:10:46 +00:00
|
|
|
methodhandlers: map[Method]methodHandler{
|
2021-03-09 02:18:42 +00:00
|
|
|
CLICommand: methodSubscriberCLICommand{
|
2021-03-01 16:08:40 +00:00
|
|
|
commandOrEvent: CommandACK,
|
|
|
|
},
|
2021-03-09 02:18:42 +00:00
|
|
|
TextLogging: methodSubscriberTextLogging{
|
2021-03-01 16:08:40 +00:00
|
|
|
commandOrEvent: EventACK,
|
|
|
|
},
|
2021-03-09 02:18:42 +00:00
|
|
|
SayHello: methodSubscriberSayHello{
|
2021-03-01 16:08:40 +00:00
|
|
|
commandOrEvent: EventNACK,
|
|
|
|
},
|
2021-03-09 02:18:42 +00:00
|
|
|
ErrorLog: methodSubscriberErrorLog{
|
2021-03-01 16:08:40 +00:00
|
|
|
commandOrEvent: EventACK,
|
|
|
|
},
|
2021-02-11 14:39:19 +00:00
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
return ma
|
|
|
|
}
|
|
|
|
|
2021-03-01 16:08:40 +00:00
|
|
|
// getHandler will check the methodsAvailable map, and return the
|
|
|
|
// method handler for the method given
|
|
|
|
// as input argument.
|
|
|
|
func (m Method) getHandler(method Method) methodHandler {
|
|
|
|
ma := m.GetMethodsAvailable()
|
2021-03-05 12:10:46 +00:00
|
|
|
mh := ma.methodhandlers[method]
|
2021-03-01 16:08:40 +00:00
|
|
|
|
|
|
|
return mh
|
|
|
|
}
|
2021-02-11 14:39:19 +00:00
|
|
|
|
|
|
|
type MethodsAvailable struct {
|
2021-03-05 12:10:46 +00:00
|
|
|
methodhandlers map[Method]methodHandler
|
2021-02-11 14:39:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Check if exists will check if the Method is defined. If true the bool
|
|
|
|
// value will be set to true, and the methodHandler function for that type
|
|
|
|
// will be returned.
|
|
|
|
func (ma MethodsAvailable) CheckIfExists(m Method) (methodHandler, bool) {
|
2021-03-05 12:10:46 +00:00
|
|
|
mFunc, ok := ma.methodhandlers[m]
|
2021-02-11 14:39:19 +00:00
|
|
|
if ok {
|
2021-02-16 03:57:54 +00:00
|
|
|
// fmt.Printf("******THE TOPIC EXISTS: %v******\n", m)
|
2021-02-11 14:39:19 +00:00
|
|
|
return mFunc, true
|
|
|
|
} else {
|
2021-02-16 03:57:54 +00:00
|
|
|
// fmt.Printf("******THE TOPIC DO NOT EXIST: %v******\n", m)
|
2021-02-11 14:39:19 +00:00
|
|
|
return nil, false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-02-18 13:27:53 +00:00
|
|
|
// ------------------------------------------------------------
|
|
|
|
// Subscriber method handlers
|
2021-02-11 14:39:19 +00:00
|
|
|
// ------------------------------------------------------------
|
|
|
|
|
|
|
|
type methodHandler interface {
|
2021-03-08 13:09:14 +00:00
|
|
|
handler(proc process, message Message, node string) ([]byte, error)
|
2021-03-01 16:08:40 +00:00
|
|
|
getKind() CommandOrEvent
|
2021-02-11 14:39:19 +00:00
|
|
|
}
|
|
|
|
|
2021-03-01 16:08:40 +00:00
|
|
|
// -----
|
|
|
|
|
2021-03-09 02:18:42 +00:00
|
|
|
type methodSubscriberCLICommand struct {
|
2021-03-01 16:08:40 +00:00
|
|
|
commandOrEvent CommandOrEvent
|
|
|
|
}
|
|
|
|
|
2021-03-09 02:18:42 +00:00
|
|
|
func (m methodSubscriberCLICommand) getKind() CommandOrEvent {
|
2021-03-01 16:08:40 +00:00
|
|
|
return m.commandOrEvent
|
|
|
|
}
|
2021-02-11 14:39:19 +00:00
|
|
|
|
2021-03-09 02:18:42 +00:00
|
|
|
func (m methodSubscriberCLICommand) handler(proc process, message Message, node string) ([]byte, error) {
|
2021-02-11 14:39:19 +00:00
|
|
|
// Since the command to execute is at the first position in the
|
|
|
|
// slice we need to slice it out. The arguments are at the
|
|
|
|
// remaining positions.
|
|
|
|
c := message.Data[0]
|
|
|
|
a := message.Data[1:]
|
|
|
|
cmd := exec.Command(c, a...)
|
|
|
|
//cmd.Stdout = os.Stdout
|
|
|
|
out, err := cmd.CombinedOutput()
|
|
|
|
if err != nil {
|
|
|
|
log.Printf("error: execution of command failed: %v\n", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
outMsg := []byte(fmt.Sprintf("confirmed from node: %v: messageID: %v\n---\n%s---", node, message.ID, out))
|
|
|
|
return outMsg, nil
|
|
|
|
}
|
|
|
|
|
2021-02-18 13:27:53 +00:00
|
|
|
// -----
|
|
|
|
|
2021-03-09 02:18:42 +00:00
|
|
|
type methodSubscriberTextLogging struct {
|
2021-03-01 16:08:40 +00:00
|
|
|
commandOrEvent CommandOrEvent
|
|
|
|
}
|
|
|
|
|
2021-03-09 02:18:42 +00:00
|
|
|
func (m methodSubscriberTextLogging) getKind() CommandOrEvent {
|
2021-03-01 16:08:40 +00:00
|
|
|
return m.commandOrEvent
|
|
|
|
}
|
2021-02-11 14:39:19 +00:00
|
|
|
|
2021-03-09 02:18:42 +00:00
|
|
|
func (m methodSubscriberTextLogging) handler(proc process, message Message, node string) ([]byte, error) {
|
2021-03-02 12:46:02 +00:00
|
|
|
sub := Subject{
|
|
|
|
ToNode: string(message.ToNode),
|
|
|
|
CommandOrEvent: proc.subject.CommandOrEvent,
|
|
|
|
Method: message.Method,
|
|
|
|
}
|
|
|
|
|
2021-03-08 13:09:14 +00:00
|
|
|
logFile := filepath.Join(proc.configuration.SubscribersDataFolder, string(sub.name())+"-"+string(message.FromNode))
|
2021-03-02 12:46:02 +00:00
|
|
|
f, err := os.OpenFile(logFile, os.O_APPEND|os.O_RDWR|os.O_CREATE, os.ModeAppend)
|
|
|
|
if err != nil {
|
|
|
|
log.Printf("error: methodEventTextLogging.handler: failed to open file: %v\n", err)
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
defer f.Close()
|
|
|
|
|
2021-02-11 14:39:19 +00:00
|
|
|
for _, d := range message.Data {
|
2021-03-02 12:46:02 +00:00
|
|
|
_, err := f.Write([]byte(d))
|
|
|
|
f.Sync()
|
|
|
|
if err != nil {
|
|
|
|
log.Printf("error: methodEventTextLogging.handler: failed to write to file: %v\n", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
//s.subscriberServices.logCh <- []byte(d)
|
2021-02-11 14:39:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
outMsg := []byte("confirmed from: " + node + ": " + fmt.Sprint(message.ID))
|
|
|
|
return outMsg, nil
|
|
|
|
}
|
2021-02-18 13:27:53 +00:00
|
|
|
|
|
|
|
// -----
|
|
|
|
|
2021-03-09 02:18:42 +00:00
|
|
|
type methodSubscriberSayHello struct {
|
2021-03-01 16:08:40 +00:00
|
|
|
commandOrEvent CommandOrEvent
|
|
|
|
}
|
|
|
|
|
2021-03-09 02:18:42 +00:00
|
|
|
func (m methodSubscriberSayHello) getKind() CommandOrEvent {
|
2021-03-01 16:08:40 +00:00
|
|
|
return m.commandOrEvent
|
|
|
|
}
|
2021-02-18 13:27:53 +00:00
|
|
|
|
2021-03-09 02:18:42 +00:00
|
|
|
func (m methodSubscriberSayHello) handler(proc process, message Message, node string) ([]byte, error) {
|
2021-03-05 12:10:46 +00:00
|
|
|
//fmt.Printf("-- DEBUG 3.1: %#v, %#v, %#v\n\n", proc.subject.name(), proc.procFunc, proc.procFuncCh)
|
|
|
|
//pn := processNameGet(proc.subject.name(), processKindSubscriber)
|
|
|
|
//fmt.Printf("-- DEBUG 3.2: pn = %#v\n\n", pn)
|
|
|
|
log.Printf("<--- Received hello from %#v\n", message.FromNode)
|
2021-02-19 15:58:16 +00:00
|
|
|
// Since the handler is only called to handle a specific type of message we need
|
|
|
|
// to store it elsewhere, and choice for now is under s.metrics.sayHelloNodes
|
2021-03-04 15:27:55 +00:00
|
|
|
|
|
|
|
// send the message to the procFuncCh which is running alongside the process
|
|
|
|
// and can hold registries and handle special things for an individual process.
|
|
|
|
proc.procFuncCh <- message
|
|
|
|
|
2021-02-18 13:27:53 +00:00
|
|
|
outMsg := []byte("confirmed from: " + node + ": " + fmt.Sprint(message.ID))
|
|
|
|
return outMsg, nil
|
|
|
|
}
|
2021-02-24 14:43:31 +00:00
|
|
|
|
|
|
|
// ---
|
|
|
|
|
2021-03-09 02:18:42 +00:00
|
|
|
type methodSubscriberErrorLog struct {
|
2021-03-01 16:08:40 +00:00
|
|
|
commandOrEvent CommandOrEvent
|
|
|
|
}
|
|
|
|
|
2021-03-09 02:18:42 +00:00
|
|
|
func (m methodSubscriberErrorLog) getKind() CommandOrEvent {
|
2021-03-01 16:08:40 +00:00
|
|
|
return m.commandOrEvent
|
|
|
|
}
|
2021-02-24 14:43:31 +00:00
|
|
|
|
2021-03-09 02:18:42 +00:00
|
|
|
func (m methodSubscriberErrorLog) handler(proc process, message Message, node string) ([]byte, error) {
|
2021-03-02 12:46:02 +00:00
|
|
|
log.Printf("<--- Received error from: %v, containing: %v", message.FromNode, message.Data)
|
2021-02-24 14:43:31 +00:00
|
|
|
return nil, nil
|
|
|
|
}
|