@ -8,58 +8,54 @@ import (
"context"
"errors"
"fmt"
"net"
"sync"
"github.com/spf13/viper"
"google.golang.org/grpc"
)
// this package creates the central coordiantor and sub coordiantors for clients
// this package creates the central coordiantor and sub coordiantors to route clients
// db client interface
type D B interface {
type D atabase interface {
// getters (all create if doesnt exist)
GetReactorClient ( int ) ( string , string , string , string , error ) // returns (url, org, bucket, token, err)
}
func NewD B Admin( config * viper . Viper ) ( D B , error ) {
func NewD atabase Admin( config * viper . Viper ) ( D atabase , error ) {
return influxdb . NewDBAdmin ( config )
}
type CentralCoordinator struct {
// main coordinator
ClientConnections * ClientPacket
* SubCoordinators
//*SystemViewer
DB
* ReactorCoordinator
Database
Config * viper . Viper
// from config
Ports map [ string ] int ` mapstructure:"ports" `
Err chan error
}
type SubCoordinators struct {
Directory map [ string ] * SubCoordinator
sync . Mutex
}
func NewCentralCoordinator ( config * viper . Viper , ch chan error ) * CentralCoordinator {
// create a central coordinator to manage requests
db , err := NewD B Admin( config )
db , err := NewDatabaseAdmin ( config )
if err != nil {
ch <- err
}
c := & CentralCoordinator { Err : ch , Config : config , DB : db }
rc , err := NewReactorCoordinator ( ch )
if err != nil {
ch <- err
}
config . UnmarshalKey ( "server.ports" , rc ) // get reactor port
c := & CentralCoordinator { Err : ch , Config : config , Database : db , ReactorCoordinator : rc }
// grab config settings
if err = config . UnmarshalKey ( "server" , c ) ; err != nil {
ch <- err
}
// spawn a systemviewer DECOMIS
//c.SystemViewer = NewSystemViewer()
//.go c.SystemViewer.Start()
// subcoord map
s := make ( map [ string ] * SubCoordinator )
c . SubCoordinators = & SubCoordinators { Directory : s }
// return init coordinator
return c
}
@ -67,250 +63,126 @@ func (c *CentralCoordinator) Start() {
// starts up associated funcs
clientChan := make ( chan * ClientPacket )
l := NewListener ( clientChan , c . Err )
// grabs lis port
c . Config . UnmarshalKey ( "server.ports" , l )
// starts client listener routines
go l . Start ( )
// starting reactor coordinator
if err := c . ReactorCoordinator . Start ( ) ; err != nil {
c . Err <- err
}
// starting listener
if err := l . Start ( ) ; err != nil {
c . Err <- err
}
// lastly start client listener
go c . ClientListener ( clientChan )
}
func ( c * CentralCoordinator ) ClientListener ( ch chan * ClientPacket ) {
for client := range ch {
// basically loops until channel is closed
fmt . Printf ( "Incoming client: +%v\n" , client )
client . Response <- c . ClientHandler ( client . Client ) // respond with cred
}
}
func ( c * CentralCoordinator ) ClientHandler ( cl * Client ) * ClientResponse {
// look for sub coord
c . SubCoordinators . Lock ( )
subcoord , ok := c . SubCoordinators . Directory [ cl . Type ]
if ! ok {
// Sub Coordinator does not exists, creating
fmt . Printf ( "Cl type: %s, Port: %d\n" , cl . Type , c . Ports [ cl . Type ] )
subcoord = NewSubCoordinator ( cl . Type , c . Ports [ cl . Type ] , c . Err )
c . SubCoordinators . Directory [ cl . Type ] = subcoord
fmt . Printf ( "Creating subcord for %s on %d\n" , cl . Type , c . Ports [ cl . Type ] )
logging . Debug ( logging . DSpawn , "CC0 01 Created %v Coordinator" , cl . Type )
// returns reactor db info
var err error
cr := & ClientResponse { Port : c . Ports [ cl . Type ] }
if cl . Type == "reactor" {
// get reactor info
go c . ReactorCoordinator . ClientHandler ( cl )
// db info
cr . URL , cr . Org , cr . Token , cr . Bucket , err = c . Database . GetReactorClient ( cl . Id )
} else {
// throw error
err = errors . New ( fmt . Sprintf ( "Client type %s not recognized!" ) )
}
// unlocking
c . SubCoordinators . Unlock ( )
// starts sub coord with client credentials
fmt . Printf ( "Starting subcoord client handler\n" )
go subcoord . ClientHandler ( cl )
fmt . Printf ( "Getting db info\n" )
// setting up client response
url , org , token , bucket , err := c . DB . GetReactorClient ( cl . Id )
fmt . Printf ( "Got URL: %s, Org: %s, Token: %s, Bucket: %b\n" , url , org , token , bucket )
// returns based on cl type
if err != nil {
c . Err <- err
}
// returning info
return & ClientResponse { URL : url , Org : org , Token : token , Bucket : bucket , Port : c . Ports [ cl . Type ] }
return cr
}
type ManagerInterface interface {
Start ( )
NewManager ( * Client , chan error ) GeneralManager
GetManager ( int ) ( GeneralManager , bool )
AddManager ( int , GeneralManager )
Register ( )
type ReactorCoordinator struct {
Port int ` mapstructure:"reactor" `
* ReactorManagers
Err chan error
pb . UnimplementedMonitoringServer
}
type GeneralManager interface {
// used by sub coordinator to interact with manager
Start ( )
UpdateClient ( * Client )
type ReactorManagers struct {
Directory map [ int ] * ReactorManager
sync . RWMutex
}
type SubCoordinator struct {
Port int // port that we set up gRPC endpoint on
ManagerInterface // embed an interface to create/manager managers
//*SystemViewer
Err chan error
func NewReactorCoordinator ( errCh chan error ) ( * ReactorCoordinator , error ) {
rmap := make ( map [ int ] * ReactorManager )
rm := & ReactorManagers { Directory : rmap }
c := & ReactorCoordinator { Err : errCh , ReactorManagers : rm }
return c , nil
}
type Managers struct {
Directory map [ int ] interface { } // support for either manager
sync . RWMutex // potential perf
func ( c * ReactorCoordinator ) Start ( ) error {
logging . Debug ( logging . DStart , "RCO 01 Starting!" )
// register grpc service
return c . Register ( )
}
// interface stuff
func NewSubCoordinator ( clientType string , port int , errCh chan error ) * SubCoordinator {
c := & SubCoordinator { Err : errCh }
//c.SystemViewer = sys
man , err := NewCoordinatorType ( clientType , errCh )
if err != nil {
errCh <- err
func ( c * ReactorCoordinator ) ClientHandler ( cl * Client ) {
// updates clients if nessecary
if err := c . UpdateManager ( cl , c . Err ) ; err != nil {
c . Err <- err
}
c . ManagerInterface = man
go man . Start ( )
go man . Register ( )
return c
}
func ( c * SubCoordinator ) ClientHandler ( cl * Client ) {
// (creates and) notifies manager of client connection
c . UpdateManager ( cl )
}
func ( m * ReactorManagers ) GetManager ( id int ) ( * ReactorManager , error ) {
m . RLock ( )
defer m . RUnlock ( )
func ( c * SubCoordinator ) UpdateManager ( cl * Client ) {
// shouldn't happen all that often so should be fine to lock
fmt . Printf ( "Grabbing Manager\n" )
m , exists := c . GetManager ( cl . Id )
rm , exists := m . Directory [ id ]
if ! exists {
fmt . Printf ( "Creating Manager\n" )
m = c . NewManager ( cl , c . Err )
m . UpdateClient ( cl )
go c . AddManager ( cl . Id , m )
go m . Start ( )
return & ReactorManager { } , errors . New ( fmt . Sprintf ( "No manager for reactor %d!" , id ) )
}
go m . UpdateClient ( cl )
}
func ( m * Managers ) AddManager ( id int , man GeneralManager ) {
m . Lock ( )
defer m . Unlock ( )
m . Directory [ id ] = man
return rm , nil
}
func ( m * Managers) GetManager ( id int ) ( GeneralManager , bool ) {
// just read locks and reuturns
func ( m * ReactorManagers ) UpdateManager ( cl * Client , errCh chan error ) error {
// locking
m . RLock ( )
defer m . RUnlock ( )
man , exists := m . Directory [ id ]
rm , exists := m . Directory [ cl . Id ]
if ! exists {
return nil , exists
logging . Debug ( logging . DClient , "RCO 01 starting manager for reactor client %v" , cl . Id )
rm = NewReactorManager ( errCh )
if err := rm . Start ( ) ; err != nil {
return err
}
m . Directory [ cl . Id ] = rm
}
return man . ( GeneralManager ) , exists
return rm. UpdateClient ( cl )
}
func NewCoordinatorType ( clientType string , err chan error ) ( ManagerInterface , error ) {
m := make ( map [ int ] interface { } )
if clientType == "reactor" {
c := & reactorCoordinator { }
//m := make(map[uint32]*ReactorManager)
c . Managers = & Managers { Directory : m }
return c , nil
} else if clientType == "tui" {
c := & reactorCoordinator { }
//m := make(map[uint32]*TUIManager)
//c.Managers = &Managers{Directory: m}
return c , errors . New ( fmt . Sprint ( "error, TUI Not impl" ) )
func ( r * ReactorCoordinator ) Register ( ) error {
lis , err := net . Listen ( "tcp" , fmt . Sprintf ( ":%v" , r . Port ) )
if err != nil {
return err
}
return & reactorCoordinator { } , errors . New ( "Unrecognized client type" )
grpcServer := grpc . NewServer ( )
pb . RegisterMonitoringServer ( grpcServer , r )
go grpcServer . Serve ( lis )
logging . Debug ( logging . DClient , "RCO ready for client requests" )
return nil
}
// creating sub coordinators for associated gRPC handlers
// reactor coordinator
type reactorCoordinator struct {
* Managers
pb . UnimplementedMonitoringServer
}
func ( r * reactorCoordinator ) Start ( ) {
logging . Debug ( logging . DStart , "RCO 01 Starting!" )
}
func ( r * reactorCoordinator ) NewManager ( cl * Client , err chan error ) GeneralManager {
logging . Debug ( logging . DClient , "RCO 01 starting manager for %v client %v" , cl . Type , cl . Id )
return NewReactorManager ( cl , err )
}
func ( r * reactorCoordinator ) Register ( ) {
//conf := LoadConfig()
/ *
port , err := conf . GetPort ( "reactor" )
if err != nil {
panic ( err )
}
lis , err := net . Listen ( "tcp" , fmt . Sprintf ( ":%v" , port ) )
if err != nil {
panic ( err )
}
grpcServer := grpc . NewServer ( )
pb . RegisterMonitoringServer ( grpcServer , r )
go grpcServer . Serve ( lis )
logging . Debug ( logging . DClient , "RCO ready for client requests" )
* /
}
func ( r * reactorCoordinator ) ReactorStatusHandler ( ctx context . Context , req * pb . ReactorStatusPing ) ( * pb . ReactorStatusResponse , error ) {
m , exists := r . GetManager ( int ( req . GetId ( ) ) )
if ! exists {
return & pb . ReactorStatusResponse { } , errors . New ( "Manager doesn't exists for that client" )
}
rm , ok := m . ( * ReactorManager )
if ! ok {
return & pb . ReactorStatusResponse { } , errors . New ( "Manager is not a reactor manager!" )
func ( r * ReactorCoordinator ) ReactorStatusHandler ( ctx context . Context , req * pb . ReactorStatusPing ) ( * pb . ReactorStatusResponse , error ) {
rm , err := r . GetManager ( int ( req . GetId ( ) ) )
// error checking
if err != nil {
return & pb . ReactorStatusResponse { } , err
}
return rm . ReactorStatusHandler ( ctx , req )
}
// tui coordinator
/ *
type tuiCoordinator struct {
* Managers // by embedding general struct we allow coordinator to still call general funcs
pb . UnimplementedManagementServer
}
func ( t * tuiCoordinator ) Start ( ) {
logging . Debug ( logging . DStart , "TCO 01 Starting!" )
}
func ( t * tuiCoordinator ) NewManager ( cl * Client , err chan error ) GeneralManager {
logging . Debug ( logging . DClient , "TCO 01 starting manager for %v client %v" , cl . Type , cl . Id )
return NewTUIManager ( cl , err )
}
func ( t * tuiCoordinator ) Register ( ) {
/ *
conf := LoadConfig ( )
port , err := conf . GetPort ( "tui" )
if err != nil {
panic ( err )
}
lis , err := net . Listen ( "tcp" , fmt . Sprintf ( ":%v" , port ) )
if err != nil {
// rip
}
grpcServer := grpc . NewServer ( )
pb . RegisterManagementServer ( grpcServer , t )
go grpcServer . Serve ( lis )
logging . Debug ( logging . DClient , "TCO ready for client requests" )
* /
/ *
}
func ( t * tuiCoordinator ) GetDevices ( ctx context . Context , req * pb . GetDevicesRequest ) ( * pb . GetDevicesResponse , error ) {
// grpc handler to fwd to manager
m , exists := t . GetManager ( int ( req . GetClientId ( ) ) )
if ! exists {
// doesnt exist for some reason
return & pb . GetDevicesResponse { } , errors . New ( "Manager doesn't exists for client" )
}
tm , ok := m . ( * TUIManager )
if ! ok {
return & pb . GetDevicesResponse { } , errors . New ( "Manager is not of type TUI" )
}
return tm . GetDevices ( ctx , req )
}
// unimplemented bs for grpc
func ( t * tuiCoordinator ) DeleteReactor ( ctx context . Context , req * pb . DeleteReactorRequest ) ( * pb . DeleteReactorResponse , error ) {
// TODO
return & pb . DeleteReactorResponse { } , nil
}
func ( t * tuiCoordinator ) DeleteReactorDevice ( ctx context . Context , req * pb . DeleteReactorDeviceRequest ) ( * pb . DeleteReactorDeviceResponse , error ) {
// TODO
return & pb . DeleteReactorDeviceResponse { } , nil
}
* /
KeeganForelight
2 years ago