fixing protoc gen adding rust
parent
f446b4d7dd
commit
7f0aa1a695
@ -1,7 +1,7 @@
|
||||
syntax = "proto3";
|
||||
package grpc;
|
||||
|
||||
option go_package = "internal/pkg/grpc";
|
||||
option go_package = "server/pkg/grpc";
|
||||
|
||||
service handshake {
|
||||
rpc ReactorClientHandler(ReactorClientRequest) returns (ReactorClientResponse);
|
||||
@ -0,0 +1,22 @@
|
||||
use std::fmt;
|
||||
|
||||
pub struct Device {
|
||||
address: i32,
|
||||
}
|
||||
|
||||
impl Device {
|
||||
fn new(address: i32) -> Device {
|
||||
return Device {address: address};
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Display for Device {
|
||||
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
|
||||
write!(fmt, "{}", self.address)
|
||||
}
|
||||
}
|
||||
|
||||
/// outward factory function
|
||||
pub fn create_device(address: i32) -> Device {
|
||||
return Device::new(address);
|
||||
}
|
||||
@ -0,0 +1 @@
|
||||
{"rustc_fingerprint":7536298932270653499,"outputs":{"15729799797837862367":{"success":true,"status":"","code":0,"stdout":"___\nlib___.rlib\nlib___.so\nlib___.so\nlib___.a\nlib___.so\n/usr\noff\npacked\nunpacked\n___\ndebug_assertions\npanic=\"unwind\"\nproc_macro\ntarget_arch=\"x86_64\"\ntarget_endian=\"little\"\ntarget_env=\"gnu\"\ntarget_family=\"unix\"\ntarget_feature=\"fxsr\"\ntarget_feature=\"sse\"\ntarget_feature=\"sse2\"\ntarget_has_atomic=\"16\"\ntarget_has_atomic=\"32\"\ntarget_has_atomic=\"64\"\ntarget_has_atomic=\"8\"\ntarget_has_atomic=\"ptr\"\ntarget_os=\"linux\"\ntarget_pointer_width=\"64\"\ntarget_vendor=\"unknown\"\nunix\n","stderr":""},"4614504638168534921":{"success":true,"status":"","code":0,"stdout":"rustc 1.70.0 (90c541806 2023-05-31) (Arch Linux rust 1:1.70.0-1)\nbinary: rustc\ncommit-hash: 90c541806f23a127002de5b4038be731ba1458ca\ncommit-date: 2023-05-31\nhost: x86_64-unknown-linux-gnu\nrelease: 1.70.0\nLLVM version: 15.0.7\n","stderr":""}},"successes":{}}
|
||||
@ -0,0 +1,3 @@
|
||||
Signature: 8a477f597d28d172789f06886806bc55
|
||||
# This file is a cache directory tag created by cargo.
|
||||
# For information about cache directory tags see https://bford.info/cachedir/
|
||||
@ -0,0 +1 @@
|
||||
{"rustc":17025871333922611028,"features":"[]","target":1121030462635718733,"profile":7309141686862299243,"path":1684066648322511884,"deps":[],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/reactor-24beb93947a561a5/dep-bin-reactor"}}],"rustflags":[],"metadata":7797948686568424061,"config":2202906307356721367,"compile_kind":0}
|
||||
Binary file not shown.
@ -0,0 +1 @@
|
||||
This file has an mtime of when this was started.
|
||||
@ -0,0 +1 @@
|
||||
{"message":"expected type, found `{`","code":null,"level":"error","spans":[{"file_name":"src/i2c.rs","byte_start":182,"byte_end":183,"line_start":7,"line_end":7,"column_start":26,"column_end":27,"is_primary":true,"text":[{"text":"fn send_i2c_command() -> {","highlight_start":26,"highlight_end":27}],"label":"expected type","suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[],"rendered":"\u001b[0m\u001b[1m\u001b[38;5;9merror\u001b[0m\u001b[0m\u001b[1m: expected type, found `{`\u001b[0m\n\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m--> \u001b[0m\u001b[0msrc/i2c.rs:7:26\u001b[0m\n\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\n\u001b[0m\u001b[1m\u001b[38;5;12m7\u001b[0m\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\u001b[0m \u001b[0m\u001b[0mfn send_i2c_command() -> {\u001b[0m\n\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m| \u001b[0m\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;9m^\u001b[0m\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;9mexpected type\u001b[0m\n\n"}
|
||||
Binary file not shown.
@ -0,0 +1 @@
|
||||
This file has an mtime of when this was started.
|
||||
@ -0,0 +1 @@
|
||||
{"message":"expected type, found `{`","code":null,"level":"error","spans":[{"file_name":"src/i2c.rs","byte_start":182,"byte_end":183,"line_start":7,"line_end":7,"column_start":26,"column_end":27,"is_primary":true,"text":[{"text":"fn send_i2c_command() -> {","highlight_start":26,"highlight_end":27}],"label":"expected type","suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[],"rendered":"\u001b[0m\u001b[1m\u001b[38;5;9merror\u001b[0m\u001b[0m\u001b[1m: expected type, found `{`\u001b[0m\n\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m--> \u001b[0m\u001b[0msrc/i2c.rs:7:26\u001b[0m\n\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\n\u001b[0m\u001b[1m\u001b[38;5;12m7\u001b[0m\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\u001b[0m \u001b[0m\u001b[0mfn send_i2c_command() -> {\u001b[0m\n\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m| \u001b[0m\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;9m^\u001b[0m\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;9mexpected type\u001b[0m\n\n"}
|
||||
@ -0,0 +1 @@
|
||||
{"rustc":17025871333922611028,"features":"[]","target":1121030462635718733,"profile":1021633075455700787,"path":1684066648322511884,"deps":[],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/reactor-8045e4fbaa95f18e/dep-test-bin-reactor"}}],"rustflags":[],"metadata":7797948686568424061,"config":2202906307356721367,"compile_kind":0}
|
||||
@ -0,0 +1,7 @@
|
||||
/home/spinach/src/dmac/reactor/target/debug/deps/reactor-24beb93947a561a5.rmeta: src/main.rs src/i2c.rs src/device.rs
|
||||
|
||||
/home/spinach/src/dmac/reactor/target/debug/deps/reactor-24beb93947a561a5.d: src/main.rs src/i2c.rs src/device.rs
|
||||
|
||||
src/main.rs:
|
||||
src/i2c.rs:
|
||||
src/device.rs:
|
||||
@ -0,0 +1,7 @@
|
||||
/home/spinach/src/dmac/reactor/target/debug/deps/reactor-8045e4fbaa95f18e.rmeta: src/main.rs src/i2c.rs src/device.rs
|
||||
|
||||
/home/spinach/src/dmac/reactor/target/debug/deps/reactor-8045e4fbaa95f18e.d: src/main.rs src/i2c.rs src/device.rs
|
||||
|
||||
src/main.rs:
|
||||
src/i2c.rs:
|
||||
src/device.rs:
|
||||
@ -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,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,29 +1,137 @@
|
||||
package system
|
||||
|
||||
import (
|
||||
//"log"
|
||||
"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
|
||||
|
||||
_ "context"
|
||||
const (
|
||||
Inactive Status = 0
|
||||
Active Status = 1
|
||||
)
|
||||
|
||||
// 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
|
||||
// }
|
||||
// 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,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)
|
||||
}
|
||||
*/
|
||||
Loading…
Reference in New Issue