fixing refs
parent
6acf06f21b
commit
f446b4d7dd
@ -1,27 +0,0 @@
|
||||
package api
|
||||
|
||||
import (
|
||||
"errors"
|
||||
)
|
||||
|
||||
type ReactorCoordinator interface {
|
||||
Start() error
|
||||
Ping() error
|
||||
}
|
||||
|
||||
type reactorCoordinator struct {
|
||||
id string
|
||||
}
|
||||
|
||||
func (r *reactorCoordinator) Start() error {
|
||||
return errors.New("todo")
|
||||
}
|
||||
|
||||
func (r *reactorCoordinator) Ping() error {
|
||||
return errors.New("todo")
|
||||
}
|
||||
|
||||
func StartReactor(id string) ReactorCoordinator {
|
||||
return &reactorCoordinator{id:id}
|
||||
}
|
||||
|
||||
@ -1,51 +0,0 @@
|
||||
// package Config wraps the viper library to setup/manage files for FRMS
|
||||
package config
|
||||
|
||||
import (
|
||||
"FRMS/internal/pkg/logging"
|
||||
"fmt"
|
||||
"os"
|
||||
|
||||
"github.com/spf13/viper"
|
||||
)
|
||||
|
||||
// Load the file at path/file into a viper object.
|
||||
// Expects config file to be yaml.
|
||||
func Load(file, path, ext string) (*viper.Viper, error) {
|
||||
|
||||
logging.Debug(logging.DStart, "CON loading %s", file)
|
||||
|
||||
config := viper.New()
|
||||
|
||||
//configFile := fmt.Sprintf("%s/%s.%s", path, file, ext)
|
||||
|
||||
config.SetConfigName(file)
|
||||
config.AddConfigPath(path)
|
||||
config.SetConfigType(ext)
|
||||
|
||||
// Sets env vars
|
||||
config.AutomaticEnv()
|
||||
|
||||
// create config directory if it doesn't exist
|
||||
if err := os.MkdirAll(path, 0750); err != nil && !os.IsExist(err) {
|
||||
return config, err
|
||||
}
|
||||
|
||||
// attempt to create an empty config incase it doesn't exist
|
||||
// if err := config.SafeWriteConfigAs(configFile); err != nil {
|
||||
// // if error thrown because file exists, fine to ignore
|
||||
// if _, ok := err.(viper.ConfigFileAlreadyExistsError); !ok {
|
||||
// return config, err
|
||||
// }
|
||||
// }
|
||||
|
||||
if err := config.ReadInConfig(); err != nil {
|
||||
fmt.Printf("read error %v\n", config)
|
||||
return config, err
|
||||
}
|
||||
|
||||
logging.Debug(logging.DStart, "CON Loaded configs from %#V", config.ConfigFileUsed())
|
||||
|
||||
// returning config object
|
||||
return config, nil
|
||||
}
|
||||
@ -1,62 +0,0 @@
|
||||
// Package config provides an interface to load and store config files
|
||||
// using the XDG standard ($HOME/.config/FRMS) as the base directory
|
||||
//
|
||||
// WARNING: only built for Linux
|
||||
package config
|
||||
|
||||
import (
|
||||
"FRMS/internal/pkg/logging"
|
||||
"errors"
|
||||
"fmt"
|
||||
"os"
|
||||
|
||||
"github.com/spf13/viper"
|
||||
)
|
||||
|
||||
// LoadConfig takes a filename as an aruguement and returns a *viper.Viper object.
|
||||
// Loads and stores config files into the base directory according to XDG standard ($HOME/.config/FRMS/).
|
||||
// Will create directory and config if they don't exist.
|
||||
func LoadConfig(filename string) (*viper.Viper, error) {
|
||||
|
||||
config := viper.New()
|
||||
|
||||
// default config dir
|
||||
path := fmt.Sprintf("%s/.config/FRMS", os.Getenv("HOME"))
|
||||
filetype := "yaml"
|
||||
|
||||
// checking for existence
|
||||
if _, err := os.Stat(path); errors.Is(err, os.ErrNotExist) {
|
||||
if err := os.Mkdir(path, os.ModePerm); err != nil {
|
||||
return config, err
|
||||
}
|
||||
}
|
||||
|
||||
logging.Debug(logging.DStart, "Loading config (%s)", filename)
|
||||
|
||||
// setting config file info
|
||||
config.SetConfigName(filename)
|
||||
config.SetConfigType(filetype)
|
||||
config.AddConfigPath(path)
|
||||
|
||||
config.AutomaticEnv()
|
||||
|
||||
// reading in config
|
||||
if err := config.ReadInConfig(); err != nil {
|
||||
|
||||
if _, ok := err.(viper.ConfigFileNotFoundError); ok {
|
||||
|
||||
fullpath := fmt.Sprintf("%s/%s.%s", path, filename, filetype)
|
||||
logging.Debug(logging.DStart, "CON config does not exist!")
|
||||
if err = config.WriteConfigAs(fullpath); err != nil {
|
||||
return config, err
|
||||
}
|
||||
logging.Debug(logging.DStart, "CON created at %s", fullpath)
|
||||
} else {
|
||||
return config, err
|
||||
}
|
||||
}
|
||||
|
||||
logging.Debug(logging.DStart, "CON Loaded configs from %v", config.ConfigFileUsed())
|
||||
|
||||
return config, nil
|
||||
}
|
||||
@ -1,64 +0,0 @@
|
||||
// package Database wraps some influx db methods to provide functionality.
|
||||
package database
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
|
||||
influx "github.com/influxdata/influxdb-client-go/v2"
|
||||
"github.com/spf13/viper"
|
||||
)
|
||||
|
||||
var (
|
||||
ErrDBConnection = errors.New("connection to database failed")
|
||||
ErrNoURLFound = errors.New("database url not found")
|
||||
)
|
||||
|
||||
var db influx.Client
|
||||
|
||||
// Connect takes in a config and attempts to create a client for influxdb.
|
||||
// Will automatically write changes back to config for future attempts
|
||||
func Connect(config *viper.Viper) error {
|
||||
|
||||
url := config.GetString("db.url")
|
||||
token := config.GetString("db.token")
|
||||
|
||||
if url == "" {
|
||||
return ErrNoURLFound
|
||||
}
|
||||
|
||||
db = influx.NewClient(url, token)
|
||||
|
||||
if token == "" {
|
||||
// try setup
|
||||
fmt.Printf("attempting to setup database at %v\n", url)
|
||||
|
||||
user := config.GetString("db.username")
|
||||
password := config.GetString("db.password")
|
||||
org := config.GetString("db.org")
|
||||
bucket := config.GetString("db.bucket")
|
||||
|
||||
Setup(user, pass, org, bucket
|
||||
}
|
||||
|
||||
db = influx.NewClient(url, token)
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func Setup(user, pass, org, bucket string, ret int) (string, error) {
|
||||
|
||||
resp, err := db.Setup(context.Background(), user, pass, org, bucket, ret)
|
||||
|
||||
return "", nil
|
||||
}
|
||||
|
||||
func GetBucket(id int) (string, error) {
|
||||
return "", nil
|
||||
}
|
||||
|
||||
func GetToken(id int) (string, error) {
|
||||
// bucket, err := client.BucketsAPI().FindBucketByName(context.Background(), id)
|
||||
return "", nil
|
||||
}
|
||||
@ -1,42 +0,0 @@
|
||||
syntax = "proto3";
|
||||
package grpc;
|
||||
|
||||
option go_package = "internal/pkg/grpc";
|
||||
|
||||
service device {
|
||||
// groups basic device interactions
|
||||
// get/set name based on request
|
||||
rpc Name(NameRequest) returns (NameResponse)
|
||||
}
|
||||
|
||||
message NameRequest {
|
||||
// empty for future expansion
|
||||
string Name = 1;
|
||||
}
|
||||
|
||||
message NameResponse {
|
||||
string Name = 1;
|
||||
}
|
||||
|
||||
service sensor {
|
||||
// sensor specific functions
|
||||
rpc Reading(ReadingRequest) returns (ReadingResponse)
|
||||
rpc SampleRate(SampleRateRequest) returns (SampleRateResponse)
|
||||
}
|
||||
|
||||
message ReadingRequest {
|
||||
// empty
|
||||
}
|
||||
|
||||
message ReadingResponse {
|
||||
string Reading = 1; // formatted reading "9.7 pH"
|
||||
int64 Timestamp = 2; // when the reading was taken
|
||||
}
|
||||
|
||||
message SampleRateRequest {
|
||||
int32 SampleRate = 1; // 0 to return current sample rate, value in seconds
|
||||
}
|
||||
|
||||
message SampleRateResponse {
|
||||
int32 SampleRate = 1; // returns the set sample rate
|
||||
}
|
||||
@ -1,260 +0,0 @@
|
||||
// Code generated by protoc-gen-go. DO NOT EDIT.
|
||||
// versions:
|
||||
// protoc-gen-go v1.28.1
|
||||
// protoc v3.21.12
|
||||
// source: internal/pkg/grpc/handshake.proto
|
||||
|
||||
package grpc
|
||||
|
||||
import (
|
||||
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
|
||||
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
|
||||
reflect "reflect"
|
||||
sync "sync"
|
||||
)
|
||||
|
||||
const (
|
||||
// Verify that this generated code is sufficiently up-to-date.
|
||||
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
|
||||
// Verify that runtime/protoimpl is sufficiently up-to-date.
|
||||
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
|
||||
)
|
||||
|
||||
type ReactorClientRequest struct {
|
||||
state protoimpl.MessageState
|
||||
sizeCache protoimpl.SizeCache
|
||||
unknownFields protoimpl.UnknownFields
|
||||
|
||||
Id uint32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
|
||||
Port uint32 `protobuf:"varint,2,opt,name=port,proto3" json:"port,omitempty"` // client gRPC port
|
||||
}
|
||||
|
||||
func (x *ReactorClientRequest) Reset() {
|
||||
*x = ReactorClientRequest{}
|
||||
if protoimpl.UnsafeEnabled {
|
||||
mi := &file_internal_pkg_grpc_handshake_proto_msgTypes[0]
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
}
|
||||
|
||||
func (x *ReactorClientRequest) String() string {
|
||||
return protoimpl.X.MessageStringOf(x)
|
||||
}
|
||||
|
||||
func (*ReactorClientRequest) ProtoMessage() {}
|
||||
|
||||
func (x *ReactorClientRequest) ProtoReflect() protoreflect.Message {
|
||||
mi := &file_internal_pkg_grpc_handshake_proto_msgTypes[0]
|
||||
if protoimpl.UnsafeEnabled && x != nil {
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
if ms.LoadMessageInfo() == nil {
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
return ms
|
||||
}
|
||||
return mi.MessageOf(x)
|
||||
}
|
||||
|
||||
// Deprecated: Use ReactorClientRequest.ProtoReflect.Descriptor instead.
|
||||
func (*ReactorClientRequest) Descriptor() ([]byte, []int) {
|
||||
return file_internal_pkg_grpc_handshake_proto_rawDescGZIP(), []int{0}
|
||||
}
|
||||
|
||||
func (x *ReactorClientRequest) GetId() uint32 {
|
||||
if x != nil {
|
||||
return x.Id
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (x *ReactorClientRequest) GetPort() uint32 {
|
||||
if x != nil {
|
||||
return x.Port
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
type ReactorClientResponse struct {
|
||||
state protoimpl.MessageState
|
||||
sizeCache protoimpl.SizeCache
|
||||
unknownFields protoimpl.UnknownFields
|
||||
|
||||
Id uint32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
|
||||
Url string `protobuf:"bytes,2,opt,name=url,proto3" json:"url,omitempty"`
|
||||
Org string `protobuf:"bytes,3,opt,name=org,proto3" json:"org,omitempty"`
|
||||
Token string `protobuf:"bytes,4,opt,name=token,proto3" json:"token,omitempty"`
|
||||
Bucket string `protobuf:"bytes,5,opt,name=bucket,proto3" json:"bucket,omitempty"`
|
||||
}
|
||||
|
||||
func (x *ReactorClientResponse) Reset() {
|
||||
*x = ReactorClientResponse{}
|
||||
if protoimpl.UnsafeEnabled {
|
||||
mi := &file_internal_pkg_grpc_handshake_proto_msgTypes[1]
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
}
|
||||
|
||||
func (x *ReactorClientResponse) String() string {
|
||||
return protoimpl.X.MessageStringOf(x)
|
||||
}
|
||||
|
||||
func (*ReactorClientResponse) ProtoMessage() {}
|
||||
|
||||
func (x *ReactorClientResponse) ProtoReflect() protoreflect.Message {
|
||||
mi := &file_internal_pkg_grpc_handshake_proto_msgTypes[1]
|
||||
if protoimpl.UnsafeEnabled && x != nil {
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
if ms.LoadMessageInfo() == nil {
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
return ms
|
||||
}
|
||||
return mi.MessageOf(x)
|
||||
}
|
||||
|
||||
// Deprecated: Use ReactorClientResponse.ProtoReflect.Descriptor instead.
|
||||
func (*ReactorClientResponse) Descriptor() ([]byte, []int) {
|
||||
return file_internal_pkg_grpc_handshake_proto_rawDescGZIP(), []int{1}
|
||||
}
|
||||
|
||||
func (x *ReactorClientResponse) GetId() uint32 {
|
||||
if x != nil {
|
||||
return x.Id
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (x *ReactorClientResponse) GetUrl() string {
|
||||
if x != nil {
|
||||
return x.Url
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func (x *ReactorClientResponse) GetOrg() string {
|
||||
if x != nil {
|
||||
return x.Org
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func (x *ReactorClientResponse) GetToken() string {
|
||||
if x != nil {
|
||||
return x.Token
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func (x *ReactorClientResponse) GetBucket() string {
|
||||
if x != nil {
|
||||
return x.Bucket
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
var File_internal_pkg_grpc_handshake_proto protoreflect.FileDescriptor
|
||||
|
||||
var file_internal_pkg_grpc_handshake_proto_rawDesc = []byte{
|
||||
0x0a, 0x21, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x67,
|
||||
0x72, 0x70, 0x63, 0x2f, 0x68, 0x61, 0x6e, 0x64, 0x73, 0x68, 0x61, 0x6b, 0x65, 0x2e, 0x70, 0x72,
|
||||
0x6f, 0x74, 0x6f, 0x12, 0x04, 0x67, 0x72, 0x70, 0x63, 0x22, 0x3a, 0x0a, 0x14, 0x52, 0x65, 0x61,
|
||||
0x63, 0x74, 0x6f, 0x72, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
|
||||
0x74, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x02, 0x69,
|
||||
0x64, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x6f, 0x72, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52,
|
||||
0x04, 0x70, 0x6f, 0x72, 0x74, 0x22, 0x79, 0x0a, 0x15, 0x52, 0x65, 0x61, 0x63, 0x74, 0x6f, 0x72,
|
||||
0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x0e,
|
||||
0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x02, 0x69, 0x64, 0x12, 0x10,
|
||||
0x0a, 0x03, 0x75, 0x72, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x72, 0x6c,
|
||||
0x12, 0x10, 0x0a, 0x03, 0x6f, 0x72, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6f,
|
||||
0x72, 0x67, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28,
|
||||
0x09, 0x52, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x16, 0x0a, 0x06, 0x62, 0x75, 0x63, 0x6b,
|
||||
0x65, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x62, 0x75, 0x63, 0x6b, 0x65, 0x74,
|
||||
0x32, 0x5c, 0x0a, 0x09, 0x68, 0x61, 0x6e, 0x64, 0x73, 0x68, 0x61, 0x6b, 0x65, 0x12, 0x4f, 0x0a,
|
||||
0x14, 0x52, 0x65, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x48, 0x61,
|
||||
0x6e, 0x64, 0x6c, 0x65, 0x72, 0x12, 0x1a, 0x2e, 0x67, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x65, 0x61,
|
||||
0x63, 0x74, 0x6f, 0x72, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
|
||||
0x74, 0x1a, 0x1b, 0x2e, 0x67, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x65, 0x61, 0x63, 0x74, 0x6f, 0x72,
|
||||
0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x13,
|
||||
0x5a, 0x11, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x67,
|
||||
0x72, 0x70, 0x63, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
|
||||
}
|
||||
|
||||
var (
|
||||
file_internal_pkg_grpc_handshake_proto_rawDescOnce sync.Once
|
||||
file_internal_pkg_grpc_handshake_proto_rawDescData = file_internal_pkg_grpc_handshake_proto_rawDesc
|
||||
)
|
||||
|
||||
func file_internal_pkg_grpc_handshake_proto_rawDescGZIP() []byte {
|
||||
file_internal_pkg_grpc_handshake_proto_rawDescOnce.Do(func() {
|
||||
file_internal_pkg_grpc_handshake_proto_rawDescData = protoimpl.X.CompressGZIP(file_internal_pkg_grpc_handshake_proto_rawDescData)
|
||||
})
|
||||
return file_internal_pkg_grpc_handshake_proto_rawDescData
|
||||
}
|
||||
|
||||
var file_internal_pkg_grpc_handshake_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
|
||||
var file_internal_pkg_grpc_handshake_proto_goTypes = []interface{}{
|
||||
(*ReactorClientRequest)(nil), // 0: grpc.ReactorClientRequest
|
||||
(*ReactorClientResponse)(nil), // 1: grpc.ReactorClientResponse
|
||||
}
|
||||
var file_internal_pkg_grpc_handshake_proto_depIdxs = []int32{
|
||||
0, // 0: grpc.handshake.ReactorClientHandler:input_type -> grpc.ReactorClientRequest
|
||||
1, // 1: grpc.handshake.ReactorClientHandler:output_type -> grpc.ReactorClientResponse
|
||||
1, // [1:2] is the sub-list for method output_type
|
||||
0, // [0:1] is the sub-list for method input_type
|
||||
0, // [0:0] is the sub-list for extension type_name
|
||||
0, // [0:0] is the sub-list for extension extendee
|
||||
0, // [0:0] is the sub-list for field type_name
|
||||
}
|
||||
|
||||
func init() { file_internal_pkg_grpc_handshake_proto_init() }
|
||||
func file_internal_pkg_grpc_handshake_proto_init() {
|
||||
if File_internal_pkg_grpc_handshake_proto != nil {
|
||||
return
|
||||
}
|
||||
if !protoimpl.UnsafeEnabled {
|
||||
file_internal_pkg_grpc_handshake_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
|
||||
switch v := v.(*ReactorClientRequest); i {
|
||||
case 0:
|
||||
return &v.state
|
||||
case 1:
|
||||
return &v.sizeCache
|
||||
case 2:
|
||||
return &v.unknownFields
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
file_internal_pkg_grpc_handshake_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
|
||||
switch v := v.(*ReactorClientResponse); i {
|
||||
case 0:
|
||||
return &v.state
|
||||
case 1:
|
||||
return &v.sizeCache
|
||||
case 2:
|
||||
return &v.unknownFields
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
}
|
||||
type x struct{}
|
||||
out := protoimpl.TypeBuilder{
|
||||
File: protoimpl.DescBuilder{
|
||||
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
|
||||
RawDescriptor: file_internal_pkg_grpc_handshake_proto_rawDesc,
|
||||
NumEnums: 0,
|
||||
NumMessages: 2,
|
||||
NumExtensions: 0,
|
||||
NumServices: 1,
|
||||
},
|
||||
GoTypes: file_internal_pkg_grpc_handshake_proto_goTypes,
|
||||
DependencyIndexes: file_internal_pkg_grpc_handshake_proto_depIdxs,
|
||||
MessageInfos: file_internal_pkg_grpc_handshake_proto_msgTypes,
|
||||
}.Build()
|
||||
File_internal_pkg_grpc_handshake_proto = out.File
|
||||
file_internal_pkg_grpc_handshake_proto_rawDesc = nil
|
||||
file_internal_pkg_grpc_handshake_proto_goTypes = nil
|
||||
file_internal_pkg_grpc_handshake_proto_depIdxs = nil
|
||||
}
|
||||
@ -1,21 +0,0 @@
|
||||
syntax = "proto3";
|
||||
package grpc;
|
||||
|
||||
option go_package = "internal/pkg/grpc";
|
||||
|
||||
service handshake {
|
||||
rpc ReactorClientHandler(ReactorClientRequest) returns (ReactorClientResponse);
|
||||
}
|
||||
|
||||
message ReactorClientRequest {
|
||||
uint32 id = 1;
|
||||
uint32 port = 2; // client gRPC port
|
||||
}
|
||||
|
||||
message ReactorClientResponse {
|
||||
uint32 id = 1;
|
||||
string url = 2;
|
||||
string org = 3;
|
||||
string token = 4;
|
||||
string bucket = 5;
|
||||
}
|
||||
@ -1,105 +0,0 @@
|
||||
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
|
||||
// versions:
|
||||
// - protoc-gen-go-grpc v1.2.0
|
||||
// - protoc v3.21.12
|
||||
// source: internal/pkg/grpc/handshake.proto
|
||||
|
||||
package grpc
|
||||
|
||||
import (
|
||||
context "context"
|
||||
grpc "google.golang.org/grpc"
|
||||
codes "google.golang.org/grpc/codes"
|
||||
status "google.golang.org/grpc/status"
|
||||
)
|
||||
|
||||
// This is a compile-time assertion to ensure that this generated file
|
||||
// is compatible with the grpc package it is being compiled against.
|
||||
// Requires gRPC-Go v1.32.0 or later.
|
||||
const _ = grpc.SupportPackageIsVersion7
|
||||
|
||||
// HandshakeClient is the client API for Handshake service.
|
||||
//
|
||||
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
|
||||
type HandshakeClient interface {
|
||||
ReactorClientHandler(ctx context.Context, in *ReactorClientRequest, opts ...grpc.CallOption) (*ReactorClientResponse, error)
|
||||
}
|
||||
|
||||
type handshakeClient struct {
|
||||
cc grpc.ClientConnInterface
|
||||
}
|
||||
|
||||
func NewHandshakeClient(cc grpc.ClientConnInterface) HandshakeClient {
|
||||
return &handshakeClient{cc}
|
||||
}
|
||||
|
||||
func (c *handshakeClient) ReactorClientHandler(ctx context.Context, in *ReactorClientRequest, opts ...grpc.CallOption) (*ReactorClientResponse, error) {
|
||||
out := new(ReactorClientResponse)
|
||||
err := c.cc.Invoke(ctx, "/grpc.handshake/ReactorClientHandler", in, out, opts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// HandshakeServer is the server API for Handshake service.
|
||||
// All implementations must embed UnimplementedHandshakeServer
|
||||
// for forward compatibility
|
||||
type HandshakeServer interface {
|
||||
ReactorClientHandler(context.Context, *ReactorClientRequest) (*ReactorClientResponse, error)
|
||||
mustEmbedUnimplementedHandshakeServer()
|
||||
}
|
||||
|
||||
// UnimplementedHandshakeServer must be embedded to have forward compatible implementations.
|
||||
type UnimplementedHandshakeServer struct {
|
||||
}
|
||||
|
||||
func (UnimplementedHandshakeServer) ReactorClientHandler(context.Context, *ReactorClientRequest) (*ReactorClientResponse, error) {
|
||||
return nil, status.Errorf(codes.Unimplemented, "method ReactorClientHandler not implemented")
|
||||
}
|
||||
func (UnimplementedHandshakeServer) mustEmbedUnimplementedHandshakeServer() {}
|
||||
|
||||
// UnsafeHandshakeServer may be embedded to opt out of forward compatibility for this service.
|
||||
// Use of this interface is not recommended, as added methods to HandshakeServer will
|
||||
// result in compilation errors.
|
||||
type UnsafeHandshakeServer interface {
|
||||
mustEmbedUnimplementedHandshakeServer()
|
||||
}
|
||||
|
||||
func RegisterHandshakeServer(s grpc.ServiceRegistrar, srv HandshakeServer) {
|
||||
s.RegisterService(&Handshake_ServiceDesc, srv)
|
||||
}
|
||||
|
||||
func _Handshake_ReactorClientHandler_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(ReactorClientRequest)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(HandshakeServer).ReactorClientHandler(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: "/grpc.handshake/ReactorClientHandler",
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(HandshakeServer).ReactorClientHandler(ctx, req.(*ReactorClientRequest))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
// Handshake_ServiceDesc is the grpc.ServiceDesc for Handshake service.
|
||||
// It's only intended for direct use with grpc.RegisterService,
|
||||
// and not to be introspected or modified (even as a copy)
|
||||
var Handshake_ServiceDesc = grpc.ServiceDesc{
|
||||
ServiceName: "grpc.handshake",
|
||||
HandlerType: (*HandshakeServer)(nil),
|
||||
Methods: []grpc.MethodDesc{
|
||||
{
|
||||
MethodName: "ReactorClientHandler",
|
||||
Handler: _Handshake_ReactorClientHandler_Handler,
|
||||
},
|
||||
},
|
||||
Streams: []grpc.StreamDesc{},
|
||||
Metadata: "internal/pkg/grpc/handshake.proto",
|
||||
}
|
||||
@ -1,211 +0,0 @@
|
||||
// Code generated by protoc-gen-go. DO NOT EDIT.
|
||||
// versions:
|
||||
// protoc-gen-go v1.28.1
|
||||
// protoc v3.21.12
|
||||
// source: internal/pkg/grpc/monitoring.proto
|
||||
|
||||
package grpc
|
||||
|
||||
import (
|
||||
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
|
||||
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
|
||||
reflect "reflect"
|
||||
sync "sync"
|
||||
)
|
||||
|
||||
const (
|
||||
// Verify that this generated code is sufficiently up-to-date.
|
||||
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
|
||||
// Verify that runtime/protoimpl is sufficiently up-to-date.
|
||||
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
|
||||
)
|
||||
|
||||
type ReactorAck struct {
|
||||
state protoimpl.MessageState
|
||||
sizeCache protoimpl.SizeCache
|
||||
unknownFields protoimpl.UnknownFields
|
||||
|
||||
Id int32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
|
||||
}
|
||||
|
||||
func (x *ReactorAck) Reset() {
|
||||
*x = ReactorAck{}
|
||||
if protoimpl.UnsafeEnabled {
|
||||
mi := &file_internal_pkg_grpc_monitoring_proto_msgTypes[0]
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
}
|
||||
|
||||
func (x *ReactorAck) String() string {
|
||||
return protoimpl.X.MessageStringOf(x)
|
||||
}
|
||||
|
||||
func (*ReactorAck) ProtoMessage() {}
|
||||
|
||||
func (x *ReactorAck) ProtoReflect() protoreflect.Message {
|
||||
mi := &file_internal_pkg_grpc_monitoring_proto_msgTypes[0]
|
||||
if protoimpl.UnsafeEnabled && x != nil {
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
if ms.LoadMessageInfo() == nil {
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
return ms
|
||||
}
|
||||
return mi.MessageOf(x)
|
||||
}
|
||||
|
||||
// Deprecated: Use ReactorAck.ProtoReflect.Descriptor instead.
|
||||
func (*ReactorAck) Descriptor() ([]byte, []int) {
|
||||
return file_internal_pkg_grpc_monitoring_proto_rawDescGZIP(), []int{0}
|
||||
}
|
||||
|
||||
func (x *ReactorAck) GetId() int32 {
|
||||
if x != nil {
|
||||
return x.Id
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
type ReactorPing struct {
|
||||
state protoimpl.MessageState
|
||||
sizeCache protoimpl.SizeCache
|
||||
unknownFields protoimpl.UnknownFields
|
||||
|
||||
Id int32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
|
||||
}
|
||||
|
||||
func (x *ReactorPing) Reset() {
|
||||
*x = ReactorPing{}
|
||||
if protoimpl.UnsafeEnabled {
|
||||
mi := &file_internal_pkg_grpc_monitoring_proto_msgTypes[1]
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
}
|
||||
|
||||
func (x *ReactorPing) String() string {
|
||||
return protoimpl.X.MessageStringOf(x)
|
||||
}
|
||||
|
||||
func (*ReactorPing) ProtoMessage() {}
|
||||
|
||||
func (x *ReactorPing) ProtoReflect() protoreflect.Message {
|
||||
mi := &file_internal_pkg_grpc_monitoring_proto_msgTypes[1]
|
||||
if protoimpl.UnsafeEnabled && x != nil {
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
if ms.LoadMessageInfo() == nil {
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
return ms
|
||||
}
|
||||
return mi.MessageOf(x)
|
||||
}
|
||||
|
||||
// Deprecated: Use ReactorPing.ProtoReflect.Descriptor instead.
|
||||
func (*ReactorPing) Descriptor() ([]byte, []int) {
|
||||
return file_internal_pkg_grpc_monitoring_proto_rawDescGZIP(), []int{1}
|
||||
}
|
||||
|
||||
func (x *ReactorPing) GetId() int32 {
|
||||
if x != nil {
|
||||
return x.Id
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
var File_internal_pkg_grpc_monitoring_proto protoreflect.FileDescriptor
|
||||
|
||||
var file_internal_pkg_grpc_monitoring_proto_rawDesc = []byte{
|
||||
0x0a, 0x22, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x67,
|
||||
0x72, 0x70, 0x63, 0x2f, 0x6d, 0x6f, 0x6e, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x70,
|
||||
0x72, 0x6f, 0x74, 0x6f, 0x12, 0x04, 0x67, 0x72, 0x70, 0x63, 0x22, 0x1c, 0x0a, 0x0a, 0x52, 0x65,
|
||||
0x61, 0x63, 0x74, 0x6f, 0x72, 0x41, 0x63, 0x6b, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01,
|
||||
0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x69, 0x64, 0x22, 0x1d, 0x0a, 0x0b, 0x52, 0x65, 0x61, 0x63,
|
||||
0x74, 0x6f, 0x72, 0x50, 0x69, 0x6e, 0x67, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20,
|
||||
0x01, 0x28, 0x05, 0x52, 0x02, 0x69, 0x64, 0x32, 0x49, 0x0a, 0x0a, 0x6d, 0x6f, 0x6e, 0x69, 0x74,
|
||||
0x6f, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x3b, 0x0a, 0x12, 0x52, 0x65, 0x61, 0x63, 0x74, 0x6f, 0x72,
|
||||
0x50, 0x69, 0x6e, 0x67, 0x48, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x72, 0x12, 0x11, 0x2e, 0x67, 0x72,
|
||||
0x70, 0x63, 0x2e, 0x52, 0x65, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x50, 0x69, 0x6e, 0x67, 0x1a, 0x10,
|
||||
0x2e, 0x67, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x65, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x41, 0x63, 0x6b,
|
||||
0x28, 0x01, 0x42, 0x13, 0x5a, 0x11, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x70,
|
||||
0x6b, 0x67, 0x2f, 0x67, 0x72, 0x70, 0x63, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
|
||||
}
|
||||
|
||||
var (
|
||||
file_internal_pkg_grpc_monitoring_proto_rawDescOnce sync.Once
|
||||
file_internal_pkg_grpc_monitoring_proto_rawDescData = file_internal_pkg_grpc_monitoring_proto_rawDesc
|
||||
)
|
||||
|
||||
func file_internal_pkg_grpc_monitoring_proto_rawDescGZIP() []byte {
|
||||
file_internal_pkg_grpc_monitoring_proto_rawDescOnce.Do(func() {
|
||||
file_internal_pkg_grpc_monitoring_proto_rawDescData = protoimpl.X.CompressGZIP(file_internal_pkg_grpc_monitoring_proto_rawDescData)
|
||||
})
|
||||
return file_internal_pkg_grpc_monitoring_proto_rawDescData
|
||||
}
|
||||
|
||||
var file_internal_pkg_grpc_monitoring_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
|
||||
var file_internal_pkg_grpc_monitoring_proto_goTypes = []interface{}{
|
||||
(*ReactorAck)(nil), // 0: grpc.ReactorAck
|
||||
(*ReactorPing)(nil), // 1: grpc.ReactorPing
|
||||
}
|
||||
var file_internal_pkg_grpc_monitoring_proto_depIdxs = []int32{
|
||||
1, // 0: grpc.monitoring.ReactorPingHandler:input_type -> grpc.ReactorPing
|
||||
0, // 1: grpc.monitoring.ReactorPingHandler:output_type -> grpc.ReactorAck
|
||||
1, // [1:2] is the sub-list for method output_type
|
||||
0, // [0:1] is the sub-list for method input_type
|
||||
0, // [0:0] is the sub-list for extension type_name
|
||||
0, // [0:0] is the sub-list for extension extendee
|
||||
0, // [0:0] is the sub-list for field type_name
|
||||
}
|
||||
|
||||
func init() { file_internal_pkg_grpc_monitoring_proto_init() }
|
||||
func file_internal_pkg_grpc_monitoring_proto_init() {
|
||||
if File_internal_pkg_grpc_monitoring_proto != nil {
|
||||
return
|
||||
}
|
||||
if !protoimpl.UnsafeEnabled {
|
||||
file_internal_pkg_grpc_monitoring_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
|
||||
switch v := v.(*ReactorAck); i {
|
||||
case 0:
|
||||
return &v.state
|
||||
case 1:
|
||||
return &v.sizeCache
|
||||
case 2:
|
||||
return &v.unknownFields
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
file_internal_pkg_grpc_monitoring_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
|
||||
switch v := v.(*ReactorPing); i {
|
||||
case 0:
|
||||
return &v.state
|
||||
case 1:
|
||||
return &v.sizeCache
|
||||
case 2:
|
||||
return &v.unknownFields
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
}
|
||||
type x struct{}
|
||||
out := protoimpl.TypeBuilder{
|
||||
File: protoimpl.DescBuilder{
|
||||
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
|
||||
RawDescriptor: file_internal_pkg_grpc_monitoring_proto_rawDesc,
|
||||
NumEnums: 0,
|
||||
NumMessages: 2,
|
||||
NumExtensions: 0,
|
||||
NumServices: 1,
|
||||
},
|
||||
GoTypes: file_internal_pkg_grpc_monitoring_proto_goTypes,
|
||||
DependencyIndexes: file_internal_pkg_grpc_monitoring_proto_depIdxs,
|
||||
MessageInfos: file_internal_pkg_grpc_monitoring_proto_msgTypes,
|
||||
}.Build()
|
||||
File_internal_pkg_grpc_monitoring_proto = out.File
|
||||
file_internal_pkg_grpc_monitoring_proto_rawDesc = nil
|
||||
file_internal_pkg_grpc_monitoring_proto_goTypes = nil
|
||||
file_internal_pkg_grpc_monitoring_proto_depIdxs = nil
|
||||
}
|
||||
@ -1,16 +0,0 @@
|
||||
syntax = "proto3";
|
||||
package grpc;
|
||||
|
||||
option go_package = "internal/pkg/grpc";
|
||||
|
||||
service monitoring {
|
||||
rpc ReactorPingHandler(stream ReactorPing) returns (ReactorAck);
|
||||
}
|
||||
|
||||
message ReactorAck {
|
||||
int32 id = 1;
|
||||
}
|
||||
|
||||
message ReactorPing {
|
||||
int32 id = 1;
|
||||
}
|
||||
@ -1,139 +0,0 @@
|
||||
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
|
||||
// versions:
|
||||
// - protoc-gen-go-grpc v1.2.0
|
||||
// - protoc v3.21.12
|
||||
// source: internal/pkg/grpc/monitoring.proto
|
||||
|
||||
package grpc
|
||||
|
||||
import (
|
||||
context "context"
|
||||
grpc "google.golang.org/grpc"
|
||||
codes "google.golang.org/grpc/codes"
|
||||
status "google.golang.org/grpc/status"
|
||||
)
|
||||
|
||||
// This is a compile-time assertion to ensure that this generated file
|
||||
// is compatible with the grpc package it is being compiled against.
|
||||
// Requires gRPC-Go v1.32.0 or later.
|
||||
const _ = grpc.SupportPackageIsVersion7
|
||||
|
||||
// MonitoringClient is the client API for Monitoring service.
|
||||
//
|
||||
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
|
||||
type MonitoringClient interface {
|
||||
ReactorPingHandler(ctx context.Context, opts ...grpc.CallOption) (Monitoring_ReactorPingHandlerClient, error)
|
||||
}
|
||||
|
||||
type monitoringClient struct {
|
||||
cc grpc.ClientConnInterface
|
||||
}
|
||||
|
||||
func NewMonitoringClient(cc grpc.ClientConnInterface) MonitoringClient {
|
||||
return &monitoringClient{cc}
|
||||
}
|
||||
|
||||
func (c *monitoringClient) ReactorPingHandler(ctx context.Context, opts ...grpc.CallOption) (Monitoring_ReactorPingHandlerClient, error) {
|
||||
stream, err := c.cc.NewStream(ctx, &Monitoring_ServiceDesc.Streams[0], "/grpc.monitoring/ReactorPingHandler", opts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
x := &monitoringReactorPingHandlerClient{stream}
|
||||
return x, nil
|
||||
}
|
||||
|
||||
type Monitoring_ReactorPingHandlerClient interface {
|
||||
Send(*ReactorPing) error
|
||||
CloseAndRecv() (*ReactorAck, error)
|
||||
grpc.ClientStream
|
||||
}
|
||||
|
||||
type monitoringReactorPingHandlerClient struct {
|
||||
grpc.ClientStream
|
||||
}
|
||||
|
||||
func (x *monitoringReactorPingHandlerClient) Send(m *ReactorPing) error {
|
||||
return x.ClientStream.SendMsg(m)
|
||||
}
|
||||
|
||||
func (x *monitoringReactorPingHandlerClient) CloseAndRecv() (*ReactorAck, error) {
|
||||
if err := x.ClientStream.CloseSend(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
m := new(ReactorAck)
|
||||
if err := x.ClientStream.RecvMsg(m); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return m, nil
|
||||
}
|
||||
|
||||
// MonitoringServer is the server API for Monitoring service.
|
||||
// All implementations must embed UnimplementedMonitoringServer
|
||||
// for forward compatibility
|
||||
type MonitoringServer interface {
|
||||
ReactorPingHandler(Monitoring_ReactorPingHandlerServer) error
|
||||
mustEmbedUnimplementedMonitoringServer()
|
||||
}
|
||||
|
||||
// UnimplementedMonitoringServer must be embedded to have forward compatible implementations.
|
||||
type UnimplementedMonitoringServer struct {
|
||||
}
|
||||
|
||||
func (UnimplementedMonitoringServer) ReactorPingHandler(Monitoring_ReactorPingHandlerServer) error {
|
||||
return status.Errorf(codes.Unimplemented, "method ReactorPingHandler not implemented")
|
||||
}
|
||||
func (UnimplementedMonitoringServer) mustEmbedUnimplementedMonitoringServer() {}
|
||||
|
||||
// UnsafeMonitoringServer may be embedded to opt out of forward compatibility for this service.
|
||||
// Use of this interface is not recommended, as added methods to MonitoringServer will
|
||||
// result in compilation errors.
|
||||
type UnsafeMonitoringServer interface {
|
||||
mustEmbedUnimplementedMonitoringServer()
|
||||
}
|
||||
|
||||
func RegisterMonitoringServer(s grpc.ServiceRegistrar, srv MonitoringServer) {
|
||||
s.RegisterService(&Monitoring_ServiceDesc, srv)
|
||||
}
|
||||
|
||||
func _Monitoring_ReactorPingHandler_Handler(srv interface{}, stream grpc.ServerStream) error {
|
||||
return srv.(MonitoringServer).ReactorPingHandler(&monitoringReactorPingHandlerServer{stream})
|
||||
}
|
||||
|
||||
type Monitoring_ReactorPingHandlerServer interface {
|
||||
SendAndClose(*ReactorAck) error
|
||||
Recv() (*ReactorPing, error)
|
||||
grpc.ServerStream
|
||||
}
|
||||
|
||||
type monitoringReactorPingHandlerServer struct {
|
||||
grpc.ServerStream
|
||||
}
|
||||
|
||||
func (x *monitoringReactorPingHandlerServer) SendAndClose(m *ReactorAck) error {
|
||||
return x.ServerStream.SendMsg(m)
|
||||
}
|
||||
|
||||
func (x *monitoringReactorPingHandlerServer) Recv() (*ReactorPing, error) {
|
||||
m := new(ReactorPing)
|
||||
if err := x.ServerStream.RecvMsg(m); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return m, nil
|
||||
}
|
||||
|
||||
// Monitoring_ServiceDesc is the grpc.ServiceDesc for Monitoring service.
|
||||
// It's only intended for direct use with grpc.RegisterService,
|
||||
// and not to be introspected or modified (even as a copy)
|
||||
var Monitoring_ServiceDesc = grpc.ServiceDesc{
|
||||
ServiceName: "grpc.monitoring",
|
||||
HandlerType: (*MonitoringServer)(nil),
|
||||
Methods: []grpc.MethodDesc{},
|
||||
Streams: []grpc.StreamDesc{
|
||||
{
|
||||
StreamName: "ReactorPingHandler",
|
||||
Handler: _Monitoring_ReactorPingHandler_Handler,
|
||||
ClientStreams: true,
|
||||
},
|
||||
},
|
||||
Metadata: "internal/pkg/grpc/monitoring.proto",
|
||||
}
|
||||
@ -1,335 +0,0 @@
|
||||
// Code generated by protoc-gen-go. DO NOT EDIT.
|
||||
// versions:
|
||||
// protoc-gen-go v1.28.0
|
||||
// protoc v3.6.1
|
||||
// source: internal/pkg/grpc/server.proto
|
||||
|
||||
package grpc
|
||||
|
||||
import (
|
||||
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
|
||||
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
|
||||
reflect "reflect"
|
||||
sync "sync"
|
||||
)
|
||||
|
||||
const (
|
||||
// Verify that this generated code is sufficiently up-to-date.
|
||||
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
|
||||
// Verify that runtime/protoimpl is sufficiently up-to-date.
|
||||
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
|
||||
)
|
||||
|
||||
type ClientRequest struct {
|
||||
state protoimpl.MessageState
|
||||
sizeCache protoimpl.SizeCache
|
||||
unknownFields protoimpl.UnknownFields
|
||||
|
||||
ClientId uint32 `protobuf:"varint,1,opt,name=clientId,proto3" json:"clientId,omitempty"`
|
||||
ClientType string `protobuf:"bytes,2,opt,name=clientType,proto3" json:"clientType,omitempty"`
|
||||
}
|
||||
|
||||
func (x *ClientRequest) Reset() {
|
||||
*x = ClientRequest{}
|
||||
if protoimpl.UnsafeEnabled {
|
||||
mi := &file_internal_pkg_grpc_server_proto_msgTypes[0]
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
}
|
||||
|
||||
func (x *ClientRequest) String() string {
|
||||
return protoimpl.X.MessageStringOf(x)
|
||||
}
|
||||
|
||||
func (*ClientRequest) ProtoMessage() {}
|
||||
|
||||
func (x *ClientRequest) ProtoReflect() protoreflect.Message {
|
||||
mi := &file_internal_pkg_grpc_server_proto_msgTypes[0]
|
||||
if protoimpl.UnsafeEnabled && x != nil {
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
if ms.LoadMessageInfo() == nil {
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
return ms
|
||||
}
|
||||
return mi.MessageOf(x)
|
||||
}
|
||||
|
||||
// Deprecated: Use ClientRequest.ProtoReflect.Descriptor instead.
|
||||
func (*ClientRequest) Descriptor() ([]byte, []int) {
|
||||
return file_internal_pkg_grpc_server_proto_rawDescGZIP(), []int{0}
|
||||
}
|
||||
|
||||
func (x *ClientRequest) GetClientId() uint32 {
|
||||
if x != nil {
|
||||
return x.ClientId
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (x *ClientRequest) GetClientType() string {
|
||||
if x != nil {
|
||||
return x.ClientType
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
type ClientResponse struct {
|
||||
state protoimpl.MessageState
|
||||
sizeCache protoimpl.SizeCache
|
||||
unknownFields protoimpl.UnknownFields
|
||||
|
||||
ClientId uint32 `protobuf:"varint,1,opt,name=clientId,proto3" json:"clientId,omitempty"`
|
||||
ServerPort uint32 `protobuf:"varint,2,opt,name=serverPort,proto3" json:"serverPort,omitempty"`
|
||||
Database *Database `protobuf:"bytes,3,opt,name=database,proto3" json:"database,omitempty"`
|
||||
}
|
||||
|
||||
func (x *ClientResponse) Reset() {
|
||||
*x = ClientResponse{}
|
||||
if protoimpl.UnsafeEnabled {
|
||||
mi := &file_internal_pkg_grpc_server_proto_msgTypes[1]
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
}
|
||||
|
||||
func (x *ClientResponse) String() string {
|
||||
return protoimpl.X.MessageStringOf(x)
|
||||
}
|
||||
|
||||
func (*ClientResponse) ProtoMessage() {}
|
||||
|
||||
func (x *ClientResponse) ProtoReflect() protoreflect.Message {
|
||||
mi := &file_internal_pkg_grpc_server_proto_msgTypes[1]
|
||||
if protoimpl.UnsafeEnabled && x != nil {
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
if ms.LoadMessageInfo() == nil {
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
return ms
|
||||
}
|
||||
return mi.MessageOf(x)
|
||||
}
|
||||
|
||||
// Deprecated: Use ClientResponse.ProtoReflect.Descriptor instead.
|
||||
func (*ClientResponse) Descriptor() ([]byte, []int) {
|
||||
return file_internal_pkg_grpc_server_proto_rawDescGZIP(), []int{1}
|
||||
}
|
||||
|
||||
func (x *ClientResponse) GetClientId() uint32 {
|
||||
if x != nil {
|
||||
return x.ClientId
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (x *ClientResponse) GetServerPort() uint32 {
|
||||
if x != nil {
|
||||
return x.ServerPort
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (x *ClientResponse) GetDatabase() *Database {
|
||||
if x != nil {
|
||||
return x.Database
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type Database struct {
|
||||
state protoimpl.MessageState
|
||||
sizeCache protoimpl.SizeCache
|
||||
unknownFields protoimpl.UnknownFields
|
||||
|
||||
URL string `protobuf:"bytes,1,opt,name=URL,proto3" json:"URL,omitempty"`
|
||||
ORG string `protobuf:"bytes,2,opt,name=ORG,proto3" json:"ORG,omitempty"`
|
||||
Token string `protobuf:"bytes,3,opt,name=token,proto3" json:"token,omitempty"`
|
||||
Bucket string `protobuf:"bytes,4,opt,name=bucket,proto3" json:"bucket,omitempty"`
|
||||
}
|
||||
|
||||
func (x *Database) Reset() {
|
||||
*x = Database{}
|
||||
if protoimpl.UnsafeEnabled {
|
||||
mi := &file_internal_pkg_grpc_server_proto_msgTypes[2]
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
}
|
||||
|
||||
func (x *Database) String() string {
|
||||
return protoimpl.X.MessageStringOf(x)
|
||||
}
|
||||
|
||||
func (*Database) ProtoMessage() {}
|
||||
|
||||
func (x *Database) ProtoReflect() protoreflect.Message {
|
||||
mi := &file_internal_pkg_grpc_server_proto_msgTypes[2]
|
||||
if protoimpl.UnsafeEnabled && x != nil {
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
if ms.LoadMessageInfo() == nil {
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
return ms
|
||||
}
|
||||
return mi.MessageOf(x)
|
||||
}
|
||||
|
||||
// Deprecated: Use Database.ProtoReflect.Descriptor instead.
|
||||
func (*Database) Descriptor() ([]byte, []int) {
|
||||
return file_internal_pkg_grpc_server_proto_rawDescGZIP(), []int{2}
|
||||
}
|
||||
|
||||
func (x *Database) GetURL() string {
|
||||
if x != nil {
|
||||
return x.URL
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func (x *Database) GetORG() string {
|
||||
if x != nil {
|
||||
return x.ORG
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func (x *Database) GetToken() string {
|
||||
if x != nil {
|
||||
return x.Token
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func (x *Database) GetBucket() string {
|
||||
if x != nil {
|
||||
return x.Bucket
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
var File_internal_pkg_grpc_server_proto protoreflect.FileDescriptor
|
||||
|
||||
var file_internal_pkg_grpc_server_proto_rawDesc = []byte{
|
||||
0x0a, 0x1e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x67,
|
||||
0x72, 0x70, 0x63, 0x2f, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
|
||||
0x12, 0x04, 0x67, 0x72, 0x70, 0x63, 0x22, 0x4b, 0x0a, 0x0d, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74,
|
||||
0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x6c, 0x69, 0x65, 0x6e,
|
||||
0x74, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x08, 0x63, 0x6c, 0x69, 0x65, 0x6e,
|
||||
0x74, 0x49, 0x64, 0x12, 0x1e, 0x0a, 0x0a, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70,
|
||||
0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x54,
|
||||
0x79, 0x70, 0x65, 0x22, 0x78, 0x0a, 0x0e, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73,
|
||||
0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49,
|
||||
0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x08, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49,
|
||||
0x64, 0x12, 0x1e, 0x0a, 0x0a, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x50, 0x6f, 0x72, 0x74, 0x18,
|
||||
0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x50, 0x6f, 0x72,
|
||||
0x74, 0x12, 0x2a, 0x0a, 0x08, 0x64, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x18, 0x03, 0x20,
|
||||
0x01, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x67, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x62,
|
||||
0x61, 0x73, 0x65, 0x52, 0x08, 0x64, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x22, 0x5c, 0x0a,
|
||||
0x08, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x55, 0x52, 0x4c,
|
||||
0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x55, 0x52, 0x4c, 0x12, 0x10, 0x0a, 0x03, 0x4f,
|
||||
0x52, 0x47, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x4f, 0x52, 0x47, 0x12, 0x14, 0x0a,
|
||||
0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f,
|
||||
0x6b, 0x65, 0x6e, 0x12, 0x16, 0x0a, 0x06, 0x62, 0x75, 0x63, 0x6b, 0x65, 0x74, 0x18, 0x04, 0x20,
|
||||
0x01, 0x28, 0x09, 0x52, 0x06, 0x62, 0x75, 0x63, 0x6b, 0x65, 0x74, 0x32, 0x50, 0x0a, 0x09, 0x68,
|
||||
0x61, 0x6e, 0x64, 0x73, 0x68, 0x61, 0x6b, 0x65, 0x12, 0x43, 0x0a, 0x16, 0x43, 0x6c, 0x69, 0x65,
|
||||
0x6e, 0x74, 0x44, 0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, 0x48, 0x61, 0x6e, 0x64, 0x6c,
|
||||
0x65, 0x72, 0x12, 0x13, 0x2e, 0x67, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74,
|
||||
0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x14, 0x2e, 0x67, 0x72, 0x70, 0x63, 0x2e, 0x43,
|
||||
0x6c, 0x69, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x13, 0x5a,
|
||||
0x11, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x67, 0x72,
|
||||
0x70, 0x63, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
|
||||
}
|
||||
|
||||
var (
|
||||
file_internal_pkg_grpc_server_proto_rawDescOnce sync.Once
|
||||
file_internal_pkg_grpc_server_proto_rawDescData = file_internal_pkg_grpc_server_proto_rawDesc
|
||||
)
|
||||
|
||||
func file_internal_pkg_grpc_server_proto_rawDescGZIP() []byte {
|
||||
file_internal_pkg_grpc_server_proto_rawDescOnce.Do(func() {
|
||||
file_internal_pkg_grpc_server_proto_rawDescData = protoimpl.X.CompressGZIP(file_internal_pkg_grpc_server_proto_rawDescData)
|
||||
})
|
||||
return file_internal_pkg_grpc_server_proto_rawDescData
|
||||
}
|
||||
|
||||
var file_internal_pkg_grpc_server_proto_msgTypes = make([]protoimpl.MessageInfo, 3)
|
||||
var file_internal_pkg_grpc_server_proto_goTypes = []interface{}{
|
||||
(*ClientRequest)(nil), // 0: grpc.ClientRequest
|
||||
(*ClientResponse)(nil), // 1: grpc.ClientResponse
|
||||
(*Database)(nil), // 2: grpc.Database
|
||||
}
|
||||
var file_internal_pkg_grpc_server_proto_depIdxs = []int32{
|
||||
2, // 0: grpc.ClientResponse.database:type_name -> grpc.Database
|
||||
0, // 1: grpc.handshake.ClientDiscoveryHandler:input_type -> grpc.ClientRequest
|
||||
1, // 2: grpc.handshake.ClientDiscoveryHandler:output_type -> grpc.ClientResponse
|
||||
2, // [2:3] is the sub-list for method output_type
|
||||
1, // [1:2] is the sub-list for method input_type
|
||||
1, // [1:1] is the sub-list for extension type_name
|
||||
1, // [1:1] is the sub-list for extension extendee
|
||||
0, // [0:1] is the sub-list for field type_name
|
||||
}
|
||||
|
||||
func init() { file_internal_pkg_grpc_server_proto_init() }
|
||||
func file_internal_pkg_grpc_server_proto_init() {
|
||||
if File_internal_pkg_grpc_server_proto != nil {
|
||||
return
|
||||
}
|
||||
if !protoimpl.UnsafeEnabled {
|
||||
file_internal_pkg_grpc_server_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
|
||||
switch v := v.(*ClientRequest); i {
|
||||
case 0:
|
||||
return &v.state
|
||||
case 1:
|
||||
return &v.sizeCache
|
||||
case 2:
|
||||
return &v.unknownFields
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
file_internal_pkg_grpc_server_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
|
||||
switch v := v.(*ClientResponse); i {
|
||||
case 0:
|
||||
return &v.state
|
||||
case 1:
|
||||
return &v.sizeCache
|
||||
case 2:
|
||||
return &v.unknownFields
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
file_internal_pkg_grpc_server_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
|
||||
switch v := v.(*Database); i {
|
||||
case 0:
|
||||
return &v.state
|
||||
case 1:
|
||||
return &v.sizeCache
|
||||
case 2:
|
||||
return &v.unknownFields
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
}
|
||||
type x struct{}
|
||||
out := protoimpl.TypeBuilder{
|
||||
File: protoimpl.DescBuilder{
|
||||
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
|
||||
RawDescriptor: file_internal_pkg_grpc_server_proto_rawDesc,
|
||||
NumEnums: 0,
|
||||
NumMessages: 3,
|
||||
NumExtensions: 0,
|
||||
NumServices: 1,
|
||||
},
|
||||
GoTypes: file_internal_pkg_grpc_server_proto_goTypes,
|
||||
DependencyIndexes: file_internal_pkg_grpc_server_proto_depIdxs,
|
||||
MessageInfos: file_internal_pkg_grpc_server_proto_msgTypes,
|
||||
}.Build()
|
||||
File_internal_pkg_grpc_server_proto = out.File
|
||||
file_internal_pkg_grpc_server_proto_rawDesc = nil
|
||||
file_internal_pkg_grpc_server_proto_goTypes = nil
|
||||
file_internal_pkg_grpc_server_proto_depIdxs = nil
|
||||
}
|
||||
@ -1,28 +0,0 @@
|
||||
syntax = "proto3";
|
||||
package grpc;
|
||||
|
||||
option go_package = "internal/pkg/grpc";
|
||||
|
||||
service handshake {
|
||||
rpc ClientDiscoveryHandler(ClientRequest) returns (ClientResponse);
|
||||
}
|
||||
|
||||
message ClientRequest {
|
||||
uint32 clientId = 1;
|
||||
string clientType = 2;
|
||||
string ip = 3; // client ip
|
||||
uint32 port = 4; // client port for gRPC server
|
||||
}
|
||||
|
||||
message ClientResponse {
|
||||
uint32 clientId = 1;
|
||||
uint32 serverPort = 2;
|
||||
Database database = 3;
|
||||
}
|
||||
|
||||
message Database {
|
||||
string URL = 1;
|
||||
string ORG = 2;
|
||||
string token = 3;
|
||||
string bucket = 4;
|
||||
}
|
||||
@ -1,105 +0,0 @@
|
||||
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
|
||||
// versions:
|
||||
// - protoc-gen-go-grpc v1.2.0
|
||||
// - protoc v3.21.12
|
||||
// source: internal/pkg/grpc/handshake.proto
|
||||
|
||||
package grpc
|
||||
|
||||
import (
|
||||
context "context"
|
||||
grpc "google.golang.org/grpc"
|
||||
codes "google.golang.org/grpc/codes"
|
||||
status "google.golang.org/grpc/status"
|
||||
)
|
||||
|
||||
// This is a compile-time assertion to ensure that this generated file
|
||||
// is compatible with the grpc package it is being compiled against.
|
||||
// Requires gRPC-Go v1.32.0 or later.
|
||||
const _ = grpc.SupportPackageIsVersion7
|
||||
|
||||
// HandshakeClient is the client API for Handshake service.
|
||||
//
|
||||
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
|
||||
type HandshakeClient interface {
|
||||
ReactorClientHandler(ctx context.Context, in *ReactorClientRequest, opts ...grpc.CallOption) (*ReactorClientResponse, error)
|
||||
}
|
||||
|
||||
type handshakeClient struct {
|
||||
cc grpc.ClientConnInterface
|
||||
}
|
||||
|
||||
func NewHandshakeClient(cc grpc.ClientConnInterface) HandshakeClient {
|
||||
return &handshakeClient{cc}
|
||||
}
|
||||
|
||||
func (c *handshakeClient) ReactorClientHandler(ctx context.Context, in *ReactorClientRequest, opts ...grpc.CallOption) (*ReactorClientResponse, error) {
|
||||
out := new(ReactorClientResponse)
|
||||
err := c.cc.Invoke(ctx, "/grpc.handshake/ReactorClientHandler", in, out, opts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// HandshakeServer is the server API for Handshake service.
|
||||
// All implementations must embed UnimplementedHandshakeServer
|
||||
// for forward compatibility
|
||||
type HandshakeServer interface {
|
||||
ReactorClientHandler(context.Context, *ReactorClientRequest) (*ReactorClientResponse, error)
|
||||
mustEmbedUnimplementedHandshakeServer()
|
||||
}
|
||||
|
||||
// UnimplementedHandshakeServer must be embedded to have forward compatible implementations.
|
||||
type UnimplementedHandshakeServer struct {
|
||||
}
|
||||
|
||||
func (UnimplementedHandshakeServer) ReactorClientHandler(context.Context, *ReactorClientRequest) (*ReactorClientResponse, error) {
|
||||
return nil, status.Errorf(codes.Unimplemented, "method ReactorClientHandler not implemented")
|
||||
}
|
||||
func (UnimplementedHandshakeServer) mustEmbedUnimplementedHandshakeServer() {}
|
||||
|
||||
// UnsafeHandshakeServer may be embedded to opt out of forward compatibility for this service.
|
||||
// Use of this interface is not recommended, as added methods to HandshakeServer will
|
||||
// result in compilation errors.
|
||||
type UnsafeHandshakeServer interface {
|
||||
mustEmbedUnimplementedHandshakeServer()
|
||||
}
|
||||
|
||||
func RegisterHandshakeServer(s grpc.ServiceRegistrar, srv HandshakeServer) {
|
||||
s.RegisterService(&Handshake_ServiceDesc, srv)
|
||||
}
|
||||
|
||||
func _Handshake_ReactorClientHandler_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(ReactorClientRequest)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(HandshakeServer).ReactorClientHandler(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: "/grpc.handshake/ReactorClientHandler",
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(HandshakeServer).ReactorClientHandler(ctx, req.(*ReactorClientRequest))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
// Handshake_ServiceDesc is the grpc.ServiceDesc for Handshake service.
|
||||
// It's only intended for direct use with grpc.RegisterService,
|
||||
// and not to be introspected or modified (even as a copy)
|
||||
var Handshake_ServiceDesc = grpc.ServiceDesc{
|
||||
ServiceName: "grpc.handshake",
|
||||
HandlerType: (*HandshakeServer)(nil),
|
||||
Methods: []grpc.MethodDesc{
|
||||
{
|
||||
MethodName: "ReactorClientHandler",
|
||||
Handler: _Handshake_ReactorClientHandler_Handler,
|
||||
},
|
||||
},
|
||||
Streams: []grpc.StreamDesc{},
|
||||
Metadata: "internal/pkg/grpc/handshake.proto",
|
||||
}
|
||||
@ -1,81 +0,0 @@
|
||||
package influxdb
|
||||
|
||||
import (
|
||||
_ "fmt"
|
||||
|
||||
_ "github.com/influxdata/influxdb-client-go/v2"
|
||||
"github.com/spf13/viper"
|
||||
)
|
||||
|
||||
type DBInfo struct {
|
||||
URL string `mapstructure:"url"`
|
||||
Org string `mapstructure:"org,omitempty`
|
||||
Bucket string `mapstructure:"bucket,omitempty"`
|
||||
Token string `mapstructure:"token,omitempty"`
|
||||
// Client *influxdb2.Client
|
||||
}
|
||||
|
||||
type DBAdmin struct {
|
||||
// struct for admin methods
|
||||
*DBInfo
|
||||
Config *viper.Viper
|
||||
}
|
||||
|
||||
type DBClient struct {
|
||||
// struct for client methods
|
||||
*DBInfo
|
||||
Config *viper.Viper
|
||||
}
|
||||
|
||||
func NewDBInfo(config *viper.Viper) (*DBInfo, error) {
|
||||
db := &DBInfo{}
|
||||
// grabbing config vals
|
||||
err := config.UnmarshalKey("db", db)
|
||||
return db, err
|
||||
}
|
||||
|
||||
func NewDBClient(config *viper.Viper) (*DBClient, error) {
|
||||
|
||||
client := &DBClient{Config: config}
|
||||
// grabbing config vals
|
||||
var err error
|
||||
client.DBInfo, err = NewDBInfo(config)
|
||||
return client, err
|
||||
}
|
||||
|
||||
func NewDBAdmin(config *viper.Viper) (*DBAdmin, error) {
|
||||
admin := &DBAdmin{Config: config}
|
||||
var err error
|
||||
// creating client
|
||||
admin.DBInfo, err = NewDBInfo(config)
|
||||
return admin, err
|
||||
}
|
||||
|
||||
// base level funcs
|
||||
func (d *DBInfo) Start() error {
|
||||
// connect to DB based w/ info
|
||||
return nil
|
||||
}
|
||||
|
||||
func (d *DBAdmin) GetReactorClient(id int) (url, bucket, org, token string, err error) {
|
||||
// given an id returns
|
||||
// (url, org, bucket, token, error) for said id
|
||||
/*
|
||||
client := influxdb2.NewClient(d.URL, d.Token)
|
||||
defer client.Close()
|
||||
bucket, err := client.BucketsAPI().FindBucketByName(context.Background(), id)
|
||||
if err != nil {
|
||||
return "", "", err
|
||||
}
|
||||
if d.ReactorExists(id) {
|
||||
// get corresponding reactor token and bucket
|
||||
}
|
||||
*/
|
||||
url = d.URL
|
||||
org = d.Org
|
||||
token = ""
|
||||
bucket = ""
|
||||
//err = errors.New("Unimpl")
|
||||
err = nil
|
||||
return
|
||||
}
|
||||
@ -1,112 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
import sys
|
||||
import shutil
|
||||
from typing import Optional, List, Tuple, Dict
|
||||
|
||||
import typer
|
||||
from rich import print
|
||||
from rich.columns import Columns
|
||||
from rich.console import Console
|
||||
from rich.traceback import install
|
||||
|
||||
# fmt: off
|
||||
# Mapping from topics to colors
|
||||
TOPICS = {
|
||||
"EXIT": "#9a9a99",
|
||||
"STRT": "#67a0b2",
|
||||
"PING": "#d0b343",
|
||||
"SCAN": "#70c43f",
|
||||
"SPWN": "#4878bc",
|
||||
"STOP": "#ffff00",
|
||||
#"LOG2": "#398280",
|
||||
#"CMIT": "#98719f",
|
||||
#"PERS": "#d08341",
|
||||
#"SNAP": "#FD971F",
|
||||
#"DROP": "#ff615c",
|
||||
"CLNT": "#00813c",
|
||||
#"TEST": "#fe2c79",
|
||||
#"INFO": "#ffffff",
|
||||
#"WARN": "#d08341",
|
||||
"ERRO": "#fe2626",
|
||||
}
|
||||
# fmt: on
|
||||
|
||||
|
||||
def list_topics(value: Optional[str]):
|
||||
if value is None:
|
||||
return value
|
||||
topics = value.split(",")
|
||||
for topic in topics:
|
||||
if topic not in TOPICS:
|
||||
raise typer.BadParameter(f"topic {topic} not recognized")
|
||||
return topics
|
||||
|
||||
|
||||
def main(
|
||||
file: typer.FileText = typer.Argument(None, help="File to read, stdin otherwise"),
|
||||
colorize: bool = typer.Option(True, "--no-color"),
|
||||
n_columns: Optional[int] = typer.Option(None, "--columns", "-c"),
|
||||
ignore: Optional[str] = typer.Option(None, "--ignore", "-i", callback=list_topics),
|
||||
just: Optional[str] = typer.Option(None, "--just", "-j", callback=list_topics),
|
||||
):
|
||||
topics = list(TOPICS)
|
||||
|
||||
# We can take input from a stdin (pipes) or from a file
|
||||
input_ = file if file else sys.stdin
|
||||
# Print just some topics or exclude some topics (good for avoiding verbose ones)
|
||||
if just:
|
||||
topics = just
|
||||
if ignore:
|
||||
topics = [lvl for lvl in topics if lvl not in set(ignore)]
|
||||
|
||||
topics = set(topics)
|
||||
console = Console()
|
||||
width = console.size.width
|
||||
|
||||
panic = False
|
||||
for line in input_:
|
||||
try:
|
||||
time, topic, *msg = line.strip().split(" ")
|
||||
# To ignore some topics
|
||||
if topic not in topics:
|
||||
continue
|
||||
|
||||
msg = " ".join(msg)
|
||||
|
||||
# Debug calls from the test suite aren't associated with
|
||||
# any particular peer. Otherwise we can treat second column
|
||||
# as peer id
|
||||
if topic != "TEST":
|
||||
i = int(msg[1])
|
||||
|
||||
# Colorize output by using rich syntax when needed
|
||||
if colorize and topic in TOPICS:
|
||||
color = TOPICS[topic]
|
||||
msg = f"[{color}]{msg}[/{color}]"
|
||||
|
||||
# Single column printing. Always the case for debug stmts in tests
|
||||
if n_columns is None or topic == "TEST":
|
||||
print(time, msg)
|
||||
# Multi column printing, timing is dropped to maximize horizontal
|
||||
# space. Heavylifting is done through rich.column.Columns object
|
||||
else:
|
||||
cols = ["" for _ in range(n_columns)]
|
||||
msg = "" + msg
|
||||
cols[i] = msg
|
||||
col_width = int(width / n_columns)
|
||||
cols = Columns(cols, width=col_width - 1, equal=True, expand=True)
|
||||
print(cols)
|
||||
except:
|
||||
# Code from tests or panics does not follow format
|
||||
# so we print it as is
|
||||
if line.startswith("panic"):
|
||||
panic = True
|
||||
# Output from tests is usually important so add a
|
||||
# horizontal line with hashes to make it more obvious
|
||||
if not panic:
|
||||
print("#" * console.width)
|
||||
print(line, end="")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
typer.run(main)
|
||||
@ -1,86 +0,0 @@
|
||||
package logging
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"log"
|
||||
"os"
|
||||
"strconv"
|
||||
"time"
|
||||
)
|
||||
|
||||
func getLogType() string {
|
||||
if t, ok := os.LookupEnv("LOGTYPE"); ok {
|
||||
return t
|
||||
}
|
||||
return "DEFAULT"
|
||||
}
|
||||
|
||||
func getVerbosity() int {
|
||||
v := os.Getenv("VERBOSE")
|
||||
level := 0
|
||||
if v != "" {
|
||||
var err error
|
||||
level, err = strconv.Atoi(v)
|
||||
if err != nil {
|
||||
log.Fatalf("Invalid Verbosity %v", v)
|
||||
}
|
||||
}
|
||||
return level
|
||||
}
|
||||
|
||||
type logTopic string
|
||||
|
||||
const (
|
||||
// define 4 character topic abbreviations for coloring
|
||||
DError logTopic = "ERRO"
|
||||
DClient logTopic = "CLNT"
|
||||
DStart logTopic = "STRT"
|
||||
DExit logTopic = "EXIT"
|
||||
DPing logTopic = "PING"
|
||||
DScan logTopic = "SCAN"
|
||||
DSpawn logTopic = "SPWN"
|
||||
DStop logTopic = "STOP"
|
||||
)
|
||||
|
||||
// the list can grow
|
||||
|
||||
var debugStart time.Time
|
||||
var debugVerbosity int
|
||||
|
||||
func init() {
|
||||
|
||||
debugVerbosity = getVerbosity()
|
||||
debugStart = time.Now()
|
||||
if debugVerbosity > 0 {
|
||||
path := "log/"
|
||||
if _, err := os.Stat(path); errors.Is(err, os.ErrNotExist) {
|
||||
err := os.Mkdir(path, os.ModePerm)
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
os.Exit(1)
|
||||
}
|
||||
}
|
||||
logtype := getLogType() // start with "REACTOR" etc
|
||||
timestamp := time.Now().Format("Mon-15:04:05")
|
||||
filename := fmt.Sprintf("%s-%s.log", logtype, timestamp)
|
||||
f, err := os.OpenFile(path+filename, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0664)
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
log.SetOutput(f)
|
||||
}
|
||||
|
||||
log.SetFlags(log.Flags() &^ (log.Ldate | log.Ltime)) // turns off date and time so we can set manually
|
||||
}
|
||||
|
||||
// example call Debug(dClient, "R%d connecting to client %d", r.Id, c.Id)
|
||||
func Debug(topic logTopic, format string, a ...interface{}) {
|
||||
if debugVerbosity >= 1 {
|
||||
time := time.Since(debugStart).Microseconds()
|
||||
time /= 100
|
||||
prefix := fmt.Sprintf("%06d %v ", time, string(topic))
|
||||
format = prefix + format
|
||||
log.Printf(format, a...)
|
||||
}
|
||||
}
|
||||
@ -1,138 +0,0 @@
|
||||
// Package manager provides basic manager functions to embed into higher level managers.
|
||||
package manager
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"math"
|
||||
"math/rand"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
"time"
|
||||
)
|
||||
|
||||
var (
|
||||
ErrInvalidMaxConn = errors.New("invalid max connection attempts")
|
||||
ErrManagerInactive = errors.New("manager inactive")
|
||||
ErrManagerActive = errors.New("manager active")
|
||||
ErrMaxAttemptsExceeded = errors.New("max connection attempts exceeded")
|
||||
)
|
||||
|
||||
// Status is used as an enum for the current status.
|
||||
// Could be expanded to include others such as killed, sleeping, etc.
|
||||
type Status int
|
||||
|
||||
const (
|
||||
Inactive Status = 0
|
||||
Active Status = 1
|
||||
)
|
||||
|
||||
// MaxConnAttempts is the maximum allowable connection attempts.
|
||||
// Limited to 255 to prevent excessive timeout scaling.
|
||||
const MaxConnAttempts = 0xFF
|
||||
|
||||
// Manager is a general purpose structure to implement basic capabilities.
|
||||
// Stores state in active variable, modified through atomic swaps.
|
||||
// Embeds a connection to be used in generating timeouts.
|
||||
type Manager struct {
|
||||
*connection
|
||||
active int32
|
||||
}
|
||||
|
||||
// New creates a new manager with the maxConn maximum attempts.
|
||||
// Throws ErrInvalidMaxConn if maxConn is not in [0, MaxConnAttempts].
|
||||
func New(maxConn int) (*Manager, error) {
|
||||
|
||||
if maxConn < 0 || maxConn > MaxConnAttempts {
|
||||
return &Manager{}, ErrInvalidMaxConn
|
||||
}
|
||||
|
||||
c := &connection{MaxAttempts: maxConn}
|
||||
|
||||
m := &Manager{
|
||||
connection: c,
|
||||
}
|
||||
|
||||
return m, nil
|
||||
}
|
||||
|
||||
// Start attempts to start the manager.
|
||||
// Throws ErrManagerActive error if the manager is already active.
|
||||
func (m *Manager) Start() error {
|
||||
if atomic.CompareAndSwapInt32(&m.active, 0, 1) {
|
||||
m.ResetConnections()
|
||||
return nil
|
||||
}
|
||||
|
||||
return ErrManagerActive
|
||||
}
|
||||
|
||||
// Stop attempts to stop the manager.
|
||||
// Throws ErrManagerInactive error if the manager is already inactive.
|
||||
func (m *Manager) Stop() error {
|
||||
if atomic.CompareAndSwapInt32(&m.active, 1, 0) {
|
||||
return nil
|
||||
}
|
||||
|
||||
return ErrManagerInactive
|
||||
}
|
||||
|
||||
// IsActive returns the current ManagerStatus.
|
||||
func (m *Manager) IsActive() Status {
|
||||
return Status(atomic.LoadInt32(&m.active))
|
||||
}
|
||||
|
||||
// HeartBeat will send an empty struct over ping every hb (scale).
|
||||
// The pings are sent ever (hb + rand(interval)) * scale.
|
||||
// Where scale is typically time.Millisecond, time.Second etc.
|
||||
// Will close the channel on exit to prevent leaks.
|
||||
func (m *Manager) HeartBeat(
|
||||
ping chan struct{},
|
||||
hb, interval int,
|
||||
scale time.Duration) {
|
||||
|
||||
for m.IsActive() == Active {
|
||||
ping <- struct{}{}
|
||||
|
||||
sleep := time.Duration(hb-interval) * scale
|
||||
|
||||
if interval > 0 {
|
||||
sleep += time.Duration(rand.Intn(2*interval)) * scale
|
||||
}
|
||||
|
||||
time.Sleep(sleep)
|
||||
}
|
||||
|
||||
close(ping)
|
||||
}
|
||||
|
||||
// connection keeps track of maximum and current number of connection attempts.
|
||||
// Concurrency safe as it is protected by a mutex.
|
||||
type connection struct {
|
||||
Attempts float64
|
||||
MaxAttempts int
|
||||
sync.Mutex
|
||||
}
|
||||
|
||||
// Timeout returns an exponentially decaying timeout based on attempts.
|
||||
// Returns timeout of type time.Duration in milliseconds.
|
||||
// Returns ErrMaxAttemptsExceeded if too many attempts are tried.
|
||||
func (c *connection) Timeout() (time.Duration, error) {
|
||||
|
||||
c.Lock()
|
||||
defer c.Unlock()
|
||||
|
||||
if int(c.Attempts) < c.MaxAttempts {
|
||||
to := time.Duration(50*math.Pow(2, c.Attempts)) * time.Millisecond
|
||||
c.Attempts += 1
|
||||
return to, nil
|
||||
}
|
||||
|
||||
return 0, ErrMaxAttemptsExceeded
|
||||
}
|
||||
|
||||
// ResetConnections sets the current connection attempts back to 0.
|
||||
func (c *connection) ResetConnections() {
|
||||
c.Lock()
|
||||
defer c.Unlock()
|
||||
c.Attempts = 0
|
||||
}
|
||||
@ -1,206 +0,0 @@
|
||||
package manager
|
||||
|
||||
import (
|
||||
"math/rand"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
// creating, starting and stopping tests
|
||||
|
||||
// newManager is a helper for creating new managers for tests
|
||||
func newManager(conn int, want error, t *testing.T) *Manager {
|
||||
var manager *Manager
|
||||
var err error
|
||||
assert := assert.New(t)
|
||||
|
||||
manager, err = New(conn)
|
||||
|
||||
if err != want {
|
||||
t.Fatalf(
|
||||
`New(%d) = %v, %v, %d max connections failed`,
|
||||
conn,
|
||||
manager,
|
||||
err,
|
||||
conn,
|
||||
)
|
||||
}
|
||||
|
||||
assert.Equal(manager.IsActive(), Inactive, "manager should start inactive")
|
||||
|
||||
return manager
|
||||
}
|
||||
|
||||
// TestEmptyManager creates a new manager with 0 max connections
|
||||
func TestEmptyManager(t *testing.T) {
|
||||
conn := 0
|
||||
newManager(conn, nil, t)
|
||||
}
|
||||
|
||||
// TestPostiveManager creates a new manager with valid max connections
|
||||
func TestPositiveManager(t *testing.T) {
|
||||
conn := rand.Intn(MaxConnAttempts)
|
||||
newManager(conn, nil, t)
|
||||
}
|
||||
|
||||
// TestNegativeManager creates a new manager with negative max connections
|
||||
func TestNegativeManager(t *testing.T) {
|
||||
conn := -1 * rand.Intn(MaxConnAttempts)
|
||||
newManager(conn, ErrInvalidMaxConn, t)
|
||||
}
|
||||
|
||||
// TestInvalidManager creates a new manager with large max connections
|
||||
func TestInvalidManager(t *testing.T) {
|
||||
conn := MaxConnAttempts + 0xf
|
||||
newManager(conn, ErrInvalidMaxConn, t)
|
||||
}
|
||||
|
||||
// TestManagerLifeCycle tests that a manager can start and exit several times
|
||||
func TestManagerLifeCycle(t *testing.T) {
|
||||
|
||||
var manager *Manager
|
||||
assert := assert.New(t)
|
||||
|
||||
conn := rand.Intn(MaxConnAttempts)
|
||||
manager = newManager(conn, nil, t)
|
||||
|
||||
cycles := 10
|
||||
|
||||
// starting and stopping sequentially
|
||||
for i := 0; i < cycles; i++ {
|
||||
|
||||
assert.NoError(manager.Start(), "starting manager failed")
|
||||
assert.Equal(manager.IsActive(), Active, "manager inactive after start")
|
||||
|
||||
assert.NoError(manager.Stop(), "stopping manager failed")
|
||||
assert.Equal(manager.IsActive(), Inactive, "manager active after stop")
|
||||
}
|
||||
}
|
||||
|
||||
// TestManagerStopFail tests that stopping an inactive manager will error
|
||||
func TestManagerStopFail(t *testing.T) {
|
||||
|
||||
var manager *Manager
|
||||
assert := assert.New(t)
|
||||
|
||||
conn := rand.Intn(MaxConnAttempts)
|
||||
manager = newManager(conn, nil, t)
|
||||
|
||||
assert.NoError(manager.Start(), "starting manager failed")
|
||||
|
||||
// stopping sequentially
|
||||
assert.NoError(manager.Stop(), "stopping manager failed")
|
||||
assert.Error(manager.Stop(), "stopping inactive manager should fail")
|
||||
}
|
||||
|
||||
// TestManagerStartFail tests that starting an active manager will error
|
||||
func TestManagerStartFail(t *testing.T) {
|
||||
|
||||
var manager *Manager
|
||||
assert := assert.New(t)
|
||||
|
||||
conn := rand.Intn(MaxConnAttempts)
|
||||
manager = newManager(conn, nil, t)
|
||||
|
||||
// starting sequentially
|
||||
assert.NoError(manager.Start(), "starting manager failed")
|
||||
assert.Error(manager.Start(), "starting active manager should fail")
|
||||
}
|
||||
|
||||
// auxiliary tests
|
||||
|
||||
// TestManagerTimeout checks that timeouts exponentially backoff
|
||||
func TestManagerTimeout(t *testing.T) {
|
||||
var manager *Manager
|
||||
assert := assert.New(t)
|
||||
|
||||
conn := 10
|
||||
manager = newManager(conn, nil, t)
|
||||
|
||||
assert.NoError(manager.Start(), "starting manager failed")
|
||||
assert.Equal(manager.IsActive(), Active, "manager is inactive")
|
||||
|
||||
prevTimeout, err := manager.Timeout()
|
||||
|
||||
for i := 1; i <= conn; i++ {
|
||||
assert.NoError(err, "generating timeout failed")
|
||||
assert.True(prevTimeout > 0, "invalid timeout")
|
||||
|
||||
timeout, err := manager.Timeout()
|
||||
|
||||
if i == conn {
|
||||
assert.Error(err, "allowed exceeding max attempts")
|
||||
} else {
|
||||
assert.NoError(err, "generating timeout failed")
|
||||
assert.True(
|
||||
timeout == 2*prevTimeout,
|
||||
"incorrect timeout %d, expected %d",
|
||||
timeout, 2*prevTimeout,
|
||||
)
|
||||
}
|
||||
|
||||
prevTimeout = timeout
|
||||
}
|
||||
}
|
||||
|
||||
// TestManagerHB tests the heartbeat channel opens and closes
|
||||
func TestManagerHB(t *testing.T) {
|
||||
|
||||
var manager *Manager
|
||||
assert := assert.New(t)
|
||||
|
||||
conn := rand.Intn(MaxConnAttempts)
|
||||
manager = newManager(conn, nil, t)
|
||||
|
||||
assert.NoError(manager.Start(), "starting manager failed")
|
||||
assert.Equal(manager.IsActive(), Active, "manager is inactive")
|
||||
|
||||
ch := make(chan struct{})
|
||||
|
||||
go manager.HeartBeat(ch, 10, 0, time.Millisecond)
|
||||
|
||||
for range ch {
|
||||
// close on first ping
|
||||
assert.NoError(manager.Stop(), "stopping manager failed")
|
||||
}
|
||||
|
||||
assert.Equal(manager.IsActive(), Inactive, "manager is active")
|
||||
}
|
||||
|
||||
// TestManagerHBTiming tests the heartbeat channel timing is correct
|
||||
func TestManagerHBTiming(t *testing.T) {
|
||||
|
||||
var manager *Manager
|
||||
assert := assert.New(t)
|
||||
|
||||
conn := rand.Intn(MaxConnAttempts)
|
||||
manager = newManager(conn, nil, t)
|
||||
|
||||
assert.NoError(manager.Start(), "starting manager failed")
|
||||
assert.Equal(manager.IsActive(), Active, "manager is inactive")
|
||||
|
||||
ch := make(chan struct{})
|
||||
hb := 100
|
||||
pings := 10
|
||||
|
||||
// expected time with tolerance for other logic and worst case rand timeout
|
||||
expected := time.Duration(pings*hb+15) * time.Millisecond
|
||||
|
||||
go manager.HeartBeat(ch, hb, 1, time.Millisecond)
|
||||
|
||||
iter := 0
|
||||
start := time.Now()
|
||||
for range ch {
|
||||
// close after 10 pings
|
||||
iter += 1
|
||||
if iter >= pings {
|
||||
assert.NoError(manager.Stop(), "stopping manager failed")
|
||||
}
|
||||
}
|
||||
end := time.Now()
|
||||
|
||||
assert.Equal(manager.IsActive(), Inactive, "manager is active")
|
||||
assert.WithinDuration(start, end, expected, "inaccurate heartbeat")
|
||||
}
|
||||
@ -1,86 +0,0 @@
|
||||
// package Server provides a way to listen for incoming connections
|
||||
// and manage multiple reactor clients.
|
||||
package server
|
||||
|
||||
import (
|
||||
pb "FRMS/internal/pkg/grpc"
|
||||
<<<<<<< HEAD:server/internal/pkg/server/coordinator.go
|
||||
"FRMS/internal/pkg/influxdb"
|
||||
"FRMS/internal/pkg/logging"
|
||||
"context"
|
||||
=======
|
||||
>>>>>>> origin/wrapup:internal/pkg/server/coordinator.go
|
||||
"errors"
|
||||
"fmt"
|
||||
"net"
|
||||
"sync"
|
||||
|
||||
"github.com/spf13/viper"
|
||||
"google.golang.org/grpc"
|
||||
)
|
||||
|
||||
var (
|
||||
ErrMissingPort = errors.New("port not set")
|
||||
)
|
||||
|
||||
// Coordinator is runs on the server and is used to oversee
|
||||
// the reactor managers as well as process incoming client connections.
|
||||
type Coordinator struct {
|
||||
Config *viper.Viper
|
||||
listener net.Listener
|
||||
grpcServer *grpc.Server
|
||||
|
||||
DatabasePort int `mapstructure:"database_port"`
|
||||
GRPCPort int `mapstructure:"grpc_port"`
|
||||
|
||||
directory map[int]*ReactorManager
|
||||
managerMu sync.RWMutex
|
||||
|
||||
Err chan error
|
||||
|
||||
// grpc
|
||||
pb.UnimplementedHandshakeServer
|
||||
pb.UnimplementedMonitoringServer
|
||||
}
|
||||
|
||||
// NewCentralCoordinator creates a central coordinator with the given global
|
||||
// config and error channel.
|
||||
func NewCentralCoordinator(config *viper.Viper, ch chan error) *Coordinator {
|
||||
|
||||
rmap := make(map[int]*ReactorManager)
|
||||
|
||||
return &Coordinator{
|
||||
Err: ch,
|
||||
Config: config,
|
||||
directory: rmap,
|
||||
}
|
||||
}
|
||||
|
||||
// Start loads config, starts network listener and registers grpc handlers.
|
||||
// Ready for new clients on return.
|
||||
func (c *Coordinator) Start() error {
|
||||
|
||||
if err := c.Config.Unmarshal(c); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// ensure it shows up as missing
|
||||
if c.GRPCPort == 0 {
|
||||
c.Config.Set("grpc_port", 0)
|
||||
c.Config.WriteConfig()
|
||||
|
||||
return ErrMissingPort
|
||||
}
|
||||
|
||||
lis, err := net.Listen("tcp", fmt.Sprintf(":%v", c.GRPCPort))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
grpcServer := grpc.NewServer()
|
||||
|
||||
c.listener = lis
|
||||
c.grpcServer = grpcServer
|
||||
|
||||
return c.Register()
|
||||
}
|
||||
@ -1,13 +0,0 @@
|
||||
package server
|
||||
|
||||
type dbinfo struct {
|
||||
url string
|
||||
org string
|
||||
token string
|
||||
bucket string
|
||||
}
|
||||
|
||||
func (c *Coordinator) getReactorDatabaseCred(id int) (*dbinfo, error) {
|
||||
|
||||
return &dbinfo{}, nil
|
||||
}
|
||||
@ -1,48 +0,0 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
pb "FRMS/internal/pkg/grpc"
|
||||
"FRMS/internal/pkg/logging"
|
||||
"context"
|
||||
)
|
||||
|
||||
// ClientDiscoveryHandler implements the grpc method which can be called
|
||||
// by incoming clients to first make connection to the central
|
||||
// coordinator and receive database credentials.
|
||||
func (c *Coordinator) ReactorClientHandler(
|
||||
ctx context.Context,
|
||||
req *pb.ReactorClientRequest,
|
||||
) (*pb.ReactorClientResponse, error) {
|
||||
|
||||
id := int(req.GetId())
|
||||
|
||||
logging.Debug(
|
||||
logging.DClient,
|
||||
"LIS 00 reactor %v has connected\n",
|
||||
id,
|
||||
)
|
||||
|
||||
db, err := c.getReactorDatabaseCred(id)
|
||||
if err != nil {
|
||||
return &pb.ReactorClientResponse{}, err
|
||||
}
|
||||
|
||||
return &pb.ReactorClientResponse{
|
||||
Id: id,
|
||||
Url: db.url,
|
||||
Org: db.org,
|
||||
Token: db.token,
|
||||
Bucket: db.bucket,
|
||||
}, err
|
||||
}
|
||||
|
||||
// ReactorStatusHandler is a gRPC handler used to handle incoming
|
||||
// reactor requests containing information about said reactor.
|
||||
// It will get the associate reactor manager and pass the
|
||||
// request device information before returning an acknowledgement.
|
||||
func (c *Coordinator) ReactorStatusHandler(ctx context.Context, req *pb.ReactorStatusPing) (*pb.ReactorStatusResponse, error) {
|
||||
|
||||
// rm, err := c.LoadReactorManager(int(req.GetId()))
|
||||
|
||||
return &pb.ReactorStatusResponse{}, nil
|
||||
}
|
||||
@ -1,84 +0,0 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
//"log"
|
||||
pb "FRMS/internal/pkg/grpc"
|
||||
"FRMS/internal/pkg/logging"
|
||||
"context"
|
||||
"fmt"
|
||||
"net"
|
||||
|
||||
"google.golang.org/grpc"
|
||||
)
|
||||
|
||||
/*
|
||||
Listens on a supplied port and sends incoming clients over a supplied channel
|
||||
Waits for a response on that channel to send back to the client with DB credentials
|
||||
*/
|
||||
|
||||
type Listener struct { // exporting for easy use in the short term
|
||||
Port int `mapstructure:"lis"`
|
||||
ClientConnections chan *ClientPacket
|
||||
Err chan error
|
||||
pb.UnimplementedHandshakeServer
|
||||
}
|
||||
|
||||
type ClientPacket struct {
|
||||
*Client
|
||||
Response chan *ClientResponse
|
||||
}
|
||||
|
||||
type Client struct {
|
||||
//Ip string
|
||||
//Port int
|
||||
Id int
|
||||
Model string
|
||||
Type string
|
||||
}
|
||||
|
||||
type ClientResponse struct {
|
||||
Port int
|
||||
URL string
|
||||
Org string
|
||||
Token string
|
||||
Bucket string
|
||||
}
|
||||
|
||||
func NewListener(cch chan *ClientPacket, ech chan error) *Listener {
|
||||
l := &Listener{Err: ech, ClientConnections: cch}
|
||||
return l
|
||||
}
|
||||
|
||||
func (l *Listener) Start() error {
|
||||
// start grpc server and implement reciever
|
||||
logging.Debug(logging.DStart, "LIS 01 Started client listener")
|
||||
return l.Register()
|
||||
}
|
||||
|
||||
func (l *Listener) Register() error {
|
||||
// creates a gRPC service and binds it to our handler
|
||||
lis, err := net.Listen("tcp", fmt.Sprintf(":%v", l.Port))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
grpcServer := grpc.NewServer()
|
||||
pb.RegisterHandshakeServer(grpcServer, l)
|
||||
go grpcServer.Serve(lis)
|
||||
logging.Debug(logging.DStart, "LIS 01 Registered on port %v", l.Port)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (l *Listener) ClientDiscoveryHandler(ctx context.Context, ping *pb.ClientRequest) (*pb.ClientResponse, error) {
|
||||
// incoming client ping, notify coord and wait for DB credentials to respond
|
||||
c := &Client{Id: int(ping.GetClientId()), Type: ping.GetClientType()}
|
||||
logging.Debug(logging.DClient, "LIS %v %v has connected\n", c.Type, c.Id)
|
||||
// prepare packet to send to coordinator
|
||||
ch := make(chan *ClientResponse)
|
||||
p := &ClientPacket{Client: c, Response: ch}
|
||||
// blocking
|
||||
l.ClientConnections <- p
|
||||
resp := <-ch
|
||||
// prepare object to return to client
|
||||
db := &pb.Database{URL: resp.URL, ORG: resp.Org, Token: resp.Token, Bucket: resp.Bucket}
|
||||
return &pb.ClientResponse{ClientId: uint32(c.Id), ServerPort: uint32(resp.Port), Database: db}, nil
|
||||
}
|
||||
@ -1,29 +0,0 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
//"log"
|
||||
|
||||
_ "context"
|
||||
)
|
||||
|
||||
// will condense into the rm soon enough
|
||||
// manager connects to client on start and returns the gRPC connection to make gRPC clients
|
||||
|
||||
// type ClientManager struct {
|
||||
// *Client // gives access to c.Ip c.Id etc
|
||||
// Hb time.Duration // used for managing hb timer for client
|
||||
// Sig chan bool
|
||||
// sync.Mutex
|
||||
// }
|
||||
|
||||
// func NewClientManager(cl *Client) *ClientManager {
|
||||
// return &ClientManager{Client: cl}
|
||||
// }
|
||||
|
||||
// func (m *ClientManager) UpdateClient(cl *Client) error {
|
||||
// m.Lock()
|
||||
// defer m.Unlock()
|
||||
// logging.Debug(logging.DClient, "MAN Updating client %v", cl.Id)
|
||||
// m.Client = cl
|
||||
// return nil
|
||||
// }
|
||||
@ -1,121 +0,0 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
"FRMS/internal/pkg/logging"
|
||||
"FRMS/internal/pkg/manager"
|
||||
"errors"
|
||||
"time"
|
||||
)
|
||||
|
||||
var (
|
||||
ErrNoReactorManager = errors.New("no reactor manager found")
|
||||
)
|
||||
|
||||
// ReactorManager can be started/stopped as clients connect/disconnect.
|
||||
type ReactorManager struct {
|
||||
Manager // base manager interface
|
||||
}
|
||||
|
||||
// Manager is an interface requiring a structure that can be started
|
||||
// and stopped as well as provide timeouts in milliseconds.
|
||||
type Manager interface {
|
||||
Start() error // status checks
|
||||
Stop() error
|
||||
Timeout() (time.Duration, error) // TO Generator
|
||||
}
|
||||
|
||||
// NewManager returns a manager fulfilling the Manager interface as well as
|
||||
// any potential errors.
|
||||
func NewManager(max int) (Manager, error) {
|
||||
return manager.New(max)
|
||||
}
|
||||
|
||||
// GetReactorManager returns a reactor manager for passed id.
|
||||
// Throws error if manager not found for id.
|
||||
func (c *Coordinator) LoadReactorManager(id int) (*ReactorManager, error) {
|
||||
|
||||
c.managerMu.RLock()
|
||||
defer c.managerMu.RUnlock()
|
||||
|
||||
rm, exists := c.directory[id]
|
||||
|
||||
if !exists {
|
||||
logging.Debug(
|
||||
logging.DClient,
|
||||
"RCO 00 creating manager for %v",
|
||||
id,
|
||||
)
|
||||
|
||||
m, err := NewManager(0)
|
||||
|
||||
rm = &ReactorManager{
|
||||
Manager: m,
|
||||
}
|
||||
|
||||
if err = rm.Start(); err != nil {
|
||||
return rm, err
|
||||
}
|
||||
|
||||
c.directory[id] = rm
|
||||
}
|
||||
|
||||
return rm, nil
|
||||
}
|
||||
|
||||
// // NewReactorManager takes in a client, config and channel to pass errors on.
|
||||
// // Returns a new reactor manager as well as any errors that occured during
|
||||
// // creation.
|
||||
// // Uses MaxConnectionAttempts which defaults to 10 to prevent
|
||||
// // unnessecary network load and/or timeout lengths.
|
||||
// func NewReactorManager(
|
||||
// ) (*ReactorManager, error) {
|
||||
|
||||
// m, err := NewManager(MaxConnectionAttempts)
|
||||
|
||||
// if err != nil {
|
||||
// return &ReactorManager{}, err
|
||||
// }
|
||||
|
||||
// return r, err
|
||||
// }
|
||||
|
||||
// Start logs the start and calls start on the embedded manager.
|
||||
func (r *ReactorManager) Start() error {
|
||||
// logging.Debug(logging.DStart, "RMA starting", r.Id)
|
||||
return r.Manager.Start()
|
||||
}
|
||||
|
||||
// Stop logs the stop and calls stop on the embedded manager.
|
||||
func (r *ReactorManager) Stop() error {
|
||||
// logging.Debug(logging.DExit, "RMA %v stopping", r.Id)
|
||||
return r.Manager.Stop()
|
||||
}
|
||||
|
||||
// UpdateClient is used to change the underlying manager client if there
|
||||
// changes to its data.
|
||||
//
|
||||
// BUG(Keegan): Client is not protected by a lock and may lead to races
|
||||
// func (r *ReactorManager) UpdateClient(cl *Client) error {
|
||||
// logging.Debug(logging.DClient, "RMA %v updating client", r.Id)
|
||||
// r.Client = cl
|
||||
// return nil
|
||||
// }
|
||||
|
||||
// // ReactorDeviceHandler processes incoming device information and
|
||||
// // updates the manager accordingly.
|
||||
// func (r *ReactorManager) ReactorDeviceHandler(devs []*pb.Device) error {
|
||||
|
||||
// logging.Debug(logging.DClient, "CCO recieved ping from %v", r.Id)
|
||||
|
||||
// for _, dev := range devs {
|
||||
// logging.Debug(
|
||||
// logging.DClient,
|
||||
// "CCO %v device %v is %v",
|
||||
// r.Id,
|
||||
// dev.GetAddr(),
|
||||
// dev.GetStatus().String(),
|
||||
// )
|
||||
// }
|
||||
|
||||
// return nil
|
||||
// }
|
||||
@ -1,149 +0,0 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
pb "FRMS/internal/pkg/grpc"
|
||||
"FRMS/internal/pkg/logging"
|
||||
"FRMS/internal/pkg/manager"
|
||||
"time"
|
||||
|
||||
//"FRMS/internal/pkg/device"
|
||||
"context"
|
||||
"fmt"
|
||||
_ "log"
|
||||
|
||||
"github.com/spf13/viper"
|
||||
)
|
||||
|
||||
// manager stuff
|
||||
|
||||
type Manager interface {
|
||||
Start() error // status checks
|
||||
Exit() error
|
||||
Timeout() (time.Duration, error) // TO Generator
|
||||
}
|
||||
|
||||
func NewManager(max int) Manager {
|
||||
// takes a heartbeat and max connection attempts
|
||||
return manager.New(max)
|
||||
}
|
||||
|
||||
type ReactorManager struct {
|
||||
Manager // base manager interface
|
||||
// *ClientManager // client manager (OUTDATED)
|
||||
*Client // access to ID etc
|
||||
// StatusMon *StatusMonitor putting on pause
|
||||
// *ReactorDevices
|
||||
Config *viper.Viper // config to update
|
||||
Err chan error
|
||||
}
|
||||
|
||||
// type ReactorDevices struct {
|
||||
// // device struct
|
||||
// Devices map[int]DeviceManager
|
||||
// sync.RWMutex
|
||||
// }
|
||||
|
||||
func NewReactorManager(cl *Client, config *viper.Viper, errCh chan error) *ReactorManager {
|
||||
// making managers
|
||||
m := NewManager(6)
|
||||
r := &ReactorManager{
|
||||
Manager: m,
|
||||
Client: cl,
|
||||
Config: config,
|
||||
Err: errCh,
|
||||
}
|
||||
return r
|
||||
}
|
||||
|
||||
func (r *ReactorManager) Start() error {
|
||||
// allows for extra stuff
|
||||
logging.Debug(logging.DStart, "RMA %v starting", r.Id)
|
||||
return r.Manager.Start()
|
||||
//go r.StatusMon.Send(&DeviceInfo{Id: r.Id, Type: "Reactor", Status: "[green]ONLINE[white]"}, "Reactor")
|
||||
}
|
||||
|
||||
func (r *ReactorManager) Exit() error {
|
||||
// allows for extra stuff
|
||||
logging.Debug(logging.DExit, "RMA %v exiting", r.Id)
|
||||
return r.Manager.Exit()
|
||||
//go r.StatusMon.Send(&DeviceInfo{Id: r.Id, Type: "Reactor", Status: "[red]OFFLINE[white]", Data: fmt.Sprintf("Last Seen %v", time.Now().Format("Mon at 03:04:05pm MST"))}, "Reactor")
|
||||
}
|
||||
|
||||
func (r *ReactorManager) UpdateClient(cl *Client) error {
|
||||
// this is probably unnessecary
|
||||
fmt.Printf("Reactor Manager %d updating client!\n", r.Id)
|
||||
r.Client = cl
|
||||
return nil
|
||||
}
|
||||
|
||||
func (r *ReactorManager) ReactorStatusHandler(ctx context.Context, req *pb.ReactorStatusPing) (*pb.ReactorStatusResponse, error) {
|
||||
// function client will call to update reactor information
|
||||
//go r.PingReset()
|
||||
fmt.Printf("Recieved ping from %d!\n", req.GetId())
|
||||
// update devices/sensors
|
||||
for _, dev := range req.GetDevices() {
|
||||
fmt.Printf("Device %d is %s ", dev.GetAddr(), dev.GetStatus().String())
|
||||
}
|
||||
fmt.Printf("\n")
|
||||
// go r.UpdateDevices(req.GetDevices())
|
||||
|
||||
return &pb.ReactorStatusResponse{Id: int32(r.Id)}, nil
|
||||
}
|
||||
|
||||
// // device stuff
|
||||
|
||||
// type DeviceManager interface {
|
||||
// LoadConfig() error
|
||||
// UpdateStatus(string) error
|
||||
// String() string // printing
|
||||
// }
|
||||
|
||||
// func NewDeviceManager(addr int, config *viper.Viper, prefix string) (DeviceManager, error) {
|
||||
// // returns a manager struct
|
||||
// return device.NewDeviceManager(addr, config, prefix)
|
||||
// }
|
||||
|
||||
//func (r *ReactorManager) UpdateDevices(devs []*pb.Device) {
|
||||
// // pass updates to correct manager
|
||||
// r.ReactorDevices.RLock() // read lock only
|
||||
// defer r.ReactorDevices.RUnlock()
|
||||
|
||||
// for _, dev := range devs {
|
||||
// // looping over devs
|
||||
// if dm, ok := r.ReactorDevices.Devices[int(dev.GetAddr())]; ok {
|
||||
// // device manager found
|
||||
// go dm.UpdateStatus(dev.GetStatus().String())
|
||||
// //fmt.Println(dm)
|
||||
// } else {
|
||||
// // not found
|
||||
// go r.AddDevice(dev, r.Id, r.Config, r.Err)
|
||||
// }
|
||||
// }
|
||||
//}
|
||||
|
||||
// func (r *ReactorDevices) AddDevice(dev *pb.Device, id int, config *viper.Viper, errCh chan error) {
|
||||
|
||||
// // setting vars
|
||||
// prefix := fmt.Sprintf("reactors.%d.", id)
|
||||
// addr := int(dev.GetAddr())
|
||||
// var dm DeviceManager
|
||||
// var err error
|
||||
// // write locking
|
||||
// r.Lock()
|
||||
// defer r.Unlock()
|
||||
|
||||
// if dm, err = NewDeviceManager(addr, config, prefix); err != nil {
|
||||
// errCh <- err
|
||||
// }
|
||||
|
||||
// // setting status
|
||||
// if err = dm.UpdateStatus(dev.GetStatus().String()); err != nil {
|
||||
// errCh <- err
|
||||
// }
|
||||
|
||||
// // loading config
|
||||
// if err = dm.LoadConfig(); err != nil {
|
||||
// errCh <- err
|
||||
// }
|
||||
// r.Devices[int(addr)] = dm
|
||||
// }
|
||||
@ -1,19 +0,0 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
pb "FRMS/internal/pkg/grpc"
|
||||
"FRMS/internal/pkg/logging"
|
||||
)
|
||||
|
||||
func (c *Coordinator) Register() error {
|
||||
// register services
|
||||
pb.RegisterHandshakeServer(c.grpcServer, c)
|
||||
|
||||
go c.grpcServer.Serve(c.listener)
|
||||
// testing
|
||||
pb.RegisterMonitoringServer(c.grpcServer, c)
|
||||
|
||||
logging.Debug(logging.DStart, "CCO 00 registered grpc")
|
||||
|
||||
return nil
|
||||
}
|
||||
@ -1,309 +0,0 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
_ "fmt"
|
||||
// sensor components
|
||||
)
|
||||
|
||||
/*
|
||||
|
||||
type StatusMonitor struct {
|
||||
// allows for embedding into managers
|
||||
TransactionId chan uint32 // monotonically increases to track outdated reqs
|
||||
DevChan chan *DeviceInfo // channel for device status
|
||||
ReactorChan chan *DeviceInfo // channel for reactor status
|
||||
*SystemViewer
|
||||
DevBuf *devbuf
|
||||
sync.Mutex
|
||||
}
|
||||
|
||||
type devbuf struct {
|
||||
ReactorId int // reactor we are looking at, if any
|
||||
Buf map[string]map[int]*DeviceInfo // convienent way to store/seperate device data
|
||||
sync.Mutex
|
||||
}
|
||||
|
||||
func NewBuffer() map[string]map[int]*DeviceInfo {
|
||||
rbuf := make(map[int]*DeviceInfo)
|
||||
dbuf := make(map[int]*DeviceInfo)
|
||||
sbuf := make(map[string]map[int]*DeviceInfo)
|
||||
sbuf["Reactor"] = rbuf
|
||||
sbuf["Device"] = dbuf
|
||||
return sbuf
|
||||
}
|
||||
|
||||
func NewStatusMonitor(t string, id int, sys *SystemViewer) *StatusMonitor {
|
||||
tid := make(chan uint32)
|
||||
sm := &StatusMonitor{TransactionId: tid}
|
||||
sm.SystemViewer = sys
|
||||
logging.Debug(logging.DClient, "SYS Creating new status monitor")
|
||||
if t == "Reactor" {
|
||||
// reactor status monitor
|
||||
sm.ReactorChan = sys.AddReactorSender()
|
||||
sm.DevChan = sys.AddDeviceSender(id)
|
||||
go sm.GenerateIds()
|
||||
} else {
|
||||
// tui status monitor
|
||||
sbuf := NewBuffer()
|
||||
//sm.ReactorChan, sbuf["Reactor"] = sys.AddListener(id,0)
|
||||
sm.DevBuf = &devbuf{Buf: sbuf} // makes it easier to work with
|
||||
go sm.UpdateListener(id, 0)
|
||||
}
|
||||
return sm
|
||||
}
|
||||
|
||||
func (s *StatusMonitor) GenerateIds() {
|
||||
var id uint32
|
||||
id = 0
|
||||
for {
|
||||
s.TransactionId <- id
|
||||
id += 1
|
||||
}
|
||||
}
|
||||
|
||||
func (s *StatusMonitor) Send(d *DeviceInfo, dtype string) {
|
||||
d.TransactionId = <-s.TransactionId
|
||||
logging.Debug(logging.DClient, "SYS 01 Sending update for: %s (%s)", d.Type, d.Status)
|
||||
if dtype == "Reactor" {
|
||||
s.ReactorChan <- d
|
||||
} else {
|
||||
s.DevChan <- d
|
||||
}
|
||||
}
|
||||
|
||||
func (s *StatusMonitor) GetBuffer() []*DeviceInfo {
|
||||
// also clears buffer
|
||||
s.DevBuf.Lock()
|
||||
defer s.DevBuf.Unlock()
|
||||
res := []*DeviceInfo{}
|
||||
if len(s.DevBuf.Buf["Reactor"]) != 0 || len(s.DevBuf.Buf["Device"]) != 0 {
|
||||
logging.Debug(logging.DClient, "Clearing buff %v", s.DevBuf.Buf)
|
||||
}
|
||||
for _, devs := range s.DevBuf.Buf {
|
||||
for _, dev := range devs {
|
||||
// loops over reactors then devices
|
||||
res = append(res, dev)
|
||||
}
|
||||
}
|
||||
s.DevBuf.Buf = NewBuffer() // clearing old buffer
|
||||
return res
|
||||
}
|
||||
|
||||
func (s *StatusMonitor) UpdateListener(tid, reactorId uint32) {
|
||||
s.DevBuf.Lock()
|
||||
defer s.DevBuf.Unlock()
|
||||
// clearing proper buffer
|
||||
if reactorId == 0 {
|
||||
logging.Debug(logging.DClient, "SYS 01 Adding %v as reactor listener", tid)
|
||||
s.DevBuf.Buf["Reactor"] = make(map[uint32]*DeviceInfo)
|
||||
s.ReactorChan, s.DevBuf.Buf["Reactor"] = s.SystemViewer.AddListener(tid, reactorId)
|
||||
go s.Listen(s.ReactorChan)
|
||||
} else {
|
||||
logging.Debug(logging.DClient, "SYS 01 Adding %v as reactor %v listener", tid, reactorId)
|
||||
s.DevBuf.Buf["Device"] = make(map[uint32]*DeviceInfo) // clearing old devices
|
||||
if s.DevBuf.ReactorId != reactorId && s.DevBuf.ReactorId != 0 {
|
||||
go s.SystemViewer.RemoveListener(s.DevBuf.ReactorId, tid)
|
||||
}
|
||||
s.DevBuf.ReactorId = reactorId
|
||||
s.DevChan, s.DevBuf.Buf["Device"] = s.SystemViewer.AddListener(tid, reactorId)
|
||||
go s.Listen(s.DevChan)
|
||||
}
|
||||
}
|
||||
|
||||
func (s *StatusMonitor) UpdateBuffer(d *DeviceInfo, dtype string, ch chan *DeviceInfo) {
|
||||
s.DevBuf.Lock()
|
||||
defer s.DevBuf.Unlock()
|
||||
logging.Debug(logging.DClient, "SYS 01 Dev %v update requested", d)
|
||||
if dev, exists := s.DevBuf.Buf[dtype][d.Id]; exists {
|
||||
// already a device in the buffer
|
||||
if dev.TransactionId > d.TransactionId {
|
||||
logging.Debug(logging.DClient, "SYS 01 Update Processed. Old: %v, New: %v \n", dev, d)
|
||||
d = dev // not sure if i can do this lol
|
||||
}
|
||||
}
|
||||
if ch == s.ReactorChan || ch == s.DevChan {
|
||||
// hacky way to check if the device came from a listener of a current channel
|
||||
s.DevBuf.Buf[dtype][d.Id] = d
|
||||
} else {
|
||||
logging.Debug(logging.DClient, "Dev out of date!")
|
||||
}
|
||||
}
|
||||
|
||||
func (s *StatusMonitor) Listen(ch chan *DeviceInfo) {
|
||||
for dev := range ch {
|
||||
if dev.Type == "Reactor" {
|
||||
go s.UpdateBuffer(dev, "Reactor", ch)
|
||||
} else {
|
||||
go s.UpdateBuffer(dev, "Device", ch)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
type InfoStream struct {
|
||||
// base stream for any reactor/device
|
||||
// NewSender embedds the channel to send updates on
|
||||
// NewListener will add the statusmon to the list of devs to echo to
|
||||
Stream chan *DeviceInfo
|
||||
Layout *syslayout
|
||||
*listeners
|
||||
}
|
||||
|
||||
type listeners struct {
|
||||
sync.RWMutex
|
||||
Listeners map[uint32]*lischan
|
||||
}
|
||||
|
||||
type lischan struct {
|
||||
sync.WaitGroup
|
||||
StatusChan chan *DeviceInfo
|
||||
}
|
||||
|
||||
type syslayout struct {
|
||||
Devs map[uint32]*DeviceInfo
|
||||
uint32 //index
|
||||
sync.RWMutex
|
||||
}
|
||||
|
||||
func NewLisChan(ch chan *DeviceInfo) *lischan {
|
||||
l := &lischan{StatusChan: ch}
|
||||
return l
|
||||
}
|
||||
|
||||
func NewInfoStream() *InfoStream {
|
||||
dch := make(chan *DeviceInfo)
|
||||
s := &InfoStream{Stream: dch}
|
||||
m := make(map[uint32]*DeviceInfo)
|
||||
s.Layout = &syslayout{Devs: m}
|
||||
s.listeners = &listeners{Listeners: make(map[uint32]*lischan)}
|
||||
return s
|
||||
}
|
||||
|
||||
func (s *InfoStream) Start() {
|
||||
// consistency
|
||||
go s.Listen()
|
||||
}
|
||||
|
||||
// goal is to hook every new manager into the reactor status chan
|
||||
func (s *InfoStream) AddSender() chan *DeviceInfo {
|
||||
return s.Stream
|
||||
}
|
||||
|
||||
func (s *InfoStream) Listen() {
|
||||
for deviceInfo := range s.Stream {
|
||||
go s.Update(deviceInfo)
|
||||
}
|
||||
}
|
||||
|
||||
func (s *InfoStream) Update(d *DeviceInfo) {
|
||||
s.Layout.Lock()
|
||||
defer s.Layout.Unlock()
|
||||
if dev, ok := s.Layout.Devs[d.Id]; !ok {
|
||||
d.Index = s.Layout.uint32
|
||||
s.Layout.uint32 += 1
|
||||
} else {
|
||||
d.Index = dev.Index
|
||||
}
|
||||
s.Layout.Devs[d.Id] = d
|
||||
go s.Echo(d)
|
||||
}
|
||||
|
||||
func (l *listeners) Echo(d *DeviceInfo) {
|
||||
l.RLock()
|
||||
defer l.RUnlock()
|
||||
// read only lock
|
||||
for _, lis := range l.Listeners {
|
||||
lis.Add(1)
|
||||
go func(listener *lischan, dev *DeviceInfo) {
|
||||
defer listener.Done()
|
||||
listener.StatusChan <- dev
|
||||
}(lis, d)
|
||||
}
|
||||
}
|
||||
|
||||
func (s *InfoStream) AddListener(id int, ch chan *DeviceInfo) map[uint32]*DeviceInfo {
|
||||
// if i get a memory leak ill eat my shoe
|
||||
s.listeners.Lock()
|
||||
defer s.listeners.Unlock()
|
||||
if _, ok := s.listeners.Listeners[id]; ok {
|
||||
// exists
|
||||
go s.RemoveListener(id)
|
||||
}
|
||||
s.listeners.Listeners[id] = NewLisChan(ch)
|
||||
logging.Debug(logging.DClient, "SYS 01 Getting Devices")
|
||||
//s.Layout.RLock()
|
||||
//defer s.Layout.RUnlock()
|
||||
logging.Debug(logging.DClient, "SYS 01 Returning Devices %v", s.Layout.Devs)
|
||||
return s.Layout.Devs
|
||||
}
|
||||
|
||||
func (l *listeners) RemoveListener(id int) {
|
||||
l.Lock()
|
||||
defer l.Unlock()
|
||||
if lis, ok := l.Listeners[id]; ok {
|
||||
delete(l.Listeners, id)
|
||||
go func(ls *lischan) {
|
||||
ls.Wait()
|
||||
close(ls.StatusChan)
|
||||
}(lis)
|
||||
}
|
||||
}
|
||||
|
||||
// status buffer maintaince
|
||||
|
||||
type SystemViewer struct {
|
||||
// stores system directory and provide methods to be embedded in managers
|
||||
ReactorStream *InfoStream // can add itself as a listener to provide methods
|
||||
DeviceStream *ds
|
||||
}
|
||||
|
||||
type ds struct {
|
||||
Reactors map[uint32]*InfoStream //map from reactor id to its device info stream
|
||||
sync.Mutex
|
||||
}
|
||||
|
||||
func NewSystemViewer() *SystemViewer {
|
||||
rs := NewInfoStream()
|
||||
s := &SystemViewer{ReactorStream: rs}
|
||||
m := make(map[uint32]*InfoStream)
|
||||
s.DeviceStream = &ds{Reactors: m}
|
||||
return s
|
||||
}
|
||||
|
||||
func (s *SystemViewer) Start() {
|
||||
go s.ReactorStream.Start()
|
||||
}
|
||||
|
||||
func (s *SystemViewer) AddReactorSender() chan *DeviceInfo {
|
||||
return s.ReactorStream.AddSender()
|
||||
}
|
||||
|
||||
func (s *SystemViewer) AddDeviceSender(reactorId uint32) chan *DeviceInfo {
|
||||
s.DeviceStream.Lock()
|
||||
defer s.DeviceStream.Unlock()
|
||||
var ds *InfoStream
|
||||
var ok bool
|
||||
if ds, ok = s.DeviceStream.Reactors[reactorId]; !ok {
|
||||
ds = NewInfoStream()
|
||||
s.DeviceStream.Reactors[reactorId] = ds
|
||||
go ds.Start()
|
||||
}
|
||||
return ds.AddSender()
|
||||
}
|
||||
|
||||
func (s *SystemViewer) AddListener(id, rid int) (chan *DeviceInfo, map[uint32]*DeviceInfo) {
|
||||
// returns a listener for that chan
|
||||
ch := make(chan *DeviceInfo)
|
||||
if rid != 0 {
|
||||
return ch, s.DeviceStream.Reactors[rid].AddListener(id, ch)
|
||||
} else {
|
||||
return ch, s.ReactorStream.AddListener(id, ch)
|
||||
}
|
||||
}
|
||||
|
||||
func (s *SystemViewer) RemoveListener(rid, tid int) {
|
||||
// removes chan for specific tid and rid
|
||||
s.DeviceStream.Lock()
|
||||
defer s.DeviceStream.Unlock()
|
||||
go s.DeviceStream.Reactors[rid].RemoveListener(tid)
|
||||
}
|
||||
*/
|
||||
@ -1,118 +0,0 @@
|
||||
// package system uses linux commands to get hardware info for identifation
|
||||
package system
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"errors"
|
||||
"fmt"
|
||||
"hash/fnv"
|
||||
"net"
|
||||
"os/exec"
|
||||
"strings"
|
||||
)
|
||||
|
||||
func GetId() (int, error) {
|
||||
// gets the mac address and hashes into consistent id
|
||||
maccmd := fmt.Sprintf("ifconfig %v | awk '/ether / {print $2}'", et)
|
||||
var stderr bytes.Buffer
|
||||
var out bytes.Buffer
|
||||
cmd := exec.Command("bash", "-c", maccmd)
|
||||
cmd.Stdout = &out
|
||||
cmd.Stderr = &stderr
|
||||
if err := cmd.Run(); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
hash := fnv.New32a()
|
||||
hash.Write(out.Bytes())
|
||||
id := hash.Sum32()
|
||||
return int(id), nil
|
||||
}
|
||||
|
||||
func GetIp() (string, error) {
|
||||
ipcmd := "ip route get 1 | sed 's/^.*src \([^ ]*\).*$/\1/;q'"
|
||||
var stderr bytes.Buffer
|
||||
var out bytes.Buffer
|
||||
cmd := exec.Command("bash", "-c", ipcmd)
|
||||
cmd.Stdout = &out
|
||||
cmd.Stderr = &stderr
|
||||
if err := cmd.Run(); err != nil {
|
||||
return "", err
|
||||
}
|
||||
ip := strings.Trim(out.String(), " \n")
|
||||
return ip, nil
|
||||
|
||||
}
|
||||
|
||||
func GetPort() (int, error) {
|
||||
// obsolete
|
||||
if addr, err := net.ResolveTCPAddr("tcp", ":0"); err != nil {
|
||||
return 0, err
|
||||
} else if lis, err := net.ListenTCP("tcp", addr); err != nil {
|
||||
return 0, err
|
||||
} else {
|
||||
defer lis.Close()
|
||||
return lis.Addr().(*net.TCPAddr).Port, nil
|
||||
}
|
||||
}
|
||||
|
||||
func GetBus() (int, error) {
|
||||
// preset busses
|
||||
busList := map[string]int{"raspberrypi": 1, "beaglebone": 2}
|
||||
// vars
|
||||
var bus int
|
||||
var ok bool
|
||||
|
||||
if name, err =: GetModel(); err != nil {
|
||||
return bus, err
|
||||
} else if bus, ok = busList[b]; !ok {
|
||||
return 0, errors.New(fmt.Sprintf("No bus for dev %s", b))
|
||||
}
|
||||
|
||||
// returns correct bus
|
||||
return bus, nil
|
||||
}
|
||||
|
||||
func GetModel() (string, error) {
|
||||
var stderr, out bytes.Buffer
|
||||
cmd := exec.Command("bash", "-c", "hostname")
|
||||
cmd.Stdout = &out
|
||||
cmd.Stderr = &stderr
|
||||
if err := cmd.Run(); err != nil {
|
||||
return "", err
|
||||
}
|
||||
b := out.String()
|
||||
b = strings.Trim(b, " \n")
|
||||
return b, nil
|
||||
}
|
||||
|
||||
func Get() error {
|
||||
// responsible for filling out struct
|
||||
//bus := map[string]int{"raspberrypi":1,"beaglebone":2} // eventually will replace this with a config file
|
||||
|
||||
ipcmd := "ifconfig eth0 | awk '/inet / {print $2}'"
|
||||
maccmd := "ifconfig eth0 | awk '/ether / {print $2}'"
|
||||
devcmd := "lshw -C system 2>/dev/null | head -n 1"
|
||||
|
||||
res := [3]bytes.Buffer{}
|
||||
var stderr bytes.Buffer
|
||||
cmds := []string{ipcmd, maccmd, devcmd}
|
||||
for i, c := range cmds {
|
||||
cmd := exec.Command("bash", "-c", c)
|
||||
cmd.Stdout = &res[i]
|
||||
cmd.Stderr = &stderr
|
||||
err := cmd.Run()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
// formatting
|
||||
ip := res[0].String()
|
||||
ip = strings.Trim(ip, " \n")
|
||||
|
||||
hash := fnv.New32a()
|
||||
hash.Write(res[1].Bytes())
|
||||
|
||||
b := res[2].String()
|
||||
b = strings.Trim(b, " \n")
|
||||
return nil
|
||||
}
|
||||
@ -1,90 +0,0 @@
|
||||
// Package websocket sets up websocket connections with clients and allows live reactor readouts.
|
||||
package websocket
|
||||
|
||||
// creates websocket server and upgrades incoming connections
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"net/http"
|
||||
|
||||
ws "github.com/gorilla/websocket"
|
||||
)
|
||||
|
||||
type ReactorTest struct {
|
||||
Id int `json:"id"`
|
||||
Name string `json:"name"`
|
||||
}
|
||||
|
||||
type WebSocket struct {
|
||||
// dummy struct for interface
|
||||
N string
|
||||
}
|
||||
|
||||
func New() *WebSocket {
|
||||
return &WebSocket{}
|
||||
}
|
||||
|
||||
func (s *WebSocket) Start() {
|
||||
fmt.Println("Starting ws server!")
|
||||
setupRoutes()
|
||||
http.ListenAndServe(":8080", nil)
|
||||
}
|
||||
|
||||
// default opts allow all origins
|
||||
var upgrader = ws.Upgrader{
|
||||
CheckOrigin: func(r *http.Request) bool { return true },
|
||||
}
|
||||
|
||||
// reader
|
||||
func reader(conn *ws.Conn) {
|
||||
|
||||
for {
|
||||
// read forever
|
||||
//messageType, p, err := conn.ReadMessage()
|
||||
_, p, err := conn.ReadMessage()
|
||||
|
||||
if err != nil {
|
||||
if ws.IsCloseError(err, ws.CloseNormalClosure, ws.CloseGoingAway) {
|
||||
// normally closed
|
||||
return
|
||||
}
|
||||
panic(err)
|
||||
}
|
||||
fmt.Printf("Msg: %s\n", string(p))
|
||||
}
|
||||
}
|
||||
|
||||
func serverWs(w http.ResponseWriter, r *http.Request) {
|
||||
fmt.Println(r.Host)
|
||||
|
||||
websocket, err := upgrader.Upgrade(w, r, nil)
|
||||
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
// try sending reactor
|
||||
t1 := &ReactorTest{Id: 1111, Name: "test1"}
|
||||
t2 := &ReactorTest{Id: 1112, Name: "test2"}
|
||||
t3 := &ReactorTest{Id: 1113, Name: "test3"}
|
||||
n := []*ReactorTest{t1, t2, t3}
|
||||
msg, err := json.Marshal(n)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
// pass to connection
|
||||
if err := websocket.WriteMessage(ws.TextMessage, msg); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
// pass to reader
|
||||
reader(websocket)
|
||||
}
|
||||
|
||||
func setupRoutes() {
|
||||
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
|
||||
fmt.Fprintf(w, "Simple Server")
|
||||
})
|
||||
|
||||
http.HandleFunc("/ws", serverWs)
|
||||
}
|
||||
Loading…
Reference in New Issue