diff --git a/Gopkg.lock b/Gopkg.lock index 9c67e72b6..87641a1ed 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -2,356 +2,194 @@ [[projects]] - digest = "1:c84a587136cb69cecc11f3dbe9f9001444044c0dba74997b07f7e4c150b07cda" name = "github.com/DATA-DOG/go-sqlmock" packages = ["."] - pruneopts = "UT" revision = "3f9954f6f6697845b082ca57995849ddf614f450" version = "v1.3.3" [[projects]] - digest = "1:abeb38ade3f32a92943e5be54f55ed6d6e3b6602761d74b4aab4c9dd45c18abd" + name = "github.com/StackExchange/wmi" + packages = ["."] + revision = "5d049714c4a64225c3c79a7cf7d02f7fb5b96338" + version = "1.0.0" + +[[projects]] name = "github.com/fsnotify/fsnotify" packages = ["."] - pruneopts = "UT" revision = "c2828203cd70a50dcccfb2761f8b1f8ceef9a8e9" version = "v1.4.7" [[projects]] - digest = "1:b532ee3f683c057e797694b5bfeb3827d89e6adf41c53dbc80e549bca76364ea" + name = "github.com/go-ole/go-ole" + packages = [".","oleutil"] + revision = "97b6244175ae18ea6eef668034fd6565847501c9" + version = "v1.2.4" + +[[projects]] name = "github.com/golang/protobuf" - packages = [ - "jsonpb", - "proto", - "protoc-gen-go/descriptor", - "protoc-gen-go/generator", - "protoc-gen-go/generator/internal/remap", - "protoc-gen-go/plugin", - "ptypes", - "ptypes/any", - "ptypes/duration", - "ptypes/struct", - "ptypes/timestamp", - "ptypes/wrappers", - ] - pruneopts = "UT" + packages = ["jsonpb","proto","protoc-gen-go/descriptor","protoc-gen-go/generator","protoc-gen-go/generator/internal/remap","protoc-gen-go/plugin","ptypes","ptypes/any","ptypes/duration","ptypes/struct","ptypes/timestamp","ptypes/wrappers"] revision = "6c65a5562fc06764971b7c5d05c76c75e84bdbf7" version = "v1.3.2" [[projects]] - digest = "1:bf40199583e5143d1472fc34d10d6f4b69d97572142acf343b3e43136da40823" name = "github.com/google/go-cmp" - packages = [ - "cmp", - "cmp/internal/diff", - "cmp/internal/flags", - "cmp/internal/function", - "cmp/internal/value", - ] - pruneopts = "UT" + packages = ["cmp","cmp/internal/diff","cmp/internal/flags","cmp/internal/function","cmp/internal/value"] revision = "6f77996f0c42f7b84e5a2b252227263f93432e9b" version = "v0.3.0" [[projects]] - digest = "1:07ac748d2913b3c6d963aceec7fc4348c34a4ea58c0063779d08c2717380f7e9" name = "github.com/grpc-ecosystem/grpc-gateway" - packages = [ - "internal", - "runtime", - "utilities", - ] - pruneopts = "UT" + packages = ["internal","runtime","utilities"] revision = "bebc7374a79e1105d786ef3468b474e47d652511" version = "v1.9.4" [[projects]] - digest = "1:c0d19ab64b32ce9fe5cf4ddceba78d5bc9807f0016db6b1183599da3dcc24d10" name = "github.com/hashicorp/hcl" - packages = [ - ".", - "hcl/ast", - "hcl/parser", - "hcl/printer", - "hcl/scanner", - "hcl/strconv", - "hcl/token", - "json/parser", - "json/scanner", - "json/token", - ] - pruneopts = "UT" + packages = [".","hcl/ast","hcl/parser","hcl/printer","hcl/scanner","hcl/strconv","hcl/token","json/parser","json/scanner","json/token"] revision = "8cb6e5b959231cc1119e43259c4a608f9c51a241" version = "v1.0.0" [[projects]] - digest = "1:870d441fe217b8e689d7949fef6e43efbc787e50f200cb1e70dbca9204a1d6be" name = "github.com/inconshreveable/mousetrap" packages = ["."] - pruneopts = "UT" revision = "76626ae9c91c4f2a10f34cad8ce83ea42c93bb75" version = "v1.0" [[projects]] - digest = "1:31e761d97c76151dde79e9d28964a812c46efc5baee4085b86f68f0c654450de" name = "github.com/konsorten/go-windows-terminal-sequences" packages = ["."] - pruneopts = "UT" revision = "f55edac94c9bbba5d6182a4be46d86a2c9b5b50e" version = "v1.0.2" [[projects]] - digest = "1:5a0ef768465592efca0412f7e838cdc0826712f8447e70e6ccc52eb441e9ab13" name = "github.com/magiconair/properties" packages = ["."] - pruneopts = "UT" revision = "de8848e004dd33dc07a2947b3d76f618a7fc7ef1" version = "v1.8.1" [[projects]] - digest = "1:4a49346ca45376a2bba679ca0e83bec949d780d4e927931317904bad482943ec" name = "github.com/mattn/go-sqlite3" packages = ["."] - pruneopts = "UT" revision = "c7c4067b79cc51e6dfdcef5c702e74b1e0fa7c75" version = "v1.10.0" [[projects]] - digest = "1:53bc4cd4914cd7cd52139990d5170d6dc99067ae31c56530621b18b35fc30318" name = "github.com/mitchellh/mapstructure" packages = ["."] - pruneopts = "UT" revision = "3536a929edddb9a5b34bd6861dc4a9647cb459fe" version = "v1.1.2" [[projects]] - digest = "1:93131d8002d7025da13582877c32d1fc302486775a1b06f62241741006428c5e" name = "github.com/pelletier/go-toml" packages = ["."] - pruneopts = "UT" revision = "728039f679cbcd4f6a54e080d2219a4c4928c546" version = "v1.4.0" [[projects]] - digest = "1:04457f9f6f3ffc5fea48e71d62f2ca256637dee0a04d710288e27e05c8b41976" + name = "github.com/shirou/gopsutil" + packages = ["cpu","disk","host","internal/common","mem","net","process"] + revision = "d80c43f9c984a48783daf22f4bd9278006ae483a" + version = "v2.19.7" + +[[projects]] + branch = "master" + name = "github.com/shirou/w32" + packages = ["."] + revision = "bb4de0191aa41b5507caa14b0650cdbddcd9280b" + +[[projects]] name = "github.com/sirupsen/logrus" packages = ["."] - pruneopts = "UT" revision = "839c75faf7f98a33d445d181f3018b5c3409a45e" version = "v1.4.2" [[projects]] - digest = "1:bb495ec276ab82d3dd08504bbc0594a65de8c3b22c6f2aaa92d05b73fbf3a82e" name = "github.com/spf13/afero" - packages = [ - ".", - "mem", - ] - pruneopts = "UT" + packages = [".","mem"] revision = "588a75ec4f32903aa5e39a2619ba6a4631e28424" version = "v1.2.2" [[projects]] - digest = "1:08d65904057412fc0270fc4812a1c90c594186819243160dc779a402d4b6d0bc" name = "github.com/spf13/cast" packages = ["."] - pruneopts = "UT" revision = "8c9545af88b134710ab1cd196795e7f2388358d7" version = "v1.3.0" [[projects]] - digest = "1:e096613fb7cf34743d49af87d197663cfccd61876e2219853005a57baedfa562" name = "github.com/spf13/cobra" packages = ["."] - pruneopts = "UT" revision = "f2b07da1e2c38d5f12845a4f607e2e1018cbb1f5" version = "v0.0.5" [[projects]] - digest = "1:1b753ec16506f5864d26a28b43703c58831255059644351bbcb019b843950900" name = "github.com/spf13/jwalterweatherman" packages = ["."] - pruneopts = "UT" revision = "94f6ae3ed3bceceafa716478c5fbf8d29ca601a1" version = "v1.1.0" [[projects]] - digest = "1:c1b1102241e7f645bc8e0c22ae352e8f0dc6484b6cb4d132fa9f24174e0119e2" name = "github.com/spf13/pflag" packages = ["."] - pruneopts = "UT" revision = "298182f68c66c05229eb03ac171abe6e309ee79a" version = "v1.0.3" [[projects]] - digest = "1:11118bd196646c6515fea3d6c43f66162833c6ae4939bfb229b9956d91c6cf17" name = "github.com/spf13/viper" packages = ["."] - pruneopts = "UT" revision = "b5bf975e5823809fb22c7644d008757f78a4259e" version = "v1.4.0" [[projects]] branch = "master" - digest = "1:6bae001f7c4cddc9ebf2b47bd5ff1bd3978a84b422c468d6037dad284c8c8e9d" name = "github.com/tyler-smith/go-bip39" - packages = [ - ".", - "wordlists", - ] - pruneopts = "UT" + packages = [".","wordlists"] revision = "dbb3b84ba2ef14e894f5e33d6c6e43641e665738" [[projects]] branch = "master" - digest = "1:6bc5f992ed1dd4346d657b7467f7b3c61b3188607770ee20ab3ad75ab666e3c7" name = "golang.org/x/crypto" - packages = [ - "ed25519", - "ed25519/internal/edwards25519", - "pbkdf2", - "sha3", - ] - pruneopts = "UT" + packages = ["ed25519","ed25519/internal/edwards25519","pbkdf2","sha3"] revision = "4def268fd1a49955bfb3dda92fe3db4f924f2285" [[projects]] branch = "master" - digest = "1:d31a812696686f0059241fa6c3b56d89ada56dddde4db1d5036de5c1084000c5" name = "golang.org/x/net" - packages = [ - "http/httpguts", - "http2", - "http2/hpack", - "idna", - "internal/timeseries", - "trace", - ] - pruneopts = "UT" + packages = ["http/httpguts","http2","http2/hpack","idna","internal/timeseries","trace"] revision = "da137c7871d730100384dbcf36e6f8fa493aef5b" [[projects]] branch = "master" - digest = "1:a0e4b2275e7939970d395eb6d03f409378eb586aab72e0a461d95e3435c6c5c4" name = "golang.org/x/sys" - packages = [ - "cpu", - "unix", - ] - pruneopts = "UT" + packages = ["cpu","unix","windows"] revision = "fae7ac547cb717d141c433a2a173315e216b64c4" [[projects]] - digest = "1:8d8faad6b12a3a4c819a3f9618cb6ee1fa1cfc33253abeeea8b55336721e3405" name = "golang.org/x/text" - packages = [ - "collate", - "collate/build", - "internal/colltab", - "internal/gen", - "internal/language", - "internal/language/compact", - "internal/tag", - "internal/triegen", - "internal/ucd", - "language", - "secure/bidirule", - "transform", - "unicode/bidi", - "unicode/cldr", - "unicode/norm", - "unicode/rangetable", - ] - pruneopts = "UT" + packages = ["collate","collate/build","internal/colltab","internal/gen","internal/language","internal/language/compact","internal/tag","internal/triegen","internal/ucd","language","secure/bidirule","transform","unicode/bidi","unicode/cldr","unicode/norm","unicode/rangetable"] revision = "342b2e1fbaa52c93f31447ad2c6abc048c63e475" version = "v0.3.2" [[projects]] branch = "master" - digest = "1:1233ed1b527b0ff66c3df5879f7e80b1d8631e030cc45821b77fc25acd0d72a6" name = "google.golang.org/genproto" - packages = [ - "googleapis/api/annotations", - "googleapis/api/httpbody", - "googleapis/rpc/status", - "protobuf/field_mask", - ] - pruneopts = "UT" + packages = ["googleapis/api/annotations","googleapis/api/httpbody","googleapis/rpc/status","protobuf/field_mask"] revision = "3bdd9d9f5532d75d09efb230bd767d265245cfe5" [[projects]] - digest = "1:118eaeffc8cc29314354c26079c4142568834e9f465631f461a25526f71b0de8" name = "google.golang.org/grpc" - packages = [ - ".", - "balancer", - "balancer/base", - "balancer/roundrobin", - "binarylog/grpc_binarylog_v1", - "codes", - "connectivity", - "credentials", - "credentials/internal", - "encoding", - "encoding/proto", - "grpclog", - "internal", - "internal/backoff", - "internal/balancerload", - "internal/binarylog", - "internal/channelz", - "internal/envconfig", - "internal/grpcrand", - "internal/grpcsync", - "internal/syscall", - "internal/transport", - "keepalive", - "metadata", - "naming", - "peer", - "resolver", - "resolver/dns", - "resolver/passthrough", - "serviceconfig", - "stats", - "status", - "tap", - "test/bufconn", - ] - pruneopts = "UT" + packages = [".","balancer","balancer/base","balancer/roundrobin","binarylog/grpc_binarylog_v1","codes","connectivity","credentials","credentials/internal","encoding","encoding/proto","grpclog","internal","internal/backoff","internal/balancerload","internal/binarylog","internal/channelz","internal/envconfig","internal/grpcrand","internal/grpcsync","internal/syscall","internal/transport","keepalive","metadata","naming","peer","resolver","resolver/dns","resolver/passthrough","serviceconfig","stats","status","tap","test/bufconn"] revision = "1d89a3c832915b2314551c1d2a506874d62e53f7" version = "v1.22.0" [[projects]] - digest = "1:4d2e5a73dc1500038e504a8d78b986630e3626dc027bc030ba5c75da257cdb96" name = "gopkg.in/yaml.v2" packages = ["."] - pruneopts = "UT" revision = "51d6538a90f86fe93ac480b35f37b2be17fef232" version = "v2.2.2" [solve-meta] analyzer-name = "dep" analyzer-version = 1 - input-imports = [ - "github.com/DATA-DOG/go-sqlmock", - "github.com/golang/protobuf/proto", - "github.com/google/go-cmp/cmp", - "github.com/grpc-ecosystem/grpc-gateway/runtime", - "github.com/grpc-ecosystem/grpc-gateway/utilities", - "github.com/mattn/go-sqlite3", - "github.com/sirupsen/logrus", - "github.com/spf13/cobra", - "github.com/spf13/viper", - "github.com/tyler-smith/go-bip39", - "golang.org/x/crypto/ed25519", - "golang.org/x/crypto/sha3", - "golang.org/x/net/context", - "google.golang.org/genproto/googleapis/api/annotations", - "google.golang.org/grpc", - "google.golang.org/grpc/codes", - "google.golang.org/grpc/grpclog", - "google.golang.org/grpc/status", - "google.golang.org/grpc/test/bufconn", - ] + inputs-digest = "a58916738556e36d4a28d9c8538e132b5de70979dbe768bfabdee186988aa298" solver-name = "gps-cdcl" solver-version = 1 diff --git a/Gopkg.toml b/Gopkg.toml index a471d0980..047b56de6 100644 --- a/Gopkg.toml +++ b/Gopkg.toml @@ -72,4 +72,7 @@ [[constraint]] branch = "master" - name = "github.com/tyler-smith/go-bip39" \ No newline at end of file + name = "github.com/tyler-smith/go-bip39" +[[constraint]] + name = "github.com/shirou/gopsutil" + version = "2.19.7" diff --git a/ZooBC.postman_collection.json b/ZooBC.postman_collection.json new file mode 100644 index 000000000..54f8e6f6a --- /dev/null +++ b/ZooBC.postman_collection.json @@ -0,0 +1,90 @@ +{ + "info": { + "_postman_id": "e8cb55b1-5c13-4894-8106-52f4bf019eee", + "name": "ZooBC", + "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json" + }, + "item": [ + { + "name": "blocks", + "item": [ + { + "name": "GetBlocks", + "request": { + "method": "GET", + "header": [], + "body": { + "mode": "raw", + "raw": "" + }, + "url": { + "raw": "{{host}}/v1/block/GetBlocks?Limit=10&Height=0&Chaintype=0", + "host": [ + "{{host}}" + ], + "path": [ + "v1", + "block", + "GetBlocks" + ], + "query": [ + { + "key": "Limit", + "value": "10" + }, + { + "key": "Height", + "value": "0" + }, + { + "key": "Chaintype", + "value": "0" + } + ] + } + }, + "response": [] + }, + { + "name": "GetBlock", + "request": { + "method": "GET", + "header": [], + "body": { + "mode": "raw", + "raw": "" + }, + "url": { + "raw": "{{host}}/v1/block/GetBlock?ID=-8826204794314169398", + "host": [ + "{{host}}" + ], + "path": [ + "v1", + "block", + "GetBlock" + ], + "query": [ + { + "key": "ID", + "value": "-8826204794314169398" + }, + { + "key": "Height", + "value": "20", + "disabled": true + }, + { + "key": "Chaintype", + "value": "0", + "disabled": true + } + ] + } + }, + "response": [] + } + ] + } + ] +} \ No newline at end of file diff --git a/api/api.go b/api/api.go index 1d07e32cf..3e65f70b6 100644 --- a/api/api.go +++ b/api/api.go @@ -1,12 +1,16 @@ package api import ( + "context" "fmt" + "github.com/grpc-ecosystem/grpc-gateway/runtime" + "github.com/zoobc/zoobc-core/common/interceptor" "net" + "net/http" "github.com/zoobc/zoobc-core/common/chaintype" coreService "github.com/zoobc/zoobc-core/core/service" - p2p "github.com/zoobc/zoobc-core/p2p" + "github.com/zoobc/zoobc-core/p2p" "github.com/zoobc/zoobc-core/common/crypto" "github.com/zoobc/zoobc-core/common/transaction" @@ -33,9 +37,10 @@ func init() { } func startGrpcServer(port int, queryExecutor query.ExecutorInterface, p2pHostService p2p.ServiceInterface, - blockServices map[int32]coreService.BlockServiceInterface) { + blockServices map[int32]coreService.BlockServiceInterface, ownerAccountAddress string) { grpcServer := grpc.NewServer( - grpc.UnaryInterceptor(util.NewServerInterceptor(apiLogger)), + grpc.UnaryInterceptor(interceptor.NewServerInterceptor(apiLogger)), + grpc.StreamInterceptor(interceptor.NewStreamInterceptor(ownerAccountAddress)), ) actionTypeSwitcher := &transaction.TypeSwitcher{ Executor: queryExecutor, @@ -84,7 +89,12 @@ func startGrpcServer(port int, queryExecutor query.ExecutorInterface, p2pHostSer rpcService.RegisterNodeAdminServiceServer(grpcServer, &handler.NodeAdminHandler{ Service: service.NewNodeAdminService(queryExecutor), }) - + rpcService.RegisterNodeHardwareServiceServer(grpcServer, &handler.NodeHardwareHandler{ + Service: service.NewNodeHardwareService( + ownerAccountAddress, + crypto.NewSignature(), + ), + }) // Set GRPC handler for unconfirmed // run grpc-gateway handler go func() { @@ -97,6 +107,31 @@ func startGrpcServer(port int, queryExecutor query.ExecutorInterface, p2pHostSer // Start starts api servers in the given port and passing query executor func Start(grpcPort, restPort int, queryExecutor query.ExecutorInterface, p2pHostService p2p.ServiceInterface, - blockServices map[int32]coreService.BlockServiceInterface) { - startGrpcServer(grpcPort, queryExecutor, p2pHostService, blockServices) + blockServices map[int32]coreService.BlockServiceInterface, ownerAccountAddress string) { + startGrpcServer(grpcPort, queryExecutor, p2pHostService, blockServices, ownerAccountAddress) + go func() { + _ = runProxy(restPort, grpcPort) + }() +} + +/** +runProxy only ran when `Debug` flag is set to `true` in `config.toml` +this function open a http endpoint that will be proxy to our rpc service +*/ +func runProxy(apiPort, rpcPort int) error { + ctx := context.Background() + ctx, cancel := context.WithCancel(ctx) + defer cancel() + mux := runtime.NewServeMux() + opts := []grpc.DialOption{grpc.WithInsecure()} + _ = rpcService.RegisterAccountBalanceServiceHandlerFromEndpoint(ctx, mux, fmt.Sprintf("localhost:%d", rpcPort), opts) + _ = rpcService.RegisterBlockServiceHandlerFromEndpoint(ctx, mux, fmt.Sprintf("localhost:%d", rpcPort), opts) + _ = rpcService.RegisterHostServiceHandlerFromEndpoint(ctx, mux, fmt.Sprintf("localhost:%d", rpcPort), opts) + _ = rpcService.RegisterMempoolServiceHandlerFromEndpoint(ctx, mux, fmt.Sprintf("localhost:%d", rpcPort), opts) + _ = rpcService.RegisterNodeHardwareServiceHandlerFromEndpoint(ctx, mux, fmt.Sprintf("localhost:%d", rpcPort), opts) + _ = rpcService.RegisterNodeRegistrationServiceHandlerFromEndpoint(ctx, mux, fmt.Sprintf("localhost:%d", rpcPort), opts) + _ = rpcService.RegisterNodeAdminServiceHandlerFromEndpoint(ctx, mux, fmt.Sprintf("localhost:%d", rpcPort), opts) + _ = rpcService.RegisterTransactionServiceHandlerFromEndpoint(ctx, mux, fmt.Sprintf("localhost:%d", rpcPort), opts) + + return http.ListenAndServe(fmt.Sprintf(":%d", apiPort), mux) } diff --git a/api/client/GetNodeHardware/client.go b/api/client/GetNodeHardware/client.go new file mode 100644 index 000000000..fe1442ade --- /dev/null +++ b/api/client/GetNodeHardware/client.go @@ -0,0 +1,68 @@ +package main + +import ( + "bytes" + "context" + "encoding/hex" + "github.com/zoobc/zoobc-core/common/constant" + "github.com/zoobc/zoobc-core/common/crypto" + "github.com/zoobc/zoobc-core/common/util" + "google.golang.org/grpc/metadata" + "time" + + log "github.com/sirupsen/logrus" + rpcModel "github.com/zoobc/zoobc-core/common/model" + rpcService "github.com/zoobc/zoobc-core/common/service" + "google.golang.org/grpc" +) + +func main() { + conn, err := grpc.Dial(":7000", grpc.WithInsecure()) + if err != nil { + log.Fatalf("did not connect: %s", err) + } + defer conn.Close() + + c := rpcService.NewNodeHardwareServiceClient(conn) + var stream rpcService.NodeHardwareService_GetNodeHardwareClient + + if err != nil { + log.Fatalf("error calling rpcService.GetAccountBalance: %s", err) + } + waitC := make(chan struct{}) + signature := crypto.Signature{} + + go func() { + for { + currentTime := uint64(time.Now().Unix()) + buffer := bytes.NewBuffer([]byte{}) + buffer.Write(util.ConvertUint32ToBytes(uint32(rpcModel.RequestType_GetNodeHardware))) + buffer.Write(util.ConvertUint64ToBytes(currentTime)) + sig := signature.Sign( + buffer.Bytes(), + constant.NodeSignatureTypeDefault, + "concur vocalist rotten busload gap quote stinging undiluted surfer goofiness deviation starved", + ) + buffer.Write(sig) + + ctx := context.Background() + md := metadata.Pairs("authorization", hex.EncodeToString(buffer.Bytes())) + ctx = metadata.NewOutgoingContext(ctx, md) + stream, err = c.GetNodeHardware(ctx) + log.Println("Sleeping...") + time.Sleep(2 * time.Second) + log.Println("Sending request...") + err = stream.Send(&rpcModel.GetNodeHardwareRequest{}) + if err != nil { + log.Fatalf("error sending request to rpcService.GetNodeHardware: %s", err) + } + response, err := stream.Recv() + if err != nil { + log.Fatalf("error receiving response from rpcService.GetNodeHardware: %s", err) + } + log.Printf("response from remote rpcService.GetNodeHardware(): %s", response) + } + }() + <-waitC + _ = stream.CloseSend() +} diff --git a/api/client/GetProofOfOwnership/client.go b/api/client/GetProofOfOwnership/client.go index 99e08f685..5f9d9fdc6 100644 --- a/api/client/GetProofOfOwnership/client.go +++ b/api/client/GetProofOfOwnership/client.go @@ -4,6 +4,7 @@ import ( "bytes" "context" "fmt" + "github.com/zoobc/zoobc-core/common/constant" "github.com/sirupsen/logrus" log "github.com/sirupsen/logrus" @@ -35,7 +36,7 @@ func main() { c := rpc_service.NewNodeAdminServiceClient(conn) sig := crypto.NewSignature().Sign([]byte("BCZEGOb3WNx3fDOVf9ZS4EjvOIv_UeW4TVBQJ_6tHKlE"), - "BCZEGOb3WNx3fDOVf9ZS4EjvOIv_UeW4TVBQJ_6tHKlE", + constant.NodeSignatureTypeDefault, "concur vocalist rotten busload gap quote stinging undiluted surfer goofiness deviation starved") buffer := bytes.NewBuffer([]byte{}) buffer.Write(util.ConvertUint32ToBytes(1)) diff --git a/api/handler/nodeHardwareHandler.go b/api/handler/nodeHardwareHandler.go new file mode 100644 index 000000000..970978565 --- /dev/null +++ b/api/handler/nodeHardwareHandler.go @@ -0,0 +1,33 @@ +package handler + +import ( + "github.com/zoobc/zoobc-core/api/service" + rpcService "github.com/zoobc/zoobc-core/common/service" + "io" +) + +type NodeHardwareHandler struct { + Service service.NodeHardwareServiceInterface +} + +func (nhh *NodeHardwareHandler) GetNodeHardware( + stream rpcService.NodeHardwareService_GetNodeHardwareServer, +) error { + for { + in, err := stream.Recv() + if err == io.EOF { + return nil + } + if in == nil { + return nil + } + nodeHardware, err := nhh.Service.GetNodeHardware(in) + if err != nil { + return err + } + err = stream.Send(nodeHardware) + if err != nil { + return err + } + } +} diff --git a/api/service/nodeHardwareApiService.go b/api/service/nodeHardwareApiService.go new file mode 100644 index 000000000..db47c1e19 --- /dev/null +++ b/api/service/nodeHardwareApiService.go @@ -0,0 +1,131 @@ +package service + +import ( + "github.com/shirou/gopsutil/cpu" + "github.com/shirou/gopsutil/disk" + "github.com/shirou/gopsutil/host" + "github.com/shirou/gopsutil/mem" + "github.com/zoobc/zoobc-core/common/blocker" + "github.com/zoobc/zoobc-core/common/crypto" + "github.com/zoobc/zoobc-core/common/model" + "runtime" +) + +type ( + NodeHardwareServiceInterface interface { + GetNodeHardware(request *model.GetNodeHardwareRequest) (*model.GetNodeHardwareResponse, error) + } + + NodeHardwareService struct { + OwnerAccountAddress string + Signature crypto.SignatureInterface + } +) + +func NewNodeHardwareService( + ownerAccountAddress string, + signature crypto.SignatureInterface, +) *NodeHardwareService { + return &NodeHardwareService{ + OwnerAccountAddress: ownerAccountAddress, + Signature: signature, + } +} + +func (nhs *NodeHardwareService) GetNodeHardware(request *model.GetNodeHardwareRequest) (*model.GetNodeHardwareResponse, error) { + var ( + nodeHardware *model.NodeHardware + cpuStats []*model.CPUInformation + err error + diskStat *disk.UsageStat + ) + + runtimeOS := runtime.GOOS + // memory + vmStat, err := mem.VirtualMemory() + if err != nil { + return nil, blocker.NewBlocker( + blocker.ServerError, + err.Error(), + ) + } + if runtimeOS == "windows" { + diskStat, err = disk.Usage("\\") + } else { + diskStat, err = disk.Usage("/") + } + if err != nil { + return nil, blocker.NewBlocker( + blocker.ServerError, + err.Error(), + ) + } + // host or machine kernel, uptime, platform Info + hostStat, err := host.Info() + if err != nil { + return nil, blocker.NewBlocker( + blocker.ServerError, + err.Error(), + ) + } + // cpu - get CPU number of cores and speed + cpuStat, err := cpu.Info() + if err != nil { + return nil, blocker.NewBlocker( + blocker.ServerError, + err.Error(), + ) + } + percentage, err := cpu.Percent(0, true) + if err != nil { + return nil, blocker.NewBlocker( + blocker.ServerError, + err.Error(), + ) + } + // host or machine kernel, uptime, platform Info + for i := 0; i < len(cpuStat); i++ { + cpuStats = append(cpuStats, &model.CPUInformation{ + Family: cpuStat[i].Family, + CPUIndex: cpuStat[i].CPU, + ModelName: cpuStat[i].ModelName, + VendorId: cpuStat[i].VendorID, + Mhz: cpuStat[i].Mhz, + CacheSize: cpuStat[i].CacheSize, + UsedPercent: percentage[i], + Cores: cpuStat[i].Cores, + CoreID: cpuStat[i].CoreID, + }) + + } + nodeHardware = &model.NodeHardware{ + CPUInformation: cpuStats, + MemoryInformation: &model.MemoryInformation{ + Total: vmStat.Total, + Free: vmStat.Free, + Available: vmStat.Available, + Used: vmStat.Used, + UsedPercent: vmStat.UsedPercent, + }, + StorageInformation: &model.StorageInformation{ + FsType: diskStat.Fstype, + Total: diskStat.Total, + Free: diskStat.Free, + Used: diskStat.Used, + UsedPercent: diskStat.UsedPercent, + }, + HostInformation: &model.HostInformation{ + Uptime: hostStat.Uptime, + OS: hostStat.OS, + Platform: hostStat.Platform, + PlatformFamily: hostStat.PlatformFamily, + PlatformVersion: hostStat.PlatformVersion, + NumberOfRunningProcess: hostStat.Procs, + HostID: hostStat.HostID, + HostName: hostStat.Hostname, + }, + } + return &model.GetNodeHardwareResponse{ + NodeHardware: nodeHardware, + }, nil +} diff --git a/api/service/nodeHardwareApiService_test.go b/api/service/nodeHardwareApiService_test.go new file mode 100644 index 000000000..f5aceca7f --- /dev/null +++ b/api/service/nodeHardwareApiService_test.go @@ -0,0 +1,43 @@ +package service + +import ( + "github.com/zoobc/zoobc-core/common/crypto" + "reflect" + "testing" +) + +var ( + mockSignature = crypto.NewSignature() + mockOwnerAddress = "BCZEGOb3WNx3fDOVf9ZS4EjvOIv_UeW4TVBQJ_6tHKlE" +) + +func TestNewNodeHardwareService(t *testing.T) { + type args struct { + ownerAccountAddress string + signature crypto.SignatureInterface + } + tests := []struct { + name string + args args + want *NodeHardwareService + }{ + { + name: "NewNodeHardwareService:success", + args: args{ + ownerAccountAddress: mockOwnerAddress, + signature: mockSignature, + }, + want: &NodeHardwareService{ + OwnerAccountAddress: mockOwnerAddress, + Signature: mockSignature, + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := NewNodeHardwareService(tt.args.ownerAccountAddress, tt.args.signature); !reflect.DeepEqual(got, tt.want) { + t.Errorf("NewNodeHardwareService() = %v, want %v", got, tt.want) + } + }) + } +} diff --git a/cmd/transaction/transactionGenerator.go b/cmd/transaction/transactionGenerator.go index 12071db4a..9f457232f 100644 --- a/cmd/transaction/transactionGenerator.go +++ b/cmd/transaction/transactionGenerator.go @@ -3,6 +3,7 @@ package transaction import ( "encoding/hex" "fmt" + "github.com/zoobc/zoobc-core/common/constant" "time" "github.com/zoobc/zoobc-core/common/transaction" @@ -40,7 +41,7 @@ func GenerateTransactionBytes(logger *logrus.Logger, unsignedTxBytes, _ := util.GetTransactionBytes(tx, false) tx.Signature = signature.Sign( unsignedTxBytes, - tx.SenderAccountAddress, + constant.NodeSignatureTypeDefault, seed, ) signedTxBytes, _ := util.GetTransactionBytes(tx, true) diff --git a/common/blocker/blocker.go b/common/blocker/blocker.go index 724464301..7e3bc9b0b 100644 --- a/common/blocker/blocker.go +++ b/common/blocker/blocker.go @@ -19,6 +19,7 @@ var ( AppErr TypeBlocker = "AppErr" AuthErr TypeBlocker = "AuthErr" ValidationErr TypeBlocker = "ValidationErr" + ServerError TypeBlocker = "ServerError" ) func NewBlocker(typeBlocker TypeBlocker, message string) error { diff --git a/common/constant/fieldsSize.go b/common/constant/fieldsSize.go index 6d1947b45..73ee74268 100644 --- a/common/constant/fieldsSize.go +++ b/common/constant/fieldsSize.go @@ -18,7 +18,10 @@ var ( TransactionBodyLength uint32 = 4 // AccountSignature TODO: this is valid for signatures using Ed25519. in future we might have more implementations AccountSignature uint32 = 64 - + // SignatureType variables + SignatureType uint32 = 4 + AuthRequestType = 4 + AuthTimestamp = 8 // DatasetPropertyLength is max length of string property name in dataset DatasetPropertyLength uint32 = 4 // DatasetValueLength is max length of string property value in dataset diff --git a/common/crypto/nodeAdmin.go b/common/crypto/nodeAdmin.go new file mode 100644 index 000000000..0f071df6a --- /dev/null +++ b/common/crypto/nodeAdmin.go @@ -0,0 +1,56 @@ +package crypto + +import ( + "bytes" + "encoding/hex" + "github.com/zoobc/zoobc-core/common/blocker" + "github.com/zoobc/zoobc-core/common/constant" + "github.com/zoobc/zoobc-core/common/model" + "github.com/zoobc/zoobc-core/common/util" +) + +var LastRequestTimestamp uint64 + +// VerifyAuthAPI verify the request body and the signature of the request message, checking include +// request type checking, and the validity of the signature to the owner address +// return nil if valid, and Blocker object otherwise +func VerifyAuthAPI( + ownerAddress, + auth string, + requestType model.RequestType) error { + // parse + var ( + authRequestType int32 + authTimestamp uint64 + ) + signature := NewSignature() + authBytes, err := hex.DecodeString(auth) + if err != nil { + return err + } + authBytesBuffer := bytes.NewBuffer(authBytes) + authRequestType = int32(util.ConvertBytesToUint32(authBytesBuffer.Next(constant.AuthRequestType))) + authTimestamp = util.ConvertBytesToUint64(authBytesBuffer.Next(constant.AuthTimestamp)) + if authRequestType != int32(requestType) { + return blocker.NewBlocker( + blocker.RequestParameterErr, + "invalid request type", + ) + } + if authTimestamp <= LastRequestTimestamp { + return blocker.NewBlocker( + blocker.ValidationErr, + "timestamp is in the past", + ) + } + LastRequestTimestamp = authTimestamp + signatureValid := signature.VerifySignature( + authBytes[:constant.AuthRequestType+constant.AuthTimestamp], + authBytes[constant.AuthRequestType+constant.AuthTimestamp:], + ownerAddress, + ) + if !signatureValid { + return blocker.NewBlocker(blocker.ValidationErr, "request signature invalid") + } + return nil +} diff --git a/common/crypto/nodeAdmin_test.go b/common/crypto/nodeAdmin_test.go new file mode 100644 index 000000000..6056b6694 --- /dev/null +++ b/common/crypto/nodeAdmin_test.go @@ -0,0 +1,116 @@ +package crypto + +import ( + "bytes" + "encoding/hex" + "github.com/zoobc/zoobc-core/common/constant" + "github.com/zoobc/zoobc-core/common/model" + "github.com/zoobc/zoobc-core/common/util" + "testing" +) + +var ( + mockOwnerAddress = "BCZEGOb3WNx3fDOVf9ZS4EjvOIv_UeW4TVBQJ_6tHKlE" + mockOwnerSeed = "concur vocalist rotten busload gap quote stinging undiluted surfer goofiness deviation starved" + mockValidAuth, + mockInvalidTimestampAuth, + mockInvalidRequestTypeAuth, + mockInvalidSignatureAuth string +) + +func setupVerifyAuthAPI() { + var ( + bufferValid *bytes.Buffer + bufferInvalidTimestamp *bytes.Buffer + bufferInvalidRequestType *bytes.Buffer + ) + bufferValid = bytes.NewBuffer([]byte{}) + bufferInvalidRequestType = bytes.NewBuffer([]byte{}) + bufferInvalidTimestamp = bytes.NewBuffer([]byte{}) + bufferValid.Write(util.ConvertUint32ToBytes(0)) + bufferValid.Write(util.ConvertUint64ToBytes(10000)) + bufferInvalidRequestType.Write(util.ConvertUint32ToBytes(10000)) + bufferInvalidRequestType.Write(util.ConvertUint64ToBytes(10000)) + bufferInvalidTimestamp.Write(util.ConvertUint32ToBytes(0)) + bufferInvalidTimestamp.Write(util.ConvertUint64ToBytes(0)) + validSignature := (&Signature{}).Sign( + bufferValid.Bytes(), + constant.NodeSignatureTypeDefault, + mockOwnerSeed, + ) + bufferValid.Write(validSignature) + mockValidAuth = hex.EncodeToString(bufferValid.Bytes()) + bufferValid.Write([]byte{1, 2}) + mockInvalidSignatureAuth = hex.EncodeToString(bufferValid.Bytes()) + mockInvalidTimestampAuth = hex.EncodeToString(bufferInvalidTimestamp.Bytes()) + mockInvalidRequestTypeAuth = hex.EncodeToString(bufferInvalidRequestType.Bytes()) +} + +func TestVerifyAuthAPI(t *testing.T) { + setupVerifyAuthAPI() + type args struct { + ownerAddress string + auth string + requestType model.RequestType + } + tests := []struct { + name string + args args + wantErr bool + }{ + { + name: "VerifyAuthAPI:fail-invalid-auth", + args: args{ + ownerAddress: "", + auth: "XXXX", + requestType: 0, + }, + wantErr: true, + }, + { + name: "VerifyAuthAPI:fail-invalid-requestType", + args: args{ + ownerAddress: "", + auth: mockInvalidRequestTypeAuth, + requestType: 0, + }, + wantErr: true, + }, + { + name: "VerifyAuthAPI:fail-invalid-timestamp", + args: args{ + ownerAddress: "", + auth: mockInvalidTimestampAuth, + requestType: 0, + }, + wantErr: true, + }, + { + name: "VerifyAuthAPI:fail-invalid-signature", + args: args{ + ownerAddress: mockOwnerAddress, + auth: mockInvalidSignatureAuth, + requestType: 0, + }, + wantErr: true, + }, + { + name: "VerifyAuthAPI:success", + args: args{ + ownerAddress: mockOwnerAddress, + auth: mockValidAuth, + requestType: 0, + }, + wantErr: false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if err := VerifyAuthAPI(tt.args.ownerAddress, tt.args.auth, + tt.args.requestType); (err != nil) != tt.wantErr { + t.Errorf("VerifyAuthAPI() error = %v, wantErr %v", err, tt.wantErr) + } + LastRequestTimestamp = 0 + }) + } +} diff --git a/common/crypto/signature.go b/common/crypto/signature.go index 52f07e89e..3c510f6ae 100644 --- a/common/crypto/signature.go +++ b/common/crypto/signature.go @@ -10,7 +10,7 @@ import ( type ( SignatureInterface interface { - Sign(payload []byte, accountAddress, seed string) []byte + Sign(payload []byte, signatureType uint32, seed string) []byte SignByNode(payload []byte, nodeSeed string) []byte VerifySignature(payload, signature []byte, accountAddress string) bool } @@ -27,10 +27,21 @@ func NewSignature() *Signature { // Sign accept account ID and payload to be signed then return the signature byte based on the // signature method associated with account.Type -func (sig *Signature) Sign(payload []byte, accountAddress, seed string) []byte { - accountPrivateKey := ed25519GetPrivateKeyFromSeed(seed) - signature := ed25519.Sign(accountPrivateKey, payload) - return signature +func (sig *Signature) Sign(payload []byte, signatureType uint32, seed string) []byte { + buffer := bytes.NewBuffer([]byte{}) + buffer.Write(util.ConvertUint32ToBytes(signatureType)) + switch signatureType { + case 0: + accountPrivateKey := ed25519GetPrivateKeyFromSeed(seed) + signature := ed25519.Sign(accountPrivateKey, payload) + buffer.Write(signature) + return buffer.Bytes() + default: + accountPrivateKey := ed25519GetPrivateKeyFromSeed(seed) + signature := ed25519.Sign(accountPrivateKey, payload) + buffer.Write(signature) + return buffer.Bytes() + } } // SignByNode special method for signing block only, there will be no multiple signature options diff --git a/common/crypto/signature_test.go b/common/crypto/signature_test.go index 1d736e915..20c8fad50 100644 --- a/common/crypto/signature_test.go +++ b/common/crypto/signature_test.go @@ -1,6 +1,7 @@ package crypto import ( + "github.com/zoobc/zoobc-core/common/constant" "reflect" "testing" ) @@ -26,9 +27,9 @@ func TestNewSignature(t *testing.T) { func TestSignature_Sign(t *testing.T) { type args struct { - payload []byte - accountAddress string - seed string + payload []byte + signatureType uint32 + seed string } tests := []struct { name string @@ -38,22 +39,22 @@ func TestSignature_Sign(t *testing.T) { { name: "Sign:valid", args: args{ - payload: []byte{12, 43, 65, 65, 12, 123, 43, 12, 1, 24, 5, 5, 12, 54}, - accountAddress: "BCZEGOb3WNx3fDOVf9ZS4EjvOIv_UeW4TVBQJ_6tHKlE", - seed: "concur vocalist rotten busload gap quote stinging undiluted surfer goofiness deviation starved", + payload: []byte{12, 43, 65, 65, 12, 123, 43, 12, 1, 24, 5, 5, 12, 54}, + signatureType: constant.NodeSignatureTypeDefault, + seed: "concur vocalist rotten busload gap quote stinging undiluted surfer goofiness deviation starved", }, - want: []byte{42, 62, 47, 200, 180, 101, 85, 204, 179, 147, 143, 68, 30, 111, 6, 94, 81, 248, 219, 43, 90, 6, 167, + want: []byte{0, 0, 0, 0, 42, 62, 47, 200, 180, 101, 85, 204, 179, 147, 143, 68, 30, 111, 6, 94, 81, 248, 219, 43, 90, 6, 167, 45, 132, 96, 130, 0, 153, 244, 159, 137, 159, 113, 78, 9, 164, 154, 213, 255, 17, 206, 153, 156, 176, 206, 33, 103, 72, 182, 228, 148, 234, 15, 176, 243, 50, 221, 106, 152, 53, 54, 173, 15}, }, { name: "Sign:valid-{default type}", args: args{ - payload: []byte{12, 43, 65, 65, 12, 123, 43, 12, 1, 24, 5, 5, 12, 54}, - accountAddress: "BCZEGOb3WNx3fDOVf9ZS4EjvOIv_UeW4TVBQJ_6tHKlE", - seed: "concur vocalist rotten busload gap quote stinging undiluted surfer goofiness deviation starved", + payload: []byte{12, 43, 65, 65, 12, 123, 43, 12, 1, 24, 5, 5, 12, 54}, + signatureType: 1011, + seed: "concur vocalist rotten busload gap quote stinging undiluted surfer goofiness deviation starved", }, - want: []byte{42, 62, 47, 200, 180, 101, 85, 204, 179, 147, 143, 68, 30, 111, 6, 94, 81, 248, 219, 43, 90, 6, 167, + want: []byte{243, 3, 0, 0, 42, 62, 47, 200, 180, 101, 85, 204, 179, 147, 143, 68, 30, 111, 6, 94, 81, 248, 219, 43, 90, 6, 167, 45, 132, 96, 130, 0, 153, 244, 159, 137, 159, 113, 78, 9, 164, 154, 213, 255, 17, 206, 153, 156, 176, 206, 33, 103, 72, 182, 228, 148, 234, 15, 176, 243, 50, 221, 106, 152, 53, 54, 173, 15}, }, @@ -61,7 +62,7 @@ func TestSignature_Sign(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { s := &Signature{} - got := s.Sign(tt.args.payload, tt.args.accountAddress, tt.args.seed) + got := s.Sign(tt.args.payload, tt.args.signatureType, tt.args.seed) if !reflect.DeepEqual(got, tt.want) { t.Errorf("Signature.Sign() = %v, want %v", got, tt.want) } diff --git a/common/util/interceptor.go b/common/interceptor/interceptor.go similarity index 64% rename from common/util/interceptor.go rename to common/interceptor/interceptor.go index 6766504c1..47a9c0c50 100644 --- a/common/util/interceptor.go +++ b/common/interceptor/interceptor.go @@ -1,8 +1,12 @@ -package util +package interceptor import ( "context" "fmt" + "github.com/zoobc/zoobc-core/common/blocker" + "github.com/zoobc/zoobc-core/common/crypto" + "github.com/zoobc/zoobc-core/common/model" + "google.golang.org/grpc/metadata" "runtime" "time" @@ -114,3 +118,54 @@ func NewClientInterceptor(logger *logrus.Logger) grpc.UnaryClientInterceptor { } } + +/* +NewStreamInterceptor +validate request against the destination service and the signature with the node owner +*/ +func NewStreamInterceptor(ownerAddress string) grpc.StreamServerInterceptor { + return func( + srv interface{}, ss grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler, + ) error { + var ( + errHandler error + requestType model.RequestType + ) + switch info.FullMethod { + case "/service.NodeHardwareService/GetNodeHardware": + requestType = model.RequestType_GetNodeHardware + default: + // unprotected service, by pass the auth checking + requestType = -1 + } + md, ok := metadata.FromIncomingContext(ss.Context()) + if !ok { + return blocker.NewBlocker( + blocker.AuthErr, + "metadata not provided", + ) + } + authSlice := md.Get("authorization") + if authSlice == nil { + return blocker.NewBlocker( + blocker.AuthErr, + "authorization metadata not provided", + ) + } + if requestType > -1 { + // validate request + // todo: this is verifying against whatever owner address is in the config file, update this + // todo: to follow how `claim` node work. + err := crypto.VerifyAuthAPI( + ownerAddress, + authSlice[0], + requestType) + if err != nil { + return err + } + } + + errHandler = handler(srv, ss) + return errHandler + } +} diff --git a/common/interceptor/interceptor_test.go b/common/interceptor/interceptor_test.go new file mode 100644 index 000000000..1f920f912 --- /dev/null +++ b/common/interceptor/interceptor_test.go @@ -0,0 +1,323 @@ +package interceptor + +import ( + "bytes" + "context" + "encoding/hex" + "github.com/google/go-cmp/cmp" + "github.com/sirupsen/logrus" + "github.com/zoobc/zoobc-core/common/constant" + "github.com/zoobc/zoobc-core/common/crypto" + rpcModel "github.com/zoobc/zoobc-core/common/model" + "github.com/zoobc/zoobc-core/common/util" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/metadata" + "google.golang.org/grpc/status" + "testing" + "time" +) + +var ( + mockOwnerAddress = "BCZEGOb3WNx3fDOVf9ZS4EjvOIv_UeW4TVBQJ_6tHKlE" + mockOwnerSeed = "concur vocalist rotten busload gap quote stinging undiluted surfer goofiness deviation starved" +) + +type ( + mockServerStreamSuccess struct{} + mockServerStreamNoAuth struct { + mockServerStreamSuccess + } + mockServerStreamNoMetadata struct { + mockServerStreamSuccess + } + mockServerStreamInvalidAuth struct { + mockServerStreamSuccess + } +) + +func (*mockServerStreamSuccess) SetHeader(metadata.MD) error { return nil } +func (*mockServerStreamSuccess) SendHeader(metadata.MD) error { return nil } +func (*mockServerStreamSuccess) SetTrailer(metadata.MD) {} +func (*mockServerStreamSuccess) Context() context.Context { + currentTime := uint64(time.Now().Unix()) + buffer := bytes.NewBuffer([]byte{}) + buffer.Write(util.ConvertUint32ToBytes(uint32(rpcModel.RequestType_GetNodeHardware))) + buffer.Write(util.ConvertUint64ToBytes(currentTime)) + sig := (crypto.NewSignature()).Sign( + buffer.Bytes(), + constant.NodeSignatureTypeDefault, + mockOwnerSeed, + ) + buffer.Write(sig) + ctx := context.Background() + md := metadata.Pairs("authorization", hex.EncodeToString(buffer.Bytes())) + ctx = metadata.NewIncomingContext(ctx, md) + return ctx +} +func (*mockServerStreamSuccess) SendMsg(m interface{}) error { return nil } +func (*mockServerStreamSuccess) RecvMsg(m interface{}) error { return nil } + +func (*mockServerStreamNoAuth) Context() context.Context { + ctx := context.Background() + md := metadata.Pairs("foo", "bar") + ctx = metadata.NewIncomingContext(ctx, md) + return ctx +} + +func (*mockServerStreamNoMetadata) Context() context.Context { + ctx := context.Background() + return ctx +} + +func (*mockServerStreamInvalidAuth) Context() context.Context { + // sign with invalid request type parameter + currentTime := uint64(time.Now().Unix()) + buffer := bytes.NewBuffer([]byte{}) + buffer.Write(util.ConvertUint32ToBytes(uint32(1435))) + buffer.Write(util.ConvertUint64ToBytes(currentTime)) + sig := (crypto.NewSignature()).Sign( + buffer.Bytes(), + constant.NodeSignatureTypeDefault, + mockOwnerSeed, + ) + buffer.Write(sig) + ctx := context.Background() + md := metadata.Pairs("authorization", hex.EncodeToString(buffer.Bytes())) + ctx = metadata.NewIncomingContext(ctx, md) + return ctx +} + +func TestNewServerInterceptor(t *testing.T) { + type args struct { + logger *logrus.Logger + } + tests := []struct { + name string + args args + want grpc.UnaryServerInterceptor + wantRecover bool + }{ + { + name: "wantRecover", + args: args{ + logger: logrus.New(), + }, + want: func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) { + return nil, status.Errorf(codes.Internal, "there's something wrong") + }, + wantRecover: true, + }, + { + name: "wantNotRecover", + args: args{ + logger: logrus.New(), + }, + want: func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) { + return nil, status.Errorf(codes.Internal, "there's something wrong") + }, + wantRecover: false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got := NewServerInterceptor(tt.args.logger) + if cmp.Equal(got, tt.want) { + t.Errorf("NewInterceptor() = %v, want %v", got, tt.want) + } + testServerInterceptor(got, tt.wantRecover) + }) + } +} + +func testServerInterceptor(fn grpc.UnaryServerInterceptor, wantRecover bool) { + var ( + handler grpc.UnaryHandler + ) + if wantRecover { + handler = func(ctx context.Context, req interface{}) (resp interface{}, err error) { + panic(handler) + } + } else { + handler = func(ctx context.Context, req interface{}) (resp interface{}, err error) { + return nil, status.Errorf(codes.Internal, "there's something wrong") + } + } + _, _ = fn(context.Background(), nil, &grpc.UnaryServerInfo{}, handler) +} + +func TestNewClientInterceptor(t *testing.T) { + type args struct { + logger *logrus.Logger + } + tests := []struct { + name string + args args + want grpc.UnaryClientInterceptor + wantRecover bool + }{ + { + name: "wantRecover", + args: args{ + logger: logrus.New(), + }, + want: func( + ctx context.Context, + method string, + req, reply interface{}, + cc *grpc.ClientConn, + invoker grpc.UnaryInvoker, + opts ...grpc.CallOption) error { + return status.Errorf(codes.Internal, "there's something wrong") + }, + wantRecover: false, + }, + { + name: "wantRecover", + args: args{ + logger: logrus.New(), + }, + want: func( + ctx context.Context, + method string, + req, reply interface{}, + cc *grpc.ClientConn, + invoker grpc.UnaryInvoker, + opts ...grpc.CallOption) error { + return status.Errorf(codes.Internal, "there's something wrong") + }, + wantRecover: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got := NewClientInterceptor(tt.args.logger) + if cmp.Equal(got, tt.want) { + t.Errorf("NewClientInterceptor() = %v, want %v", got, tt.want) + } + testClientInterceptor(got, tt.wantRecover) + }) + } +} + +func testClientInterceptor(fn grpc.UnaryClientInterceptor, wantRecover bool) { + var ( + invoker grpc.UnaryInvoker + ) + if wantRecover { + invoker = func(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, opts ...grpc.CallOption) error { + panic(invoker) + } + } else { + invoker = func(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, opts ...grpc.CallOption) error { + return status.Errorf(codes.Internal, "there's something wrong") + } + } + + cc, _ := grpc.Dial("127.0.0.1:8001", grpc.WithInsecure()) + _ = fn(context.Background(), "testMethod", nil, nil, cc, invoker, nil) + +} + +func TestNewNodeAdminAuthStreamInterceptor(t *testing.T) { + + type args struct { + ownerAddress string + fullMethod string + handler grpc.StreamHandler + serverStream grpc.ServerStream + } + tests := []struct { + name string + args args + want grpc.StreamServerInterceptor + wantInnerErr bool + }{ + { + name: "wantErr:noMetadata", + args: args{ + ownerAddress: mockOwnerAddress, + fullMethod: "/service.NodeHardwareService/GetNodeHardware", + serverStream: &mockServerStreamNoMetadata{}, + }, + want: func(srv interface{}, ss grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) (err error) { + return nil + }, + wantInnerErr: true, + }, + { + name: "wantErr:noAuth", + args: args{ + ownerAddress: mockOwnerAddress, + fullMethod: "/service.NodeHardwareService/GetNodeHardware", + serverStream: &mockServerStreamNoAuth{}, + }, + want: func(srv interface{}, ss grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) (err error) { + return nil + }, + wantInnerErr: true, + }, + { + name: "wantSuccess:GetNodeHardware", + args: args{ + ownerAddress: mockOwnerAddress, + fullMethod: "/service.NodeHardwareService/GetNodeHardware", + serverStream: &mockServerStreamSuccess{}, + handler: func(srv interface{}, stream grpc.ServerStream) error { + return nil + }, + }, + want: func(srv interface{}, ss grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) (err error) { + return nil + }, + wantInnerErr: false, + }, + { + name: "wantFail:invalidSignature", + args: args{ + ownerAddress: mockOwnerAddress, + fullMethod: "/service.NodeHardwareService/GetNodeHardware", + serverStream: &mockServerStreamInvalidAuth{}, + handler: func(srv interface{}, stream grpc.ServerStream) error { + return nil + }, + }, + want: func(srv interface{}, ss grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) (err error) { + return nil + }, + wantInnerErr: true, + }, + { + name: "wantSuccess:unprotectedService", + args: args{ + ownerAddress: mockOwnerAddress, + fullMethod: "/nonProtectedService", + serverStream: &mockServerStreamSuccess{}, + handler: func(srv interface{}, stream grpc.ServerStream) error { + return nil + }, + }, + want: func(srv interface{}, ss grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) (err error) { + return nil + }, + wantInnerErr: false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got := NewStreamInterceptor(tt.args.ownerAddress) + if cmp.Equal(got, tt.want) { + t.Errorf("NewInterceptor() = %v, want %v", got, tt.want) + } + info := &grpc.StreamServerInfo{ + FullMethod: tt.args.fullMethod, + IsClientStream: true, + IsServerStream: true, + } + err := got(nil, tt.args.serverStream, info, tt.args.handler) + if err != nil && tt.wantInnerErr != true { + t.Error("unexpected error occurred") + } + }) + } +} diff --git a/common/model/auth.pb.go b/common/model/auth.pb.go new file mode 100644 index 000000000..4e625181a --- /dev/null +++ b/common/model/auth.pb.go @@ -0,0 +1,62 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: model/auth.proto + +package model + +import ( + fmt "fmt" + proto "github.com/golang/protobuf/proto" + math "math" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package + +// RequestType used to sign a node administration request +type RequestType int32 + +const ( + RequestType_GetNodeHardware RequestType = 0 +) + +var RequestType_name = map[int32]string{ + 0: "GetNodeHardware", +} + +var RequestType_value = map[string]int32{ + "GetNodeHardware": 0, +} + +func (x RequestType) String() string { + return proto.EnumName(RequestType_name, int32(x)) +} + +func (RequestType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_50b87fa4d1f0d790, []int{0} +} + +func init() { + proto.RegisterEnum("model.RequestType", RequestType_name, RequestType_value) +} + +func init() { proto.RegisterFile("model/auth.proto", fileDescriptor_50b87fa4d1f0d790) } + +var fileDescriptor_50b87fa4d1f0d790 = []byte{ + // 124 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0xc8, 0xcd, 0x4f, 0x49, + 0xcd, 0xd1, 0x4f, 0x2c, 0x2d, 0xc9, 0xd0, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x05, 0x8b, + 0x68, 0x29, 0x71, 0x71, 0x07, 0xa5, 0x16, 0x96, 0xa6, 0x16, 0x97, 0x84, 0x54, 0x16, 0xa4, 0x0a, + 0x09, 0x73, 0xf1, 0xbb, 0xa7, 0x96, 0xf8, 0xe5, 0xa7, 0xa4, 0x7a, 0x24, 0x16, 0xa5, 0x94, 0x27, + 0x16, 0xa5, 0x0a, 0x30, 0x38, 0x69, 0x45, 0x69, 0xa4, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, + 0xe7, 0xe7, 0xea, 0x57, 0xe5, 0xe7, 0x27, 0x25, 0x43, 0x48, 0xdd, 0xe4, 0xfc, 0xa2, 0x54, 0xfd, + 0xe4, 0xfc, 0xdc, 0xdc, 0xfc, 0x3c, 0x7d, 0xb0, 0x79, 0x49, 0x6c, 0x60, 0xd3, 0x8d, 0x01, 0x01, + 0x00, 0x00, 0xff, 0xff, 0x81, 0xae, 0x54, 0x43, 0x71, 0x00, 0x00, 0x00, +} diff --git a/common/model/nodeHardware.pb.go b/common/model/nodeHardware.pb.go new file mode 100644 index 000000000..bf440768b --- /dev/null +++ b/common/model/nodeHardware.pb.go @@ -0,0 +1,559 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: model/nodeHardware.proto + +package model + +import ( + fmt "fmt" + proto "github.com/golang/protobuf/proto" + math "math" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package + +type GetNodeHardwareResponse struct { + NodeHardware *NodeHardware `protobuf:"bytes,1,opt,name=NodeHardware,proto3" json:"NodeHardware,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GetNodeHardwareResponse) Reset() { *m = GetNodeHardwareResponse{} } +func (m *GetNodeHardwareResponse) String() string { return proto.CompactTextString(m) } +func (*GetNodeHardwareResponse) ProtoMessage() {} +func (*GetNodeHardwareResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_ce967b26533b171c, []int{0} +} + +func (m *GetNodeHardwareResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_GetNodeHardwareResponse.Unmarshal(m, b) +} +func (m *GetNodeHardwareResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_GetNodeHardwareResponse.Marshal(b, m, deterministic) +} +func (m *GetNodeHardwareResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetNodeHardwareResponse.Merge(m, src) +} +func (m *GetNodeHardwareResponse) XXX_Size() int { + return xxx_messageInfo_GetNodeHardwareResponse.Size(m) +} +func (m *GetNodeHardwareResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GetNodeHardwareResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_GetNodeHardwareResponse proto.InternalMessageInfo + +func (m *GetNodeHardwareResponse) GetNodeHardware() *NodeHardware { + if m != nil { + return m.NodeHardware + } + return nil +} + +type GetNodeHardwareRequest struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GetNodeHardwareRequest) Reset() { *m = GetNodeHardwareRequest{} } +func (m *GetNodeHardwareRequest) String() string { return proto.CompactTextString(m) } +func (*GetNodeHardwareRequest) ProtoMessage() {} +func (*GetNodeHardwareRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_ce967b26533b171c, []int{1} +} + +func (m *GetNodeHardwareRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_GetNodeHardwareRequest.Unmarshal(m, b) +} +func (m *GetNodeHardwareRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_GetNodeHardwareRequest.Marshal(b, m, deterministic) +} +func (m *GetNodeHardwareRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetNodeHardwareRequest.Merge(m, src) +} +func (m *GetNodeHardwareRequest) XXX_Size() int { + return xxx_messageInfo_GetNodeHardwareRequest.Size(m) +} +func (m *GetNodeHardwareRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GetNodeHardwareRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_GetNodeHardwareRequest proto.InternalMessageInfo + +type NodeHardware struct { + CPUInformation []*CPUInformation `protobuf:"bytes,1,rep,name=CPUInformation,proto3" json:"CPUInformation,omitempty"` + MemoryInformation *MemoryInformation `protobuf:"bytes,2,opt,name=MemoryInformation,proto3" json:"MemoryInformation,omitempty"` + StorageInformation *StorageInformation `protobuf:"bytes,3,opt,name=StorageInformation,proto3" json:"StorageInformation,omitempty"` + HostInformation *HostInformation `protobuf:"bytes,4,opt,name=HostInformation,proto3" json:"HostInformation,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *NodeHardware) Reset() { *m = NodeHardware{} } +func (m *NodeHardware) String() string { return proto.CompactTextString(m) } +func (*NodeHardware) ProtoMessage() {} +func (*NodeHardware) Descriptor() ([]byte, []int) { + return fileDescriptor_ce967b26533b171c, []int{2} +} + +func (m *NodeHardware) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_NodeHardware.Unmarshal(m, b) +} +func (m *NodeHardware) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_NodeHardware.Marshal(b, m, deterministic) +} +func (m *NodeHardware) XXX_Merge(src proto.Message) { + xxx_messageInfo_NodeHardware.Merge(m, src) +} +func (m *NodeHardware) XXX_Size() int { + return xxx_messageInfo_NodeHardware.Size(m) +} +func (m *NodeHardware) XXX_DiscardUnknown() { + xxx_messageInfo_NodeHardware.DiscardUnknown(m) +} + +var xxx_messageInfo_NodeHardware proto.InternalMessageInfo + +func (m *NodeHardware) GetCPUInformation() []*CPUInformation { + if m != nil { + return m.CPUInformation + } + return nil +} + +func (m *NodeHardware) GetMemoryInformation() *MemoryInformation { + if m != nil { + return m.MemoryInformation + } + return nil +} + +func (m *NodeHardware) GetStorageInformation() *StorageInformation { + if m != nil { + return m.StorageInformation + } + return nil +} + +func (m *NodeHardware) GetHostInformation() *HostInformation { + if m != nil { + return m.HostInformation + } + return nil +} + +type CPUInformation struct { + Family string `protobuf:"bytes,1,opt,name=Family,proto3" json:"Family,omitempty"` + CPUIndex int32 `protobuf:"varint,2,opt,name=CPUIndex,proto3" json:"CPUIndex,omitempty"` + Model string `protobuf:"bytes,3,opt,name=Model,proto3" json:"Model,omitempty"` + ModelName string `protobuf:"bytes,4,opt,name=ModelName,proto3" json:"ModelName,omitempty"` + VendorId string `protobuf:"bytes,5,opt,name=VendorId,proto3" json:"VendorId,omitempty"` + Mhz float64 `protobuf:"fixed64,6,opt,name=Mhz,proto3" json:"Mhz,omitempty"` + CacheSize int32 `protobuf:"varint,7,opt,name=CacheSize,proto3" json:"CacheSize,omitempty"` + UsedPercent float64 `protobuf:"fixed64,8,opt,name=UsedPercent,proto3" json:"UsedPercent,omitempty"` + CoreID string `protobuf:"bytes,9,opt,name=CoreID,proto3" json:"CoreID,omitempty"` + Cores int32 `protobuf:"varint,10,opt,name=Cores,proto3" json:"Cores,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CPUInformation) Reset() { *m = CPUInformation{} } +func (m *CPUInformation) String() string { return proto.CompactTextString(m) } +func (*CPUInformation) ProtoMessage() {} +func (*CPUInformation) Descriptor() ([]byte, []int) { + return fileDescriptor_ce967b26533b171c, []int{3} +} + +func (m *CPUInformation) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_CPUInformation.Unmarshal(m, b) +} +func (m *CPUInformation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_CPUInformation.Marshal(b, m, deterministic) +} +func (m *CPUInformation) XXX_Merge(src proto.Message) { + xxx_messageInfo_CPUInformation.Merge(m, src) +} +func (m *CPUInformation) XXX_Size() int { + return xxx_messageInfo_CPUInformation.Size(m) +} +func (m *CPUInformation) XXX_DiscardUnknown() { + xxx_messageInfo_CPUInformation.DiscardUnknown(m) +} + +var xxx_messageInfo_CPUInformation proto.InternalMessageInfo + +func (m *CPUInformation) GetFamily() string { + if m != nil { + return m.Family + } + return "" +} + +func (m *CPUInformation) GetCPUIndex() int32 { + if m != nil { + return m.CPUIndex + } + return 0 +} + +func (m *CPUInformation) GetModel() string { + if m != nil { + return m.Model + } + return "" +} + +func (m *CPUInformation) GetModelName() string { + if m != nil { + return m.ModelName + } + return "" +} + +func (m *CPUInformation) GetVendorId() string { + if m != nil { + return m.VendorId + } + return "" +} + +func (m *CPUInformation) GetMhz() float64 { + if m != nil { + return m.Mhz + } + return 0 +} + +func (m *CPUInformation) GetCacheSize() int32 { + if m != nil { + return m.CacheSize + } + return 0 +} + +func (m *CPUInformation) GetUsedPercent() float64 { + if m != nil { + return m.UsedPercent + } + return 0 +} + +func (m *CPUInformation) GetCoreID() string { + if m != nil { + return m.CoreID + } + return "" +} + +func (m *CPUInformation) GetCores() int32 { + if m != nil { + return m.Cores + } + return 0 +} + +type HostInformation struct { + Uptime uint64 `protobuf:"varint,1,opt,name=Uptime,proto3" json:"Uptime,omitempty"` + OS string `protobuf:"bytes,2,opt,name=OS,proto3" json:"OS,omitempty"` + Platform string `protobuf:"bytes,3,opt,name=Platform,proto3" json:"Platform,omitempty"` + PlatformFamily string `protobuf:"bytes,4,opt,name=PlatformFamily,proto3" json:"PlatformFamily,omitempty"` + PlatformVersion string `protobuf:"bytes,5,opt,name=PlatformVersion,proto3" json:"PlatformVersion,omitempty"` + NumberOfRunningProcess uint64 `protobuf:"varint,6,opt,name=NumberOfRunningProcess,proto3" json:"NumberOfRunningProcess,omitempty"` + HostID string `protobuf:"bytes,7,opt,name=HostID,proto3" json:"HostID,omitempty"` + HostName string `protobuf:"bytes,8,opt,name=HostName,proto3" json:"HostName,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *HostInformation) Reset() { *m = HostInformation{} } +func (m *HostInformation) String() string { return proto.CompactTextString(m) } +func (*HostInformation) ProtoMessage() {} +func (*HostInformation) Descriptor() ([]byte, []int) { + return fileDescriptor_ce967b26533b171c, []int{4} +} + +func (m *HostInformation) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_HostInformation.Unmarshal(m, b) +} +func (m *HostInformation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_HostInformation.Marshal(b, m, deterministic) +} +func (m *HostInformation) XXX_Merge(src proto.Message) { + xxx_messageInfo_HostInformation.Merge(m, src) +} +func (m *HostInformation) XXX_Size() int { + return xxx_messageInfo_HostInformation.Size(m) +} +func (m *HostInformation) XXX_DiscardUnknown() { + xxx_messageInfo_HostInformation.DiscardUnknown(m) +} + +var xxx_messageInfo_HostInformation proto.InternalMessageInfo + +func (m *HostInformation) GetUptime() uint64 { + if m != nil { + return m.Uptime + } + return 0 +} + +func (m *HostInformation) GetOS() string { + if m != nil { + return m.OS + } + return "" +} + +func (m *HostInformation) GetPlatform() string { + if m != nil { + return m.Platform + } + return "" +} + +func (m *HostInformation) GetPlatformFamily() string { + if m != nil { + return m.PlatformFamily + } + return "" +} + +func (m *HostInformation) GetPlatformVersion() string { + if m != nil { + return m.PlatformVersion + } + return "" +} + +func (m *HostInformation) GetNumberOfRunningProcess() uint64 { + if m != nil { + return m.NumberOfRunningProcess + } + return 0 +} + +func (m *HostInformation) GetHostID() string { + if m != nil { + return m.HostID + } + return "" +} + +func (m *HostInformation) GetHostName() string { + if m != nil { + return m.HostName + } + return "" +} + +type MemoryInformation struct { + Total uint64 `protobuf:"varint,1,opt,name=Total,proto3" json:"Total,omitempty"` + // This is the kernel's notion of free memory; RAM chips whose bits nobody + // cares about the value of right now. For a human consumable number, + // Available is what you really want. + Free uint64 `protobuf:"varint,2,opt,name=Free,proto3" json:"Free,omitempty"` + // RAM available for programs to allocate + Available uint64 `protobuf:"varint,3,opt,name=Available,proto3" json:"Available,omitempty"` + Used uint64 `protobuf:"varint,4,opt,name=Used,proto3" json:"Used,omitempty"` + UsedPercent float64 `protobuf:"fixed64,5,opt,name=UsedPercent,proto3" json:"UsedPercent,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *MemoryInformation) Reset() { *m = MemoryInformation{} } +func (m *MemoryInformation) String() string { return proto.CompactTextString(m) } +func (*MemoryInformation) ProtoMessage() {} +func (*MemoryInformation) Descriptor() ([]byte, []int) { + return fileDescriptor_ce967b26533b171c, []int{5} +} + +func (m *MemoryInformation) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_MemoryInformation.Unmarshal(m, b) +} +func (m *MemoryInformation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_MemoryInformation.Marshal(b, m, deterministic) +} +func (m *MemoryInformation) XXX_Merge(src proto.Message) { + xxx_messageInfo_MemoryInformation.Merge(m, src) +} +func (m *MemoryInformation) XXX_Size() int { + return xxx_messageInfo_MemoryInformation.Size(m) +} +func (m *MemoryInformation) XXX_DiscardUnknown() { + xxx_messageInfo_MemoryInformation.DiscardUnknown(m) +} + +var xxx_messageInfo_MemoryInformation proto.InternalMessageInfo + +func (m *MemoryInformation) GetTotal() uint64 { + if m != nil { + return m.Total + } + return 0 +} + +func (m *MemoryInformation) GetFree() uint64 { + if m != nil { + return m.Free + } + return 0 +} + +func (m *MemoryInformation) GetAvailable() uint64 { + if m != nil { + return m.Available + } + return 0 +} + +func (m *MemoryInformation) GetUsed() uint64 { + if m != nil { + return m.Used + } + return 0 +} + +func (m *MemoryInformation) GetUsedPercent() float64 { + if m != nil { + return m.UsedPercent + } + return 0 +} + +type StorageInformation struct { + FsType string `protobuf:"bytes,1,opt,name=FsType,proto3" json:"FsType,omitempty"` + Total uint64 `protobuf:"varint,2,opt,name=Total,proto3" json:"Total,omitempty"` + Free uint64 `protobuf:"varint,3,opt,name=Free,proto3" json:"Free,omitempty"` + Used uint64 `protobuf:"varint,4,opt,name=Used,proto3" json:"Used,omitempty"` + UsedPercent float64 `protobuf:"fixed64,5,opt,name=UsedPercent,proto3" json:"UsedPercent,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *StorageInformation) Reset() { *m = StorageInformation{} } +func (m *StorageInformation) String() string { return proto.CompactTextString(m) } +func (*StorageInformation) ProtoMessage() {} +func (*StorageInformation) Descriptor() ([]byte, []int) { + return fileDescriptor_ce967b26533b171c, []int{6} +} + +func (m *StorageInformation) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_StorageInformation.Unmarshal(m, b) +} +func (m *StorageInformation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_StorageInformation.Marshal(b, m, deterministic) +} +func (m *StorageInformation) XXX_Merge(src proto.Message) { + xxx_messageInfo_StorageInformation.Merge(m, src) +} +func (m *StorageInformation) XXX_Size() int { + return xxx_messageInfo_StorageInformation.Size(m) +} +func (m *StorageInformation) XXX_DiscardUnknown() { + xxx_messageInfo_StorageInformation.DiscardUnknown(m) +} + +var xxx_messageInfo_StorageInformation proto.InternalMessageInfo + +func (m *StorageInformation) GetFsType() string { + if m != nil { + return m.FsType + } + return "" +} + +func (m *StorageInformation) GetTotal() uint64 { + if m != nil { + return m.Total + } + return 0 +} + +func (m *StorageInformation) GetFree() uint64 { + if m != nil { + return m.Free + } + return 0 +} + +func (m *StorageInformation) GetUsed() uint64 { + if m != nil { + return m.Used + } + return 0 +} + +func (m *StorageInformation) GetUsedPercent() float64 { + if m != nil { + return m.UsedPercent + } + return 0 +} + +func init() { + proto.RegisterType((*GetNodeHardwareResponse)(nil), "model.GetNodeHardwareResponse") + proto.RegisterType((*GetNodeHardwareRequest)(nil), "model.GetNodeHardwareRequest") + proto.RegisterType((*NodeHardware)(nil), "model.NodeHardware") + proto.RegisterType((*CPUInformation)(nil), "model.CPUInformation") + proto.RegisterType((*HostInformation)(nil), "model.HostInformation") + proto.RegisterType((*MemoryInformation)(nil), "model.MemoryInformation") + proto.RegisterType((*StorageInformation)(nil), "model.StorageInformation") +} + +func init() { proto.RegisterFile("model/nodeHardware.proto", fileDescriptor_ce967b26533b171c) } + +var fileDescriptor_ce967b26533b171c = []byte{ + // 586 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x54, 0x4d, 0xaf, 0xd2, 0x4c, + 0x14, 0x4e, 0x4b, 0xe1, 0xa5, 0xc3, 0x1b, 0xae, 0x8e, 0x8a, 0xd5, 0xb8, 0x20, 0x5d, 0x18, 0x62, + 0x22, 0x24, 0xd7, 0x44, 0x57, 0x26, 0x2a, 0x37, 0x78, 0x59, 0xf0, 0x91, 0xe1, 0x72, 0x17, 0xee, + 0x86, 0xf6, 0x5c, 0x68, 0xd2, 0x76, 0x70, 0x3a, 0xa8, 0xf0, 0x1b, 0xdc, 0x18, 0xfd, 0x05, 0xfe, + 0x52, 0x33, 0xa7, 0x05, 0x4a, 0x8b, 0x1b, 0x37, 0xcd, 0x79, 0xce, 0xc7, 0x33, 0xe7, 0x3c, 0x67, + 0xa6, 0xc4, 0x89, 0x84, 0x0f, 0x61, 0x2f, 0x16, 0x3e, 0x5c, 0x73, 0xe9, 0x7f, 0xe5, 0x12, 0xba, + 0x6b, 0x29, 0x94, 0xa0, 0x55, 0x8c, 0xb8, 0x8c, 0x3c, 0xfe, 0x08, 0x6a, 0x9c, 0x8b, 0x33, 0x48, + 0xd6, 0x22, 0x4e, 0x80, 0xbe, 0x21, 0xff, 0xe7, 0xfd, 0x8e, 0xd1, 0x36, 0x3a, 0x8d, 0xcb, 0x07, + 0x5d, 0x2c, 0xec, 0x9e, 0x94, 0x9c, 0x24, 0xba, 0x0e, 0x69, 0x95, 0x38, 0x3f, 0x6f, 0x20, 0x51, + 0xee, 0x6f, 0xf3, 0x94, 0x93, 0xbe, 0x25, 0xcd, 0xfe, 0x74, 0x3e, 0x8c, 0xef, 0x84, 0x8c, 0xb8, + 0x0a, 0x44, 0xec, 0x18, 0xed, 0x4a, 0xa7, 0x71, 0xf9, 0x28, 0x3b, 0xe5, 0x34, 0xc8, 0x0a, 0xc9, + 0x74, 0x40, 0xee, 0x8f, 0x20, 0x12, 0x72, 0x9b, 0x67, 0x30, 0xb1, 0x4f, 0x27, 0x63, 0x28, 0xc5, + 0x59, 0xb9, 0x84, 0x0e, 0x09, 0x9d, 0x29, 0x21, 0xf9, 0x12, 0xf2, 0x44, 0x15, 0x24, 0x7a, 0x92, + 0x11, 0x95, 0x13, 0xd8, 0x99, 0x22, 0xfa, 0x8e, 0x5c, 0x5c, 0x8b, 0x44, 0xe5, 0x79, 0x2c, 0xe4, + 0x69, 0x65, 0x3c, 0x85, 0x28, 0x2b, 0xa6, 0xbb, 0xbf, 0xcc, 0xa2, 0x28, 0xb4, 0x45, 0x6a, 0x03, + 0x1e, 0x05, 0xe1, 0x16, 0x97, 0x60, 0xb3, 0x0c, 0xd1, 0xa7, 0xa4, 0x8e, 0x99, 0x3e, 0x7c, 0xc3, + 0xb1, 0xab, 0xec, 0x80, 0xe9, 0x43, 0x52, 0x1d, 0xe9, 0x03, 0x71, 0x0c, 0x9b, 0xa5, 0x80, 0x3e, + 0x23, 0x36, 0x1a, 0x63, 0x1e, 0x01, 0x36, 0x66, 0xb3, 0xa3, 0x43, 0xf3, 0xdd, 0x42, 0xec, 0x0b, + 0x39, 0xf4, 0x9d, 0x2a, 0x06, 0x0f, 0x98, 0xde, 0x23, 0x95, 0xd1, 0x6a, 0xe7, 0xd4, 0xda, 0x46, + 0xc7, 0x60, 0xda, 0xd4, 0x5c, 0x7d, 0xee, 0xad, 0x60, 0x16, 0xec, 0xc0, 0xf9, 0x0f, 0x8f, 0x3f, + 0x3a, 0x68, 0x9b, 0x34, 0xe6, 0x09, 0xf8, 0x53, 0x90, 0x1e, 0xc4, 0xca, 0xa9, 0x63, 0x5d, 0xde, + 0xa5, 0xa7, 0xea, 0x0b, 0x09, 0xc3, 0x2b, 0xc7, 0x4e, 0xa7, 0x4a, 0x91, 0xee, 0x5c, 0x5b, 0x89, + 0x43, 0x90, 0x33, 0x05, 0xee, 0x4f, 0xb3, 0xa4, 0xac, 0x66, 0x98, 0xaf, 0x55, 0x10, 0xa5, 0x97, + 0xd3, 0x62, 0x19, 0xa2, 0x4d, 0x62, 0x4e, 0x66, 0xa8, 0x88, 0xcd, 0xcc, 0xc9, 0x4c, 0xcf, 0x35, + 0x0d, 0xb9, 0xd2, 0x85, 0x99, 0x1c, 0x07, 0x4c, 0x9f, 0x93, 0xe6, 0xde, 0xce, 0x34, 0x4e, 0x65, + 0x29, 0x78, 0x69, 0x87, 0x5c, 0xec, 0x3d, 0xb7, 0x20, 0x13, 0xbd, 0xd8, 0x54, 0xa2, 0xa2, 0x9b, + 0xbe, 0x26, 0xad, 0xf1, 0x26, 0x5a, 0x80, 0x9c, 0xdc, 0xb1, 0x4d, 0x1c, 0x07, 0xf1, 0x72, 0x2a, + 0x85, 0x07, 0x49, 0x82, 0xe2, 0x59, 0xec, 0x2f, 0x51, 0x3d, 0x0d, 0x0e, 0x78, 0x85, 0x62, 0xda, + 0x2c, 0x43, 0xba, 0x7b, 0x6d, 0xe1, 0xca, 0xea, 0x69, 0xf7, 0x7b, 0xec, 0xfe, 0x30, 0xce, 0x3c, + 0x01, 0xad, 0xe0, 0x8d, 0x50, 0x3c, 0xcc, 0x64, 0x49, 0x01, 0xa5, 0xc4, 0x1a, 0x48, 0x00, 0xd4, + 0xc5, 0x62, 0x68, 0xeb, 0x1d, 0xbe, 0xff, 0xc2, 0x83, 0x90, 0x2f, 0x42, 0x40, 0x69, 0x2c, 0x76, + 0x74, 0xe8, 0x0a, 0xbd, 0x30, 0x54, 0xc4, 0x62, 0x68, 0x17, 0xf7, 0x5a, 0x2d, 0xed, 0xd5, 0xfd, + 0x6e, 0x9c, 0x7b, 0x4e, 0x78, 0x89, 0x93, 0x9b, 0xed, 0x1a, 0x0e, 0x97, 0x18, 0xd1, 0xb1, 0x59, + 0xf3, 0x5c, 0xb3, 0x95, 0x5c, 0xb3, 0xff, 0xd4, 0xce, 0x87, 0x17, 0x9f, 0x3a, 0xcb, 0x40, 0xad, + 0x36, 0x8b, 0xae, 0x27, 0xa2, 0xde, 0x4e, 0x88, 0x85, 0x97, 0x7e, 0x5f, 0x7a, 0x42, 0x42, 0xcf, + 0x13, 0x51, 0x24, 0xe2, 0x1e, 0x3e, 0xce, 0x45, 0x0d, 0x7f, 0x8e, 0xaf, 0xfe, 0x04, 0x00, 0x00, + 0xff, 0xff, 0x18, 0x0c, 0x98, 0x0b, 0x38, 0x05, 0x00, 0x00, +} diff --git a/common/schema b/common/schema index 582e9a0f2..18bbcb54a 160000 --- a/common/schema +++ b/common/schema @@ -1 +1 @@ -Subproject commit 582e9a0f27ace410ec3f5a59ae5624e08e8b953e +Subproject commit 18bbcb54a55e95b9b88f68ceb8ea31f14e851938 diff --git a/common/service/nodeHardware.pb.go b/common/service/nodeHardware.pb.go new file mode 100644 index 000000000..64b66ab91 --- /dev/null +++ b/common/service/nodeHardware.pb.go @@ -0,0 +1,147 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: service/nodeHardware.proto + +package service + +import ( + context "context" + fmt "fmt" + proto "github.com/golang/protobuf/proto" + model "github.com/zoobc/zoobc-core/common/model" + _ "google.golang.org/genproto/googleapis/api/annotations" + grpc "google.golang.org/grpc" + math "math" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package + +func init() { proto.RegisterFile("service/nodeHardware.proto", fileDescriptor_a9639805248a2100) } + +var fileDescriptor_a9639805248a2100 = []byte{ + // 183 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0xcf, 0xbd, 0x0a, 0xc2, 0x30, + 0x10, 0x07, 0x70, 0xbb, 0x28, 0x74, 0x11, 0xea, 0x22, 0x41, 0x1d, 0x9c, 0x44, 0x34, 0x11, 0x7d, + 0x03, 0x17, 0x9d, 0x1c, 0x14, 0x1c, 0xdc, 0xd2, 0xf4, 0xa8, 0x81, 0x26, 0xff, 0x9a, 0xa4, 0x0a, + 0x3e, 0xbd, 0xd0, 0x76, 0x28, 0xa2, 0xcb, 0x0d, 0xf7, 0xbb, 0xcf, 0x98, 0x79, 0x72, 0x4f, 0xad, + 0x48, 0x58, 0x64, 0x74, 0x94, 0x2e, 0x7b, 0x49, 0x47, 0xbc, 0x74, 0x08, 0x48, 0x06, 0xad, 0xb1, + 0xb1, 0x41, 0x46, 0xc5, 0x8f, 0x12, 0x36, 0xc9, 0x81, 0xbc, 0x20, 0x21, 0x4b, 0x2d, 0xa4, 0xb5, + 0x08, 0x32, 0x68, 0x58, 0xdf, 0xe8, 0xd6, 0xc4, 0xa3, 0x53, 0xa7, 0xe7, 0xd2, 0x8c, 0x4b, 0xae, + 0xf1, 0xf0, 0x40, 0xa1, 0x2b, 0xc9, 0x94, 0xd7, 0x2b, 0xf8, 0x57, 0xfe, 0x4c, 0x8f, 0x8a, 0x7c, + 0x60, 0xb3, 0x7f, 0xec, 0x4b, 0x58, 0x4f, 0xf3, 0xde, 0x22, 0xda, 0x44, 0xfb, 0xd5, 0x6d, 0x99, + 0xeb, 0x70, 0xaf, 0x52, 0xae, 0x60, 0xc4, 0x1b, 0x48, 0x55, 0x13, 0xd7, 0x0a, 0x8e, 0x84, 0x82, + 0x31, 0xb0, 0xa2, 0x7d, 0x2a, 0xed, 0xd7, 0x37, 0xee, 0x3e, 0x01, 0x00, 0x00, 0xff, 0xff, 0x68, + 0x6b, 0xe8, 0x5b, 0x02, 0x01, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// NodeHardwareServiceClient is the client API for NodeHardwareService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type NodeHardwareServiceClient interface { + GetNodeHardware(ctx context.Context, opts ...grpc.CallOption) (NodeHardwareService_GetNodeHardwareClient, error) +} + +type nodeHardwareServiceClient struct { + cc *grpc.ClientConn +} + +func NewNodeHardwareServiceClient(cc *grpc.ClientConn) NodeHardwareServiceClient { + return &nodeHardwareServiceClient{cc} +} + +func (c *nodeHardwareServiceClient) GetNodeHardware(ctx context.Context, opts ...grpc.CallOption) (NodeHardwareService_GetNodeHardwareClient, error) { + stream, err := c.cc.NewStream(ctx, &_NodeHardwareService_serviceDesc.Streams[0], "/service.NodeHardwareService/GetNodeHardware", opts...) + if err != nil { + return nil, err + } + x := &nodeHardwareServiceGetNodeHardwareClient{stream} + return x, nil +} + +type NodeHardwareService_GetNodeHardwareClient interface { + Send(*model.GetNodeHardwareRequest) error + Recv() (*model.GetNodeHardwareResponse, error) + grpc.ClientStream +} + +type nodeHardwareServiceGetNodeHardwareClient struct { + grpc.ClientStream +} + +func (x *nodeHardwareServiceGetNodeHardwareClient) Send(m *model.GetNodeHardwareRequest) error { + return x.ClientStream.SendMsg(m) +} + +func (x *nodeHardwareServiceGetNodeHardwareClient) Recv() (*model.GetNodeHardwareResponse, error) { + m := new(model.GetNodeHardwareResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +// NodeHardwareServiceServer is the server API for NodeHardwareService service. +type NodeHardwareServiceServer interface { + GetNodeHardware(NodeHardwareService_GetNodeHardwareServer) error +} + +func RegisterNodeHardwareServiceServer(s *grpc.Server, srv NodeHardwareServiceServer) { + s.RegisterService(&_NodeHardwareService_serviceDesc, srv) +} + +func _NodeHardwareService_GetNodeHardware_Handler(srv interface{}, stream grpc.ServerStream) error { + return srv.(NodeHardwareServiceServer).GetNodeHardware(&nodeHardwareServiceGetNodeHardwareServer{stream}) +} + +type NodeHardwareService_GetNodeHardwareServer interface { + Send(*model.GetNodeHardwareResponse) error + Recv() (*model.GetNodeHardwareRequest, error) + grpc.ServerStream +} + +type nodeHardwareServiceGetNodeHardwareServer struct { + grpc.ServerStream +} + +func (x *nodeHardwareServiceGetNodeHardwareServer) Send(m *model.GetNodeHardwareResponse) error { + return x.ServerStream.SendMsg(m) +} + +func (x *nodeHardwareServiceGetNodeHardwareServer) Recv() (*model.GetNodeHardwareRequest, error) { + m := new(model.GetNodeHardwareRequest) + if err := x.ServerStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +var _NodeHardwareService_serviceDesc = grpc.ServiceDesc{ + ServiceName: "service.NodeHardwareService", + HandlerType: (*NodeHardwareServiceServer)(nil), + Methods: []grpc.MethodDesc{}, + Streams: []grpc.StreamDesc{ + { + StreamName: "GetNodeHardware", + Handler: _NodeHardwareService_GetNodeHardware_Handler, + ServerStreams: true, + ClientStreams: true, + }, + }, + Metadata: "service/nodeHardware.proto", +} diff --git a/common/service/nodeHardware.pb.gw.go b/common/service/nodeHardware.pb.gw.go new file mode 100644 index 000000000..75cb12ab1 --- /dev/null +++ b/common/service/nodeHardware.pb.gw.go @@ -0,0 +1,151 @@ +// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT. +// source: service/nodeHardware.proto + +/* +Package service is a reverse proxy. + +It translates gRPC into RESTful JSON APIs. +*/ +package service + +import ( + "context" + "io" + "net/http" + + "github.com/golang/protobuf/proto" + "github.com/grpc-ecosystem/grpc-gateway/runtime" + "github.com/grpc-ecosystem/grpc-gateway/utilities" + "github.com/zoobc/zoobc-core/common/model" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/grpclog" + "google.golang.org/grpc/status" +) + +var _ codes.Code +var _ io.Reader +var _ status.Status +var _ = runtime.String +var _ = utilities.NewDoubleArray + +func request_NodeHardwareService_GetNodeHardware_0(ctx context.Context, marshaler runtime.Marshaler, client NodeHardwareServiceClient, req *http.Request, pathParams map[string]string) (NodeHardwareService_GetNodeHardwareClient, runtime.ServerMetadata, error) { + var metadata runtime.ServerMetadata + stream, err := client.GetNodeHardware(ctx) + if err != nil { + grpclog.Infof("Failed to start streaming: %v", err) + return nil, metadata, err + } + dec := marshaler.NewDecoder(req.Body) + handleSend := func() error { + var protoReq model.GetNodeHardwareRequest + err := dec.Decode(&protoReq) + if err == io.EOF { + return err + } + if err != nil { + grpclog.Infof("Failed to decode request: %v", err) + return err + } + if err := stream.Send(&protoReq); err != nil { + grpclog.Infof("Failed to send request: %v", err) + return err + } + return nil + } + if err := handleSend(); err != nil { + if cerr := stream.CloseSend(); cerr != nil { + grpclog.Infof("Failed to terminate client stream: %v", cerr) + } + if err == io.EOF { + return stream, metadata, nil + } + return nil, metadata, err + } + go func() { + for { + if err := handleSend(); err != nil { + break + } + } + if err := stream.CloseSend(); err != nil { + grpclog.Infof("Failed to terminate client stream: %v", err) + } + }() + header, err := stream.Header() + if err != nil { + grpclog.Infof("Failed to get header from client: %v", err) + return nil, metadata, err + } + metadata.HeaderMD = header + return stream, metadata, nil +} + +// RegisterNodeHardwareServiceHandlerFromEndpoint is same as RegisterNodeHardwareServiceHandler but +// automatically dials to "endpoint" and closes the connection when "ctx" gets done. +func RegisterNodeHardwareServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { + conn, err := grpc.Dial(endpoint, opts...) + if err != nil { + return err + } + defer func() { + if err != nil { + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) + } + return + } + go func() { + <-ctx.Done() + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) + } + }() + }() + + return RegisterNodeHardwareServiceHandler(ctx, mux, conn) +} + +// RegisterNodeHardwareServiceHandler registers the http handlers for service NodeHardwareService to "mux". +// The handlers forward requests to the grpc endpoint over "conn". +func RegisterNodeHardwareServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { + return RegisterNodeHardwareServiceHandlerClient(ctx, mux, NewNodeHardwareServiceClient(conn)) +} + +// RegisterNodeHardwareServiceHandlerClient registers the http handlers for service NodeHardwareService +// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "NodeHardwareServiceClient". +// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "NodeHardwareServiceClient" +// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in +// "NodeHardwareServiceClient" to call the correct interceptors. +func RegisterNodeHardwareServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client NodeHardwareServiceClient) error { + + mux.Handle("GET", pattern_NodeHardwareService_GetNodeHardware_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_NodeHardwareService_GetNodeHardware_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_NodeHardwareService_GetNodeHardware_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +var ( + pattern_NodeHardwareService_GetNodeHardware_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "node", "GetNodeHardware"}, "", runtime.AssumeColonVerbOpt(true))) +) + +var ( + forward_NodeHardwareService_GetNodeHardware_0 = runtime.ForwardResponseStream +) diff --git a/common/transaction/fixtureGenerator.go b/common/transaction/fixtureGenerator.go index 821326b4e..b4ab8c796 100644 --- a/common/transaction/fixtureGenerator.go +++ b/common/transaction/fixtureGenerator.go @@ -1,6 +1,7 @@ package transaction import ( + "github.com/zoobc/zoobc-core/common/constant" "github.com/zoobc/zoobc-core/common/crypto" "github.com/zoobc/zoobc-core/common/model" "github.com/zoobc/zoobc-core/common/util" @@ -22,7 +23,7 @@ func GetFixturesForNoderegistration() (poownMessage *model.ProofOfOwnershipMessa poownMessageBytes := util.GetProofOfOwnershipMessageBytes(poownMessage) poownSignature := crypto.NewSignature().Sign( poownMessageBytes, - senderAddress1, + constant.NodeSignatureTypeDefault, senderSeed1, ) poown = &model.ProofOfOwnership{ @@ -57,7 +58,7 @@ func GetFixturesForUpdateNoderegistration() (poownMessage *model.ProofOfOwnershi poownMessageBytes := util.GetProofOfOwnershipMessageBytes(poownMessage) poownSignature := crypto.NewSignature().Sign( poownMessageBytes, - senderAddress1, + constant.NodeSignatureTypeDefault, senderSeed1, ) poown = &model.ProofOfOwnership{ diff --git a/common/transaction/nodeRegistration_test.go b/common/transaction/nodeRegistration_test.go index 58a796581..40e71ec80 100644 --- a/common/transaction/nodeRegistration_test.go +++ b/common/transaction/nodeRegistration_test.go @@ -585,7 +585,7 @@ func TestNodeRegistration_GetSize(t *testing.T) { NodeAddress: "127.0.0.1", }, }, - want: 277, + want: 281, }, } for _, tt := range tests { diff --git a/common/util/interceptor_test.go b/common/util/interceptor_test.go deleted file mode 100644 index a9daa4338..000000000 --- a/common/util/interceptor_test.go +++ /dev/null @@ -1,144 +0,0 @@ -package util - -import ( - "context" - "testing" - - "github.com/google/go-cmp/cmp" - "github.com/sirupsen/logrus" - "google.golang.org/grpc" - "google.golang.org/grpc/codes" - "google.golang.org/grpc/status" -) - -func TestNewServerInterceptor(t *testing.T) { - - type args struct { - logger *logrus.Logger - } - tests := []struct { - name string - args args - want grpc.UnaryServerInterceptor - wantRecover bool - }{ - { - name: "wantRecover", - args: args{ - logger: logrus.New(), - }, - want: func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) { - return nil, status.Errorf(codes.Internal, "there's something wrong") - }, - wantRecover: true, - }, - { - name: "wantNotRecover", - args: args{ - logger: logrus.New(), - }, - want: func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) { - return nil, status.Errorf(codes.Internal, "there's something wrong") - }, - wantRecover: false, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - got := NewServerInterceptor(tt.args.logger) - if cmp.Equal(got, tt.want) { - t.Errorf("NewInterceptor() = %v, want %v", got, tt.want) - } - testServerInterceptor(got, tt.wantRecover) - }) - } -} - -func testServerInterceptor(fn grpc.UnaryServerInterceptor, wantRecover bool) { - var ( - handler grpc.UnaryHandler - ) - if wantRecover { - handler = func(ctx context.Context, req interface{}) (resp interface{}, err error) { - panic(handler) - } - } else { - handler = func(ctx context.Context, req interface{}) (resp interface{}, err error) { - return nil, status.Errorf(codes.Internal, "there's something wrong") - } - } - _, _ = fn(context.Background(), nil, &grpc.UnaryServerInfo{}, handler) -} - -func TestNewClientInterceptor(t *testing.T) { - type args struct { - logger *logrus.Logger - } - tests := []struct { - name string - args args - want grpc.UnaryClientInterceptor - wantRecover bool - }{ - { - name: "wantRecover", - args: args{ - logger: logrus.New(), - }, - want: func( - ctx context.Context, - method string, - req, reply interface{}, - cc *grpc.ClientConn, - invoker grpc.UnaryInvoker, - opts ...grpc.CallOption) error { - return status.Errorf(codes.Internal, "there's something wrong") - }, - wantRecover: false, - }, - { - name: "wantRecover", - args: args{ - logger: logrus.New(), - }, - want: func( - ctx context.Context, - method string, - req, reply interface{}, - cc *grpc.ClientConn, - invoker grpc.UnaryInvoker, - opts ...grpc.CallOption) error { - return status.Errorf(codes.Internal, "there's something wrong") - }, - wantRecover: true, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - got := NewClientInterceptor(tt.args.logger) - if cmp.Equal(got, tt.want) { - t.Errorf("NewClientInterceptor() = %v, want %v", got, tt.want) - } - testClientInterceptor(got, tt.wantRecover) - }) - } -} - -func testClientInterceptor(fn grpc.UnaryClientInterceptor, wantRecover bool) { - var ( - invoker grpc.UnaryInvoker - ) - if wantRecover { - invoker = func(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, opts ...grpc.CallOption) error { - panic(invoker) - } - } else { - invoker = func(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, opts ...grpc.CallOption) error { - return status.Errorf(codes.Internal, "there's something wrong") - } - } - - cc, _ := grpc.Dial("127.0.0.1:8001", grpc.WithInsecure()) - _ = fn(context.Background(), "testMethod", nil, nil, cc, invoker, nil) - -} diff --git a/common/util/nodeRegistration.go b/common/util/nodeRegistration.go index 5c6bdef7a..44d474ddb 100644 --- a/common/util/nodeRegistration.go +++ b/common/util/nodeRegistration.go @@ -11,7 +11,7 @@ import ( func GetProofOfOwnershipSize(withSignature bool) uint32 { message := constant.AccountAddress + constant.BlockHash + constant.Height if withSignature { - return message + constant.NodeSignature + return message + constant.NodeSignature + constant.SignatureType } return message } @@ -30,7 +30,7 @@ func GetProofOfOwnershipBytes(poown *model.ProofOfOwnership) []byte { func ParseProofOfOwnershipBytes(poownBytes []byte) *model.ProofOfOwnership { buffer := bytes.NewBuffer(poownBytes) poownMessageBytes := buffer.Next(int(GetProofOfOwnershipSize(false))) - signature := buffer.Next(int(constant.NodeSignature)) + signature := buffer.Next(int(constant.NodeSignature + constant.SignatureType)) return &model.ProofOfOwnership{ MessageBytes: poownMessageBytes, Signature: signature, diff --git a/main.go b/main.go index cd413069b..861ebf59a 100644 --- a/main.go +++ b/main.go @@ -37,6 +37,7 @@ var ( p2pServiceInstance p2p.ServiceInterface queryExecutor *query.Executor observerInstance *observer.Observer + ownerAccountAddress string ) var ( @@ -68,6 +69,7 @@ func init() { if apiHTTPPort == 0 { apiHTTPPort = 8000 } + ownerAccountAddress = viper.GetString("ownerAccountAddress") } dbInstance = database.NewSqliteDB() @@ -84,9 +86,9 @@ func init() { observerInstance = observer.NewObserver() } -func startServices(queryExecutor query.ExecutorInterface) { +func startServices(queryExecutor query.ExecutorInterface, ownerAccountAddress string) { startP2pService() - api.Start(apiRPCPort, apiHTTPPort, queryExecutor, p2pServiceInstance, blockServices) + api.Start(apiRPCPort, apiHTTPPort, queryExecutor, p2pServiceInstance, blockServices, ownerAccountAddress) } func startP2pService() { @@ -174,7 +176,7 @@ func main() { logrus.Fatal(err) } - startServices(queryExecutor) + startServices(queryExecutor, ownerAccountAddress) mainchainSyncChannel := make(chan bool, 1) mainchainSyncChannel <- true diff --git a/p2p/native/service/client.go b/p2p/native/service/client.go index 77bd87c3a..d86680128 100644 --- a/p2p/native/service/client.go +++ b/p2p/native/service/client.go @@ -2,6 +2,7 @@ package service import ( "context" + "github.com/zoobc/zoobc-core/common/interceptor" "sync" log "github.com/sirupsen/logrus" @@ -51,7 +52,7 @@ func NewPeerServiceClient() PeerServiceClientInterface { conn, err := grpc.Dial( nativeUtil.GetFullAddressPeer(destinationPeer), grpc.WithInsecure(), - grpc.WithUnaryInterceptor(util.NewClientInterceptor(apiLogger)), + grpc.WithUnaryInterceptor(interceptor.NewClientInterceptor(apiLogger)), ) if err != nil { return nil, err diff --git a/p2p/native/service/server.go b/p2p/native/service/server.go index 9a1ec1332..023917ef6 100644 --- a/p2p/native/service/server.go +++ b/p2p/native/service/server.go @@ -4,6 +4,7 @@ import ( "context" "errors" "fmt" + "github.com/zoobc/zoobc-core/common/interceptor" "net" log "github.com/sirupsen/logrus" @@ -62,7 +63,7 @@ func (ss *ServerService) StartListening(listener net.Listener) error { apiLogger.Info("P2P: Listening to grpc communication...") grpcServer := grpc.NewServer( - grpc.UnaryInterceptor(util.NewServerInterceptor(apiLogger)), + grpc.UnaryInterceptor(interceptor.NewServerInterceptor(apiLogger)), ) service.RegisterP2PCommunicationServer(grpcServer, ss) return grpcServer.Serve(listener)