Fix license

Signed-off-by: Drasko Draskovic <drasko.draskovic@gmail.com>

.env

@@ -3,19 +3,21 @@ COCOS_JAEGER_PORT=6831
 COCOS_JAEGER_FRONTEND=16686
 COCOS_JAEGER_COLLECTOR=14268
 COCOS_JAEGER_CONFIGS=5778
-COCOS_JAEGER_URL=http://jaeger:4318
+COCOS_JAEGER_URL=http://jaeger:14268/api/traces
 COCOS_JAEGER_TRACE_RATIO=1.0
-COCOS_JAEGER_COLLECTOR_OTLP_ENABLED=true
-COCOS_JAEGER_OLTP_HTTP_PORT=4318
 
 ## Core Services
 
 ### Manager
-MANAGER_GRPC_HOST=""
+MANAGER_HTTP_HOST="cocos-manager"
+MANAGER_HTTP_PORT=9021
+MANAGER_HTTP_SERVER_CERT=""
+MANAGER_HTTP_SERVER_KEY=""
+MANAGER_GRPC_HOST="cocos-manager"
 MANAGER_GRPC_PORT=7003
 MANAGER_GRPC_SERVER_CERT=""
 MANAGER_GRPC_SERVER_KEY=""
-AGENT_GRPC_URL="localhost:7002"
+AGENT_GRPC_URL="192.168.100.4:7002"
 AGENT_GRPC_TIMEOUT=""
 AGENT_GRPC_CA_CERTS=""
 AGENT_GRPC_CLIENT_TLS=""
@@ -26,3 +28,6 @@ MANAGER_QEMU_ENABLE_SEV=false
 MANAGER_QEMU_SEV_CBITPOS=51
 MANAGER_QEMU_OVMF_CODE_FILE=/usr/share/OVMF/OVMF_CODE.fd
 MANAGER_QEMU_OVMF_VARS_FILE=/usr/share/OVMF/OVMF_VARS.fd
+
+# Docker image tag
+COCOS_RELEASE_TAG=latest

.github/workflows/checkproto.yaml

@@ -29,13 +29,13 @@ jobs:
       - name: Install Go
         uses: actions/setup-go@v5
         with:
-          go-version: 1.22.x
+          go-version: 1.21.x
 
       - name: Set up protoc
         run: |
-          PROTOC_VERSION=27.2
-          PROTOC_GEN_VERSION=v1.34.2
-          PROTOC_GRPC_VERSION=v1.4.0
+          PROTOC_VERSION=25.2
+          PROTOC_GEN_VERSION=v1.31.0
+          PROTOC_GRPC_VERSION=v1.3.0
 
           # Download and install protoc
           PROTOC_ZIP=protoc-$PROTOC_VERSION-linux-x86_64.zip

.github/workflows/hal.yml

@@ -18,7 +18,7 @@ jobs:
     - name: Install Go
       uses: actions/setup-go@v5
       with:
-        go-version: 1.22.x
+        go-version: 1.21.x
         cache-dependency-path: "go.sum"
 
     - name: Checkout cocos

.github/workflows/main.yaml

@@ -19,12 +19,12 @@ jobs:
       - name: Install Go
         uses: actions/setup-go@v5
         with:
-          go-version: 1.22.x
+          go-version: 1.21.x
 
       - name: golangci-lint
-        uses: golangci/golangci-lint-action@v6
+        uses: golangci/golangci-lint-action@v3
         with:
-          version: v1.59.1
+          version: latest
 
       - name: Build
         run: |

.gitignore

@@ -2,11 +2,7 @@ build
 
 build
 cmd/manager/img
+cmd/manager/iso
+cmd/manager/tmp
 
 .cov
-
-*.pem
-
-dist/
-results.zip
-*.spec

.golangci.yaml

@@ -1,6 +1,6 @@
 run:
   timeout: 3m
-
+  
 issues:
   max-issues-per-linter: 10
   max-same-issues: 10
@@ -15,7 +15,10 @@ linters-settings:
 
   gocritic:
     enabled-checks:
+      - captLocal
       - dupImport
+      - singleCaseSwitch
+      - switchTrue
       - importShadow
       - httpNoBody
       - paramTypeCombine
@@ -31,6 +34,9 @@ linters-settings:
       - style
       - experimental
       - opinionated
+  misspell:
+    ignore-words:
+      - "mosquitto"
   stylecheck:
     checks: ["-ST1000", "-ST1003", "-ST1020", "-ST1021", "-ST1022"]
   goheader:
@@ -77,4 +83,4 @@ linters:
     - makezero
     - mirror
     - nakedret
-    - dupword
+    - dupword

Makefile

@@ -1,12 +1,12 @@
 BUILD_DIR = build
 SERVICES = manager agent cli
-BACKEND_INFO = backend_info
 CGO_ENABLED ?= 0
 GOARCH ?= amd64
 VERSION ?= $(shell git describe --abbrev=0 --tags --always)
 COMMIT ?= $(shell git rev-parse HEAD)
 TIME ?= $(shell date +%F_%T)
-EMBED_ENABLED ?= 0
+empty:=
+space:= $(empty) $(empty)
 
 define compile_service
 	CGO_ENABLED=$(CGO_ENABLED) GOOS=$(GOOS) GOARCH=$(GOARCH) GOARM=$(GOARM) \
@@ -14,23 +14,16 @@ define compile_service
 	-X 'github.com/absmach/magistrala.BuildTime=$(TIME)' \
 	-X 'github.com/absmach/magistrala.Version=$(VERSION)' \
 	-X 'github.com/absmach/magistrala.Commit=$(COMMIT)'" \
-	$(if $(filter 1,$(EMBED_ENABLED)),-tags "embed",) \
 	-o ${BUILD_DIR}/cocos-$(1) cmd/$(1)/main.go
 endef
 
-.PHONY: all $(SERVICES) $(BACKEND_INFO)
+.PHONY: all $(SERVICES)
 
 all: $(SERVICES)
 
 $(SERVICES):
-	$(call compile_service,$@)
-
-$(BACKEND_INFO):
-	$(MAKE) -C ./scripts/backend_info
+	$(call compile_service,$(@))
 
 protoc:
 	protoc -I. --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative agent/agent.proto
 	protoc -I. --go_out=./pkg --go_opt=paths=source_relative --go-grpc_out=./pkg --go-grpc_opt=paths=source_relative manager/manager.proto
-
-mocks:
-	go generate ./...

README.md

@@ -7,55 +7,35 @@ based on the [Confidential Computing][cc] and [Trusted Execution Environments (T
 </p>
 
 With Cocos AI it becomes possible to run AI/ML workloads on combined datasets from multiple organizations
-while guaranteeing the privacy and security of the data and the algorithm.
+while guaranteeing the privacy and security of the data and the algorithms.
 Data is always encrypted, protected by hardware secure enclaves (Trusted Execution Environments),
 attested via secure remote attestation protocols, and invisible to cloud processors or any other
 3rd party to which computation is offloaded.
 
-## Features
-
-Cocos AI is implementing the following features:
-
-- TEE enablement, deployment and monitoring (secure VM manager)
-- HAL for TEEs based on hardened Linux kernel, secure bootloader and custom-tailored embedded rootfs for minimal TCB
-- In-enclave agent, netowrking controller and other system software
-- Encrypted asynchronous data transfer and result delivery
-- API for programmable platform manipulation
-- HW and SW supported attestation with verification tools
-- CLI for system interaction
-
 ## Usage
 
-Clone the repo and create binaries:
+The quickest way to start using Cocos is via the CLI. The latest version can be downloaded from the [official releases page][rel].
+
+It can also be built and used from the project's root directory:
 
 ```bash
-git clone git@github.com:ultravioletrs/cocos.git
-make
+make cli
+./build/cocos-cli version
 ```
 
-This will create 3 binaries:
-```bash
-ls build/
-# cocos-agent  cocos-cli  cocos-manager
-```
-
-- Manager can be deployed on the AMD SEV-SNP host
-- Agent can be built into [EOS][eos]-based HAL
-- CLI can be used to communicate to remote Agent.
+Additional details on using the CLI can be found in the [CLI documentation](https://docs.cocos.ai/cli).
 
 ## Documentation
 
-Project documentation is hosted at [Cocos AI official docs page][docs].
-
-Documentation is generated from the [docs repository](https://github.com/ultravioletrs/docs).
+Official documentation is hosted at [Cocos official docs page][docs]. Documentation is auto-generated, checkout the instructions on [official docs repository](https://github.com/ultravioletrs/docs).
 
 ## License
 Cocos AI is published under permissive open-source [Apache-2.0](LICENSE) license.
 
 [cc]: https://confidentialcomputing.io/white-papers-reports/
 [cocos]: https://cocos.ai/
-[rel]: https://github.com/ultravioletrs/cocos/releases
+[rel]: https://github.com/ultraviolet/cocos/releases
 [tee]: https://en.wikipedia.org/wiki/Trusted_execution_environment
 [docs]: https://docs.cocos.ultraviolet.rs
-[cli]: https://docs.cocos.ultraviolet.rs/cli
-[eos]: https://github.com/ultravioletrs/eos
+[rel]: https://github.com/ultravioletrs/cocos/releases
+

agent/README.md

@@ -15,6 +15,7 @@ The service is configured using the environment variables from the following tab
 | AGENT_GRPC_SERVER_KEY         | Path to gRPC server key in pem format                  | ""                             |
 | AGENT_GRPC_SERVER_CA_CERTS    | Path to gRPC server CA certificate                     | ""                             |
 | AGENT_GRPC_CLIENT_CA_CERTS    | Path to gRPC client CA certificate                     | ""                             |
+| COCOS_NOTIFICATION_SERVER_URL | Server to receive notification events from agent.      | http:/localhost:9000           |
 
 
 ## Deployment

agent/agent.pb.go

@@ -3,8 +3,8 @@
 
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.34.2
-// 	protoc        v5.27.2
+// 	protoc-gen-go v1.31.0
+// 	protoc        v4.25.2
 // source: agent/agent.proto
 
 package agent
@@ -28,8 +28,9 @@ type AlgoRequest struct {
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Algorithm    []byte `protobuf:"bytes,1,opt,name=algorithm,proto3" json:"algorithm,omitempty"`
-	Requirements []byte `protobuf:"bytes,2,opt,name=requirements,proto3" json:"requirements,omitempty"`
+	Algorithm []byte `protobuf:"bytes,1,opt,name=algorithm,proto3" json:"algorithm,omitempty"`
+	Provider  string `protobuf:"bytes,2,opt,name=provider,proto3" json:"provider,omitempty"`
+	Id        string `protobuf:"bytes,3,opt,name=id,proto3" json:"id,omitempty"`
 }
 
 func (x *AlgoRequest) Reset() {
@@ -71,11 +72,18 @@ func (x *AlgoRequest) GetAlgorithm() []byte {
 	return nil
 }
 
-func (x *AlgoRequest) GetRequirements() []byte {
+func (x *AlgoRequest) GetProvider() string {
 	if x != nil {
-		return x.Requirements
+		return x.Provider
 	}
-	return nil
+	return ""
+}
+
+func (x *AlgoRequest) GetId() string {
+	if x != nil {
+		return x.Id
+	}
+	return ""
 }
 
 type AlgoResponse struct {
@@ -122,7 +130,8 @@ type DataRequest struct {
 	unknownFields protoimpl.UnknownFields
 
 	Dataset  []byte `protobuf:"bytes,1,opt,name=dataset,proto3" json:"dataset,omitempty"`
-	Filename string `protobuf:"bytes,2,opt,name=filename,proto3" json:"filename,omitempty"`
+	Provider string `protobuf:"bytes,2,opt,name=provider,proto3" json:"provider,omitempty"`
+	Id       string `protobuf:"bytes,3,opt,name=id,proto3" json:"id,omitempty"`
 }
 
 func (x *DataRequest) Reset() {
@@ -164,9 +173,16 @@ func (x *DataRequest) GetDataset() []byte {
 	return nil
 }
 
-func (x *DataRequest) GetFilename() string {
+func (x *DataRequest) GetProvider() string {
 	if x != nil {
-		return x.Filename
+		return x.Provider
+	}
+	return ""
+}
+
+func (x *DataRequest) GetId() string {
+	if x != nil {
+		return x.Id
 	}
 	return ""
 }
@@ -213,6 +229,8 @@ type ResultRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
+
+	Consumer string `protobuf:"bytes,1,opt,name=consumer,proto3" json:"consumer,omitempty"`
 }
 
 func (x *ResultRequest) Reset() {
@@ -247,6 +265,13 @@ func (*ResultRequest) Descriptor() ([]byte, []int) {
 	return file_agent_agent_proto_rawDescGZIP(), []int{4}
 }
 
+func (x *ResultRequest) GetConsumer() string {
+	if x != nil {
+		return x.Consumer
+	}
+	return ""
+}
+
 type ResultResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -392,45 +417,48 @@ var File_agent_agent_proto protoreflect.FileDescriptor
 
 var file_agent_agent_proto_rawDesc = []byte{
 	0x0a, 0x11, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2f, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x70, 0x72,
-	0x6f, 0x74, 0x6f, 0x12, 0x05, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x22, 0x4f, 0x0a, 0x0b, 0x41, 0x6c,
+	0x6f, 0x74, 0x6f, 0x12, 0x05, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x22, 0x57, 0x0a, 0x0b, 0x41, 0x6c,
 	0x67, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x6c, 0x67,
 	0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x61, 0x6c,
-	0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x12, 0x22, 0x0a, 0x0c, 0x72, 0x65, 0x71, 0x75, 0x69,
-	0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0c, 0x72,
-	0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x0e, 0x0a, 0x0c, 0x41,
-	0x6c, 0x67, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x43, 0x0a, 0x0b, 0x44,
-	0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x64, 0x61,
-	0x74, 0x61, 0x73, 0x65, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x64, 0x61, 0x74,
-	0x61, 0x73, 0x65, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65,
-	0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65,
-	0x22, 0x0e, 0x0a, 0x0c, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x22, 0x0f, 0x0a, 0x0d, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x74, 0x22, 0x24, 0x0a, 0x0e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x0c, 0x52, 0x04, 0x66, 0x69, 0x6c, 0x65, 0x22, 0x35, 0x0a, 0x12, 0x41, 0x74, 0x74, 0x65, 0x73,
-	0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a,
-	0x0b, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01,
-	0x28, 0x0c, 0x52, 0x0a, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x44, 0x61, 0x74, 0x61, 0x22, 0x29,
-	0x0a, 0x13, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73,
-	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x01, 0x20,
-	0x01, 0x28, 0x0c, 0x52, 0x04, 0x66, 0x69, 0x6c, 0x65, 0x32, 0xfb, 0x01, 0x0a, 0x0c, 0x41, 0x67,
-	0x65, 0x6e, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x33, 0x0a, 0x04, 0x41, 0x6c,
-	0x67, 0x6f, 0x12, 0x12, 0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x41, 0x6c, 0x67, 0x6f, 0x52,
-	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x13, 0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x41,
-	0x6c, 0x67, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x28, 0x01, 0x12,
-	0x33, 0x0a, 0x04, 0x44, 0x61, 0x74, 0x61, 0x12, 0x12, 0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e,
-	0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x13, 0x2e, 0x61, 0x67,
-	0x65, 0x6e, 0x74, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x22, 0x00, 0x28, 0x01, 0x12, 0x39, 0x0a, 0x06, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x14,
+	0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x72, 0x6f, 0x76, 0x69,
+	0x64, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x70, 0x72, 0x6f, 0x76, 0x69,
+	0x64, 0x65, 0x72, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x02, 0x69, 0x64, 0x22, 0x0e, 0x0a, 0x0c, 0x41, 0x6c, 0x67, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x22, 0x53, 0x0a, 0x0b, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x07, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x12, 0x1a, 0x0a, 0x08,
+	0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08,
+	0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x03,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x22, 0x0e, 0x0a, 0x0c, 0x44, 0x61, 0x74, 0x61,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2b, 0x0a, 0x0d, 0x52, 0x65, 0x73, 0x75,
+	0x6c, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x6f, 0x6e,
+	0x73, 0x75, 0x6d, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x63, 0x6f, 0x6e,
+	0x73, 0x75, 0x6d, 0x65, 0x72, 0x22, 0x24, 0x0a, 0x0e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x66, 0x69, 0x6c, 0x65, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x66, 0x69, 0x6c, 0x65, 0x22, 0x35, 0x0a, 0x12, 0x41,
+	0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x61,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x44, 0x61,
+	0x74, 0x61, 0x22, 0x29, 0x0a, 0x13, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x66, 0x69, 0x6c,
+	0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x66, 0x69, 0x6c, 0x65, 0x32, 0xf5, 0x01,
+	0x0a, 0x0c, 0x41, 0x67, 0x65, 0x6e, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x31,
+	0x0a, 0x04, 0x41, 0x6c, 0x67, 0x6f, 0x12, 0x12, 0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x41,
+	0x6c, 0x67, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x13, 0x2e, 0x61, 0x67, 0x65,
+	0x6e, 0x74, 0x2e, 0x41, 0x6c, 0x67, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
+	0x00, 0x12, 0x31, 0x0a, 0x04, 0x44, 0x61, 0x74, 0x61, 0x12, 0x12, 0x2e, 0x61, 0x67, 0x65, 0x6e,
+	0x74, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x13, 0x2e,
+	0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x22, 0x00, 0x12, 0x37, 0x0a, 0x06, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x14,
 	0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x65, 0x71,
 	0x75, 0x65, 0x73, 0x74, 0x1a, 0x15, 0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x52, 0x65, 0x73,
-	0x75, 0x6c, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x30, 0x01, 0x12,
-	0x46, 0x0a, 0x0b, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x19,
-	0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x61, 0x67, 0x65, 0x6e,
-	0x74, 0x2e, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73,
-	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x42, 0x09, 0x5a, 0x07, 0x2e, 0x2f, 0x61, 0x67, 0x65,
-	0x6e, 0x74, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x75, 0x6c, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x46, 0x0a,
+	0x0b, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x19, 0x2e, 0x61,
+	0x67, 0x65, 0x6e, 0x74, 0x2e, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e,
+	0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x22, 0x00, 0x42, 0x09, 0x5a, 0x07, 0x2e, 0x2f, 0x61, 0x67, 0x65, 0x6e, 0x74,
+	0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -446,7 +474,7 @@ func file_agent_agent_proto_rawDescGZIP() []byte {
 }
 
 var file_agent_agent_proto_msgTypes = make([]protoimpl.MessageInfo, 8)
-var file_agent_agent_proto_goTypes = []any{
+var file_agent_agent_proto_goTypes = []interface{}{
 	(*AlgoRequest)(nil),         // 0: agent.AlgoRequest
 	(*AlgoResponse)(nil),        // 1: agent.AlgoResponse
 	(*DataRequest)(nil),         // 2: agent.DataRequest
@@ -478,7 +506,7 @@ func file_agent_agent_proto_init() {
 		return
 	}
 	if !protoimpl.UnsafeEnabled {
-		file_agent_agent_proto_msgTypes[0].Exporter = func(v any, i int) any {
+		file_agent_agent_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*AlgoRequest); i {
 			case 0:
 				return &v.state
@@ -490,7 +518,7 @@ func file_agent_agent_proto_init() {
 				return nil
 			}
 		}
-		file_agent_agent_proto_msgTypes[1].Exporter = func(v any, i int) any {
+		file_agent_agent_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*AlgoResponse); i {
 			case 0:
 				return &v.state
@@ -502,7 +530,7 @@ func file_agent_agent_proto_init() {
 				return nil
 			}
 		}
-		file_agent_agent_proto_msgTypes[2].Exporter = func(v any, i int) any {
+		file_agent_agent_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*DataRequest); i {
 			case 0:
 				return &v.state
@@ -514,7 +542,7 @@ func file_agent_agent_proto_init() {
 				return nil
 			}
 		}
-		file_agent_agent_proto_msgTypes[3].Exporter = func(v any, i int) any {
+		file_agent_agent_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*DataResponse); i {
 			case 0:
 				return &v.state
@@ -526,7 +554,7 @@ func file_agent_agent_proto_init() {
 				return nil
 			}
 		}
-		file_agent_agent_proto_msgTypes[4].Exporter = func(v any, i int) any {
+		file_agent_agent_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*ResultRequest); i {
 			case 0:
 				return &v.state
@@ -538,7 +566,7 @@ func file_agent_agent_proto_init() {
 				return nil
 			}
 		}
-		file_agent_agent_proto_msgTypes[5].Exporter = func(v any, i int) any {
+		file_agent_agent_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*ResultResponse); i {
 			case 0:
 				return &v.state
@@ -550,7 +578,7 @@ func file_agent_agent_proto_init() {
 				return nil
 			}
 		}
-		file_agent_agent_proto_msgTypes[6].Exporter = func(v any, i int) any {
+		file_agent_agent_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*AttestationRequest); i {
 			case 0:
 				return &v.state
@@ -562,7 +590,7 @@ func file_agent_agent_proto_init() {
 				return nil
 			}
 		}
-		file_agent_agent_proto_msgTypes[7].Exporter = func(v any, i int) any {
+		file_agent_agent_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*AttestationResponse); i {
 			case 0:
 				return &v.state

agent/agent.proto

@@ -8,27 +8,30 @@ package agent;
 option go_package = "./agent";
 
 service AgentService {
-  rpc Algo(stream AlgoRequest) returns (AlgoResponse) {}
-  rpc Data(stream DataRequest) returns (DataResponse) {}
-  rpc Result(ResultRequest) returns (stream ResultResponse) {}
+  rpc Algo(AlgoRequest) returns (AlgoResponse) {}
+  rpc Data(DataRequest) returns (DataResponse) {}
+  rpc Result(ResultRequest) returns (ResultResponse) {}
   rpc Attestation(AttestationRequest) returns (AttestationResponse) {}
 }
 
 message AlgoRequest {
   bytes algorithm = 1;
-  bytes requirements = 2;
+  string provider = 2;
+  string id = 3;
 }
 
 message AlgoResponse {}
 
 message DataRequest {
   bytes dataset = 1;
-  string filename = 2;
+  string provider = 2;
+  string id = 3;
 }
 
 message DataResponse {}
 
 message ResultRequest {
+  string consumer = 1;
 }
 
 message ResultResponse {

agent/agent_grpc.pb.go

@@ -3,8 +3,8 @@
 
 // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
 // versions:
-// - protoc-gen-go-grpc v1.4.0
-// - protoc             v5.27.2
+// - protoc-gen-go-grpc v1.3.0
+// - protoc             v4.25.2
 // source: agent/agent.proto
 
 package agent
@@ -18,8 +18,8 @@ import (
 
 // 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.62.0 or later.
-const _ = grpc.SupportPackageIsVersion8
+// Requires gRPC-Go v1.32.0 or later.
+const _ = grpc.SupportPackageIsVersion7
 
 const (
 	AgentService_Algo_FullMethodName        = "/agent.AgentService/Algo"
@@ -32,9 +32,9 @@ const (
 //
 // 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 AgentServiceClient interface {
-	Algo(ctx context.Context, opts ...grpc.CallOption) (AgentService_AlgoClient, error)
-	Data(ctx context.Context, opts ...grpc.CallOption) (AgentService_DataClient, error)
-	Result(ctx context.Context, in *ResultRequest, opts ...grpc.CallOption) (AgentService_ResultClient, error)
+	Algo(ctx context.Context, in *AlgoRequest, opts ...grpc.CallOption) (*AlgoResponse, error)
+	Data(ctx context.Context, in *DataRequest, opts ...grpc.CallOption) (*DataResponse, error)
+	Result(ctx context.Context, in *ResultRequest, opts ...grpc.CallOption) (*ResultResponse, error)
 	Attestation(ctx context.Context, in *AttestationRequest, opts ...grpc.CallOption) (*AttestationResponse, error)
 }
 
@@ -46,113 +46,36 @@ func NewAgentServiceClient(cc grpc.ClientConnInterface) AgentServiceClient {
 	return &agentServiceClient{cc}
 }
 
-func (c *agentServiceClient) Algo(ctx context.Context, opts ...grpc.CallOption) (AgentService_AlgoClient, error) {
-	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
-	stream, err := c.cc.NewStream(ctx, &AgentService_ServiceDesc.Streams[0], AgentService_Algo_FullMethodName, cOpts...)
+func (c *agentServiceClient) Algo(ctx context.Context, in *AlgoRequest, opts ...grpc.CallOption) (*AlgoResponse, error) {
+	out := new(AlgoResponse)
+	err := c.cc.Invoke(ctx, AgentService_Algo_FullMethodName, in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
-	x := &agentServiceAlgoClient{ClientStream: stream}
-	return x, nil
+	return out, nil
 }
 
-type AgentService_AlgoClient interface {
-	Send(*AlgoRequest) error
-	CloseAndRecv() (*AlgoResponse, error)
-	grpc.ClientStream
-}
-
-type agentServiceAlgoClient struct {
-	grpc.ClientStream
-}
-
-func (x *agentServiceAlgoClient) Send(m *AlgoRequest) error {
-	return x.ClientStream.SendMsg(m)
-}
-
-func (x *agentServiceAlgoClient) CloseAndRecv() (*AlgoResponse, error) {
-	if err := x.ClientStream.CloseSend(); err != nil {
-		return nil, err
-	}
-	m := new(AlgoResponse)
-	if err := x.ClientStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-func (c *agentServiceClient) Data(ctx context.Context, opts ...grpc.CallOption) (AgentService_DataClient, error) {
-	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
-	stream, err := c.cc.NewStream(ctx, &AgentService_ServiceDesc.Streams[1], AgentService_Data_FullMethodName, cOpts...)
+func (c *agentServiceClient) Data(ctx context.Context, in *DataRequest, opts ...grpc.CallOption) (*DataResponse, error) {
+	out := new(DataResponse)
+	err := c.cc.Invoke(ctx, AgentService_Data_FullMethodName, in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
-	x := &agentServiceDataClient{ClientStream: stream}
-	return x, nil
+	return out, nil
 }
 
-type AgentService_DataClient interface {
-	Send(*DataRequest) error
-	CloseAndRecv() (*DataResponse, error)
-	grpc.ClientStream
-}
-
-type agentServiceDataClient struct {
-	grpc.ClientStream
-}
-
-func (x *agentServiceDataClient) Send(m *DataRequest) error {
-	return x.ClientStream.SendMsg(m)
-}
-
-func (x *agentServiceDataClient) CloseAndRecv() (*DataResponse, error) {
-	if err := x.ClientStream.CloseSend(); err != nil {
-		return nil, err
-	}
-	m := new(DataResponse)
-	if err := x.ClientStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-func (c *agentServiceClient) Result(ctx context.Context, in *ResultRequest, opts ...grpc.CallOption) (AgentService_ResultClient, error) {
-	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
-	stream, err := c.cc.NewStream(ctx, &AgentService_ServiceDesc.Streams[2], AgentService_Result_FullMethodName, cOpts...)
+func (c *agentServiceClient) Result(ctx context.Context, in *ResultRequest, opts ...grpc.CallOption) (*ResultResponse, error) {
+	out := new(ResultResponse)
+	err := c.cc.Invoke(ctx, AgentService_Result_FullMethodName, in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
-	x := &agentServiceResultClient{ClientStream: stream}
-	if err := x.ClientStream.SendMsg(in); err != nil {
-		return nil, err
-	}
-	if err := x.ClientStream.CloseSend(); err != nil {
-		return nil, err
-	}
-	return x, nil
-}
-
-type AgentService_ResultClient interface {
-	Recv() (*ResultResponse, error)
-	grpc.ClientStream
-}
-
-type agentServiceResultClient struct {
-	grpc.ClientStream
-}
-
-func (x *agentServiceResultClient) Recv() (*ResultResponse, error) {
-	m := new(ResultResponse)
-	if err := x.ClientStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
+	return out, nil
 }
 
 func (c *agentServiceClient) Attestation(ctx context.Context, in *AttestationRequest, opts ...grpc.CallOption) (*AttestationResponse, error) {
-	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(AttestationResponse)
-	err := c.cc.Invoke(ctx, AgentService_Attestation_FullMethodName, in, out, cOpts...)
+	err := c.cc.Invoke(ctx, AgentService_Attestation_FullMethodName, in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -163,9 +86,9 @@ func (c *agentServiceClient) Attestation(ctx context.Context, in *AttestationReq
 // All implementations must embed UnimplementedAgentServiceServer
 // for forward compatibility
 type AgentServiceServer interface {
-	Algo(AgentService_AlgoServer) error
-	Data(AgentService_DataServer) error
-	Result(*ResultRequest, AgentService_ResultServer) error
+	Algo(context.Context, *AlgoRequest) (*AlgoResponse, error)
+	Data(context.Context, *DataRequest) (*DataResponse, error)
+	Result(context.Context, *ResultRequest) (*ResultResponse, error)
 	Attestation(context.Context, *AttestationRequest) (*AttestationResponse, error)
 	mustEmbedUnimplementedAgentServiceServer()
 }
@@ -174,14 +97,14 @@ type AgentServiceServer interface {
 type UnimplementedAgentServiceServer struct {
 }
 
-func (UnimplementedAgentServiceServer) Algo(AgentService_AlgoServer) error {
-	return status.Errorf(codes.Unimplemented, "method Algo not implemented")
+func (UnimplementedAgentServiceServer) Algo(context.Context, *AlgoRequest) (*AlgoResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Algo not implemented")
 }
-func (UnimplementedAgentServiceServer) Data(AgentService_DataServer) error {
-	return status.Errorf(codes.Unimplemented, "method Data not implemented")
+func (UnimplementedAgentServiceServer) Data(context.Context, *DataRequest) (*DataResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Data not implemented")
 }
-func (UnimplementedAgentServiceServer) Result(*ResultRequest, AgentService_ResultServer) error {
-	return status.Errorf(codes.Unimplemented, "method Result not implemented")
+func (UnimplementedAgentServiceServer) Result(context.Context, *ResultRequest) (*ResultResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Result not implemented")
 }
 func (UnimplementedAgentServiceServer) Attestation(context.Context, *AttestationRequest) (*AttestationResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method Attestation not implemented")
@@ -199,77 +122,58 @@ func RegisterAgentServiceServer(s grpc.ServiceRegistrar, srv AgentServiceServer)
 	s.RegisterService(&AgentService_ServiceDesc, srv)
 }
 
-func _AgentService_Algo_Handler(srv interface{}, stream grpc.ServerStream) error {
-	return srv.(AgentServiceServer).Algo(&agentServiceAlgoServer{ServerStream: stream})
-}
-
-type AgentService_AlgoServer interface {
-	SendAndClose(*AlgoResponse) error
-	Recv() (*AlgoRequest, error)
-	grpc.ServerStream
-}
-
-type agentServiceAlgoServer struct {
-	grpc.ServerStream
-}
-
-func (x *agentServiceAlgoServer) SendAndClose(m *AlgoResponse) error {
-	return x.ServerStream.SendMsg(m)
-}
-
-func (x *agentServiceAlgoServer) Recv() (*AlgoRequest, error) {
-	m := new(AlgoRequest)
-	if err := x.ServerStream.RecvMsg(m); err != nil {
+func _AgentService_Algo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AlgoRequest)
+	if err := dec(in); err != nil {
 		return nil, err
 	}
-	return m, nil
+	if interceptor == nil {
+		return srv.(AgentServiceServer).Algo(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: AgentService_Algo_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(AgentServiceServer).Algo(ctx, req.(*AlgoRequest))
+	}
+	return interceptor(ctx, in, info, handler)
 }
 
-func _AgentService_Data_Handler(srv interface{}, stream grpc.ServerStream) error {
-	return srv.(AgentServiceServer).Data(&agentServiceDataServer{ServerStream: stream})
-}
-
-type AgentService_DataServer interface {
-	SendAndClose(*DataResponse) error
-	Recv() (*DataRequest, error)
-	grpc.ServerStream
-}
-
-type agentServiceDataServer struct {
-	grpc.ServerStream
-}
-
-func (x *agentServiceDataServer) SendAndClose(m *DataResponse) error {
-	return x.ServerStream.SendMsg(m)
-}
-
-func (x *agentServiceDataServer) Recv() (*DataRequest, error) {
-	m := new(DataRequest)
-	if err := x.ServerStream.RecvMsg(m); err != nil {
+func _AgentService_Data_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(DataRequest)
+	if err := dec(in); err != nil {
 		return nil, err
 	}
-	return m, nil
-}
-
-func _AgentService_Result_Handler(srv interface{}, stream grpc.ServerStream) error {
-	m := new(ResultRequest)
-	if err := stream.RecvMsg(m); err != nil {
-		return err
+	if interceptor == nil {
+		return srv.(AgentServiceServer).Data(ctx, in)
 	}
-	return srv.(AgentServiceServer).Result(m, &agentServiceResultServer{ServerStream: stream})
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: AgentService_Data_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(AgentServiceServer).Data(ctx, req.(*DataRequest))
+	}
+	return interceptor(ctx, in, info, handler)
 }
 
-type AgentService_ResultServer interface {
-	Send(*ResultResponse) error
-	grpc.ServerStream
-}
-
-type agentServiceResultServer struct {
-	grpc.ServerStream
-}
-
-func (x *agentServiceResultServer) Send(m *ResultResponse) error {
-	return x.ServerStream.SendMsg(m)
+func _AgentService_Result_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ResultRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(AgentServiceServer).Result(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: AgentService_Result_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(AgentServiceServer).Result(ctx, req.(*ResultRequest))
+	}
+	return interceptor(ctx, in, info, handler)
 }
 
 func _AgentService_Attestation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
@@ -297,27 +201,23 @@ var AgentService_ServiceDesc = grpc.ServiceDesc{
 	ServiceName: "agent.AgentService",
 	HandlerType: (*AgentServiceServer)(nil),
 	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "Algo",
+			Handler:    _AgentService_Algo_Handler,
+		},
+		{
+			MethodName: "Data",
+			Handler:    _AgentService_Data_Handler,
+		},
+		{
+			MethodName: "Result",
+			Handler:    _AgentService_Result_Handler,
+		},
 		{
 			MethodName: "Attestation",
 			Handler:    _AgentService_Attestation_Handler,
 		},
 	},
-	Streams: []grpc.StreamDesc{
-		{
-			StreamName:    "Algo",
-			Handler:       _AgentService_Algo_Handler,
-			ClientStreams: true,
-		},
-		{
-			StreamName:    "Data",
-			Handler:       _AgentService_Data_Handler,
-			ClientStreams: true,
-		},
-		{
-			StreamName:    "Result",
-			Handler:       _AgentService_Result_Handler,
-			ServerStreams: true,
-		},
-	},
+	Streams:  []grpc.StreamDesc{},
 	Metadata: "agent/agent.proto",
 }

agent/algorithm/algorithm.go

@@ -1,49 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package algorithm
-
-import (
-	"context"
-
-	"google.golang.org/grpc/metadata"
-)
-
-type AlgorithType string
-
-const (
-	AlgoTypeBin    AlgorithType = "bin"
-	AlgoTypePython AlgorithType = "python"
-	AlgoTypeWasm   AlgorithType = "wasm"
-	AlgoTypeDocker AlgorithType = "docker"
-	AlgoTypeKey                 = "algo_type"
-	AlgoArgsKey                 = "algo_args"
-
-	ResultsDir     = "results"
-	DatasetsDir    = "datasets"
-	AlgoWorkingDir = "/cocos"
-)
-
-func AlgorithmTypeToContext(ctx context.Context, algoType string) context.Context {
-	return metadata.AppendToOutgoingContext(ctx, AlgoTypeKey, algoType)
-}
-
-func AlgorithmTypeFromContext(ctx context.Context) string {
-	return metadata.ValueFromIncomingContext(ctx, AlgoTypeKey)[0]
-}
-
-func AlgorithmArgsToContext(ctx context.Context, algoArgs []string) context.Context {
-	for _, arg := range algoArgs {
-		ctx = metadata.AppendToOutgoingContext(ctx, AlgoArgsKey, arg)
-	}
-	return ctx
-}
-
-func AlgorithmArgsFromContext(ctx context.Context) []string {
-	return metadata.ValueFromIncomingContext(ctx, AlgoArgsKey)
-}
-
-// Algorithm is an interface that specifies the API for an algorithm.
-type Algorithm interface {
-	// Run executes the algorithm and returns the result.
-	Run() error
-}

agent/algorithm/binary/binary.go

@@ -1,47 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package binary
-
-import (
-	"fmt"
-	"io"
-	"log/slog"
-	"os/exec"
-
-	"github.com/ultravioletrs/cocos/agent/algorithm"
-	"github.com/ultravioletrs/cocos/agent/events"
-)
-
-var _ algorithm.Algorithm = (*binary)(nil)
-
-type binary struct {
-	algoFile string
-	stderr   io.Writer
-	stdout   io.Writer
-	args     []string
-}
-
-func NewAlgorithm(logger *slog.Logger, eventsSvc events.Service, algoFile string, args []string) algorithm.Algorithm {
-	return &binary{
-		algoFile: algoFile,
-		stderr:   &algorithm.Stderr{Logger: logger, EventSvc: eventsSvc},
-		stdout:   &algorithm.Stdout{Logger: logger},
-		args:     args,
-	}
-}
-
-func (b *binary) Run() error {
-	cmd := exec.Command(b.algoFile, b.args...)
-	cmd.Stderr = b.stderr
-	cmd.Stdout = b.stdout
-
-	if err := cmd.Start(); err != nil {
-		return fmt.Errorf("error starting algorithm: %v", err)
-	}
-
-	if err := cmd.Wait(); err != nil {
-		return fmt.Errorf("algorithm execution error: %v", err)
-	}
-
-	return nil
-}

agent/algorithm/docker/docker.go

@@ -1,170 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package docker
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"log/slog"
-	"os"
-	"path"
-
-	"github.com/docker/docker/api/types/container"
-	"github.com/docker/docker/api/types/image"
-	"github.com/docker/docker/api/types/mount"
-	"github.com/docker/docker/client"
-	"github.com/ultravioletrs/cocos/agent/algorithm"
-	"github.com/ultravioletrs/cocos/agent/events"
-)
-
-const (
-	containerName     = "agent_container"
-	datasetsMountPath = "/cocos/datasets"
-	resultsMountPath  = "/cocos/results"
-)
-
-var _ algorithm.Algorithm = (*docker)(nil)
-
-type docker struct {
-	algoFile string
-	logger   *slog.Logger
-	stderr   io.Writer
-	stdout   io.Writer
-}
-
-func NewAlgorithm(logger *slog.Logger, eventsSvc events.Service, algoFile string) algorithm.Algorithm {
-	d := &docker{
-		algoFile: algoFile,
-		logger:   logger,
-		stderr:   &algorithm.Stderr{Logger: logger, EventSvc: eventsSvc},
-		stdout:   &algorithm.Stdout{Logger: logger},
-	}
-
-	return d
-}
-
-func (d *docker) Run() error {
-	ctx := context.Background()
-
-	// Create a new Docker client.
-	cli, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())
-	if err != nil {
-		return fmt.Errorf("could not create a new Docker client: %v", err)
-	}
-
-	// Open the Docker image tar file.
-	imageFile, err := os.Open(d.algoFile)
-	if err != nil {
-		return fmt.Errorf("could not open Docker image: %v", err)
-	}
-	defer imageFile.Close()
-
-	// Load the Docker image from the tar file.
-	resp, err := cli.ImageLoad(ctx, imageFile, true)
-	if err != nil {
-		return fmt.Errorf("could not load Docker image from file: %v", err)
-	}
-	defer resp.Body.Close()
-
-	// List the loaded images to get the image ID.
-	images, err := cli.ImageList(ctx, image.ListOptions{})
-	if err != nil {
-		return fmt.Errorf("could not get the Docker image list: %v", err)
-	}
-
-	var imageID string = ""
-	var dockerImageName string = ""
-	for _, image := range images {
-		for _, tag := range image.RepoTags {
-			imageID = image.ID
-			dockerImageName = tag
-			break
-		}
-	}
-
-	if imageID == "" {
-		return fmt.Errorf("could not find image ID")
-	}
-
-	// Create and start the container.
-	respContainer, err := cli.ContainerCreate(ctx, &container.Config{
-		Image: dockerImageName,
-	}, &container.HostConfig{
-		Mounts: []mount.Mount{
-			{
-				Type:   mount.TypeBind,
-				Source: path.Join(algorithm.AlgoWorkingDir, algorithm.DatasetsDir),
-				Target: datasetsMountPath,
-			},
-			{
-				Type:   mount.TypeBind,
-				Source: path.Join(algorithm.AlgoWorkingDir, algorithm.ResultsDir),
-				Target: resultsMountPath,
-			},
-		},
-	}, nil, nil, containerName)
-	if err != nil {
-		return fmt.Errorf("could not create a Docker container: %v", err)
-	}
-
-	if err := cli.ContainerStart(ctx, respContainer.ID, container.StartOptions{}); err != nil {
-		return fmt.Errorf("could not start a Docker container: %v", err)
-	}
-
-	statusCh, errCh := cli.ContainerWait(ctx, respContainer.ID, container.WaitConditionNotRunning)
-	select {
-	case err := <-errCh:
-		if err != nil {
-			return fmt.Errorf("could not wait for a Docker container: %v", err)
-		}
-	case <-statusCh:
-	}
-
-	stdout, err := cli.ContainerLogs(ctx, respContainer.ID, container.LogsOptions{ShowStdout: true})
-	if err != nil {
-		return fmt.Errorf("could not read stdout from the container: %v", err)
-	}
-	defer stdout.Close()
-
-	err = writeToOut(stdout, d.stdout)
-	if err != nil {
-		d.logger.Warn(fmt.Sprintf("could not write to stdout: %v", err))
-	}
-
-	stderr, err := cli.ContainerLogs(ctx, respContainer.ID, container.LogsOptions{ShowStderr: true})
-	if err != nil {
-		d.logger.Warn(fmt.Sprintf("could not read stderr from the container: %v", err))
-	}
-	defer stderr.Close()
-
-	err = writeToOut(stderr, d.stderr)
-	if err != nil {
-		d.logger.Warn(fmt.Sprintf("could not write to stderr: %v", err))
-	}
-
-	defer func() {
-		if err = cli.ContainerRemove(ctx, respContainer.ID, container.RemoveOptions{Force: true}); err != nil {
-			d.logger.Warn(fmt.Sprintf("error could not remove container: %v", err))
-		}
-
-		if _, err := cli.ImageRemove(ctx, imageID, image.RemoveOptions{Force: true}); err != nil {
-			d.logger.Warn(fmt.Sprintf("error could not remove image: %v", err))
-		}
-	}()
-
-	return nil
-}
-
-func writeToOut(readCloser io.ReadCloser, ioWriter io.Writer) error {
-	content, err := io.ReadAll(readCloser)
-	if err != nil {
-		return fmt.Errorf("could not convert content from the container: %v", err)
-	}
-
-	if _, err := ioWriter.Write(content); err != nil {
-		return fmt.Errorf("could not write to output: %v", err)
-	}
-
-	return nil
-}

agent/algorithm/logging.go

@@ -1,73 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package algorithm
-
-import (
-	"bytes"
-	"io"
-	"log/slog"
-
-	"github.com/ultravioletrs/cocos/agent/events"
-)
-
-var (
-	_ io.Writer = &Stdout{}
-	_ io.Writer = &Stderr{}
-)
-
-const bufSize = 1024
-
-type Stdout struct {
-	Logger *slog.Logger
-}
-
-// Write implements io.Writer.
-func (s *Stdout) Write(p []byte) (n int, err error) {
-	inBuf := bytes.NewBuffer(p)
-
-	buf := make([]byte, bufSize)
-
-	for {
-		n, err := inBuf.Read(buf)
-		if err != nil {
-			if err == io.EOF {
-				break
-			}
-			return len(p) - inBuf.Len(), err
-		}
-
-		s.Logger.Debug(string(buf[:n]))
-	}
-
-	return len(p), nil
-}
-
-type Stderr struct {
-	Logger   *slog.Logger
-	EventSvc events.Service
-}
-
-// Write implements io.Writer.
-func (s *Stderr) Write(p []byte) (n int, err error) {
-	inBuf := bytes.NewBuffer(p)
-
-	buf := make([]byte, bufSize)
-
-	for {
-		n, err := inBuf.Read(buf)
-		if err != nil {
-			if err == io.EOF {
-				break
-			}
-			return len(p) - inBuf.Len(), err
-		}
-
-		s.Logger.Error(string(buf[:n]))
-	}
-
-	if err := s.EventSvc.SendEvent("algorithm-run", "error", nil); err != nil {
-		return len(p), err
-	}
-
-	return len(p), nil
-}

agent/algorithm/logging_test.go

@@ -1,85 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package algorithm
-
-import (
-	"strings"
-	"testing"
-
-	mglog "github.com/absmach/magistrala/logger"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
-	"github.com/ultravioletrs/cocos/agent/events/mocks"
-)
-
-func TestStdoutWrite(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    string
-		expected []string
-	}{
-		{
-			name:     "Single line",
-			input:    "Hello, World!",
-			expected: []string{"Hello, World!"},
-		},
-		{
-			name:     "Multiple lines",
-			input:    "Line 1\nLine 2\nLine 3",
-			expected: []string{"Line 1\nLine 2\nLine 3"},
-		},
-		{
-			name:     "Long input",
-			input:    strings.Repeat("a", bufSize+100),
-			expected: []string{strings.Repeat("a", bufSize), strings.Repeat("a", 100)},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			stdout := &Stdout{Logger: mglog.NewMock()}
-			n, err := stdout.Write([]byte(tt.input))
-
-			assert.NoError(t, err)
-			assert.Equal(t, len(tt.input), n)
-		})
-	}
-}
-
-func TestStderrWrite(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    string
-		expected []string
-	}{
-		{
-			name:     "Single line",
-			input:    "Error: Something went wrong",
-			expected: []string{"Error: Something went wrong"},
-		},
-		{
-			name:     "Multiple lines",
-			input:    "Error 1\nError 2\nError 3",
-			expected: []string{"Error 1\nError 2\nError 3"},
-		},
-		{
-			name:     "Long input",
-			input:    strings.Repeat("e", bufSize+100),
-			expected: []string{strings.Repeat("e", bufSize), strings.Repeat("e", 100)},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			mockEventService := mocks.NewService(t)
-			mockEventService.On("SendEvent", "algorithm-run", "error", mock.Anything).Return(nil)
-
-			stderr := &Stderr{Logger: mglog.NewMock(), EventSvc: mockEventService}
-			n, err := stderr.Write([]byte(tt.input))
-
-			assert.NoError(t, err)
-			assert.Equal(t, len(tt.input), n)
-			mockEventService.AssertExpectations(t)
-		})
-	}
-}

agent/algorithm/python/python.go

@@ -1,97 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package python
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"log/slog"
-	"os"
-	"os/exec"
-	"path/filepath"
-
-	"github.com/ultravioletrs/cocos/agent/algorithm"
-	"github.com/ultravioletrs/cocos/agent/events"
-	"google.golang.org/grpc/metadata"
-)
-
-const (
-	PyRuntime    = "python3"
-	pyRuntimeKey = "python_runtime"
-)
-
-func PythonRunTimeToContext(ctx context.Context, runtime string) context.Context {
-	return metadata.AppendToOutgoingContext(ctx, pyRuntimeKey, runtime)
-}
-
-func PythonRunTimeFromContext(ctx context.Context) string {
-	return metadata.ValueFromIncomingContext(ctx, pyRuntimeKey)[0]
-}
-
-var _ algorithm.Algorithm = (*python)(nil)
-
-type python struct {
-	algoFile         string
-	stderr           io.Writer
-	stdout           io.Writer
-	runtime          string
-	requirementsFile string
-	args             []string
-}
-
-func NewAlgorithm(logger *slog.Logger, eventsSvc events.Service, runtime, requirementsFile, algoFile string, args []string) algorithm.Algorithm {
-	p := &python{
-		algoFile:         algoFile,
-		stderr:           &algorithm.Stderr{Logger: logger, EventSvc: eventsSvc},
-		stdout:           &algorithm.Stdout{Logger: logger},
-		requirementsFile: requirementsFile,
-		args:             args,
-	}
-	if runtime != "" {
-		p.runtime = runtime
-	} else {
-		p.runtime = PyRuntime
-	}
-	return p
-}
-
-func (p *python) Run() error {
-	venvPath := "venv"
-	createVenvCmd := exec.Command(p.runtime, "-m", "venv", venvPath)
-	createVenvCmd.Stderr = p.stderr
-	createVenvCmd.Stdout = p.stdout
-	if err := createVenvCmd.Run(); err != nil {
-		return fmt.Errorf("error creating virtual environment: %v", err)
-	}
-
-	pythonPath := filepath.Join(venvPath, "bin", "python")
-
-	if p.requirementsFile != "" {
-		rcmd := exec.Command(pythonPath, "-m", "pip", "install", "-r", p.requirementsFile)
-		rcmd.Stderr = p.stderr
-		rcmd.Stdout = p.stdout
-		if err := rcmd.Run(); err != nil {
-			return fmt.Errorf("error installing requirements: %v", err)
-		}
-	}
-
-	args := append([]string{p.algoFile}, p.args...)
-	cmd := exec.Command(pythonPath, args...)
-	cmd.Stderr = p.stderr
-	cmd.Stdout = p.stdout
-
-	if err := cmd.Start(); err != nil {
-		return fmt.Errorf("error starting algorithm: %v", err)
-	}
-
-	if err := cmd.Wait(); err != nil {
-		return fmt.Errorf("algorithm execution error: %v", err)
-	}
-
-	if err := os.RemoveAll(venvPath); err != nil {
-		return fmt.Errorf("error removing virtual environment: %v", err)
-	}
-
-	return nil
-}

agent/algorithm/results_test.go

@@ -1,82 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package algorithm_test
-
-import (
-	"os"
-	"testing"
-
-	"github.com/ultravioletrs/cocos/agent/algorithm"
-	"github.com/ultravioletrs/cocos/internal"
-)
-
-func TestZipDirectory(t *testing.T) {
-	cases := []struct {
-		name        string
-		directories []string
-		files       []string
-		expected    []string
-	}{
-		{
-			name:        "empty directory",
-			directories: []string{"testdata"},
-		},
-		{
-			name:  "single file",
-			files: []string{"file1.txt"},
-		},
-		{
-			name:        "directory with single file",
-			directories: []string{"testdata"},
-			expected:    []string{"testdata/file1.txt"},
-		},
-		{
-			name:        "directory with multiple files",
-			directories: []string{"testdata"},
-			expected: []string{
-				"testdata/file1.txt",
-				"testdata/file2.txt",
-				"testdata/file3.txt",
-			},
-		},
-		{
-			name:        "nested directories",
-			directories: []string{"testdata", "testdata/nested"},
-			expected: []string{
-				"testdata/nested/file1.txt",
-				"testdata/nested/file2.txt",
-				"testdata/nested/file3.txt",
-			},
-		},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			if err := os.Mkdir(algorithm.ResultsDir, 0o755); err != nil {
-				t.Fatalf("error creating results directory: %s", err.Error())
-			}
-			defer func() {
-				if err := os.RemoveAll(algorithm.ResultsDir); err != nil {
-					t.Fatalf("error removing results directory and its contents: %s", err.Error())
-				}
-			}()
-
-			for _, dir := range tc.directories {
-				if dir != "" {
-					if err := os.Mkdir(algorithm.ResultsDir+"/"+dir, 0o755); err != nil {
-						t.Fatalf("error creating test directory: %s", err.Error())
-					}
-				}
-			}
-			for _, file := range tc.files {
-				if _, err := os.Create(algorithm.ResultsDir + "/" + file); err != nil {
-					t.Fatalf("error creating test file: %s", err.Error())
-				}
-			}
-
-			if _, err := internal.ZipDirectoryToMemory(algorithm.ResultsDir); err != nil {
-				t.Errorf("ZipDirectory() error = %v", err)
-			}
-		})
-	}
-}

agent/algorithm/wasm/wasm.go

@@ -1,53 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package wasm
-
-import (
-	"fmt"
-	"io"
-	"log/slog"
-	"os/exec"
-
-	"github.com/ultravioletrs/cocos/agent/algorithm"
-	"github.com/ultravioletrs/cocos/agent/events"
-)
-
-const wasmRuntime = "wasmedge"
-
-var mapDirOption = []string{"--dir", ".:" + algorithm.ResultsDir}
-
-var _ algorithm.Algorithm = (*wasm)(nil)
-
-type wasm struct {
-	algoFile string
-	stderr   io.Writer
-	stdout   io.Writer
-	args     []string
-}
-
-func NewAlgorithm(logger *slog.Logger, eventsSvc events.Service, algoFile string, args []string) algorithm.Algorithm {
-	return &wasm{
-		algoFile: algoFile,
-		stderr:   &algorithm.Stderr{Logger: logger, EventSvc: eventsSvc},
-		stdout:   &algorithm.Stdout{Logger: logger},
-		args:     args,
-	}
-}
-
-func (w *wasm) Run() error {
-	args := append(mapDirOption, w.algoFile)
-	args = append(args, w.args...)
-	cmd := exec.Command(wasmRuntime, args...)
-	cmd.Stderr = w.stderr
-	cmd.Stdout = w.stdout
-
-	if err := cmd.Start(); err != nil {
-		return fmt.Errorf("error starting algorithm: %v", err)
-	}
-
-	if err := cmd.Wait(); err != nil {
-		return fmt.Errorf("algorithm execution error: %v", err)
-	}
-
-	return nil
-}

agent/api/grpc/client.go

@@ -0,0 +1,218 @@
+// Copyright (c) Ultraviolet
+// SPDX-License-Identifier: Apache-2.0
+package grpc
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/go-kit/kit/endpoint"
+	kitgrpc "github.com/go-kit/kit/transport/grpc"
+	"github.com/ultravioletrs/cocos/agent"
+	"google.golang.org/grpc"
+)
+
+const svcName = "agent.AgentService"
+
+type grpcClient struct {
+	algo        endpoint.Endpoint
+	data        endpoint.Endpoint
+	result      endpoint.Endpoint
+	attestation endpoint.Endpoint
+	timeout     time.Duration
+}
+
+// NewClient returns new gRPC client instance.
+func NewClient(conn *grpc.ClientConn, timeout time.Duration) agent.AgentServiceClient {
+	return &grpcClient{
+		algo: kitgrpc.NewClient(
+			conn,
+			svcName,
+			"Algo",
+			encodeAlgoRequest,
+			decodeAlgoResponse,
+			agent.AlgoResponse{},
+		).Endpoint(),
+		data: kitgrpc.NewClient(
+			conn,
+			svcName,
+			"Data",
+			encodeDataRequest,
+			decodeDataResponse,
+			agent.DataResponse{},
+		).Endpoint(),
+		result: kitgrpc.NewClient(
+			conn,
+			svcName,
+			"Result",
+			encodeResultRequest,
+			decodeResultResponse,
+			agent.ResultResponse{},
+		).Endpoint(),
+		attestation: kitgrpc.NewClient(
+			conn,
+			svcName,
+			"Attestation",
+			encodeAttestationRequest,
+			decodeAttestationResponse,
+			agent.AttestationResponse{},
+		).Endpoint(),
+		timeout: timeout,
+	}
+}
+
+// encodeAlgoRequest is a transport/grpc.EncodeRequestFunc that
+// converts a user-domain algoReq to a gRPC request.
+func encodeAlgoRequest(_ context.Context, request interface{}) (interface{}, error) {
+	req, ok := request.(*algoReq)
+	if !ok {
+		return nil, fmt.Errorf("invalid request type: %T", request)
+	}
+
+	return &agent.AlgoRequest{
+		Algorithm: req.Algorithm,
+		Provider:  req.Provider,
+		Id:        req.Id,
+	}, nil
+}
+
+// decodeAlgoResponse is a transport/grpc.DecodeResponseFunc that
+// converts a gRPC AlgoResponse to a user-domain response.
+func decodeAlgoResponse(_ context.Context, grpcResponse interface{}) (interface{}, error) {
+	_, ok := grpcResponse.(*agent.AlgoResponse)
+	if !ok {
+		return nil, fmt.Errorf("invalid response type: %T", grpcResponse)
+	}
+
+	return algoRes{}, nil
+}
+
+// encodeDataRequest is a transport/grpc.EncodeRequestFunc that
+// converts a user-domain dataReq to a gRPC request.
+func encodeDataRequest(_ context.Context, request interface{}) (interface{}, error) {
+	req, ok := request.(*dataReq)
+	if !ok {
+		return nil, fmt.Errorf("invalid request type: %T", request)
+	}
+
+	return &agent.DataRequest{
+		Dataset:  req.Dataset,
+		Provider: req.Provider,
+		Id:       req.Id,
+	}, nil
+}
+
+// decodeDataResponse is a transport/grpc.DecodeResponseFunc that
+// converts a gRPC DataResponse to a user-domain response.
+func decodeDataResponse(_ context.Context, grpcResponse interface{}) (interface{}, error) {
+	_, ok := grpcResponse.(*agent.DataResponse)
+	if !ok {
+		return nil, fmt.Errorf("invalid response type: %T", grpcResponse)
+	}
+
+	return dataRes{}, nil
+}
+
+// encodeResultRequest is a transport/grpc.EncodeRequestFunc that
+// converts a user-domain resultReq to a gRPC request.
+func encodeResultRequest(_ context.Context, request interface{}) (interface{}, error) {
+	req, ok := request.(*resultReq)
+	if !ok {
+		return nil, fmt.Errorf("invalid request type: %T", request)
+	}
+
+	return &agent.ResultRequest{
+		Consumer: req.Consumer,
+	}, nil
+}
+
+// decodeResultResponse is a transport/grpc.DecodeResponseFunc that
+// converts a gRPC ResultResponse to a user-domain response.
+func decodeResultResponse(_ context.Context, grpcResponse interface{}) (interface{}, error) {
+	response, ok := grpcResponse.(*agent.ResultResponse)
+	if !ok {
+		return nil, fmt.Errorf("invalid response type: %T", grpcResponse)
+	}
+
+	return resultRes{
+		File: response.File,
+	}, nil
+}
+
+// encodeAttestationRequest is a transport/grpc.EncodeRequestFunc that
+// converts a user-domain attestationReq to a gRPC request.
+func encodeAttestationRequest(_ context.Context, request interface{}) (interface{}, error) {
+	req, ok := request.(*attestationReq)
+	if !ok {
+		return nil, fmt.Errorf("invalid request type: %T", request)
+	}
+	return &agent.AttestationRequest{ReportData: req.ReportData[:]}, nil
+}
+
+// decodeAttestationResponse is a transport/grpc.DecodeResponseFunc that
+// converts a gRPC AttestationResponse to a user-domain response.
+func decodeAttestationResponse(_ context.Context, grpcResponse interface{}) (interface{}, error) {
+	response, ok := grpcResponse.(*agent.AttestationResponse)
+	if !ok {
+		return nil, fmt.Errorf("invalid response type: %T", grpcResponse)
+	}
+
+	return attestationRes{
+		File: response.File,
+	}, nil
+}
+
+// Algo implements the Algo method of the agent.AgentServiceClient interface.
+func (c grpcClient) Algo(ctx context.Context, request *agent.AlgoRequest, _ ...grpc.CallOption) (*agent.AlgoResponse, error) {
+	ctx, cancel := context.WithTimeout(ctx, c.timeout)
+	defer cancel()
+
+	_, err := c.algo(ctx, &algoReq{Algorithm: request.Algorithm, Provider: request.Provider, Id: request.Id})
+	if err != nil {
+		return nil, err
+	}
+
+	return &agent.AlgoResponse{}, nil
+}
+
+// Data implements the Data method of the agent.AgentServiceClient interface.
+func (c grpcClient) Data(ctx context.Context, request *agent.DataRequest, _ ...grpc.CallOption) (*agent.DataResponse, error) {
+	ctx, cancel := context.WithTimeout(ctx, c.timeout)
+	defer cancel()
+
+	_, err := c.data(ctx, &dataReq{Dataset: request.Dataset, Provider: request.Provider, Id: request.Id})
+	if err != nil {
+		return nil, err
+	}
+
+	return &agent.DataResponse{}, nil
+}
+
+// Result implements the Result method of the agent.AgentServiceClient interface.
+func (c grpcClient) Result(ctx context.Context, request *agent.ResultRequest, _ ...grpc.CallOption) (*agent.ResultResponse, error) {
+	ctx, cancel := context.WithTimeout(ctx, c.timeout)
+	defer cancel()
+
+	res, err := c.result(ctx, &resultReq{Consumer: request.Consumer})
+	if err != nil {
+		return nil, err
+	}
+
+	resultRes := res.(resultRes)
+	return &agent.ResultResponse{File: resultRes.File}, nil
+}
+
+// Result implements the Result method of the agent.AgentServiceClient interface.
+func (c grpcClient) Attestation(ctx context.Context, request *agent.AttestationRequest, _ ...grpc.CallOption) (*agent.AttestationResponse, error) {
+	ctx, cancel := context.WithTimeout(ctx, c.timeout)
+	defer cancel()
+
+	res, err := c.attestation(ctx, &attestationReq{ReportData: [agent.ReportDataSize]byte(request.ReportData)})
+	if err != nil {
+		return nil, err
+	}
+
+	attestationRes := res.(attestationRes)
+	return &agent.AttestationResponse{File: attestationRes.File}, nil
+}

agent/api/grpc/endpoint.go

@@ -17,7 +17,7 @@ func algoEndpoint(svc agent.Service) endpoint.Endpoint {
 			return algoRes{}, err
 		}
 
-		algo := agent.Algorithm{Algorithm: req.Algorithm, Requirements: req.Requirements}
+		algo := agent.Algorithm{Algorithm: req.Algorithm, Provider: req.Provider, ID: req.Id}
 
 		err := svc.Algo(ctx, algo)
 		if err != nil {
@@ -36,7 +36,7 @@ func dataEndpoint(svc agent.Service) endpoint.Endpoint {
 			return dataRes{}, err
 		}
 
-		dataset := agent.Dataset{Dataset: req.Dataset, Filename: req.Filename}
+		dataset := agent.Dataset{Dataset: req.Dataset, Provider: req.Provider, ID: req.Id}
 
 		err := svc.Data(ctx, dataset)
 		if err != nil {
@@ -54,7 +54,7 @@ func resultEndpoint(svc agent.Service) endpoint.Endpoint {
 		if err := req.validate(); err != nil {
 			return resultRes{}, err
 		}
-		file, err := svc.Result(ctx)
+		file, err := svc.Result(ctx, req.Consumer)
 		if err != nil {
 			return resultRes{}, err
 		}

agent/api/grpc/interceptors.go

@@ -1,74 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package grpc
-
-import (
-	"context"
-
-	"github.com/ultravioletrs/cocos/agent"
-	"github.com/ultravioletrs/cocos/agent/auth"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/codes"
-	"google.golang.org/grpc/status"
-)
-
-type authInterceptor struct {
-	auth auth.Authenticator
-}
-
-type wrappedServerStream struct {
-	grpc.ServerStream
-	ctx context.Context
-}
-
-func (s *wrappedServerStream) Context() context.Context {
-	return s.ctx
-}
-
-func NewAuthInterceptor(authSvc auth.Authenticator) (grpc.UnaryServerInterceptor, grpc.StreamServerInterceptor) {
-	ai := &authInterceptor{auth: authSvc}
-	return ai.AuthUnaryInterceptor(), ai.AuthStreamInterceptor()
-}
-
-func (s *authInterceptor) AuthStreamInterceptor() grpc.StreamServerInterceptor {
-	return func(srv interface{}, stream grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
-		switch info.FullMethod {
-		case agent.AgentService_Algo_FullMethodName:
-			if _, err := s.auth.AuthenticateUser(stream.Context(), auth.AlgorithmProviderRole); err != nil {
-				return status.Errorf(codes.Unauthenticated, err.Error())
-			}
-			return handler(srv, stream)
-		case agent.AgentService_Data_FullMethodName:
-			ctx, err := s.auth.AuthenticateUser(stream.Context(), auth.DataProviderRole)
-			if err != nil {
-				return status.Errorf(codes.Unauthenticated, err.Error())
-			}
-			wrapped := &wrappedServerStream{ServerStream: stream, ctx: ctx}
-			return handler(srv, wrapped)
-		case agent.AgentService_Result_FullMethodName:
-			ctx, err := s.auth.AuthenticateUser(stream.Context(), auth.ConsumerRole)
-			if err != nil {
-				return status.Errorf(codes.Unauthenticated, err.Error())
-			}
-			wrapped := &wrappedServerStream{ServerStream: stream, ctx: ctx}
-			return handler(srv, wrapped)
-		default:
-			return handler(srv, stream)
-		}
-	}
-}
-
-func (s *authInterceptor) AuthUnaryInterceptor() grpc.UnaryServerInterceptor {
-	return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
-		switch info.FullMethod {
-		case agent.AgentService_Result_FullMethodName:
-			ctx, err := s.auth.AuthenticateUser(ctx, auth.ConsumerRole)
-			if err != nil {
-				return nil, status.Errorf(codes.Unauthenticated, err.Error())
-			}
-			return handler(ctx, req)
-		default:
-			return handler(ctx, req)
-		}
-	}
-}

agent/api/grpc/interceptors_test.go

@@ -1,152 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package grpc
-
-import (
-	"context"
-	"testing"
-
-	"github.com/stretchr/testify/mock"
-	"github.com/ultravioletrs/cocos/agent"
-	"github.com/ultravioletrs/cocos/agent/auth"
-	"github.com/ultravioletrs/cocos/agent/mocks"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/metadata"
-)
-
-func TestAuthUnaryInterceptor(t *testing.T) {
-	authmock := new(mocks.Authenticator)
-	tests := []struct {
-		name       string
-		authorized bool
-		method     string
-		role       auth.UserRole
-		wantErr    bool
-	}{
-		{
-			name:       "authorized result method",
-			authorized: true,
-			method:     agent.AgentService_Result_FullMethodName,
-			role:       auth.ConsumerRole,
-			wantErr:    false,
-		},
-		{
-			name:       "unauthorized result method",
-			authorized: false,
-			method:     agent.AgentService_Result_FullMethodName,
-			role:       auth.ConsumerRole,
-			wantErr:    true,
-		},
-		{
-			name:       "other method",
-			authorized: false,
-			method:     "OtherMethod",
-			role:       auth.ConsumerRole,
-			wantErr:    false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			switch tt.authorized {
-			case true:
-				mockCall := authmock.On("AuthenticateUser", context.Background(), tt.role).Return(context.Background(), nil)
-				mockCall.Once()
-			case false:
-				mockCall := authmock.On("AuthenticateUser", context.Background(), tt.role).Return(context.Background(), auth.ErrMissingMetadata)
-				mockCall.Once()
-			}
-			unaryInt, _ := NewAuthInterceptor(authmock)
-
-			_, err := unaryInt(context.Background(), nil, &grpc.UnaryServerInfo{FullMethod: tt.method}, func(ctx context.Context, req interface{}) (interface{}, error) {
-				return nil, nil
-			})
-
-			if tt.wantErr && err == nil {
-				t.Errorf("expected error, got none")
-			} else if !tt.wantErr && err != nil {
-				t.Errorf("unexpected error: %v", err)
-			}
-		})
-	}
-}
-
-func TestAuthStreamInterceptor(t *testing.T) {
-	authmock := new(mocks.Authenticator)
-	tests := []struct {
-		name       string
-		authorized bool
-		method     string
-		role       auth.UserRole
-		wantErr    bool
-	}{
-		{
-			name:       "authorized algo method",
-			authorized: true,
-			method:     agent.AgentService_Algo_FullMethodName,
-			role:       auth.AlgorithmProviderRole,
-			wantErr:    false,
-		},
-		{
-			name:       "unauthorized algo method",
-			authorized: false,
-			method:     agent.AgentService_Algo_FullMethodName,
-			role:       auth.AlgorithmProviderRole,
-			wantErr:    true,
-		},
-		{
-			name:       "authorized data method",
-			authorized: true,
-			method:     agent.AgentService_Data_FullMethodName,
-			role:       auth.DataProviderRole,
-			wantErr:    false,
-		},
-		{
-			name:       "unauthorized data method",
-			authorized: false,
-			method:     agent.AgentService_Data_FullMethodName,
-			role:       auth.DataProviderRole,
-			wantErr:    true,
-		},
-		{
-			name:       "other method",
-			authorized: false,
-			method:     "OtherMethod",
-			role:       auth.DataProviderRole,
-			wantErr:    false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			switch tt.authorized {
-			case true:
-				mockCall := authmock.On("AuthenticateUser", mock.Anything, tt.role).Return(context.Background(), nil)
-				mockCall.Once()
-			case false:
-				mockCall := authmock.On("AuthenticateUser", mock.Anything, tt.role).Return(context.Background(), auth.ErrMissingMetadata)
-				mockCall.Once()
-			}
-			_, streamInt := NewAuthInterceptor(authmock)
-
-			err := streamInt(nil, &mockServerStream{ctx: metadata.NewIncomingContext(context.Background(), metadata.Pairs())}, &grpc.StreamServerInfo{FullMethod: tt.method}, func(srv interface{}, stream grpc.ServerStream) error {
-				return nil
-			})
-
-			if tt.wantErr && err == nil {
-				t.Errorf("expected error, got none")
-			} else if !tt.wantErr && err != nil {
-				t.Errorf("unexpected error: %v", err)
-			}
-		})
-	}
-}
-
-type mockServerStream struct {
-	grpc.ServerStream
-	ctx context.Context
-}
-
-func (m *mockServerStream) Context() context.Context {
-	return m.ctx
-}

agent/api/grpc/requests.go

@@ -7,30 +7,46 @@ import (
 )
 
 type algoReq struct {
-	Algorithm    []byte `protobuf:"bytes,1,opt,name=algorithm,proto3" json:"algorithm,omitempty"`
-	Requirements []byte
+	Algorithm []byte `protobuf:"bytes,1,opt,name=algorithm,proto3" json:"algorithm,omitempty"`
+	Provider  string `protobuf:"bytes,2,opt,name=provider,proto3" json:"provider,omitempty"`
+	Id        string `protobuf:"bytes,3,opt,name=id,proto3" json:"id,omitempty"`
 }
 
 func (req algoReq) validate() error {
 	if len(req.Algorithm) == 0 {
 		return errors.New("algorithm binary is required")
 	}
+	if req.Id == "" {
+		return errors.New("malformed entity")
+	}
+	if req.Provider == "" {
+		return errors.New("malformed entity")
+	}
 	return nil
 }
 
 type dataReq struct {
 	Dataset  []byte `protobuf:"bytes,1,opt,name=dataset,proto3" json:"dataset,omitempty"`
-	Filename string
+	Provider string `protobuf:"bytes,2,opt,name=provider,proto3" json:"provider,omitempty"`
+	Id       string `protobuf:"bytes,3,opt,name=id,proto3" json:"id,omitempty"`
 }
 
 func (req dataReq) validate() error {
 	if len(req.Dataset) == 0 {
 		return errors.New("dataset CSV file is required")
 	}
+	if req.Id == "" {
+		return errors.New("malformed entity")
+	}
+	if req.Provider == "" {
+		return errors.New("malformed entity")
+	}
 	return nil
 }
 
-type resultReq struct{}
+type resultReq struct {
+	Consumer string `protobuf:"bytes,1,opt,name=consumer,proto3" json:"consumer,omitempty"`
+}
 
 func (req resultReq) validate() error {
 	// No request parameters to validate, so no validation logic needed

agent/api/grpc/server.go

@@ -3,21 +3,13 @@
 package grpc
 
 import (
-	"bytes"
 	"context"
 	"errors"
-	"io"
 
 	"github.com/go-kit/kit/transport/grpc"
 	"github.com/ultravioletrs/cocos/agent"
-	"google.golang.org/grpc/codes"
-	"google.golang.org/grpc/status"
 )
 
-const bufferSize = 1024 * 1024
-
-var _ agent.AgentServiceServer = (*grpcServer)(nil)
-
 type grpcServer struct {
 	algo        grpc.Handler
 	data        grpc.Handler
@@ -56,8 +48,9 @@ func decodeAlgoRequest(_ context.Context, grpcReq interface{}) (interface{}, err
 	req := grpcReq.(*agent.AlgoRequest)
 
 	return algoReq{
-		Algorithm:    req.Algorithm,
-		Requirements: req.Requirements,
+		Algorithm: req.Algorithm,
+		Provider:  req.Provider,
+		Id:        req.Id,
 	}, nil
 }
 
@@ -70,7 +63,8 @@ func decodeDataRequest(_ context.Context, grpcReq interface{}) (interface{}, err
 
 	return dataReq{
 		Dataset:  req.Dataset,
-		Filename: req.Filename,
+		Provider: req.Provider,
+		Id:       req.Id,
 	}, nil
 }
 
@@ -79,7 +73,8 @@ func encodeDataResponse(_ context.Context, response interface{}) (interface{}, e
 }
 
 func decodeResultRequest(_ context.Context, grpcReq interface{}) (interface{}, error) {
-	return resultReq{}, nil
+	req := grpcReq.(*agent.ResultRequest)
+	return resultReq{Consumer: req.Consumer}, nil
 }
 
 func encodeResultResponse(_ context.Context, response interface{}) (interface{}, error) {
@@ -104,77 +99,31 @@ func encodeAttestationResponse(_ context.Context, response interface{}) (interfa
 	}, nil
 }
 
-// Algo implements agent.AgentServiceServer.
-func (s *grpcServer) Algo(stream agent.AgentService_AlgoServer) error {
-	var algoFile, reqFile []byte
-	for {
-		algoChunk, err := stream.Recv()
-		if err == io.EOF {
-			break
-		}
-		if err != nil {
-			return status.Error(codes.Internal, err.Error())
-		}
-		algoFile = append(algoFile, algoChunk.Algorithm...)
-		reqFile = append(reqFile, algoChunk.Requirements...)
-	}
-	_, res, err := s.algo.ServeGRPC(stream.Context(), &agent.AlgoRequest{Algorithm: algoFile, Requirements: reqFile})
+func (s *grpcServer) Algo(ctx context.Context, req *agent.AlgoRequest) (*agent.AlgoResponse, error) {
+	_, res, err := s.algo.ServeGRPC(ctx, req)
 	if err != nil {
-		return err
+		return nil, err
 	}
 	ar := res.(*agent.AlgoResponse)
-	return stream.SendAndClose(ar)
+	return ar, nil
 }
 
-// Data implements agent.AgentServiceServer.
-func (s *grpcServer) Data(stream agent.AgentService_DataServer) error {
-	var dataFile []byte
-	var filename string
-	for {
-		dataChunk, err := stream.Recv()
-		if err == io.EOF {
-			break
-		}
-		if err != nil {
-			return status.Error(codes.Internal, err.Error())
-		}
-		dataFile = append(dataFile, dataChunk.Dataset...)
-		filename = dataChunk.Filename
-	}
-	_, res, err := s.data.ServeGRPC(stream.Context(), &agent.DataRequest{Dataset: dataFile, Filename: filename})
+func (s *grpcServer) Data(ctx context.Context, req *agent.DataRequest) (*agent.DataResponse, error) {
+	_, res, err := s.data.ServeGRPC(ctx, req)
 	if err != nil {
-		return err
+		return nil, err
 	}
-	ar := res.(*agent.DataResponse)
-	return stream.SendAndClose(ar)
+	dr := res.(*agent.DataResponse)
+	return dr, nil
 }
 
-func (s *grpcServer) Result(req *agent.ResultRequest, stream agent.AgentService_ResultServer) error {
-	_, res, err := s.result.ServeGRPC(stream.Context(), req)
+func (s *grpcServer) Result(ctx context.Context, req *agent.ResultRequest) (*agent.ResultResponse, error) {
+	_, res, err := s.result.ServeGRPC(ctx, req)
 	if err != nil {
-		return err
+		return nil, err
 	}
 	rr := res.(*agent.ResultResponse)
-
-	reusltBuffer := bytes.NewBuffer(rr.File)
-
-	buf := make([]byte, bufferSize)
-
-	for {
-		n, err := reusltBuffer.Read(buf)
-		if err == io.EOF {
-			break
-		}
-		if err != nil {
-			return status.Error(codes.Internal, err.Error())
-		}
-
-		if err := stream.Send(&agent.ResultResponse{File: buf[:n]}); err != nil {
-			return status.Error(codes.Internal, err.Error())
-		}
-	}
-
-	return nil
+	return rr, nil
 }
 
 func (s *grpcServer) Attestation(ctx context.Context, req *agent.AttestationRequest) (*agent.AttestationResponse, error) {

agent/api/logging.go

@@ -53,7 +53,7 @@ func (lm *loggingMiddleware) Data(ctx context.Context, dataset agent.Dataset) (e
 	return lm.svc.Data(ctx, dataset)
 }
 
-func (lm *loggingMiddleware) Result(ctx context.Context) (response []byte, err error) {
+func (lm *loggingMiddleware) Result(ctx context.Context, consumer string) (response []byte, err error) {
 	defer func(begin time.Time) {
 		message := fmt.Sprintf("Method Result took %s to complete", time.Since(begin))
 		if err != nil {
@@ -63,7 +63,7 @@ func (lm *loggingMiddleware) Result(ctx context.Context) (response []byte, err e
 		lm.logger.Info(fmt.Sprintf("%s without errors", message))
 	}(time.Now())
 
-	return lm.svc.Result(ctx)
+	return lm.svc.Result(ctx, consumer)
 }
 
 func (lm *loggingMiddleware) Attestation(ctx context.Context, reportData [agent.ReportDataSize]byte) (response []byte, err error) {

agent/api/metrics.go

@@ -50,13 +50,13 @@ func (ms *metricsMiddleware) Data(ctx context.Context, dataset agent.Dataset) er
 	return ms.svc.Data(ctx, dataset)
 }
 
-func (ms *metricsMiddleware) Result(ctx context.Context) ([]byte, error) {
+func (ms *metricsMiddleware) Result(ctx context.Context, consumer string) ([]byte, error) {
 	defer func(begin time.Time) {
 		ms.counter.With("method", "result").Add(1)
 		ms.latency.With("method", "result").Observe(time.Since(begin).Seconds())
 	}(time.Now())
 
-	return ms.svc.Result(ctx)
+	return ms.svc.Result(ctx, consumer)
 }
 
 func (ms *metricsMiddleware) Attestation(ctx context.Context, reportData [agent.ReportDataSize]byte) ([]byte, error) {

agent/auth/auth.go

@@ -1,174 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-
-package auth
-
-import (
-	"context"
-	"crypto"
-	"crypto/ecdsa"
-	"crypto/ed25519"
-	"crypto/rsa"
-	"crypto/sha256"
-	"crypto/x509"
-	"encoding/base64"
-
-	"github.com/absmach/magistrala/pkg/errors"
-	"github.com/ultravioletrs/cocos/agent"
-	"google.golang.org/grpc/codes"
-	"google.golang.org/grpc/metadata"
-	"google.golang.org/grpc/status"
-)
-
-type UserRole string
-
-const (
-	UserMetadataKey                = "user-id"
-	SignatureMetadataKey           = "signature"
-	ConsumerRole          UserRole = "consumer"
-	DataProviderRole      UserRole = "data-provider"
-	AlgorithmProviderRole UserRole = "algorithm-provider"
-)
-
-var (
-	ErrMissingMetadata             = errors.New("missing metadata")
-	ErrInvalidMetadata             = errors.New("invalid metadata")
-	ErrSignatureVerificationFailed = errors.New("signature verification failed")
-)
-
-//go:generate mockery --name Authenticator --output=../mocks --filename auth.go --quiet --note "Copyright (c) Ultraviolet \n // SPDX-License-Identifier: Apache-2.0"
-type Authenticator interface {
-	AuthenticateUser(ctx context.Context, role UserRole) (context.Context, error)
-}
-
-type service struct {
-	resultConsumers   []interface{}
-	datasetProviders  []interface{}
-	algorithmProvider interface{}
-}
-
-func New(manifest agent.Computation) (Authenticator, error) {
-	s := &service{}
-	for _, rc := range manifest.ResultConsumers {
-		pubKey, err := x509.ParsePKIXPublicKey(rc.UserKey)
-		if err != nil {
-			return nil, err
-		}
-
-		pKey, err := decodePublicKey(pubKey)
-		if err != nil {
-			return nil, err
-		}
-
-		s.resultConsumers = append(s.resultConsumers, pKey)
-	}
-
-	for _, dp := range manifest.Datasets {
-		pubKey, err := x509.ParsePKIXPublicKey(dp.UserKey)
-		if err != nil {
-			return nil, err
-		}
-
-		pKey, err := decodePublicKey(pubKey)
-		if err != nil {
-			return nil, err
-		}
-
-		s.datasetProviders = append(s.datasetProviders, pKey)
-	}
-
-	pubKey, err := x509.ParsePKIXPublicKey(manifest.Algorithm.UserKey)
-	if err != nil {
-		return nil, err
-	}
-
-	pKey, err := decodePublicKey(pubKey)
-	if err != nil {
-		return nil, err
-	}
-
-	s.algorithmProvider = pKey
-	return s, nil
-}
-
-func extractSignature(md metadata.MD) (string, error) {
-	signature := md.Get(SignatureMetadataKey)
-	if len(signature) != 1 {
-		return "", status.Errorf(codes.Unauthenticated, "invalid metadata")
-	}
-
-	return signature[0], nil
-}
-
-func verifySignature(role UserRole, signature string, publicKey any) error {
-	hash := sha256.Sum256([]byte(role))
-	sigByte, err := base64.StdEncoding.DecodeString(signature)
-	if err != nil {
-		return err
-	}
-
-	var ok bool
-
-	switch publicKey := publicKey.(type) {
-	case *rsa.PublicKey:
-		if err = rsa.VerifyPKCS1v15(publicKey, crypto.SHA256, hash[:], sigByte); err != nil {
-			return err
-		}
-		return nil
-	case *ecdsa.PublicKey:
-		ok = ecdsa.VerifyASN1(publicKey, hash[:], sigByte)
-	case ed25519.PublicKey:
-		ok = ed25519.Verify(publicKey, []byte(role), sigByte)
-	}
-
-	if !ok {
-		return ErrSignatureVerificationFailed
-	}
-
-	return nil
-}
-
-func (s *service) AuthenticateUser(ctx context.Context, role UserRole) (context.Context, error) {
-	md, ok := metadata.FromIncomingContext(ctx)
-	if !ok {
-		return nil, ErrMissingMetadata
-	}
-	signature, err := extractSignature(md)
-	if err != nil {
-		return nil, errors.Wrap(err, ErrInvalidMetadata)
-	}
-
-	switch role {
-	case ConsumerRole:
-		for i, rc := range s.resultConsumers {
-			if err := verifySignature(role, signature, rc); err == nil {
-				return agent.IndexToContext(ctx, i), nil
-			}
-		}
-	case DataProviderRole:
-		for _, dp := range s.datasetProviders {
-			if err := verifySignature(role, signature, dp); err == nil {
-				return ctx, nil
-			}
-		}
-	case AlgorithmProviderRole:
-		if err := verifySignature(role, signature, s.algorithmProvider); err == nil {
-			return ctx, nil
-		}
-	}
-
-	return ctx, ErrSignatureVerificationFailed
-}
-
-func decodePublicKey(key any) (pubKey any, err error) {
-	switch key := key.(type) {
-	case *rsa.PublicKey:
-		return key, nil
-	case *ecdsa.PublicKey:
-		return key, nil
-	case ed25519.PublicKey:
-		return key, nil
-	default:
-		return nil, errors.New("unsupported public key type")
-	}
-}

agent/auth/auth_test.go

@@ -1,158 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package auth
-
-import (
-	"context"
-	"crypto"
-	"crypto/ecdsa"
-	"crypto/ed25519"
-	"crypto/elliptic"
-	"crypto/rand"
-	"crypto/rsa"
-	"crypto/sha256"
-	"crypto/x509"
-	"encoding/base64"
-	"testing"
-
-	"github.com/absmach/magistrala/pkg/errors"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"github.com/ultravioletrs/cocos/agent"
-	"google.golang.org/grpc/metadata"
-)
-
-func TestAuthenticateUser(t *testing.T) {
-	resultConsumerKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
-	require.NoError(t, err)
-
-	dataProviderKey, err := rsa.GenerateKey(rand.Reader, 2048)
-	require.NoError(t, err)
-
-	pubEd25519Key, algorithmProviderKey, err := ed25519.GenerateKey(rand.Reader)
-	require.NoError(t, err)
-
-	resultConsumerPubKey, err := x509.MarshalPKIXPublicKey(&resultConsumerKey.PublicKey)
-	require.NoError(t, err)
-
-	dataProviderPubKey, err := x509.MarshalPKIXPublicKey(&dataProviderKey.PublicKey)
-	require.NoError(t, err)
-
-	algorithmProviderPubKey, err := x509.MarshalPKIXPublicKey(pubEd25519Key)
-	require.NoError(t, err)
-
-	manifest := agent.Computation{
-		ResultConsumers: []agent.ResultConsumer{{UserKey: resultConsumerPubKey}},
-		Datasets:        []agent.Dataset{{UserKey: dataProviderPubKey}},
-		Algorithm:       agent.Algorithm{UserKey: algorithmProviderPubKey},
-	}
-
-	auth, err := New(manifest)
-	if err != nil {
-		t.Fatalf("failed to create authenticator: %v", err)
-	}
-
-	testCases := []struct {
-		name        string
-		role        UserRole
-		key         any
-		expectedErr error
-	}{
-		{
-			name:        "valid result consumer",
-			role:        ConsumerRole,
-			key:         resultConsumerKey,
-			expectedErr: nil,
-		},
-		{
-			name:        "valid data provider",
-			role:        DataProviderRole,
-			key:         dataProviderKey,
-			expectedErr: nil,
-		},
-		{
-			name:        "valid algorithm provider",
-			role:        AlgorithmProviderRole,
-			key:         algorithmProviderKey,
-			expectedErr: nil,
-		},
-		{
-			name:        "invalid role",
-			role:        "invalid-role",
-			key:         resultConsumerKey,
-			expectedErr: ErrSignatureVerificationFailed,
-		},
-		{
-			name:        "invalid key",
-			role:        ConsumerRole,
-			key:         dataProviderKey,
-			expectedErr: ErrSignatureVerificationFailed,
-		},
-		{
-			name:        "missing signature",
-			role:        ConsumerRole,
-			key:         resultConsumerKey,
-			expectedErr: ErrInvalidMetadata,
-		},
-		{
-			name:        "missing metadata",
-			role:        ConsumerRole,
-			key:         resultConsumerKey,
-			expectedErr: ErrMissingMetadata,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			signature, err := signRole(tc.role, tc.key)
-			if err != nil {
-				t.Fatalf("failed to sign role: %v", err)
-			}
-
-			ctx := context.Background()
-
-			switch tc.name {
-			case "missing signature":
-				ctx = metadata.NewIncomingContext(ctx, metadata.Pairs())
-			case "missing metadata":
-			default:
-				ctx = metadata.NewIncomingContext(ctx, metadata.Pairs(SignatureMetadataKey, signature))
-			}
-
-			ctx, err = auth.AuthenticateUser(ctx, tc.role)
-			assert.True(t, errors.Contains(err, tc.expectedErr), "expected error %v, got %v", tc.expectedErr, err)
-
-			if err == nil {
-				switch id, ok := agent.IndexFromContext(ctx); {
-				case tc.role == ConsumerRole:
-					assert.True(t, ok, "expected index in context")
-					assert.Equal(t, 0, id, "expected index 0 in context")
-				default:
-					assert.False(t, ok, "expected no index in context")
-				}
-			}
-		})
-	}
-}
-
-func signRole(role UserRole, key crypto.PrivateKey) (string, error) {
-	var signature []byte
-	var err error
-
-	switch k := key.(type) {
-	case ed25519.PrivateKey:
-		signature, err = k.Sign(rand.Reader, []byte(role), crypto.Hash(0))
-	case *rsa.PrivateKey, *ecdsa.PrivateKey:
-		hash := sha256.Sum256([]byte(role))
-		signer := key.(crypto.Signer)
-		signature, err = signer.Sign(rand.Reader, hash[:], crypto.SHA256)
-	default:
-		return "", errors.New("unsupported key type")
-	}
-
-	if err != nil {
-		return "", err
-	}
-
-	return base64.StdEncoding.EncodeToString(signature), nil
-}

agent/computations.go

@@ -3,14 +3,15 @@
 package agent
 
 import (
-	"context"
 	"encoding/json"
 	"fmt"
-
-	"google.golang.org/grpc/metadata"
+	"reflect"
 )
 
-var _ fmt.Stringer = (*Datasets)(nil)
+var (
+	_ fmt.Stringer = (*Datasets)(nil)
+	_ fmt.Stringer = (*Algorithms)(nil)
+)
 
 type AgentConfig struct {
 	LogLevel     string `json:"log_level"`
@@ -20,21 +21,16 @@ type AgentConfig struct {
 	KeyFile      string `json:"server_key"`
 	ServerCAFile string `json:"server_ca_file"`
 	ClientCAFile string `json:"client_ca_file"`
-	AttestedTls  bool   `json:"attested_tls"`
 }
 
 type Computation struct {
-	ID              string           `json:"id,omitempty"`
-	Name            string           `json:"name,omitempty"`
-	Description     string           `json:"description,omitempty"`
-	Datasets        Datasets         `json:"datasets,omitempty"`
-	Algorithm       Algorithm        `json:"algorithm,omitempty"`
-	ResultConsumers []ResultConsumer `json:"result_consumers,omitempty"`
-	AgentConfig     AgentConfig      `json:"agent_config,omitempty"`
-}
-
-type ResultConsumer struct {
-	UserKey []byte `json:"user_key,omitempty"`
+	ID              string      `json:"id,omitempty"`
+	Name            string      `json:"name,omitempty"`
+	Description     string      `json:"description,omitempty"`
+	Datasets        Datasets    `json:"datasets,omitempty"`
+	Algorithms      Algorithms  `json:"algorithms,omitempty"`
+	ResultConsumers []string    `json:"result_consumers,omitempty"`
+	AgentConfig     AgentConfig `json:"agent_config,omitempty"`
 }
 
 func (d *Datasets) String() string {
@@ -45,44 +41,42 @@ func (d *Datasets) String() string {
 	return string(dat)
 }
 
+func (a *Algorithms) String() string {
+	dat, err := json.Marshal(a)
+	if err != nil {
+		return ""
+	}
+	return string(dat)
+}
+
 type Dataset struct {
 	Dataset  []byte   `json:"-"`
 	Hash     [32]byte `json:"hash,omitempty"`
-	UserKey  []byte   `json:"user_key,omitempty"`
-	Filename string   `json:"filename,omitempty"`
+	Provider string   `json:"provider,omitempty"`
+	ID       string   `json:"id,omitempty"`
 }
 
 type Datasets []Dataset
 
 type Algorithm struct {
-	Algorithm    []byte   `json:"-"`
-	Hash         [32]byte `json:"hash,omitempty"`
-	UserKey      []byte   `json:"user_key,omitempty"`
-	Requirements []byte   `json:"-"`
+	Algorithm []byte   `json:"-"`
+	Hash      [32]byte `json:"hash,omitempty"`
+	Provider  string   `json:"provider,omitempty"`
+	ID        string   `json:"id,omitempty"`
 }
 
-type ManifestIndexKey struct{}
+type Algorithms []Algorithm
 
-func IndexToContext(ctx context.Context, index int) context.Context {
-	return context.WithValue(ctx, ManifestIndexKey{}, index)
-}
-
-func IndexFromContext(ctx context.Context) (int, bool) {
-	index, ok := ctx.Value(ManifestIndexKey{}).(int)
-	return index, ok
-}
-
-const DecompressKey = "decompress"
-
-func DecompressFromContext(ctx context.Context) bool {
-	vals := metadata.ValueFromIncomingContext(ctx, DecompressKey)
-	if len(vals) == 0 {
-		return false
+func containsID(slice interface{}, id string) int {
+	rangeOnMe := reflect.ValueOf(slice)
+	for i := 0; i < rangeOnMe.Len(); i++ {
+		s := rangeOnMe.Index(i)
+		f := s.FieldByName("ID")
+		if f.IsValid() {
+			if f.Interface() == id {
+				return i
+			}
+		}
 	}
-
-	return vals[0] == "true"
-}
-
-func DecompressToContext(ctx context.Context, decompress bool) context.Context {
-	return metadata.AppendToOutgoingContext(ctx, DecompressKey, fmt.Sprintf("%t", decompress))
+	return -1
 }

agent/events/events.go

@@ -27,7 +27,6 @@ type AgentEvent struct {
 	Status        string          `json:"status,omitempty"`
 }
 
-//go:generate mockery --name Service --output=./mocks --filename events.go --quiet --note "Copyright (c) Ultraviolet \n // SPDX-License-Identifier: Apache-2.0"
 type Service interface {
 	SendEvent(event, status string, details json.RawMessage) error
 	Close() error

agent/events/mocks/events.go

@@ -1,67 +0,0 @@
-// Code generated by mockery v2.43.2. DO NOT EDIT.
-
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-
-package mocks
-
-import (
-	json "encoding/json"
-
-	mock "github.com/stretchr/testify/mock"
-)
-
-// Service is an autogenerated mock type for the Service type
-type Service struct {
-	mock.Mock
-}
-
-// Close provides a mock function with given fields:
-func (_m *Service) Close() error {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Close")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// SendEvent provides a mock function with given fields: event, status, details
-func (_m *Service) SendEvent(event string, status string, details json.RawMessage) error {
-	ret := _m.Called(event, status, details)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SendEvent")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(string, string, json.RawMessage) error); ok {
-		r0 = rf(event, status, details)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// NewService creates a new instance of Service. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewService(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Service {
-	mock := &Service{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}

agent/mocks/agent.go

@@ -1,129 +0,0 @@
-// Code generated by mockery v2.43.2. DO NOT EDIT.
-
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-
-package mocks
-
-import (
-	context "context"
-
-	agent "github.com/ultravioletrs/cocos/agent"
-
-	mock "github.com/stretchr/testify/mock"
-)
-
-// Service is an autogenerated mock type for the Service type
-type Service struct {
-	mock.Mock
-}
-
-// Algo provides a mock function with given fields: ctx, algorithm
-func (_m *Service) Algo(ctx context.Context, algorithm agent.Algorithm) error {
-	ret := _m.Called(ctx, algorithm)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Algo")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, agent.Algorithm) error); ok {
-		r0 = rf(ctx, algorithm)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Attestation provides a mock function with given fields: ctx, reportData
-func (_m *Service) Attestation(ctx context.Context, reportData [64]byte) ([]byte, error) {
-	ret := _m.Called(ctx, reportData)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Attestation")
-	}
-
-	var r0 []byte
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, [64]byte) ([]byte, error)); ok {
-		return rf(ctx, reportData)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, [64]byte) []byte); ok {
-		r0 = rf(ctx, reportData)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]byte)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, [64]byte) error); ok {
-		r1 = rf(ctx, reportData)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Data provides a mock function with given fields: ctx, dataset
-func (_m *Service) Data(ctx context.Context, dataset agent.Dataset) error {
-	ret := _m.Called(ctx, dataset)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Data")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, agent.Dataset) error); ok {
-		r0 = rf(ctx, dataset)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Result provides a mock function with given fields: ctx
-func (_m *Service) Result(ctx context.Context) ([]byte, error) {
-	ret := _m.Called(ctx)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Result")
-	}
-
-	var r0 []byte
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context) ([]byte, error)); ok {
-		return rf(ctx)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context) []byte); ok {
-		r0 = rf(ctx)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]byte)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
-		r1 = rf(ctx)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// NewService creates a new instance of Service. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewService(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Service {
-	mock := &Service{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}

agent/mocks/auth.go

@@ -1,63 +0,0 @@
-// Code generated by mockery v2.43.2. DO NOT EDIT.
-
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-
-package mocks
-
-import (
-	context "context"
-
-	auth "github.com/ultravioletrs/cocos/agent/auth"
-
-	mock "github.com/stretchr/testify/mock"
-)
-
-// Authenticator is an autogenerated mock type for the Authenticator type
-type Authenticator struct {
-	mock.Mock
-}
-
-// AuthenticateUser provides a mock function with given fields: ctx, role
-func (_m *Authenticator) AuthenticateUser(ctx context.Context, role auth.UserRole) (context.Context, error) {
-	ret := _m.Called(ctx, role)
-
-	if len(ret) == 0 {
-		panic("no return value specified for AuthenticateUser")
-	}
-
-	var r0 context.Context
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, auth.UserRole) (context.Context, error)); ok {
-		return rf(ctx, role)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, auth.UserRole) context.Context); ok {
-		r0 = rf(ctx, role)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(context.Context)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, auth.UserRole) error); ok {
-		r1 = rf(ctx, role)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// NewAuthenticator creates a new instance of Authenticator. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewAuthenticator(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Authenticator {
-	mock := &Authenticator{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}

agent/quoteprovider/embed.go

@@ -1,38 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-
-//go:build embed
-// +build embed
-
-package quoteprovider
-
-import (
-	"github.com/google/go-sev-guest/client"
-	pb "github.com/google/go-sev-guest/proto/sevsnp"
-	cocosai "github.com/ultravioletrs/cocos"
-)
-
-var _ client.QuoteProvider = (*embeddedQuoteProvider)(nil)
-
-type embeddedQuoteProvider struct {
-}
-
-func GetQuoteProvider() (client.QuoteProvider, error) {
-	return &embeddedQuoteProvider{}, nil
-}
-
-// GetQuote returns the SEV quote for the given report data.
-func (e *embeddedQuoteProvider) GetRawQuote(reportData [64]byte) ([]byte, error) {
-	return cocosai.EmbeddedAttestation, nil
-}
-
-// IsSupported returns true if the SEV platform is supported.
-func (e *embeddedQuoteProvider) IsSupported() bool {
-	return true
-}
-
-// Product returns the SEV product information.
-// unimplemented since it is deprecated and not used.
-func (e *embeddedQuoteProvider) Product() *pb.SevProduct {
-	panic("unimplemented")
-}

agent/quoteprovider/sev.go

@@ -1,13 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-
-//go:build !embed
-// +build !embed
-
-package quoteprovider
-
-import "github.com/google/go-sev-guest/client"
-
-func GetQuoteProvider() (client.QuoteProvider, error) {
-	return client.GetQuoteProvider()
-}

agent/service.go

@@ -9,28 +9,19 @@ import (
 	"errors"
 	"fmt"
 	"log/slog"
-	"os"
-	"path/filepath"
+	"os/exec"
 	"slices"
 
 	"github.com/google/go-sev-guest/client"
-	"github.com/ultravioletrs/cocos/agent/algorithm"
-	"github.com/ultravioletrs/cocos/agent/algorithm/binary"
-	"github.com/ultravioletrs/cocos/agent/algorithm/docker"
-	"github.com/ultravioletrs/cocos/agent/algorithm/python"
-	"github.com/ultravioletrs/cocos/agent/algorithm/wasm"
 	"github.com/ultravioletrs/cocos/agent/events"
-	"github.com/ultravioletrs/cocos/internal"
+	"github.com/ultravioletrs/cocos/pkg/socket"
 	"golang.org/x/crypto/sha3"
 )
 
 var _ Service = (*agentService)(nil)
 
-const (
-	// ReportDataSize is the size of the report data expected by the attestation service.
-	ReportDataSize     = 64
-	algoFilePermission = 0o700
-)
+// ReportDataSize is the size of the report data expected by the attestation service.
+const ReportDataSize = 64
 
 var (
 	// ErrMalformedEntity indicates malformed entity specification (e.g.
@@ -39,148 +30,99 @@ var (
 	// ErrUnauthorizedAccess indicates missing or invalid credentials provided
 	// when accessing a protected resource.
 	ErrUnauthorizedAccess = errors.New("missing or invalid credentials provided")
-	// ErrUndeclaredAlgorithm indicates algorithm was not declared in computation manifest.
-	ErrUndeclaredDataset = errors.New("dataset not declared in computation manifest")
-	// ErrAllManifestItemsReceived indicates no new computation manifest items expected.
-	ErrAllManifestItemsReceived = errors.New("all expected manifest Items have been received")
-	// ErrUndeclaredConsumer indicates the consumer requesting results in not declared in computation manifest.
-	ErrUndeclaredConsumer = errors.New("result consumer is undeclared in computation manifest")
-	// ErrResultsNotReady indicates the computation results are not ready.
-	ErrResultsNotReady = errors.New("computation results are not yet ready")
-	// ErrStateNotReady agent received a request in the wrong state.
-	ErrStateNotReady = errors.New("agent not expecting this operation in the current state")
-	// ErrHashMismatch provided algorithm/dataset does not match hash in manifest.
-	ErrHashMismatch = errors.New("malformed data, hash does not match manifest")
-	// ErrFileNameMismatch provided dataset filename does not match filename in manifest.
-	ErrFileNameMismatch = errors.New("malformed data, filename does not match manifest")
-	// ErrAllResultsConsumed indicates all results have been consumed.
-	ErrAllResultsConsumed = errors.New("all results have been consumed by declared consumers")
+	// errUndeclaredAlgorithm indicates algorithm was not declared in computation manifest.
+	errUndeclaredAlgorithm = errors.New("algorithm not declared in computation manifest")
+	// errUndeclaredAlgorithm indicates algorithm was not declared in computation manifest.
+	errUndeclaredDataset = errors.New("dataset not declared in computation manifest")
+	// errProviderMissmatch algorithm/dataset provider does not match computation manifest.
+	errProviderMissmatch = errors.New("provider does not match declaration on manifest")
+	// errAllManifestItemsReceived indicates no new computation manifest items expected.
+	errAllManifestItemsReceived = errors.New("all expected manifest Items have been received")
+	// errUndeclaredConsumer indicates the consumer requesting results in not declared in computation manifest.
+	errUndeclaredConsumer = errors.New("result consumer is undeclared in computation manifest")
+	// errResultsNotReady indicates the computation results are not ready.
+	errResultsNotReady = errors.New("computation results are not yet ready")
+	// errStateNotReady agent received a request in the wrong state.
+	errStateNotReady = errors.New("agent not expecting this operation in the current state")
+	// errHashMismatch provided algorithm/dataset does not match hash in manifest.
+	errHashMismatch = errors.New("malformed data, hash does not match manifest")
 )
 
 // Service specifies an API that must be fullfiled by the domain service
 // implementation, and all of its decorators (e.g. logging & metrics).
-//
-//go:generate mockery --name Service --output=mocks --filename agent.go --quiet --note "Copyright (c) Ultraviolet \n // SPDX-License-Identifier: Apache-2.0"
 type Service interface {
 	Algo(ctx context.Context, algorithm Algorithm) error
 	Data(ctx context.Context, dataset Dataset) error
-	Result(ctx context.Context) ([]byte, error)
+	Result(ctx context.Context, consumer string) ([]byte, error)
 	Attestation(ctx context.Context, reportData [ReportDataSize]byte) ([]byte, error)
 }
 
 type agentService struct {
-	computation   Computation          // Holds the current computation request details.
-	algorithm     algorithm.Algorithm  // Filepath to the algorithm received for the computation.
-	result        []byte               // Stores the result of the computation.
-	sm            *StateMachine        // Manages the state transitions of the agent service.
-	runError      error                // Stores any error encountered during the computation run.
-	eventSvc      events.Service       // Service for publishing events related to computation.
-	quoteProvider client.QuoteProvider // Provider for generating attestation quotes.
+	computation Computation    // Holds the current computation request details.
+	algorithms  [][]byte       // Stores the algorithms received for the computation.
+	datasets    [][]byte       // Stores the datasets received for the computation.
+	result      []byte         // Stores the result of the computation.
+	sm          *StateMachine  // Manages the state transitions of the agent service.
+	runError    error          // Stores any error encountered during the computation run.
+	eventSvc    events.Service // Service for publishing events related to computation.
 }
 
+const (
+	socketPath = "unix_socket"
+	pyRuntime  = "python3"
+)
+
 var _ Service = (*agentService)(nil)
 
 // New instantiates the agent service implementation.
-func New(ctx context.Context, logger *slog.Logger, eventSvc events.Service, cmp Computation, quoteProvider client.QuoteProvider) Service {
+func New(ctx context.Context, logger *slog.Logger, eventSvc events.Service, cmp Computation) Service {
 	svc := &agentService{
-		sm:            NewStateMachine(logger, cmp),
-		eventSvc:      eventSvc,
-		quoteProvider: quoteProvider,
+		sm:       NewStateMachine(logger),
+		eventSvc: eventSvc,
 	}
-
 	go svc.sm.Start(ctx)
 	svc.sm.SendEvent(start)
 	svc.sm.StateFunctions[idle] = svc.publishEvent("in-progress", json.RawMessage{})
-	svc.sm.StateFunctions[receivingManifest] = svc.publishEvent("in-progress", json.RawMessage{})
-	svc.sm.StateFunctions[receivingAlgorithm] = svc.publishEvent("in-progress", json.RawMessage{})
+	svc.sm.StateFunctions[receivingManifests] = svc.publishEvent("in-progress", json.RawMessage{})
+	svc.sm.StateFunctions[receivingAlgorithms] = svc.publishEvent("in-progress", json.RawMessage{})
 	svc.sm.StateFunctions[receivingData] = svc.publishEvent("in-progress", json.RawMessage{})
 	svc.sm.StateFunctions[resultsReady] = svc.publishEvent("in-progress", json.RawMessage{})
 	svc.sm.StateFunctions[complete] = svc.publishEvent("in-progress", json.RawMessage{})
 	svc.sm.StateFunctions[running] = svc.runComputation
-	svc.sm.StateFunctions[failed] = svc.publishEvent("failed", json.RawMessage{})
 
 	svc.computation = cmp
-
-	svc.sm.SendEvent(manifestReceived)
+	svc.sm.SendEvent(manifestsReceived)
 	return svc
 }
 
-func (as *agentService) Algo(ctx context.Context, algo Algorithm) error {
-	if as.sm.GetState() != receivingAlgorithm {
-		return ErrStateNotReady
+func (as *agentService) Algo(ctx context.Context, algorithm Algorithm) error {
+	if as.sm.GetState() != receivingAlgorithms {
+		return errStateNotReady
 	}
-	if as.algorithm != nil {
-		return ErrAllManifestItemsReceived
+	if len(as.computation.Algorithms) == 0 {
+		return errAllManifestItemsReceived
 	}
 
-	hash := sha3.Sum256(algo.Algorithm)
+	hash := sha3.Sum256(algorithm.Algorithm)
 
-	if hash != as.computation.Algorithm.Hash {
-		return ErrHashMismatch
-	}
-
-	currentDir, err := os.Getwd()
-	if err != nil {
-		return fmt.Errorf("error getting current directory: %v", err)
-	}
-
-	f, err := os.Create(filepath.Join(currentDir, "algorithm"))
-	if err != nil {
-		return fmt.Errorf("error creating algorithm file: %v", err)
-	}
-
-	if _, err := f.Write(algo.Algorithm); err != nil {
-		return fmt.Errorf("error writing algorithm to file: %v", err)
-	}
-
-	if err := os.Chmod(f.Name(), algoFilePermission); err != nil {
-		return fmt.Errorf("error changing file permissions: %v", err)
-	}
-
-	if err := f.Close(); err != nil {
-		return fmt.Errorf("error closing file: %v", err)
-	}
-
-	algoType := algorithm.AlgorithmTypeFromContext(ctx)
-	if algoType == "" {
-		algoType = string(algorithm.AlgoTypeBin)
-	}
-
-	args := algorithm.AlgorithmArgsFromContext(ctx)
-
-	switch algoType {
-	case string(algorithm.AlgoTypeBin):
-		as.algorithm = binary.NewAlgorithm(as.sm.logger, as.eventSvc, f.Name(), args)
-	case string(algorithm.AlgoTypePython):
-		var requirementsFile string
-		if len(algo.Requirements) > 0 {
-			fr, err := os.CreateTemp("", "requirements.txt")
-			if err != nil {
-				return fmt.Errorf("error creating requirments file: %v", err)
-			}
-
-			if _, err := fr.Write(algo.Requirements); err != nil {
-				return fmt.Errorf("error writing requirements to file: %v", err)
-			}
-			if err := fr.Close(); err != nil {
-				return fmt.Errorf("error closing file: %v", err)
-			}
-			requirementsFile = fr.Name()
+	index := containsID(as.computation.Algorithms, algorithm.ID)
+	switch index {
+	case -1:
+		return errUndeclaredAlgorithm
+	default:
+		if as.computation.Algorithms[index].Provider != algorithm.Provider {
+			return errProviderMissmatch
 		}
-		runtime := python.PythonRunTimeFromContext(ctx)
-		as.algorithm = python.NewAlgorithm(as.sm.logger, as.eventSvc, runtime, requirementsFile, f.Name(), args)
-	case string(algorithm.AlgoTypeWasm):
-		as.algorithm = wasm.NewAlgorithm(as.sm.logger, as.eventSvc, f.Name(), args)
-	case string(algorithm.AlgoTypeDocker):
-		as.algorithm = docker.NewAlgorithm(as.sm.logger, as.eventSvc, f.Name())
+		if hash != as.computation.Algorithms[index].Hash {
+			return errHashMismatch
+		}
+		as.computation.Algorithms = slices.Delete(as.computation.Algorithms, index, index+1)
 	}
 
-	if err := os.Mkdir(algorithm.DatasetsDir, 0o755); err != nil {
-		return fmt.Errorf("error creating datasets directory: %v", err)
-	}
+	as.algorithms = append(as.algorithms, algorithm.Algorithm)
 
-	if as.algorithm != nil {
-		as.sm.SendEvent(algorithmReceived)
+	if len(as.computation.Algorithms) == 0 {
+		as.sm.SendEvent(algorithmsReceived)
 	}
 
 	return nil
@@ -188,49 +130,29 @@ func (as *agentService) Algo(ctx context.Context, algo Algorithm) error {
 
 func (as *agentService) Data(ctx context.Context, dataset Dataset) error {
 	if as.sm.GetState() != receivingData {
-		return ErrStateNotReady
+		return errStateNotReady
 	}
 	if len(as.computation.Datasets) == 0 {
-		return ErrAllManifestItemsReceived
+		return errAllManifestItemsReceived
 	}
 
 	hash := sha3.Sum256(dataset.Dataset)
 
-	matched := false
-	for i, d := range as.computation.Datasets {
-		if hash == d.Hash {
-			if d.Filename != "" && d.Filename != dataset.Filename {
-				return ErrFileNameMismatch
-			}
-
-			as.computation.Datasets = slices.Delete(as.computation.Datasets, i, i+1)
-
-			if DecompressFromContext(ctx) {
-				if err := internal.UnzipFromMemory(dataset.Dataset, algorithm.DatasetsDir); err != nil {
-					return fmt.Errorf("error decompressing dataset: %v", err)
-				}
-			} else {
-				f, err := os.Create(fmt.Sprintf("%s/%s", algorithm.DatasetsDir, dataset.Filename))
-				if err != nil {
-					return fmt.Errorf("error creating dataset file: %v", err)
-				}
-
-				if _, err := f.Write(dataset.Dataset); err != nil {
-					return fmt.Errorf("error writing dataset to file: %v", err)
-				}
-				if err := f.Close(); err != nil {
-					return fmt.Errorf("error closing file: %v", err)
-				}
-			}
-
-			matched = true
-			break
+	index := containsID(as.computation.Datasets, dataset.ID)
+	switch index {
+	case -1:
+		return errUndeclaredDataset
+	default:
+		if as.computation.Datasets[index].Provider != dataset.Provider {
+			return errProviderMissmatch
 		}
+		if hash != as.computation.Datasets[index].Hash {
+			return errHashMismatch
+		}
+		as.computation.Datasets = slices.Delete(as.computation.Datasets, index, index+1)
 	}
 
-	if !matched {
-		return ErrUndeclaredDataset
-	}
+	as.datasets = append(as.datasets, dataset.Dataset)
 
 	if len(as.computation.Datasets) == 0 {
 		as.sm.SendEvent(dataReceived)
@@ -239,28 +161,34 @@ func (as *agentService) Data(ctx context.Context, dataset Dataset) error {
 	return nil
 }
 
-func (as *agentService) Result(ctx context.Context) ([]byte, error) {
-	if as.sm.GetState() != resultsReady && as.sm.GetState() != failed {
-		return []byte{}, ErrResultsNotReady
+func (as *agentService) Result(ctx context.Context, consumer string) ([]byte, error) {
+	if as.sm.GetState() != resultsReady {
+		return []byte{}, errResultsNotReady
 	}
 	if len(as.computation.ResultConsumers) == 0 {
-		return []byte{}, ErrAllResultsConsumed
+		return []byte{}, errAllManifestItemsReceived
 	}
-	index, ok := IndexFromContext(ctx)
-	if !ok {
-		return []byte{}, ErrUndeclaredConsumer
+	index := slices.Index(as.computation.ResultConsumers, consumer)
+	switch index {
+	case -1:
+		return []byte{}, errUndeclaredConsumer
+	default:
+		as.computation.ResultConsumers = slices.Delete(as.computation.ResultConsumers, index, index+1)
 	}
-	as.computation.ResultConsumers = slices.Delete(as.computation.ResultConsumers, index, index+1)
 
-	if len(as.computation.ResultConsumers) == 0 && as.sm.GetState() == resultsReady {
+	if len(as.computation.ResultConsumers) == 0 {
 		as.sm.SendEvent(resultsConsumed)
 	}
-
+	// Return the result file or an error
 	return as.result, as.runError
 }
 
 func (as *agentService) Attestation(ctx context.Context, reportData [ReportDataSize]byte) ([]byte, error) {
-	rawQuote, err := as.quoteProvider.GetRawQuote(reportData)
+	provider, err := client.GetQuoteProvider()
+	if err != nil {
+		return []byte{}, err
+	}
+	rawQuote, err := provider.GetRawQuote(reportData)
 	if err != nil {
 		return []byte{}, err
 	}
@@ -271,49 +199,16 @@ func (as *agentService) Attestation(ctx context.Context, reportData [ReportDataS
 func (as *agentService) runComputation() {
 	as.publishEvent("starting", json.RawMessage{})()
 	as.sm.logger.Debug("computation run started")
-	defer func() {
-		if as.runError != nil {
-			as.sm.SendEvent(runFailed)
-		} else {
-			as.sm.SendEvent(runComplete)
-		}
-	}()
-
-	if err := os.Mkdir(algorithm.ResultsDir, 0o755); err != nil {
-		as.runError = fmt.Errorf("error creating results directory: %s", err.Error())
-		as.sm.logger.Warn(as.runError.Error())
-		as.publishEvent("failed", json.RawMessage{})()
-		return
-	}
-
-	defer func() {
-		if err := os.RemoveAll(algorithm.ResultsDir); err != nil {
-			as.sm.logger.Warn(fmt.Sprintf("error removing results directory and its contents: %s", err.Error()))
-		}
-		if err := os.RemoveAll(algorithm.DatasetsDir); err != nil {
-			as.sm.logger.Warn(fmt.Sprintf("error removing datasets directory and its contents: %s", err.Error()))
-		}
-	}()
-
+	defer as.sm.SendEvent(runComplete)
 	as.publishEvent("in-progress", json.RawMessage{})()
-	if err := as.algorithm.Run(); err != nil {
-		as.runError = err
-		as.sm.logger.Warn(fmt.Sprintf("failed to run computation: %s", err.Error()))
-		as.publishEvent("failed", json.RawMessage{})()
-		return
-	}
-
-	results, err := internal.ZipDirectoryToMemory(algorithm.ResultsDir)
+	result, err := run(as.algorithms[0], as.datasets[0])
 	if err != nil {
 		as.runError = err
-		as.sm.logger.Warn(fmt.Sprintf("failed to zip results: %s", err.Error()))
 		as.publishEvent("failed", json.RawMessage{})()
 		return
 	}
-
 	as.publishEvent("complete", json.RawMessage{})()
-
-	as.result = results
+	as.result = result
 }
 
 func (as *agentService) publishEvent(status string, details json.RawMessage) func() {
@@ -323,3 +218,39 @@ func (as *agentService) publishEvent(status string, details json.RawMessage) fun
 		}
 	}
 }
+
+func run(algoContent, dataContent []byte) ([]byte, error) {
+	listener, err := socket.StartUnixSocketServer(socketPath)
+	if err != nil {
+		return nil, fmt.Errorf("error creating stdout pipe: %v", err)
+	}
+	defer listener.Close()
+
+	// Create channels for received data and errors
+	dataChannel := make(chan []byte)
+	errorChannel := make(chan error)
+
+	var result []byte
+
+	go socket.AcceptConnection(listener, dataChannel, errorChannel)
+
+	// Construct the Python script content with CSV data as a command-line argument
+	script := string(algoContent)
+	data := string(dataContent)
+	cmd := exec.Command(pyRuntime, "-c", script, data, socketPath)
+
+	if err := cmd.Start(); err != nil {
+		return nil, fmt.Errorf("error starting Python script: %v", err)
+	}
+
+	if err := cmd.Wait(); err != nil {
+		return nil, fmt.Errorf("python script execution error: %v", err)
+	}
+
+	select {
+	case result = <-dataChannel:
+		return result, nil
+	case err = <-errorChannel:
+		return nil, fmt.Errorf("error receiving data: %v", err)
+	}
+}

agent/state.go

@@ -10,29 +10,27 @@ import (
 )
 
 //go:generate stringer -type=state
-type state uint8
+type state int
 
 const (
 	idle state = iota
-	receivingManifest
-	receivingAlgorithm
+	receivingManifests
+	receivingAlgorithms
 	receivingData
 	running
 	resultsReady
 	complete
-	failed
 )
 
-type event uint8
+type event int
 
 const (
 	start event = iota
-	manifestReceived
-	algorithmReceived
+	manifestsReceived
+	algorithmsReceived
 	dataReceived
 	runComplete
 	resultsConsumed
-	runFailed
 )
 
 // StateMachine represents the state machine.
@@ -43,40 +41,32 @@ type StateMachine struct {
 	Transitions    map[state]map[event]state
 	StateFunctions map[state]func()
 	logger         *slog.Logger
-	wg             *sync.WaitGroup
 }
 
 // NewStateMachine creates a new StateMachine.
-func NewStateMachine(logger *slog.Logger, cmp Computation) *StateMachine {
+func NewStateMachine(logger *slog.Logger) *StateMachine {
 	sm := &StateMachine{
 		State:          idle,
 		EventChan:      make(chan event),
 		Transitions:    make(map[state]map[event]state),
 		StateFunctions: make(map[state]func()),
 		logger:         logger,
-		wg:             &sync.WaitGroup{},
 	}
 
 	sm.Transitions[idle] = make(map[event]state)
-	sm.Transitions[idle][start] = receivingManifest
+	sm.Transitions[idle][start] = receivingManifests
 
-	sm.Transitions[receivingManifest] = make(map[event]state)
-	sm.Transitions[receivingManifest][manifestReceived] = receivingAlgorithm
+	sm.Transitions[receivingManifests] = make(map[event]state)
+	sm.Transitions[receivingManifests][manifestsReceived] = receivingAlgorithms
 
-	sm.Transitions[receivingAlgorithm] = make(map[event]state)
-	switch len(cmp.Datasets) {
-	case 0:
-		sm.Transitions[receivingAlgorithm][algorithmReceived] = running
-	default:
-		sm.Transitions[receivingAlgorithm][algorithmReceived] = receivingData
-	}
+	sm.Transitions[receivingAlgorithms] = make(map[event]state)
+	sm.Transitions[receivingAlgorithms][algorithmsReceived] = receivingData
 
 	sm.Transitions[receivingData] = make(map[event]state)
 	sm.Transitions[receivingData][dataReceived] = running
 
 	sm.Transitions[running] = make(map[event]state)
 	sm.Transitions[running][runComplete] = resultsReady
-	sm.Transitions[running][runFailed] = failed
 
 	sm.Transitions[resultsReady] = make(map[event]state)
 	sm.Transitions[resultsReady][resultsConsumed] = complete
@@ -86,24 +76,19 @@ func NewStateMachine(logger *slog.Logger, cmp Computation) *StateMachine {
 
 // Start the state machine.
 func (sm *StateMachine) Start(ctx context.Context) {
-	sm.wg.Add(1)
-	defer sm.wg.Done()
 	for {
 		select {
 		case event := <-sm.EventChan:
-			sm.mu.Lock()
-			nextState, valid := sm.Transitions[sm.State][event]
+			nextState, valid := sm.Transitions[sm.GetState()][event]
 			if valid {
+				sm.mu.Lock()
 				sm.State = nextState
-				sm.logger.Debug(fmt.Sprintf("Transition: %v -> %v\n", sm.State, nextState))
+				sm.mu.Unlock()
+				sm.logger.Debug(fmt.Sprintf("Transition: %v -> %v\n", sm.GetState(), nextState))
 			} else {
-				sm.logger.Error(fmt.Sprintf("Invalid transition: %v -> ???\n", sm.State))
+				sm.logger.Error(fmt.Sprintf("Invalid transition: %v -> ???\n", sm.GetState()))
 			}
-			sm.mu.Unlock()
-
-			sm.mu.Lock()
-			stateFunc, exists := sm.StateFunctions[sm.State]
-			sm.mu.Unlock()
+			stateFunc, exists := sm.StateFunctions[sm.GetState()]
 			if exists {
 				go stateFunc()
 			}
@@ -120,12 +105,13 @@ func (sm *StateMachine) SendEvent(event event) {
 
 func (sm *StateMachine) GetState() state {
 	sm.mu.Lock()
-	defer sm.mu.Unlock()
-	return sm.State
+	state := sm.State
+	sm.mu.Unlock()
+	return state
 }
 
 func (sm *StateMachine) SetState(state state) {
 	sm.mu.Lock()
-	defer sm.mu.Unlock()
 	sm.State = state
+	sm.mu.Unlock()
 }

agent/state_string.go

@@ -9,21 +9,20 @@ func _() {
 	// Re-run the stringer command to generate them again.
 	var x [1]struct{}
 	_ = x[idle-0]
-	_ = x[receivingManifest-1]
-	_ = x[receivingAlgorithm-2]
+	_ = x[receivingManifests-1]
+	_ = x[receivingAlgorithms-2]
 	_ = x[receivingData-3]
 	_ = x[running-4]
 	_ = x[resultsReady-5]
 	_ = x[complete-6]
-	_ = x[failed-7]
 }
 
-const _state_name = "idlereceivingManifestreceivingAlgorithmreceivingDatarunningresultsReadycompletefailed"
+const _state_name = "idlereceivingManifestsreceivingAlgorithmsreceivingDatarunningresultsReadycomplete"
 
-var _state_index = [...]uint8{0, 4, 21, 39, 52, 59, 71, 79, 85}
+var _state_index = [...]uint8{0, 4, 22, 41, 54, 61, 73, 81}
 
 func (i state) String() string {
-	if i >= state(len(_state_index)-1) {
+	if i < 0 || i >= state(len(_state_index)-1) {
 		return "state(" + strconv.FormatInt(int64(i), 10) + ")"
 	}
 	return _state_name[_state_index[i]:_state_index[i+1]]

agent/state_test.go

@@ -10,54 +10,45 @@ import (
 	mglog "github.com/absmach/magistrala/logger"
 )
 
-var cmp = Computation{
-	Datasets: []Dataset{
-		{
-			Dataset: []byte("test"),
-			UserKey: []byte("test"),
-		},
-	},
-}
-
 func TestStateMachineTransitions(t *testing.T) {
-	cases := []struct {
+	testCases := []struct {
 		fromState state
 		event     event
 		expected  state
-		cmp       Computation
 	}{
-		{idle, start, receivingManifest, cmp},
-		{receivingManifest, manifestReceived, receivingAlgorithm, cmp},
-		{receivingAlgorithm, algorithmReceived, receivingData, cmp},
-		{receivingAlgorithm, algorithmReceived, running, Computation{}},
-		{receivingData, dataReceived, running, cmp},
-		{running, runComplete, resultsReady, cmp},
-		{resultsReady, resultsConsumed, complete, cmp},
+		{idle, start, receivingManifests},
+		{receivingManifests, manifestsReceived, receivingAlgorithms},
+		{receivingAlgorithms, algorithmsReceived, receivingData},
+		{receivingData, dataReceived, running},
+		{running, runComplete, resultsReady},
+		{resultsReady, resultsConsumed, complete},
 	}
 
-	for _, tc := range cases {
-		t.Run(fmt.Sprintf("Transition from %v to %v", tc.fromState, tc.expected), func(t *testing.T) {
-			sm := NewStateMachine(mglog.NewMock(), tc.cmp)
+	for _, testCase := range testCases {
+		t.Run(fmt.Sprintf("Transition from %v to %v", testCase.fromState, testCase.expected), func(t *testing.T) {
+			sm := NewStateMachine(mglog.NewMock())
+			done := make(chan struct{})
 			ctx, cancel := context.WithCancel(context.Background())
 			go func() {
 				sm.Start(ctx)
+				close(done)
 			}()
-			sm.wg.Wait()
-			sm.SetState(tc.fromState)
+			sm.SetState(testCase.fromState)
 
-			sm.SendEvent(tc.event)
+			sm.SendEvent(testCase.event)
 
-			if sm.GetState() != tc.expected {
-				t.Errorf("Expected state %v after the event, but got %v", tc.expected, sm.GetState())
+			if sm.GetState() != testCase.expected {
+				t.Errorf("Expected state %v after the event, but got %v", testCase.expected, sm.GetState())
 			}
 			close(sm.EventChan)
 			cancel()
+			<-done
 		})
 	}
 }
 
 func TestStateMachineInvalidTransition(t *testing.T) {
-	sm := NewStateMachine(mglog.NewMock(), cmp)
+	sm := NewStateMachine(mglog.NewMock())
 	ctx, cancel := context.WithCancel(context.Background())
 	go sm.Start(ctx)
 

attestation.go

@@ -1,12 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-
-//go:build embed
-// +build embed
-
-package cocosai
-
-import _ "embed"
-
-//go:embed attestation.bin
-var EmbeddedAttestation []byte

cli/README.md

@@ -1,6 +1,6 @@
 # Agent CLI
 
-This repository contains the command-line interface (CLI) tool for interacting with the Agent and manager service. The CLI allows you to perform various tasks such as running computations, uploading algorithm and datasets, and retrieving results.
+This repository contains the command-line interface (CLI) tool for interacting with the Agent and manager service. The CLI allows you to perform various tasks such as running computations, uploading algorithms and datasets, and retrieving results.
 
 ## Build
 
@@ -12,18 +12,26 @@ make cli
 
 ## Usage
 
+#### Run Computation
+
+To run a computation, use the following command:
+
+```bash
+./build/cocos-cli manager run --computation '{"name": "my-computation"}'
+```
+
 #### Get attestation
 Retrieves attestation information from the SEV guest and saves it to a file.
 To retrieve attestation from agent, use the following command:
 ```bash
-./build/cocos-cli attestation get '<report_data>'
+./build/cocos-cli agent attestation get '<report_data>'
 ```
 
 #### Validate attestation
 Validates the retrieved attestation information against a specified policy and checks its authenticity.
 To validate and verify attestation from agent, use the following command:
 ```bash
-./build/cocos-cli attestation validate '<attestation>' --report_data '<report_data>'
+./build/cocos-cli agent attestation validate '<attestation>' --report_data '<report_data>'
 ```
 ##### Flags
 - --config: Path to a JSON file containing the validation configuration. This can be used to override individual flags.
@@ -62,41 +70,21 @@ To validate and verify attestation from agent, use the following command:
 To upload an algorithm, use the following command:
 
 ```bash
-./build/cocos-cli algo /path/to/algorithm <private_key_file_path>
+./build/cocos-cli agent algo /path/to/algorithm
 ```
 
-##### Flags
-- -a, --algorithm string        Algorithm type to run (default "bin")
--     --args stringArray        Arguments to pass to the algorithm
--     --python-runtime string   Python runtime to use (default "python3")
-- -r, --requirements string     Python requirements file
-
 #### Upload Dataset
 
 To upload a dataset, use the following command:
 
 ```bash
-./build/cocos-cli data /path/to/dataset.csv <private_key_file_path>
+./build/cocos-cli agent data /path/to/dataset.csv
 ```
 
-Users can also upload directories which will be compressed on transit. Once received by agent they will be stored as compressed files or decompressed if the user passed the decompression argument.
-
-##### Flags
-- -d, --decompress   Decompress the dataset on agent
-
-
-
 #### Retrieve result
 
 To retrieve the computation result, use the following command:
 
 ```bash
-./build/cocos-cli result <private_key_file_path>
-```
-
-#### Checksum
-When defining the manifest dataset and algorithm checksums are required. This can be done as below:
-
-```bash
-./build/cocos-cli checksum <path_to_dataset_or_algorithm>
-```
+./build/cocos-cli agent result
+```

cli/algorithms.go

@@ -3,84 +3,40 @@
 package cli
 
 import (
-	"context"
-	"encoding/pem"
 	"log"
 	"os"
 
 	"github.com/spf13/cobra"
 	"github.com/ultravioletrs/cocos/agent"
-	"github.com/ultravioletrs/cocos/agent/algorithm"
-	"github.com/ultravioletrs/cocos/agent/algorithm/python"
-	"google.golang.org/grpc/metadata"
 )
 
-var (
-	pythonRuntime    string
-	algoType         string
-	requirementsFile string
-	algoArgs         []string
-)
-
-func (cli *CLI) NewAlgorithmCmd() *cobra.Command {
-	cmd := &cobra.Command{
+func (cli *CLI) NewAlgorithmsCmd() *cobra.Command {
+	return &cobra.Command{
 		Use:     "algo",
 		Short:   "Upload an algorithm binary",
-		Example: "algo <algo_file> <private_key_file_path>",
-		Args:    cobra.ExactArgs(2),
+		Example: "algo <algo_file> <id> <provider>",
+		Args:    cobra.ExactArgs(3),
 		Run: func(cmd *cobra.Command, args []string) {
 			algorithmFile := args[0]
 
-			log.Println("Uploading algorithm file:", algorithmFile)
+			log.Println("Uploading algorithm binary:", algorithmFile)
 
 			algorithm, err := os.ReadFile(algorithmFile)
 			if err != nil {
 				log.Fatalf("Error reading algorithm file: %v", err)
 			}
 
-			var req []byte
-			if requirementsFile != "" {
-				req, err = os.ReadFile(requirementsFile)
-				if err != nil {
-					log.Fatalf("Error reading requirments file: %v", err)
-				}
-			}
-
 			algoReq := agent.Algorithm{
-				Algorithm:    algorithm,
-				Requirements: req,
+				Algorithm: algorithm,
+				ID:        args[1],
+				Provider:  args[2],
 			}
 
-			privKeyFile, err := os.ReadFile(args[1])
-			if err != nil {
-				log.Fatalf("Error reading private key file: %v", err)
-			}
-
-			pemBlock, _ := pem.Decode(privKeyFile)
-
-			privKey := decodeKey(pemBlock)
-
-			ctx := metadata.NewOutgoingContext(cmd.Context(), metadata.New(make(map[string]string)))
-
-			if err := cli.agentSDK.Algo(addAlgoMetadata(ctx), algoReq, privKey); err != nil {
-				log.Fatalf("Error uploading algorithm with error: %v", err)
+			if err := cli.agentSDK.Algo(cmd.Context(), algoReq); err != nil {
+				log.Fatalf("Error uploading algorithm with ID %s and provider %s: %v", algoReq.ID, algoReq.Provider, err)
 			}
 
 			log.Println("Successfully uploaded algorithm")
 		},
 	}
-
-	cmd.Flags().StringVarP(&algoType, "algorithm", "a", string(algorithm.AlgoTypeBin), "Algorithm type to run")
-	cmd.Flags().StringVar(&pythonRuntime, "python-runtime", python.PyRuntime, "Python runtime to use")
-	cmd.Flags().StringVarP(&requirementsFile, "requirements", "r", "", "Python requirements file")
-	cmd.Flags().StringArrayVar(&algoArgs, "args", []string{}, "Arguments to pass to the algorithm")
-
-	return cmd
-}
-
-func addAlgoMetadata(ctx context.Context) context.Context {
-	ctx = algorithm.AlgorithmTypeToContext(ctx, algoType)
-	ctx = algorithm.AlgorithmArgsToContext(ctx, algoArgs)
-	ctx = python.PythonRunTimeToContext(ctx, pythonRuntime)
-	return ctx
 }

cli/attestation.go

@@ -13,7 +13,6 @@ import (
 
 	"github.com/google/go-sev-guest/abi"
 	"github.com/google/go-sev-guest/proto/check"
-	"github.com/google/go-sev-guest/proto/sevsnp"
 	"github.com/google/go-sev-guest/validate"
 	"github.com/google/go-sev-guest/verify"
 	"github.com/google/go-sev-guest/verify/trust"
@@ -41,8 +40,6 @@ const (
 	size48                  = 48
 	size64                  = 64
 	attestationFilePath     = "attestation.bin"
-	sevProductNameMilan     = "Milan"
-	sevProductNameGenoa     = "Genoa"
 	exampleJSONConfig       = `
 	{
 		"rootOfTrust":{
@@ -151,7 +148,7 @@ func (cli *CLI) NewGetAttestationCmd() *cobra.Command {
 	return &cobra.Command{
 		Use:     "get",
 		Short:   "Retrieve attestation information from agent. Report data expected in hex enoded string of length 64 bytes.",
-		Example: "get <report_data>",
+		Example: "report <report_data>",
 		Args:    cobra.ExactArgs(1),
 		Run: func(cmd *cobra.Command, args []string) {
 			log.Println("Getting attestation")
@@ -369,7 +366,7 @@ func (cli *CLI) NewValidateAttestationValidationCmd() *cobra.Command {
 		"Hex-encoded SHA-384 hash values of trusted identity keys in AMD public key format",
 	)
 	cmd.Flags().StringVar(
-		&cfg.RootOfTrust.ProductLine,
+		&cfg.RootOfTrust.Product,
 		"product",
 		"",
 		"The AMD product name for the chip that generated the attestation report.",
@@ -397,10 +394,6 @@ func (cli *CLI) NewValidateAttestationValidationCmd() *cobra.Command {
 		log.Fatalf("Failed to mark flag as required: %s", err)
 	}
 
-	if err := cmd.MarkFlagRequired("product"); err != nil {
-		log.Fatalf("Failed to mark flag as required: %s", err)
-	}
-
 	return cmd
 }
 
@@ -409,36 +402,13 @@ func verifyAndValidateAttestation(attestation []byte) error {
 	if err != nil {
 		return err
 	}
-
-	if cfg.Policy.Product == nil {
-		productName := sevsnp.SevProduct_SEV_PRODUCT_UNKNOWN
-		switch cfg.RootOfTrust.ProductLine {
-		case sevProductNameMilan:
-			productName = sevsnp.SevProduct_SEV_PRODUCT_MILAN
-		case sevProductNameGenoa:
-			productName = sevsnp.SevProduct_SEV_PRODUCT_GENOA
-		default:
-		}
-
-		if productName == sevsnp.SevProduct_SEV_PRODUCT_UNKNOWN {
-			return fmt.Errorf("product name must be %s or %s", sevProductNameMilan, sevProductNameGenoa)
-		}
-
-		sopts.Product = &sevsnp.SevProduct{
-			Name: productName,
-		}
-	} else {
-		sopts.Product = cfg.Policy.Product
-	}
-
+	sopts.Product = cfg.Policy.Product
 	sopts.Getter = &trust.RetryHTTPSGetter{
 		Timeout:       timeout,
 		MaxRetryDelay: maxRetryDelay,
 		Getter:        &trust.SimpleHTTPSGetter{},
 	}
-
-	// Only take the attestation report and ignore everything else.
-	attestationPB, err := abi.ReportCertsToProto(attestation[:abi.ReportSize])
+	attestationPB, err := abi.ReportCertsToProto(attestation)
 	if err != nil {
 		return err
 	}

cli/backend_info.go

@@ -1,144 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package cli
-
-import (
-	"encoding/base64"
-	"encoding/json"
-	"fmt"
-	"log"
-	"os"
-
-	"github.com/absmach/magistrala/pkg/errors"
-	"github.com/google/go-sev-guest/proto/check"
-	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
-)
-
-type fieldType int
-
-const (
-	measurementField fieldType = iota
-	hostDataField
-)
-
-const (
-	// 0o744 file permission gives RWX permission to the user and only the R permission to others.
-	filePermission = 0o744
-	// Length of the expected host data and measurement field in bytes.
-	hostDataLength    = 32
-	measurementLength = 48
-)
-
-var (
-	errDecode                 = errors.New("base64 string could not be decoded")
-	errDataLength             = errors.New("data does not have an adequate length")
-	errReadingBackendInfoFile = errors.New("error while reading the backend information file")
-	errUnmarshalJSON          = errors.New("failed to unmarshal json")
-	errMarshalJSON            = errors.New("failed to marshal json")
-	errWriteFile              = errors.New("failed to write to file")
-	errBackendField           = errors.New("the specified field type does not exist in the backend information")
-)
-
-type AttestationConfiguration struct {
-	SNPPolicy   *check.Policy      `json:"snp_policy,omitempty"`
-	RootOfTrust *check.RootOfTrust `json:"root_of_trust,omitempty"`
-}
-
-func (cli *CLI) NewBackendCmd() *cobra.Command {
-	return &cobra.Command{
-		Use:   "backend [command]",
-		Short: "Change backend information",
-		Run: func(cmd *cobra.Command, args []string) {
-			fmt.Printf("Change backend information\n\n")
-			fmt.Printf("Usage:\n  %s [command]\n\n", cmd.CommandPath())
-			fmt.Printf("Available Commands:\n")
-
-			// Filter out "completion" command
-			availableCommands := make([]*cobra.Command, 0)
-			for _, subCmd := range cmd.Commands() {
-				if subCmd.Name() != "completion" {
-					availableCommands = append(availableCommands, subCmd)
-				}
-			}
-
-			for _, subCmd := range availableCommands {
-				fmt.Printf("  %-15s%s\n", subCmd.Name(), subCmd.Short)
-			}
-
-			fmt.Printf("\nFlags:\n")
-			cmd.Flags().VisitAll(func(flag *pflag.Flag) {
-				fmt.Printf("  -%s, --%s %s\n", flag.Shorthand, flag.Name, flag.Usage)
-			})
-			fmt.Printf("\nUse \"%s [command] --help\" for more information about a command.\n", cmd.CommandPath())
-		},
-	}
-}
-
-func (cli *CLI) NewAddMeasurementCmd() *cobra.Command {
-	return &cobra.Command{
-		Use:     "measurement",
-		Short:   "Add measurement to the backend info file. The value should be in base64. The second parameter is backend_info.json file",
-		Example: "measurement <measurement> <backend_info.json>",
-		Args:    cobra.ExactArgs(2),
-		Run: func(cmd *cobra.Command, args []string) {
-			if err := changeAttestationConfiguration(args[1], args[0], measurementLength, measurementField); err != nil {
-				log.Fatalf("Error could not change measurement data %v", err)
-			}
-		},
-	}
-}
-
-func (cli *CLI) NewAddHostDataCmd() *cobra.Command {
-	return &cobra.Command{
-		Use:     "hostdata",
-		Short:   "Add host data to the backend info file. The value should be in base64. The second parameter is backend_info.json file",
-		Example: "hostdata <host-data> <backend_info.json>",
-		Args:    cobra.ExactArgs(2),
-		Run: func(cmd *cobra.Command, args []string) {
-			if err := changeAttestationConfiguration(args[1], args[0], hostDataLength, hostDataField); err != nil {
-				log.Fatalf("Error could not change host data %v", err)
-			}
-		},
-	}
-}
-
-func changeAttestationConfiguration(fileName, base64Data string, expectedLength int, field fieldType) error {
-	data, err := base64.StdEncoding.DecodeString(base64Data)
-	if err != nil {
-		return errDecode
-	}
-
-	if len(data) != expectedLength {
-		return errDataLength
-	}
-
-	ac := AttestationConfiguration{}
-
-	backendInfo, err := os.ReadFile(fileName)
-	if err != nil {
-		return errors.Wrap(errReadingBackendInfoFile, err)
-	}
-
-	if err = json.Unmarshal(backendInfo, &ac); err != nil {
-		return errors.Wrap(errUnmarshalJSON, err)
-	}
-
-	switch field {
-	case measurementField:
-		ac.SNPPolicy.Measurement = data
-	case hostDataField:
-		ac.SNPPolicy.HostData = data
-	default:
-		return errBackendField
-	}
-
-	fileJson, err := json.MarshalIndent(ac, "", " ")
-	if err != nil {
-		return errors.Wrap(errMarshalJSON, err)
-	}
-	if err = os.WriteFile(fileName, fileJson, filePermission); err != nil {
-		return errors.Wrap(errWriteFile, err)
-	}
-	return nil
-}

cli/cache.go

@@ -1,69 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package cli
-
-import (
-	"log"
-	"os"
-	"path"
-
-	"github.com/google/go-sev-guest/abi"
-	"github.com/google/go-sev-guest/kds"
-	"github.com/google/go-sev-guest/verify/trust"
-	"github.com/spf13/cobra"
-	"github.com/ultravioletrs/cocos/pkg/clients/grpc"
-)
-
-const (
-	caBundleName      = "ask_ark.pem"
-	filePermisionKeys = 0o766
-)
-
-func (cli *CLI) NewCABundleCmd(fileSavePath string) *cobra.Command {
-	return &cobra.Command{
-		Use:     "ca-bundle",
-		Short:   "Fetch AMD SEV-SNPs CA Bundle (ASK and ARK)",
-		Example: "ca-bundle <path_to_platform_info_json>",
-		Args:    cobra.ExactArgs(1),
-		Run: func(cmd *cobra.Command, args []string) {
-			attestationConfiguration := grpc.AttestationConfiguration{}
-			err := grpc.ReadManifest(args[0], &attestationConfiguration)
-			if err != nil {
-				log.Fatalf("Error while reading manifest: %v", err)
-			}
-
-			product := attestationConfiguration.RootOfTrust.Product
-
-			getter := trust.DefaultHTTPSGetter()
-			caURL := kds.ProductCertChainURL(abi.VcekReportSigner, product)
-
-			bundle, err := getter.Get(caURL)
-			if err != nil {
-				log.Fatalf("Error fetching ARK and ASK from AMD KDS for product: %s, error: %v", product, err)
-			}
-
-			err = os.MkdirAll(path.Join(fileSavePath, product), filePermisionKeys)
-			if err != nil {
-				log.Fatalf("Error while creating directory for product name %s, error: %v", product, err)
-			}
-
-			bundleFilePath := path.Join(fileSavePath, product, caBundleName)
-			if err = saveToFile(bundleFilePath, bundle); err != nil {
-				log.Fatalf("Error while saving ARK-ASK to file: %v", err)
-			}
-		},
-	}
-}
-
-func saveToFile(fileSavePath string, content []byte) error {
-	file, err := os.OpenFile(fileSavePath, os.O_CREATE|os.O_RDWR|os.O_TRUNC, filePermisionKeys)
-	if err != nil {
-		return err
-	}
-
-	if _, err := file.Write(content); err != nil {
-		return err
-	}
-
-	return nil
-}

cli/checksum.go

@@ -1,29 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package cli
-
-import (
-	"log"
-
-	"github.com/spf13/cobra"
-	"github.com/ultravioletrs/cocos/internal"
-)
-
-func (cli *CLI) NewFileHashCmd() *cobra.Command {
-	return &cobra.Command{
-		Use:     "checksum",
-		Short:   "Compute the sha3-256 hash of a file",
-		Example: "checksum <file>",
-		Args:    cobra.ExactArgs(1),
-		Run: func(cmd *cobra.Command, args []string) {
-			path := args[0]
-
-			hash, err := internal.ChecksumHex(path)
-			if err != nil {
-				log.Fatalf("Error computing hash: %v", err)
-			}
-
-			log.Println("Hash of file:", hash)
-		},
-	}
-}

cli/datasets.go

@@ -3,101 +3,40 @@
 package cli
 
 import (
-	"context"
-	"crypto/x509"
-	"encoding/pem"
 	"log"
 	"os"
-	"path"
 
 	"github.com/spf13/cobra"
 	"github.com/ultravioletrs/cocos/agent"
-	"github.com/ultravioletrs/cocos/internal"
-	"google.golang.org/grpc/metadata"
 )
 
-var decompressDataset bool
-
 func (cli *CLI) NewDatasetsCmd() *cobra.Command {
-	cmd := &cobra.Command{
+	return &cobra.Command{
 		Use:     "data",
-		Short:   "Upload a dataset",
-		Example: "data <dataset_path> <private_key_file_path>",
-		Args:    cobra.ExactArgs(2),
+		Short:   "Upload a dataset CSV file",
+		Example: "data <dataset.csv> <id> <provider>",
+		Args:    cobra.ExactArgs(3),
 		Run: func(cmd *cobra.Command, args []string) {
-			datasetPath := args[0]
+			datasetFile := args[0]
 
-			log.Println("Uploading dataset:", datasetPath)
+			log.Println("Uploading dataset CSV:", datasetFile)
 
-			f, err := os.Stat(datasetPath)
+			dataset, err := os.ReadFile(datasetFile)
 			if err != nil {
 				log.Fatalf("Error reading dataset file: %v", err)
 			}
 
-			var dataset []byte
-
-			if f.IsDir() {
-				dataset, err = internal.ZipDirectoryToMemory(datasetPath)
-				if err != nil {
-					log.Fatalf("Error zipping dataset directory: %v", err)
-				}
-			} else {
-				dataset, err = os.ReadFile(datasetPath)
-				if err != nil {
-					log.Fatalf("Error reading dataset file: %v", err)
-				}
-			}
-
 			dataReq := agent.Dataset{
 				Dataset:  dataset,
-				Filename: path.Base(datasetPath),
+				ID:       args[1],
+				Provider: args[2],
 			}
 
-			privKeyFile, err := os.ReadFile(args[1])
-			if err != nil {
-				log.Fatalf("Error reading private key file: %v", err)
-			}
-
-			pemBlock, _ := pem.Decode(privKeyFile)
-
-			privKey := decodeKey(pemBlock)
-
-			ctx := metadata.NewOutgoingContext(cmd.Context(), metadata.New(make(map[string]string)))
-			if err := cli.agentSDK.Data(addDatasetMetadata(ctx), dataReq, privKey); err != nil {
+			if err := cli.agentSDK.Data(cmd.Context(), dataReq); err != nil {
 				log.Fatalf("Error uploading dataset: %v", err)
 			}
 
 			log.Println("Successfully uploaded dataset")
 		},
 	}
-
-	cmd.Flags().BoolVarP(&decompressDataset, "decompress", "d", false, "Decompress the dataset on agent")
-	return cmd
-}
-
-func decodeKey(b *pem.Block) interface{} {
-	switch b.Type {
-	case rsaKeyType:
-		privKey, err := x509.ParsePKCS8PrivateKey(b.Bytes)
-		if err != nil {
-			privKey, err = x509.ParsePKCS1PrivateKey(b.Bytes)
-			if err != nil {
-				log.Fatalf("Error parsing private key: %v", err)
-			}
-		}
-		return privKey
-	case ecdsaKeyType:
-		privKey, err := x509.ParseECPrivateKey(b.Bytes)
-		if err != nil {
-			log.Fatalf("Error parsing private key: %v", err)
-		}
-		return privKey
-	default:
-		log.Fatalf("Error decoding key")
-		return nil
-	}
-}
-
-func addDatasetMetadata(ctx context.Context) context.Context {
-	return agent.DecompressToContext(ctx, decompressDataset)
 }

cli/keys.go

@@ -1,128 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package cli
-
-import (
-	"crypto/ecdsa"
-	"crypto/ed25519"
-	"crypto/elliptic"
-	"crypto/rand"
-	"crypto/rsa"
-	"crypto/x509"
-	"encoding/pem"
-	"log"
-	"os"
-	"reflect"
-
-	"github.com/spf13/cobra"
-)
-
-const (
-	keyBitSize     = 4096
-	rsaKeyType     = "PRIVATE KEY"
-	ecdsaKeyType   = "EC PRIVATE KEY"
-	ed25519KeyType = "PRIVATE KEY"
-	publicKeyType  = "PUBLIC KEY"
-	publicKeyFile  = "public.pem"
-	privateKeyFile = "private.pem"
-)
-
-var KeyType string
-
-func (cli *CLI) NewKeysCmd() *cobra.Command {
-	return &cobra.Command{
-		Use:   "keys",
-		Short: "Generate a new public/private key pair",
-		Long: "Generates a new public/private key pair using an algorithm of the users choice.\n" +
-			"Supported algorithms are RSA, ecdsa, and ed25519.",
-		Example: "./build/cocos-cli keys -k rsa",
-		Args:    cobra.ExactArgs(0),
-		Run: func(cmd *cobra.Command, args []string) {
-			switch KeyType {
-			case "ecdsa":
-				privEcdsaKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
-				if err != nil {
-					log.Fatalf("Error generating keys: %v", err)
-				}
-
-				pubKeyBytes, err := x509.MarshalPKIXPublicKey(&privEcdsaKey.PublicKey)
-				if err != nil {
-					log.Fatalf("Error marshalling public key: %v", err)
-				}
-
-				generateAndWriteKeys(privEcdsaKey, pubKeyBytes, ecdsaKeyType)
-
-			case "ed25519":
-				pubEd25519Key, privEd25519Key, err := ed25519.GenerateKey(rand.Reader)
-				if err != nil {
-					log.Fatalf("Error generating keys: %v", err)
-				}
-				pubKey, err := x509.MarshalPKIXPublicKey(pubEd25519Key)
-				if err != nil {
-					log.Fatalf("Error marshalling public key: %v", err)
-				}
-				generateAndWriteKeys(privEd25519Key, pubKey, ed25519KeyType)
-
-			// Default to RSA
-			default:
-				privKey, err := rsa.GenerateKey(rand.Reader, keyBitSize)
-				if err != nil {
-					log.Fatalf("Error generating keys: %v", err)
-				}
-
-				pubKeyBytes, err := x509.MarshalPKIXPublicKey(&privKey.PublicKey)
-				if err != nil {
-					log.Fatalf("Error marshalling public key: %v", err)
-				}
-				generateAndWriteKeys(privKey, pubKeyBytes, rsaKeyType)
-			}
-		},
-	}
-}
-
-func generateAndWriteKeys(privKey interface{}, pubKeyBytes []byte, keyType string) {
-	privFile, err := os.Create(privateKeyFile)
-	if err != nil {
-		log.Fatalf("Error creating private key file: %v", err)
-	}
-	defer privFile.Close()
-
-	var b []byte
-	switch privKey := privKey.(type) {
-	case *rsa.PrivateKey:
-		b = x509.MarshalPKCS1PrivateKey(privKey)
-	case *ecdsa.PrivateKey:
-		b, err = x509.MarshalECPrivateKey(privKey)
-	case ed25519.PrivateKey:
-		b, err = x509.MarshalPKCS8PrivateKey(privKey)
-	}
-	if err != nil {
-		log.Printf("Error marshalling private key: %v", err)
-		return
-	}
-
-	if err := pem.Encode(privFile, &pem.Block{
-		Type:  keyType,
-		Bytes: b,
-	}); err != nil {
-		log.Printf("Error encoding private key: %v", err)
-		return
-	}
-
-	pubFile, err := os.Create(publicKeyFile)
-	if err != nil {
-		log.Printf("Error creating public key file: %v", err)
-		return
-	}
-	defer pubFile.Close()
-
-	if err := pem.Encode(pubFile, &pem.Block{
-		Type:  publicKeyType,
-		Bytes: pubKeyBytes,
-	}); err != nil {
-		log.Printf("Error encoding public key: %v", err)
-		return
-	}
-
-	log.Printf("Successfully generated public/private key pair of type: %s", reflect.TypeOf(privKey).String())
-}

cli/result.go

@@ -3,35 +3,23 @@
 package cli
 
 import (
-	"encoding/pem"
 	"log"
 	"os"
 
 	"github.com/spf13/cobra"
 )
 
-const resultFilePath = "results.zip"
+const resultFilePath = "result.bin"
 
 func (cli *CLI) NewResultsCmd() *cobra.Command {
 	return &cobra.Command{
-		Use:     "result",
-		Short:   "Retrieve computation result file",
-		Example: "result <private_key_file_path>",
-		Args:    cobra.ExactArgs(1),
+		Use:   "result",
+		Short: "Retrieve computation result file",
+		Args:  cobra.ExactArgs(1),
 		Run: func(cmd *cobra.Command, args []string) {
 			log.Println("Retrieving computation result file")
 
-			privKeyFile, err := os.ReadFile(args[0])
-			if err != nil {
-				log.Fatalf("Error reading private key file: %v", err)
-			}
-
-			pemBlock, _ := pem.Decode(privKeyFile)
-
-			var result []byte
-
-			privKey := decodeKey(pemBlock)
-			result, err = cli.agentSDK.Result(cmd.Context(), privKey)
+			result, err := cli.agentSDK.Result(cmd.Context(), args[0])
 			if err != nil {
 				log.Fatalf("Error retrieving computation result: %v", err)
 			}

cli/sdk.go

@@ -2,13 +2,15 @@
 // SPDX-License-Identifier: Apache-2.0
 package cli
 
-import "github.com/ultravioletrs/cocos/pkg/sdk"
+import (
+	"github.com/ultravioletrs/cocos/agent"
+)
 
 type CLI struct {
-	agentSDK sdk.SDK
+	agentSDK agent.Service
 }
 
-func New(agentSDK sdk.SDK) *CLI {
+func New(agentSDK agent.Service) *CLI {
 	return &CLI{
 		agentSDK: agentSDK,
 	}

cmd/agent/main.go

@@ -6,24 +6,19 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"io"
 	"log"
 	"log/slog"
 
-	"github.com/absmach/magistrala/pkg/prometheus"
-	"github.com/google/go-sev-guest/client"
 	"github.com/mdlayher/vsock"
 	"github.com/ultravioletrs/cocos/agent"
 	"github.com/ultravioletrs/cocos/agent/api"
 	agentgrpc "github.com/ultravioletrs/cocos/agent/api/grpc"
-	"github.com/ultravioletrs/cocos/agent/auth"
 	"github.com/ultravioletrs/cocos/agent/events"
-	"github.com/ultravioletrs/cocos/agent/quoteprovider"
+	"github.com/ultravioletrs/cocos/internal"
 	agentlogger "github.com/ultravioletrs/cocos/internal/logger"
 	"github.com/ultravioletrs/cocos/internal/server"
 	grpcserver "github.com/ultravioletrs/cocos/internal/server/grpc"
 	"github.com/ultravioletrs/cocos/manager"
-	"github.com/ultravioletrs/cocos/manager/qemu"
 	"golang.org/x/sync/errgroup"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/reflection"
@@ -48,7 +43,6 @@ func main() {
 		log.Fatal(err)
 	}
 	defer conn.Close()
-
 	var level slog.Level
 	if err := level.UnmarshalText([]byte(cfg.AgentConfig.LogLevel)); err != nil {
 		log.Println(err)
@@ -59,18 +53,11 @@ func main() {
 
 	eventSvc, err := events.New(svcName, cfg.ID, manager.ManagerVsockPort)
 	if err != nil {
-		logger.Error(fmt.Sprintf("failed to create events service %s", err.Error()))
+		log.Printf("failed to create events service %s", err.Error())
 		return
 	}
 	defer eventSvc.Close()
-
-	qp, err := quoteprovider.GetQuoteProvider()
-	if err != nil {
-		logger.Error(fmt.Sprintf("failed to create quote provider %s", err.Error()))
-		return
-	}
-
-	svc := newService(ctx, logger, eventSvc, cfg, qp)
+	svc := newService(ctx, logger, eventSvc, cfg)
 
 	grpcServerConfig := server.Config{
 		Port:         cfg.AgentConfig.Port,
@@ -79,21 +66,13 @@ func main() {
 		KeyFile:      cfg.AgentConfig.KeyFile,
 		ServerCAFile: cfg.AgentConfig.ServerCAFile,
 		ClientCAFile: cfg.AgentConfig.ClientCAFile,
-		AttestedTLS:  cfg.AgentConfig.AttestedTls,
 	}
 
 	registerAgentServiceServer := func(srv *grpc.Server) {
 		reflection.Register(srv)
 		agent.RegisterAgentServiceServer(srv, agentgrpc.NewServer(svc))
 	}
-
-	authSvc, err := auth.New(cfg)
-	if err != nil {
-		logger.Error(fmt.Sprintf("failed to create auth service %s", err.Error()))
-		return
-	}
-
-	gs := grpcserver.New(ctx, cancel, svcName, grpcServerConfig, registerAgentServiceServer, logger, qp, authSvc)
+	gs := grpcserver.New(ctx, cancel, svcName, grpcServerConfig, registerAgentServiceServer, logger)
 
 	g.Go(func() error {
 		return gs.Start()
@@ -108,46 +87,36 @@ func main() {
 	}
 }
 
-func newService(ctx context.Context, logger *slog.Logger, eventSvc events.Service, cmp agent.Computation, qp client.QuoteProvider) agent.Service {
-	svc := agent.New(ctx, logger, eventSvc, cmp, qp)
+func newService(ctx context.Context, logger *slog.Logger, eventSvc events.Service, cmp agent.Computation) agent.Service {
+	svc := agent.New(ctx, logger, eventSvc, cmp)
 
 	svc = api.LoggingMiddleware(svc, logger)
-	counter, latency := prometheus.MakeMetrics(svcName, "api")
+	counter, latency := internal.MakeMetrics(svcName, "api")
 	svc = api.MetricsMiddleware(svc, counter, latency)
 
 	return svc
 }
 
 func readConfig() (agent.Computation, error) {
-	l, err := vsock.Listen(qemu.VsockConfigPort, nil)
+	l, err := vsock.Listen(manager.VsockConfigPort, nil)
 	if err != nil {
 		return agent.Computation{}, err
 	}
 	defer l.Close()
-
 	conn, err := l.Accept()
 	if err != nil {
 		return agent.Computation{}, err
 	}
 	defer conn.Close()
-
-	var buffer []byte
-	for {
-		chunk := make([]byte, 1024)
-		n, err := conn.Read(chunk)
-		if err != nil {
-			if err == io.EOF {
-				break
-			}
-			return agent.Computation{}, err
-		}
-		buffer = append(buffer, chunk[:n]...)
+	b := make([]byte, 1024)
+	n, err := conn.Read(b)
+	if err != nil {
+		return agent.Computation{}, err
 	}
-
 	ac := agent.Computation{
 		AgentConfig: agent.AgentConfig{},
 	}
-	if err := json.Unmarshal(buffer, &ac); err != nil {
+	if err := json.Unmarshal(b[:n], &ac); err != nil {
 		return agent.Computation{}, err
 	}
 	if ac.AgentConfig.LogLevel == "" {

cmd/cli/main.go

@@ -6,13 +6,12 @@ import (
 	"fmt"
 	"log"
 	"os"
-	"path"
 
 	mglog "github.com/absmach/magistrala/logger"
-	"github.com/caarlos0/env/v11"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
 	"github.com/ultravioletrs/cocos/cli"
+	"github.com/ultravioletrs/cocos/internal/env"
 	"github.com/ultravioletrs/cocos/pkg/clients/grpc"
 	"github.com/ultravioletrs/cocos/pkg/clients/grpc/agent"
 	"github.com/ultravioletrs/cocos/pkg/sdk"
@@ -22,12 +21,10 @@ const (
 	svcName            = "cli"
 	envPrefixAgentGRPC = "AGENT_GRPC_"
 	completion         = "completion"
-	filePermision      = 0o755
-	cocosDirectory     = ".cocos"
 )
 
 type config struct {
-	LogLevel string `env:"AGENT_LOG_LEVEL" envDefault:"info"`
+	LogLevel string `env:"AGENT_LOG_LEVEL"               envDefault:"info"`
 }
 
 func main() {
@@ -36,24 +33,13 @@ func main() {
 		log.Fatalf("failed to load %s configuration : %s", svcName, err)
 	}
 
-	homePath, err := os.UserHomeDir()
-	if err != nil {
-		log.Fatalf("Error fetching user home directory: %v", err)
-	}
-
-	directoryCachePath := path.Join(homePath, cocosDirectory)
-
-	if err := os.MkdirAll(directoryCachePath, filePermision); err != nil {
-		log.Fatalf("Error while creating directory %s, error: %v", directoryCachePath, err)
-	}
-
 	logger, err := mglog.New(os.Stdout, cfg.LogLevel)
 	if err != nil {
 		log.Fatalf("Error creating logger: %s", err)
 	}
 
 	agentGRPCConfig := grpc.Config{}
-	if err := env.ParseWithOptions(&agentGRPCConfig, env.Options{Prefix: envPrefixAgentGRPC}); err != nil {
+	if err := env.Parse(&agentGRPCConfig, env.Options{Prefix: envPrefixAgentGRPC}); err != nil {
 		logger.Error(fmt.Sprintf("failed to load %s gRPC client configuration : %s", svcName, err))
 		return
 	}
@@ -97,36 +83,16 @@ func main() {
 		},
 	}
 
-	keysCmd := cliSVC.NewKeysCmd()
-	attestationCmd := cliSVC.NewAttestationCmd()
-	backendCmd := cliSVC.NewBackendCmd()
-
 	// Agent Commands
-	rootCmd.AddCommand(cliSVC.NewAlgorithmCmd())
+	rootCmd.AddCommand(cliSVC.NewAlgorithmsCmd())
 	rootCmd.AddCommand(cliSVC.NewDatasetsCmd())
 	rootCmd.AddCommand(cliSVC.NewResultsCmd())
-	rootCmd.AddCommand(attestationCmd)
-	rootCmd.AddCommand(cliSVC.NewFileHashCmd())
-	rootCmd.AddCommand(backendCmd)
-	rootCmd.AddCommand(keysCmd)
-	rootCmd.AddCommand(cliSVC.NewCABundleCmd(directoryCachePath))
+	attestaionCmd := cliSVC.NewAttestationCmd()
+	rootCmd.AddCommand(attestaionCmd)
 
 	// Attestation commands
-	attestationCmd.AddCommand(cliSVC.NewGetAttestationCmd())
-	attestationCmd.AddCommand(cliSVC.NewValidateAttestationValidationCmd())
-
-	// Flags
-	keysCmd.PersistentFlags().StringVarP(
-		&cli.KeyType,
-		"key-type",
-		"k",
-		"rsa",
-		"User Key type",
-	)
-
-	// Backend information commands
-	backendCmd.AddCommand(cliSVC.NewAddMeasurementCmd())
-	backendCmd.AddCommand(cliSVC.NewAddHostDataCmd())
+	attestaionCmd.AddCommand(cliSVC.NewGetAttestationCmd())
+	attestaionCmd.AddCommand(cliSVC.NewValidateAttestationValidationCmd())
 
 	if err := rootCmd.Execute(); err != nil {
 		logger.Error(fmt.Sprintf("Command execution failed: %s", err))

cmd/manager/main.go

@@ -8,15 +8,14 @@ import (
 	"fmt"
 	"log"
 	"log/slog"
-	"net/url"
 	"os"
 	"strings"
 
 	mglog "github.com/absmach/magistrala/logger"
-	"github.com/absmach/magistrala/pkg/jaeger"
-	"github.com/absmach/magistrala/pkg/prometheus"
 	"github.com/absmach/magistrala/pkg/uuid"
-	"github.com/caarlos0/env/v11"
+	"github.com/ultravioletrs/cocos/internal"
+	"github.com/ultravioletrs/cocos/internal/env"
+	jaegerclient "github.com/ultravioletrs/cocos/internal/jaeger"
 	"github.com/ultravioletrs/cocos/manager"
 	"github.com/ultravioletrs/cocos/manager/api"
 	managerapi "github.com/ultravioletrs/cocos/manager/api/grpc"
@@ -36,15 +35,13 @@ const (
 )
 
 type config struct {
-	LogLevel                 string  `env:"MANAGER_LOG_LEVEL"                  envDefault:"info"`
-	JaegerURL                url.URL `env:"COCOS_JAEGER_URL"                   envDefault:"http://localhost:4318"`
-	TraceRatio               float64 `env:"COCOS_JAEGER_TRACE_RATIO"           envDefault:"1.0"`
-	InstanceID               string  `env:"MANAGER_INSTANCE_ID"                envDefault:""`
-	BackendMeasurementBinary string  `env:"MANAGER_BACKEND_MEASUREMENT_BINARY" envDefault:"../../build"`
+	LogLevel   string `env:"MANAGER_LOG_LEVEL"        envDefault:"info"`
+	JaegerURL  string `env:"COCOS_JAEGER_URL"         envDefault:"http://localhost:14268/api/traces"`
+	InstanceID string `env:"MANAGER_INSTANCE_ID"      envDefault:""`
 }
 
 func main() {
-	ctx, cancel := context.WithCancel(context.Background())
+	ctx := context.Background()
 	g, ctx := errgroup.WithContext(ctx)
 
 	var cfg config
@@ -58,13 +55,14 @@ func main() {
 	}
 
 	if cfg.InstanceID == "" {
-		if cfg.InstanceID, err = uuid.New().ID(); err != nil {
+		cfg.InstanceID, err = uuid.New().ID()
+		if err != nil {
 			logger.Error(fmt.Sprintf("Failed to generate instance ID: %s", err))
 			return
 		}
 	}
 
-	tp, err := jaeger.NewProvider(ctx, svcName, cfg.JaegerURL, cfg.InstanceID, cfg.TraceRatio)
+	tp, err := jaegerclient.NewProvider(ctx, svcName, cfg.JaegerURL, cfg.InstanceID)
 	if err != nil {
 		logger.Error(fmt.Sprintf("Failed to init Jaeger: %s", err))
 	}
@@ -76,15 +74,19 @@ func main() {
 	tracer := tp.Tracer(svcName)
 
 	qemuCfg := qemu.Config{}
-	if err := env.ParseWithOptions(&qemuCfg, env.Options{Prefix: envPrefixQemu}); err != nil {
+	if err := env.Parse(&qemuCfg, env.Options{Prefix: envPrefixQemu}); err != nil {
 		logger.Error(fmt.Sprintf("failed to load QEMU configuration: %s", err))
 		return
 	}
-	args := qemuCfg.ConstructQemuArgs()
-	logger.Info(strings.Join(args, " "))
+	exe, args, err := qemu.ExecutableAndArgs(qemuCfg)
+	if err != nil {
+		logger.Error(fmt.Sprintf("failed to parse QEMU configuration: %s", err))
+		return
+	}
+	logger.Info(fmt.Sprintf("%s %s", exe, strings.Join(args, " ")))
 
 	managerGRPCConfig := grpc.Config{}
-	if err := env.ParseWithOptions(&managerGRPCConfig, env.Options{Prefix: envPrefixGRPC}); err != nil {
+	if err := env.Parse(&managerGRPCConfig, env.Options{Prefix: envPrefixGRPC}); err != nil {
 		logger.Error(fmt.Sprintf("failed to load %s gRPC client configuration : %s", svcName, err))
 		return
 	}
@@ -101,35 +103,37 @@ func main() {
 		logger.Error(err.Error())
 		return
 	}
-
-	eventsChan := make(chan *pkgmanager.ClientStreamMessage)
-	svc, err := newService(logger, tracer, qemuCfg, eventsChan, cfg.BackendMeasurementBinary)
-	if err != nil {
+	if err := pc.Send(&pkgmanager.ClientStreamMessage{Message: &pkgmanager.ClientStreamMessage_Whoami{}}); err != nil {
 		logger.Error(err.Error())
 		return
 	}
 
+	eventsChan := make(chan *pkgmanager.ClientStreamMessage)
+	svc := newService(logger, tracer, qemuCfg, eventsChan)
+
 	mc := managerapi.NewClient(pc, svc, eventsChan)
 
 	g.Go(func() error {
-		return mc.Process(ctx, cancel)
+		return mc.Process(ctx)
 	})
 
 	if err := g.Wait(); err != nil {
 		logger.Error(fmt.Sprintf("%s service terminated: %s", svcName, err))
 	}
+
+	err = internal.DeleteFilesInDir(qemuCfg.TmpFileLoc)
+	if err != nil {
+		logger.Error(err.Error())
+	}
 }
 
-func newService(logger *slog.Logger, tracer trace.Tracer, qemuCfg qemu.Config, eventsChan chan *pkgmanager.ClientStreamMessage, backendMeasurementPath string) (manager.Service, error) {
-	svc, err := manager.New(qemuCfg, backendMeasurementPath, logger, eventsChan, qemu.NewVM)
-	if err != nil {
-		return nil, err
-	}
+func newService(logger *slog.Logger, tracer trace.Tracer, qemuCfg qemu.Config, eventsChan chan *pkgmanager.ClientStreamMessage) manager.Service {
+	svc := manager.New(qemuCfg, logger, eventsChan)
 	go svc.RetrieveAgentEventsLogs()
 	svc = api.LoggingMiddleware(svc, logger)
-	counter, latency := prometheus.MakeMetrics(svcName, "api")
+	counter, latency := internal.MakeMetrics(svcName, "api")
 	svc = api.MetricsMiddleware(svc, counter, latency)
 	svc = tracing.New(svc, tracer)
 
-	return svc, nil
+	return svc
 }

cmd/manager/script/launch-qemu.sh

@@ -0,0 +1,270 @@
+#!/bin/bash
+
+#
+# user changeable parameters
+#
+
+HDA_FILE="cmd/manager/img/focal-server-cloudimg-amd64.qcow2"
+GUEST_SIZE_IN_MB="4096"
+SEV_GUEST="1"
+SMP_NCPUS="4"
+CONSOLE="serial"
+VNC_PORT=""
+USE_VIRTIO="1"
+
+UEFI_BIOS_CODE="/usr/share/OVMF/OVMF_CODE.fd"
+UEFI_BIOS_VARS_ORIG="/usr/share/OVMF/OVMF_VARS.fd"
+UEFI_BIOS_VARS_COPY="cmd/manager/img/OVMF_VARS.fd"
+
+CBITPOS=51
+HOST_HTTP_PORT=9301
+GUEST_HTTP_PORT=9031
+HOST_GRPC_PORT=7020
+GUEST_GRPC_PORT=7002
+
+ENABLE_FILE_LOG="0"
+EXEC_QEMU_CMDLINE="0"
+
+usage() {
+    echo "$0 [options]"
+    echo "Available <commands>:"
+    echo " -hda           hard disk ($HDA_FILE)"
+    echo " -nosev         disable sev support"
+    echo " -mem           guest memory"
+    echo " -smp           number of cpus"
+    echo " -console       display console to use (serial or gxl)"
+    echo " -vnc           VNC port to use"
+    echo " -bios          bios to use (default $UEFI_BIOS_CODE)"
+    echo " -kernel        kernel to use"
+    echo " -initrd        initrd to use"
+    echo " -cdrom         CDROM image"
+    echo " -virtio        use virtio devices"
+    echo " -cbitpos       location of the C-bit"
+    echo " -hosthttp      host http port"
+    echo " -guesthttp     guest http port"
+    echo " -hostgrpc      host grpc port"
+    echo " -guestgrpc     guest grpc port"
+    echo " -origuefivars  UEFI BIOS vars original file (default $UEFI_BIOS_VARS_ORIG)"
+    echo " -copyuefivars  UEFI BIOS vars copy file (default $UEFI_BIOS_VARS_COPY)"
+    echo " -exec          execute the QEMU command (default $EXEC_QEMU_CMDLINE)"
+    echo " -filelog       enable/disable QEMU cmd line file log (default: $ENABLE_FILE_LOG)"
+    exit 1
+}
+
+while [[ $1 != "" ]]; do
+    case "$1" in
+        -hda)
+            HDA_FILE=${2}
+            shift
+            ;;
+        -nosev)
+            SEV_GUEST="0"
+            ;;
+        -mem)
+            GUEST_SIZE_IN_MB=${2}
+            shift
+            ;;
+        -console)
+            CONSOLE=${2}
+            shift
+            ;;
+        -smp)
+            SMP_NCPUS=$2
+            shift
+            ;;
+        -vnc)
+            VNC_PORT=$2
+            shift
+            ;;
+        -bios)
+            UEFI_BIOS_CODE=$2
+            shift
+            ;;
+        -initrd)
+            INITRD_FILE=$2
+            shift
+            ;;
+        -kernel)
+            KERNEL_FILE=$2
+            shift
+            ;;
+        -cdrom)
+            CDROM_FILE=$2
+            shift
+            ;;
+        -virtio)
+            USE_VIRTIO="1"
+            ;;
+        -cbitpos)
+            CBITPOS=$2
+            shift
+            ;;
+        -hosthttp)
+            HOST_HTTP_PORT=$2
+            shift
+            ;;
+        -guesthttp)
+            GUEST_HTTP_PORT=$2
+            shift
+            ;;
+        -guestgrpc)
+            GUEST_GRPC_PORT=$2
+            shift
+            ;;
+        -hostgrpc)
+            HOST_GRPC_PORT=$2
+            shift
+            ;;
+        -origuefivars)
+            UEFI_BIOS_VARS_ORIG=$2
+            shift
+            ;;
+        -copyuefivars)
+            UEFI_BIOS_VARS_COPY=$2
+            shift
+            ;;        
+        -exec)
+            EXEC_QEMU_CMDLINE="1"
+            ;;      
+        -filelog)
+            ENABLE_FILE_LOG="1"
+            ;;                           
+        *)
+            usage;;
+    esac
+    shift
+done
+
+#
+# func definitions
+#
+
+add_opts() {
+    echo -n "$* " >> ${QEMU_CMDLINE}
+}
+
+run_cmd() {
+    if ! "$@"; then
+        echo "Command '$*' failed"
+        exit 1
+    fi
+}
+
+# copy BIOS variables to new dest for VM use without modifying the original ones
+cp "$UEFI_BIOS_VARS_ORIG" "$UEFI_BIOS_VARS_COPY"
+
+#
+# Qemu cmd line construction
+#
+
+# we add all the qemu command line options into a file
+QEMU_CMDLINE=/tmp/cmdline.$$
+rm -rf ${QEMU_CMDLINE}
+
+add_opts "$(which qemu-system-x86_64)"
+
+# Basic virtual machine property
+add_opts "-enable-kvm -cpu EPYC -machine q35"
+
+# add number of VCPUs
+[ -n "$SMP_NCPUS" ] && add_opts "-smp ${SMP_NCPUS},maxcpus=64"
+
+# define guest memory
+add_opts "-m ${GUEST_SIZE_IN_MB}M,slots=5,maxmem=30G"
+
+# The OVMF binary, including the non-volatile variable store, appears as a
+# "normal" qemu drive on the host side, and it is exposed to the guest as a
+# persistent flash device.
+add_opts "-drive if=pflash,format=raw,unit=0,file=${UEFI_BIOS_CODE},readonly=on"
+add_opts "-drive if=pflash,format=raw,unit=1,file=${UEFI_BIOS_VARS_COPY}"
+
+# add CDROM if specified
+[ -n "$CDROM_FILE" ] && add_opts "-drive file=${CDROM_FILE},media=cdrom -boot d"
+
+add_opts "-netdev user,id=vmnic,hostfwd=tcp::2222-:22,hostfwd=tcp::$HOST_HTTP_PORT-:$GUEST_HTTP_PORT,hostfwd=tcp::$HOST_GRPC_PORT-:$GUEST_GRPC_PORT"
+add_opts "-device virtio-net-pci,disable-legacy=on,iommu_platform=true,netdev=vmnic,romfile="
+
+# If harddisk file is specified then add the HDD drive
+if [ -n "$HDA_FILE" ]; then
+    if [ "$USE_VIRTIO" = "1" ]; then
+        if [[ ${HDA_FILE} = *"qcow2" ]]; then
+            add_opts "-drive file=${HDA_FILE},if=none,id=disk0,format=qcow2"
+        else
+            add_opts "-drive file=${HDA_FILE},if=none,id=disk0,format=raw"
+        fi
+        add_opts "-device virtio-scsi-pci,id=scsi,disable-legacy=on,iommu_platform=true"
+        add_opts "-device scsi-hd,drive=disk0"
+    else
+        if [[ ${HDA_FILE} = *"qcow2" ]]; then
+            add_opts "-drive file=${HDA_FILE},format=qcow2"
+        else
+            add_opts "-drive file=${HDA_FILE},format=raw"
+        fi
+    fi
+fi
+
+# If this is SEV guest then add the encryption device objects to enable support
+if [ ${SEV_GUEST} = "1" ]; then
+    add_opts "-object sev-guest,id=sev0,cbitpos=${CBITPOS},reduced-phys-bits=1"
+    add_opts "-machine memory-encryption=sev0"
+fi
+
+# if console is serial then disable graphical interface
+if [ "${CONSOLE}" = "serial" ]; then
+    add_opts "-nographic"
+else
+    add_opts "-vga ${CONSOLE}"
+fi
+
+# if -kernel arg is specified then use the kernel provided in command line for boot
+if [ "${KERNEL_FILE}" != "" ]; then
+    add_opts "-kernel $KERNEL_FILE"
+    add_opts "-append \"console=ttyS0 earlyprintk=serial root=/dev/sda2\""
+    [ -n "$INITRD_FILE" ] && add_opts "-initrd ${INITRD_FILE}"
+fi
+
+# start vnc server
+[ -n "$VNC_PORT" ] && add_opts "-vnc :${VNC_PORT}" && echo "Starting VNC on port ${VNC_PORT}"
+
+# start monitor on pty
+add_opts "-monitor pty"
+
+#
+# Qemu cmd line log
+#
+
+# Set the log file path if ENABLE_FILE_LOG is 1
+if [ "$ENABLE_FILE_LOG" = "1" ]; then
+    LOG_FILE=$(pwd)/stdout.log
+
+    # Save the command line args into log file
+    cat "$QEMU_CMDLINE" > "$LOG_FILE"
+    echo >> "$LOG_FILE"
+fi
+
+ # Log the command line to the console
+cat "$QEMU_CMDLINE"
+
+#
+# Qemu cmd line execution
+#
+
+if [[ "${EXEC_QEMU_CMDLINE}" = "0" ]]; then
+    exit 0
+fi
+
+# map CTRL-C to CTRL ]
+echo "Mapping CTRL-C to CTRL-]"
+stty intr ^]
+
+echo "Launching VM ..."
+if [ "$ENABLE_FILE_LOG" = "1" ]; then
+    bash ${QEMU_CMDLINE} 2>&1 | tee -a "${LOG_FILE}"
+else 
+    bash ${QEMU_CMDLINE} 2>&1
+fi
+
+# restore the mapping
+stty intr ^c
+
+rm -rf ${QEMU_CMDLINE}

go.mod

@@ -1,78 +1,58 @@
 module github.com/ultravioletrs/cocos
 
-go 1.22.4
+go 1.21.6
 
 require (
-	github.com/absmach/magistrala v0.14.1-0.20240709113739-04c359462746
-	github.com/caarlos0/env/v11 v11.1.0
-	github.com/cenkalti/backoff/v4 v4.3.0
-	github.com/digitalocean/go-libvirt v0.0.0-20240709142323-d8406205c752
+	github.com/absmach/magistrala v0.0.0-20240119191055-d95283d31472
+	github.com/caarlos0/env/v7 v7.1.0
+	github.com/cenkalti/backoff/v4 v4.2.1
+	github.com/digitalocean/go-libvirt v0.0.0-20221205150000-2939327a8519
 	github.com/go-kit/kit v0.13.0
 	github.com/gofrs/uuid v4.4.0+incompatible
-	github.com/google/go-sev-guest v0.11.1
+	github.com/google/go-sev-guest v0.10.1
 	github.com/mdlayher/vsock v1.2.1
-	github.com/spf13/cobra v1.8.1
+	github.com/prometheus/client_golang v1.18.0
+	github.com/spf13/cobra v1.8.0
 	github.com/spf13/pflag v1.0.5
-	github.com/stretchr/testify v1.9.0
-	go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.53.0
-	go.opentelemetry.io/otel/trace v1.28.0
-	golang.org/x/crypto v0.25.0
-	golang.org/x/sync v0.7.0
-	google.golang.org/grpc v1.65.0
-	google.golang.org/protobuf v1.34.2
-)
-
-require (
-	github.com/Microsoft/go-winio v0.6.1 // indirect
-	github.com/distribution/reference v0.6.0 // indirect
-	github.com/docker/go-connections v0.5.0 // indirect
-	github.com/docker/go-units v0.5.0 // indirect
-	github.com/felixge/httpsnoop v1.0.4 // indirect
-	github.com/gogo/protobuf v1.3.2 // indirect
-	github.com/moby/docker-image-spec v1.3.1 // indirect
-	github.com/opencontainers/go-digest v1.0.0 // indirect
-	github.com/opencontainers/image-spec v1.1.0 // indirect
-	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.53.0 // indirect
-	go.opentelemetry.io/otel v1.28.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.28.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.28.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.28.0 // indirect
-	golang.org/x/mod v0.19.0 // indirect
-	golang.org/x/tools v0.23.0 // indirect
+	go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.46.1
+	go.opentelemetry.io/otel v1.21.0
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.21.0
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.21.0
+	go.opentelemetry.io/otel/sdk v1.21.0
+	go.opentelemetry.io/otel/trace v1.21.0
+	golang.org/x/crypto v0.19.0
+	golang.org/x/sync v0.6.0
+	google.golang.org/grpc v1.60.1
+	google.golang.org/protobuf v1.32.0
 )
 
 require (
+	cloud.google.com/go/compute v1.23.3 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
-	github.com/cespare/xxhash/v2 v2.3.0 // indirect
-	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
-	github.com/docker/docker v27.1.0+incompatible
+	github.com/cespare/xxhash/v2 v2.2.0 // indirect
 	github.com/go-kit/log v0.2.1 // indirect
 	github.com/go-logfmt/logfmt v0.6.0 // indirect
-	github.com/go-logr/logr v1.4.2 // indirect
+	github.com/go-logr/logr v1.4.1 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
-	github.com/golang/protobuf v1.5.4 // indirect
+	github.com/golang/protobuf v1.5.3 // indirect
 	github.com/google/go-configfs-tsm v0.2.2 // indirect
 	github.com/google/logger v1.1.1 // indirect
-	github.com/google/uuid v1.6.0 // indirect
-	github.com/grpc-ecosystem/grpc-gateway/v2 v2.20.0 // indirect
+	github.com/google/uuid v1.5.0 // indirect
+	github.com/grpc-ecosystem/grpc-gateway/v2 v2.19.0 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
+	github.com/matttproud/golang_protobuf_extensions/v2 v2.0.0 // indirect
 	github.com/mdlayher/socket v0.4.1 // indirect
 	github.com/pborman/uuid v1.2.1 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
-	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
-	github.com/prometheus/client_golang v1.19.1 // indirect
-	github.com/prometheus/client_model v0.6.1 // indirect
-	github.com/prometheus/common v0.52.2 // indirect
-	github.com/prometheus/procfs v0.13.0 // indirect
-	github.com/stretchr/objx v0.5.2 // indirect
-	go.opentelemetry.io/otel/metric v1.28.0 // indirect
-	go.opentelemetry.io/proto/otlp v1.3.1 // indirect
+	github.com/prometheus/client_model v0.5.0 // indirect
+	github.com/prometheus/common v0.45.0 // indirect
+	github.com/prometheus/procfs v0.12.0 // indirect
+	go.opentelemetry.io/otel/metric v1.21.0 // indirect
+	go.opentelemetry.io/proto/otlp v1.0.0 // indirect
 	go.uber.org/multierr v1.11.0 // indirect
-	golang.org/x/net v0.27.0 // indirect
-	golang.org/x/sys v0.22.0 // indirect
-	golang.org/x/term v0.22.0
-	golang.org/x/text v0.16.0 // indirect
-	google.golang.org/genproto/googleapis/api v0.0.0-20240701130421-f6361c86f094 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20240701130421-f6361c86f094 // indirect
-	gopkg.in/yaml.v3 v3.0.1 // indirect
+	golang.org/x/net v0.20.0 // indirect
+	golang.org/x/sys v0.17.0 // indirect
+	golang.org/x/text v0.14.0 // indirect
+	google.golang.org/genproto/googleapis/api v0.0.0-20240108191215-35c7eff3a6b1 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20240108191215-35c7eff3a6b1 // indirect
 )

go.sum

@@ -1,32 +1,31 @@
-github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow=
-github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM=
+cloud.google.com/go v0.110.8 h1:tyNdfIxjzaWctIiLYOTalaLKZ17SI44SKFW26QbOhME=
+cloud.google.com/go/compute v1.23.3 h1:6sVlXXBmbd7jNX0Ipq0trII3e4n1/MsADLK6a+aiVlk=
+cloud.google.com/go/compute v1.23.3/go.mod h1:VCgBUoMnIVIR0CscqQiPJLAG25E3ZRZMzcFZeQ+h8CI=
+cloud.google.com/go/compute/metadata v0.2.3 h1:mg4jlk7mCAj6xXp9UJ4fjI9VUI5rubuGBW5aJ7UnBMY=
+cloud.google.com/go/compute/metadata v0.2.3/go.mod h1:VAV5nSsACxMJvgaAuX6Pk2AawlZn8kiOGuCv6gTkwuA=
 github.com/VividCortex/gohistogram v1.0.0 h1:6+hBz+qvs0JOrrNhhmR7lFxo5sINxBCGXrdtl/UvroE=
 github.com/VividCortex/gohistogram v1.0.0/go.mod h1:Pf5mBqqDxYaXu3hDrrU+w6nw50o/4+TcAqDqk/vUH7g=
-github.com/absmach/magistrala v0.14.1-0.20240709113739-04c359462746 h1:Tj567KeGVygjTsSCxn4++skKiz9GkPugM1KMdIFxvfw=
-github.com/absmach/magistrala v0.14.1-0.20240709113739-04c359462746/go.mod h1:CIx3OsPFc4doJZmBWSA6LNWefcznKv9c3cLOxNxL4q4=
+github.com/absmach/magistrala v0.0.0-20240119191055-d95283d31472 h1:MdS3yTTJP/OSFkMJ4+cJ0LnRS9OyPtPxsR0mSFYglXw=
+github.com/absmach/magistrala v0.0.0-20240119191055-d95283d31472/go.mod h1:02Ip3Ow7JlPT4nb2TdZcOuf7C3ac8tzyEVwB+H1G40g=
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
-github.com/caarlos0/env/v11 v11.1.0 h1:a5qZqieE9ZfzdvbbdhTalRrHT5vu/4V1/ad1Ka6frhI=
-github.com/caarlos0/env/v11 v11.1.0/go.mod h1:LwgkYk1kDvfGpHthrWWLof3Ny7PezzFwS4QrsJdHTMo=
-github.com/cenkalti/backoff/v4 v4.3.0 h1:MyRJ/UdXutAwSAT+s3wNd7MfTIcy71VQueUuFK343L8=
-github.com/cenkalti/backoff/v4 v4.3.0/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE=
-github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
-github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/caarlos0/env/v7 v7.1.0 h1:9lzTF5amyQeWHZzuZeKlCb5FWSUxpG1js43mhbY8ozg=
+github.com/caarlos0/env/v7 v7.1.0/go.mod h1:LPPWniDUq4JaO6Q41vtlyikhMknqymCLBw0eX4dcH1E=
+github.com/cenkalti/backoff/v4 v4.2.1 h1:y4OZtCnogmCPw98Zjyt5a6+QwPLGkiQsYW5oUqylYbM=
+github.com/cenkalti/backoff/v4 v4.2.1/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE=
+github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
+github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/cncf/xds/go v0.0.0-20230607035331-e9ce68804cb4 h1:/inchEIKaYC1Akx+H+gqO04wryn5h75LSazbRlnya1k=
+github.com/cncf/xds/go v0.0.0-20230607035331-e9ce68804cb4/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
+github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/digitalocean/go-libvirt v0.0.0-20240709142323-d8406205c752 h1:NI7XEcHzWVvBfVjSVK6Qk4wmrUfoyQxCNpBjrHelZFk=
-github.com/digitalocean/go-libvirt v0.0.0-20240709142323-d8406205c752/go.mod h1:/Ok8PA2qi/ve0Py38+oL+VxoYmlowigYRyLEODRYdgc=
-github.com/distribution/reference v0.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5QvfrDyIgxBk=
-github.com/distribution/reference v0.6.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E=
-github.com/docker/docker v27.1.0+incompatible h1:rEHVQc4GZ0MIQKifQPHSFGV/dVgaZafgRf8fCPtDYBs=
-github.com/docker/docker v27.1.0+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
-github.com/docker/go-connections v0.5.0 h1:USnMq7hx7gwdVZq1L49hLXaFtUdTADjXGp+uj1Br63c=
-github.com/docker/go-connections v0.5.0/go.mod h1:ov60Kzw0kKElRwhNs9UlUHAE/F9Fe6GLaXnqyDdmEXc=
-github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4=
-github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
-github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg=
-github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
+github.com/digitalocean/go-libvirt v0.0.0-20221205150000-2939327a8519 h1:OpkN/n40cmKenDQS+IOAeW9DLhYy4DADSeZnouCEV/E=
+github.com/digitalocean/go-libvirt v0.0.0-20221205150000-2939327a8519/go.mod h1:WyJJyfmJ0gWJvjV+ZH4DOgtOYZc1KOvYyBXWCLKxsUU=
+github.com/envoyproxy/protoc-gen-validate v1.0.2 h1:QkIBuU5k+x7/QXPvPPnWXWlCdaBFApVqftFV6k087DA=
+github.com/envoyproxy/protoc-gen-validate v1.0.2/go.mod h1:GpiZQP3dDbg4JouG/NNS7QWXpgx6x8QiMKdmN72jogE=
 github.com/go-kit/kit v0.13.0 h1:OoneCcHKHQ03LfBpoQCUfCluwd2Vt3ohz+kvbJneZAU=
 github.com/go-kit/kit v0.13.0/go.mod h1:phqEHMMUbyrCFCTgH48JueqrM3md2HcAZ8N3XE4FKDg=
 github.com/go-kit/log v0.2.1 h1:MRVx0/zhvdseW+Gza6N9rVzU/IVzaeE1SFI4raAhmBU=
@@ -34,148 +33,135 @@ github.com/go-kit/log v0.2.1/go.mod h1:NwTd00d/i8cPZ3xOwwiv2PO5MOcx78fFErGNcVmBj
 github.com/go-logfmt/logfmt v0.6.0 h1:wGYYu3uicYdqXVgoYbvnkrPVXkuLM1p1ifugDMEdRi4=
 github.com/go-logfmt/logfmt v0.6.0/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs=
 github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
-github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
-github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/logr v1.4.1 h1:pKouT5E8xu9zeFC39JXRDukb6JFQPXM5p5I91188VAQ=
+github.com/go-logr/logr v1.4.1/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
 github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
 github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
 github.com/gofrs/uuid v4.4.0+incompatible h1:3qXRTX8/NbyulANqlc0lchS1gqAVxRgsuW1YrTJupqA=
 github.com/gofrs/uuid v4.4.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
-github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
-github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
-github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
-github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
+github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
+github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
+github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/go-configfs-tsm v0.2.2 h1:YnJ9rXIOj5BYD7/0DNnzs8AOp7UcvjfTvt215EWcs98=
 github.com/google/go-configfs-tsm v0.2.2/go.mod h1:EL1GTDFMb5PZQWDviGfZV9n87WeGTR/JUg13RfwkgRo=
-github.com/google/go-sev-guest v0.11.1 h1:gnww4U8fHV5DCPz4gykr1s8SEX1fFNcxCBy+vvXN24k=
-github.com/google/go-sev-guest v0.11.1/go.mod h1:qBOfb+JmgsUI3aUyzQoGC13Kpp9zwLeWvuyXmA9q77w=
+github.com/google/go-sev-guest v0.10.1 h1:kZIcGD513eqInbezqxchTtOLJlVXALyWlIXu5E0tNJE=
+github.com/google/go-sev-guest v0.10.1/go.mod h1:/5hrgGWqG7+MPTXKhQz+v9ZE+Eh4MCBdItCNwgshlrk=
 github.com/google/logger v1.1.1 h1:+6Z2geNxc9G+4D4oDO9njjjn2d0wN5d7uOo0vOIW1NQ=
 github.com/google/logger v1.1.1/go.mod h1:BkeJZ+1FhQ+/d087r4dzojEg1u2ZX+ZqG1jTUrLM+zQ=
 github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
-github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/grpc-ecosystem/grpc-gateway/v2 v2.20.0 h1:bkypFPDjIYGfCYD5mRBvpqxfYX1YCS1PXdKYWi8FsN0=
-github.com/grpc-ecosystem/grpc-gateway/v2 v2.20.0/go.mod h1:P+Lt/0by1T8bfcF3z737NnSbmxQAppXMRziHUxPOC8k=
+github.com/google/uuid v1.5.0 h1:1p67kYwdtXjb0gL0BPiP1Av9wiZPo5A8z2cWkTZ+eyU=
+github.com/google/uuid v1.5.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.19.0 h1:Wqo399gCIufwto+VfwCSvsnfGpF/w5E9CNxSwbpD6No=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.19.0/go.mod h1:qmOFXW2epJhM0qSnUUYpldc7gVz2KMQwJ/QYCDIa7XU=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
-github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
-github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
-github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
-github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
-github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
-github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/matttproud/golang_protobuf_extensions/v2 v2.0.0 h1:jWpvCLoY8Z/e3VKvlsiIGKtc+UG6U5vzxaoagmhXfyg=
+github.com/matttproud/golang_protobuf_extensions/v2 v2.0.0/go.mod h1:QUyp042oQthUoa9bqDv0ER0wrtXnBruoNd7aNjkbP+k=
 github.com/mdlayher/socket v0.4.1 h1:eM9y2/jlbs1M615oshPQOHZzj6R6wMT7bX5NPiQvn2U=
 github.com/mdlayher/socket v0.4.1/go.mod h1:cAqeGjoufqdxWkD7DkpyS+wcefOtmu5OQ8KuoJGIReA=
 github.com/mdlayher/vsock v1.2.1 h1:pC1mTJTvjo1r9n9fbm7S1j04rCgCzhCOS5DY0zqHlnQ=
 github.com/mdlayher/vsock v1.2.1/go.mod h1:NRfCibel++DgeMD8z/hP+PPTjlNJsdPOmxcnENvE+SE=
-github.com/moby/docker-image-spec v1.3.1 h1:jMKff3w6PgbfSa69GfNg+zN/XLhfXJGnEx3Nl2EsFP0=
-github.com/moby/docker-image-spec v1.3.1/go.mod h1:eKmb5VW8vQEh/BAr2yvVNvuiJuY6UIocYsFu/DxxRpo=
-github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U=
-github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM=
-github.com/opencontainers/image-spec v1.1.0 h1:8SG7/vwALn54lVB/0yZ/MMwhFrPYtpEHQb2IpWsCzug=
-github.com/opencontainers/image-spec v1.1.0/go.mod h1:W4s4sFTMaBeK1BQLXbG4AdM2szdn85PY75RI83NrTrM=
 github.com/pborman/uuid v1.2.1 h1:+ZZIw58t/ozdjRaXh/3awHfmWRbzYxJoAdNJxe/3pvw=
 github.com/pborman/uuid v1.2.1/go.mod h1:X/NO0urCmaxf9VXbdlT7C2Yzkj2IKimNn4k+gtPdI/k=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/prometheus/client_golang v1.19.1 h1:wZWJDwK+NameRJuPGDhlnFgx8e8HN3XHQeLaYJFJBOE=
-github.com/prometheus/client_golang v1.19.1/go.mod h1:mP78NwGzrVks5S2H6ab8+ZZGJLZUq1hoULYBAYBw1Ho=
-github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E=
-github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY=
-github.com/prometheus/common v0.52.2 h1:LW8Vk7BccEdONfrJBDffQGRtpSzi5CQaRZGtboOO2ck=
-github.com/prometheus/common v0.52.2/go.mod h1:lrWtQx+iDfn2mbH5GUzlH9TSHyfZpHkSiG1W7y3sF2Q=
-github.com/prometheus/procfs v0.13.0 h1:GqzLlQyfsPbaEHaQkO7tbDlriv/4o5Hudv6OXHGKX7o=
-github.com/prometheus/procfs v0.13.0/go.mod h1:cd4PFCR54QLnGKPaKGA6l+cfuNXtht43ZKY6tow0Y1g=
-github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8=
-github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=
+github.com/prometheus/client_golang v1.18.0 h1:HzFfmkOzH5Q8L8G+kSJKUx5dtG87sewO+FoDDqP5Tbk=
+github.com/prometheus/client_golang v1.18.0/go.mod h1:T+GXkCk5wSJyOqMIzVgvvjFDlkOQntgjkJWKrN5txjA=
+github.com/prometheus/client_model v0.5.0 h1:VQw1hfvPvk3Uv6Qf29VrPF32JB6rtbgI6cYPYQjL0Qw=
+github.com/prometheus/client_model v0.5.0/go.mod h1:dTiFglRmd66nLR9Pv9f0mZi7B7fk5Pm3gvsjB5tr+kI=
+github.com/prometheus/common v0.45.0 h1:2BGz0eBc2hdMDLnO/8n0jeB3oPrt2D08CekT0lneoxM=
+github.com/prometheus/common v0.45.0/go.mod h1:YJmSTw9BoKxJplESWWxlbyttQR4uaEcGyv9MZjVOJsY=
+github.com/prometheus/procfs v0.12.0 h1:jluTpSng7V9hY0O2R9DzzJHYb2xULk9VTR1V1R/k6Bo=
+github.com/prometheus/procfs v0.12.0/go.mod h1:pcuDEFsWDnvcgNzo4EEweacyhjeA9Zk3cnaOZAZEfOo=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/spf13/cobra v1.8.1 h1:e5/vxKd/rZsfSJMUX1agtjeTDf+qv1/JdBF8gg5k9ZM=
-github.com/spf13/cobra v1.8.1/go.mod h1:wHxEcudfqmLYa8iTfL+OuZPbBZkmvliBWKIezN3kD9Y=
+github.com/spf13/cobra v1.8.0 h1:7aJaZx1B85qltLMc546zn58BxxfZdR/W22ej9CFoEf0=
+github.com/spf13/cobra v1.8.0/go.mod h1:WXLWApfZ71AjXPya3WOlMsY9yMs7YeiHhFVlvLyhcho=
 github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
-github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
-github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
-github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
-github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
-go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.53.0 h1:9G6E0TXzGFVfTnawRzrPl83iHOAV7L8NJiR8RSGYV1g=
-go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.53.0/go.mod h1:azvtTADFQJA8mX80jIH/akaE7h+dbm/sVuaHqN13w74=
-go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.53.0 h1:4K4tsIXefpVJtvA/8srF4V4y0akAoPHkIslgAkjixJA=
-go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.53.0/go.mod h1:jjdQuTGVsXV4vSs+CJ2qYDeDPf9yIJV23qlIzBm73Vg=
-go.opentelemetry.io/otel v1.28.0 h1:/SqNcYk+idO0CxKEUOtKQClMK/MimZihKYMruSMViUo=
-go.opentelemetry.io/otel v1.28.0/go.mod h1:q68ijF8Fc8CnMHKyzqL6akLO46ePnjkgfIMIjUIX9z4=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.28.0 h1:3Q/xZUyC1BBkualc9ROb4G8qkH90LXEIICcs5zv1OYY=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.28.0/go.mod h1:s75jGIWA9OfCMzF0xr+ZgfrB5FEbbV7UuYo32ahUiFI=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.28.0 h1:j9+03ymgYhPKmeXGk5Zu+cIZOlVzd9Zv7QIiyItjFBU=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.28.0/go.mod h1:Y5+XiUG4Emn1hTfciPzGPJaSI+RpDts6BnCIir0SLqk=
-go.opentelemetry.io/otel/metric v1.28.0 h1:f0HGvSl1KRAU1DLgLGFjrwVyismPlnuU6JD6bOeuA5Q=
-go.opentelemetry.io/otel/metric v1.28.0/go.mod h1:Fb1eVBFZmLVTMb6PPohq3TO9IIhUisDsbJoL/+uQW4s=
-go.opentelemetry.io/otel/sdk v1.28.0 h1:b9d7hIry8yZsgtbmM0DKyPWMMUMlK9NEKuIG4aBqWyE=
-go.opentelemetry.io/otel/sdk v1.28.0/go.mod h1:oYj7ClPUA7Iw3m+r7GeEjz0qckQRJK2B8zjcZEfu7Pg=
-go.opentelemetry.io/otel/trace v1.28.0 h1:GhQ9cUuQGmNDd5BTCP2dAvv75RdMxEfTmYejp+lkx9g=
-go.opentelemetry.io/otel/trace v1.28.0/go.mod h1:jPyXzNPg6da9+38HEwElrQiHlVMTnVfM3/yv2OlIHaI=
-go.opentelemetry.io/proto/otlp v1.3.1 h1:TrMUixzpM0yuc/znrFTP9MMRh8trP93mkCiDVeXrui0=
-go.opentelemetry.io/proto/otlp v1.3.1/go.mod h1:0X1WI4de4ZsLrrJNLAQbFeLCm3T7yBkR0XqQ7niQU+8=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.46.1 h1:SpGay3w+nEwMpfVnbqOLH5gY52/foP8RE8UzTZ1pdSE=
+go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.46.1/go.mod h1:4UoMYEZOC0yN/sPGH76KPkkU7zgiEWYWL9vwmbnTJPE=
+go.opentelemetry.io/otel v1.21.0 h1:hzLeKBZEL7Okw2mGzZ0cc4k/A7Fta0uoPgaJCr8fsFc=
+go.opentelemetry.io/otel v1.21.0/go.mod h1:QZzNPQPm1zLX4gZK4cMi+71eaorMSGT3A4znnUvNNEo=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.21.0 h1:cl5P5/GIfFh4t6xyruOgJP5QiA1pw4fYYdv6nc6CBWw=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.21.0/go.mod h1:zgBdWWAu7oEEMC06MMKc5NLbA/1YDXV1sMpSqEeLQLg=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.21.0 h1:digkEZCJWobwBqMwC0cwCq8/wkkRy/OowZg5OArWZrM=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.21.0/go.mod h1:/OpE/y70qVkndM0TrxT4KBoN3RsFZP0QaofcfYrj76I=
+go.opentelemetry.io/otel/metric v1.21.0 h1:tlYWfeo+Bocx5kLEloTjbcDwBuELRrIFxwdQ36PlJu4=
+go.opentelemetry.io/otel/metric v1.21.0/go.mod h1:o1p3CA8nNHW8j5yuQLdc1eeqEaPfzug24uvsyIEJRWM=
+go.opentelemetry.io/otel/sdk v1.21.0 h1:FTt8qirL1EysG6sTQRZ5TokkU8d0ugCj8htOgThZXQ8=
+go.opentelemetry.io/otel/sdk v1.21.0/go.mod h1:Nna6Yv7PWTdgJHVRD9hIYywQBRx7pbox6nwBnZIxl/E=
+go.opentelemetry.io/otel/trace v1.21.0 h1:WD9i5gzvoUPuXIXH24ZNBudiarZDKuekPqi/E8fpfLc=
+go.opentelemetry.io/otel/trace v1.21.0/go.mod h1:LGbsEB0f9LGjN+OZaQQ26sohbOmiMR+BaslueVtS/qQ=
+go.opentelemetry.io/proto/otlp v1.0.0 h1:T0TX0tmXU8a3CbNXzEKGeU5mIVOdf0oykP+u2lIVU/I=
+go.opentelemetry.io/proto/otlp v1.0.0/go.mod h1:Sy6pihPLfYHkr3NkUbEhGHFhINUSI/v80hjKIs5JXpM=
 go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
 go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.25.0 h1:ypSNr+bnYL2YhwoMt2zPxHFmbAN1KZs/njMG3hxUp30=
-golang.org/x/crypto v0.25.0/go.mod h1:T+wALwcMOSE0kXgUAnPAHqTLW+XHgcELELW8VaDgm/M=
-golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.19.0 h1:fEdghXQSo20giMthA7cd28ZC+jts4amQ3YMXiP5oMQ8=
-golang.org/x/mod v0.19.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.19.0 h1:ENy+Az/9Y1vSrlrvBSyna3PITt4tiZLf7sgCjZBX7Wo=
+golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.26.0 h1:soB7SVo0PWrY4vPW/+ay0jKDNScG2X9wFeYlXIvJsOQ=
-golang.org/x/net v0.26.0/go.mod h1:5YKkiSynbBIh3p6iOc/vibscux0x38BZDkn8sCUPxHE=
-golang.org/x/net v0.27.0 h1:5K3Njcw06/l2y9vpGCSdcxWOYHOUk3dVNGDXN+FvAys=
-golang.org/x/net v0.27.0/go.mod h1:dDi0PyhWNoiUOrAS8uXv/vnScO4wnHQO4mj9fn/RytE=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.20.0 h1:aCL9BSgETF1k+blQaYUBx9hJ9LOGP3gAVemcZlf1Kpo=
+golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY=
+golang.org/x/oauth2 v0.15.0 h1:s8pnnxNVzjWyrvYdFUQq5llS1PX2zhPXmccZv99h7uQ=
+golang.org/x/oauth2 v0.15.0/go.mod h1:q48ptWNTY5XWf+JNten23lcvHpLJ0ZSxF5ttTHKVCAM=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
-golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.6.0 h1:5BMeUDZ7vkXGfEr1x9B4bRcTH4lpkTkpdh0T/J+qjbQ=
+golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210426230700-d19ff857e887/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.22.0 h1:RI27ohtqKCnwULzJLqkv897zojh5/DwS/ENaMzUOaWI=
-golang.org/x/sys v0.22.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/term v0.22.0 h1:BbsgPEJULsl2fV/AT3v15Mjva5yXKQDyKf+TbDz7QJk=
-golang.org/x/term v0.22.0/go.mod h1:F3qCibpT5AMpCRfhfT53vVJwhLtIVHhB9XDjfFvnMI4=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.17.0 h1:25cE3gD+tdBA7lp7QfhuV+rJiE9YXTcS3VG1SqssI/Y=
+golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
-golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
-golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/tools v0.23.0 h1:SGsXPZ+2l4JsgaCKkx+FQ9YZ5XEtA1GZYuoDjenLjvg=
-golang.org/x/tools v0.23.0/go.mod h1:pnu6ufv6vQkll6szChhK3C3L/ruaIv5eBeztNG8wtsI=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-google.golang.org/genproto/googleapis/api v0.0.0-20240701130421-f6361c86f094 h1:0+ozOGcrp+Y8Aq8TLNN2Aliibms5LEzsq99ZZmAGYm0=
-google.golang.org/genproto/googleapis/api v0.0.0-20240701130421-f6361c86f094/go.mod h1:fJ/e3If/Q67Mj99hin0hMhiNyCRmt6BQ2aWIJshUSJw=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20240701130421-f6361c86f094 h1:BwIjyKYGsK9dMCBOorzRri8MQwmi7mT9rGHsCEinZkA=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20240701130421-f6361c86f094/go.mod h1:Ue6ibwXGpU+dqIcODieyLOcgj7z8+IcskoNIgZxtrFY=
-google.golang.org/grpc v1.65.0 h1:bs/cUb4lp1G5iImFFd3u5ixQzweKizoZJAwBNLR42lc=
-google.golang.org/grpc v1.65.0/go.mod h1:WgYC2ypjlB0EiQi6wdKixMqukr6lBc0Vo+oOgjrM5ZQ=
-google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg=
-google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw=
+google.golang.org/appengine v1.6.8 h1:IhEN5q69dyKagZPYMSdIjS2HqprW324FRQZJcGqPAsM=
+google.golang.org/appengine v1.6.8/go.mod h1:1jJ3jBArFh5pcgW8gCtRJnepW8FzD1V44FJffLiz/Ds=
+google.golang.org/genproto v0.0.0-20240102182953-50ed04b92917 h1:nz5NESFLZbJGPFxDT/HCn+V1mZ8JGNoY4nUpmW/Y2eg=
+google.golang.org/genproto v0.0.0-20240102182953-50ed04b92917/go.mod h1:pZqR+glSb11aJ+JQcczCvgf47+duRuzNSKqE8YAQnV0=
+google.golang.org/genproto/googleapis/api v0.0.0-20240108191215-35c7eff3a6b1 h1:OPXtXn7fNMaXwO3JvOmF1QyTc00jsSFFz1vXXBOdCDo=
+google.golang.org/genproto/googleapis/api v0.0.0-20240108191215-35c7eff3a6b1/go.mod h1:B5xPO//w8qmBDjGReYLpR6UJPnkldGkCSMoH/2vxJeg=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240108191215-35c7eff3a6b1 h1:gphdwh0npgs8elJ4T6J+DQJHPVF7RsuJHCfwztUb4J4=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240108191215-35c7eff3a6b1/go.mod h1:daQN87bsDqDoe316QbbvX60nMoJQa4r6Ds0ZuoAe5yA=
+google.golang.org/grpc v1.60.1 h1:26+wFr+cNqSGFcOXcabYC0lUVJVRa2Sb2ortSK7VrEU=
+google.golang.org/grpc v1.60.1/go.mod h1:OlCHIeLYqSSsLi6i49B5QGdzaMZK9+M7LXN2FKz4eGM=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
+google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
+google.golang.org/protobuf v1.32.0 h1:pPC6BG5ex8PDFnkbrGU3EixyhKcQ2aDuBS36lqK/C7I=
+google.golang.org/protobuf v1.32.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
-gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

hal/linux/Config.in

@@ -1,2 +1 @@
-source "$BR2_EXTERNAL_COCOS_PATH/package/agent/Config.in"
-source "$BR2_EXTERNAL_COCOS_PATH/package/wasmedge/Config.in"
+source "$BR2_EXTERNAL_COCOS_PATH/package/agent/Config.in"

hal/linux/README.md

@@ -1,9 +1,7 @@
 # Hardware Abstraction Layer (HAL) for Confidential Computing
-
-Cocos HAL for Linux is framework for building custom in-enclave Linux distribution.
+Cocos HAL for Linux is framework for building custom in-enclave Linux distribution. 
 
 ## Usage
-
 HAL uses [Buildroot](https://buildroot.org/)'s [_External Tree_ mechanism](https://buildroot.org/downloads/manual/manual.html#outside-br-custom) for building custom distro:
 
 ```bash

hal/linux/board/cocos/linux.config

@@ -40,9 +40,6 @@ CONFIG_TMPFS_POSIX_ACL=y
 CONFIG_UNWINDER_FRAME_POINTER=y
 CONFIG_VSOCKETS=y
 CONFIG_VIRTIO_VSOCKETS=y
-CONFIG_NF_TABLES=y
-CONFIG_BPF_SYSCALL=y
-CONFIG_CGROUP_BPF=y
 
 ###
 # AMD SEV-SNP
@@ -64,4 +61,4 @@ CONFIG_PREEMPT=n
 CONFIG_PREEMPT_DYNAMIC=n
 CONFIG_DEBUG_PREEMPT=n
 CONFIG_CGROUP_MISC=y
-CONFIG_X86_CPUID=y
+CONFIG_X86_CPUID=y

hal/linux/configs/cocos_defconfig

@@ -7,7 +7,6 @@ BR2_TARGET_GENERIC_ISSUE="Welcome to Cocos"
 BR2_PACKAGE_DHCP=y
 BR2_PACKAGE_DHCP_CLIENT=y
 BR2_INIT_SYSTEMD=y
-BR2_SYSTEM_BIN_SH_BASH=y
 
 # Filesystem
 # BR2_TARGET_ROOTFS_TAR is not set
@@ -44,30 +43,6 @@ BR2_LINUX_KERNEL_NEEDS_HOST_LIBELF=y
 BR2_PACKAGE_HOST_QEMU=y
 BR2_PACKAGE_HOST_QEMU_SYSTEM_MODE=y
 
-# Docker
-BR2_PACKAGE_LIBSECCOMP_ARCH_SUPPORTS=y
-BR2_PACKAGE_LIBSECCOMP=y
-BR2_PACKAGE_CA_CERTIFICATES=y
-BR2_PACKAGE_DOCKER_CLI=y
-BR2_PACKAGE_DOCKER_COMPOSE=y
-BR2_PACKAGE_DOCKER_ENGINE=y
-BR2_PACKAGE_CONTAINERD=y
-BR2_PACKAGE_RUNC=y
-BR2_PACKAGE_IPTABLES=y
-
 # Python
 BR2_PACKAGE_PYTHON3=y
 BR2_PACKAGE_PYTHON_PIP=y
-BR2_PACKAGE_BZIP2=y
-BR2_PACKAGE_XZ=y
-BR2_PACKAGE_ZIP=y
-BR2_PACKAGE_PYTHON3_ZLIB=y
-BR2_PACKAGE_PYTHON3_XZ=y
-BR2_PACKAGE_PYTHON3_BZIP2=y
-BR2_INSTALL_LIBSTDCPP=y
-BR2_TOOLCHAIN_BUILDROOT_CXX=y
-BR2_PACKAGE_HOST_GCC_TARGET=y
-BR2_TOOLCHAIN_BUILDROOT_LIBSTDCPP=y
-BR2_PACKAGE_GCC=y
-BR2_PACKAGE_GCC_TARGET=y
-BR2_PACKAGE_LIBSTDCPP=y

hal/linux/external.mk

@@ -1 +1 @@
-include $(sort $(wildcard $(BR2_EXTERNAL_COCOS_PATH)/package/*/*.mk))
+include $(sort $(wildcard $(BR2_EXTERNAL_COCOS_PATH)/package/*/*.mk))

hal/linux/package/agent/Config.in

@@ -3,6 +3,6 @@ config BR2_PACKAGE_AGENT
 	default y
 	help
 	  Confidential Computing Agent is a state machine capable of
-	  receiving datasets and algorithm, running computations, and
-	  fetching the attestation report from within the
-	  Confidential VM.
+	  receiving data and algorithms, running computations, and 
+	  fetching the attestation report from within the 
+	  Confidential VM.

hal/linux/package/agent/agent.mk

@@ -7,21 +7,19 @@
 AGENT_VERSION = main
 AGENT_SITE = $(call github,ultravioletrs,cocos,$(AGENT_VERSION))
 
-define AGENT_BUILD_CMDS
-	$(MAKE) -C $(@D) agent EMBED_ENABLED=$(AGENT_EMBED_ENABLED)
+define AGENT_BUILD_CMDS 	
+	$(MAKE) -C $(@D) agent
 endef
 
 define AGENT_INSTALL_TARGET_CMDS
-	mkdir -p $(TARGET_DIR)/cocos/
+	$(INSTALL) -D -m 0755 $(@D)/build/cocos-agent $(TARGET_DIR)/bin
 	mkdir -p $(TARGET_DIR)/var/log/cocos
-	mkdir -p $(TARGET_DIR)/cocos_init/
-	$(INSTALL) -D -m 0750 $(@D)/build/cocos-agent $(TARGET_DIR)/bin
+	mkdir -p $(TARGET_DIR)/cocos/
 endef
 
 define AGENT_INSTALL_INIT_SYSTEMD
-	$(INSTALL) -D -m 0640 $(@D)/init/systemd/cocos-agent.service $(TARGET_DIR)/usr/lib/systemd/system/cocos-agent.service
-	$(INSTALL) -D -m 0750 $(@D)/init/systemd/agent_setup.sh $(TARGET_DIR)/cocos_init/agent_setup.sh
-	$(INSTALL) -D -m 0750 $(@D)/init/systemd/agent_start_script.sh $(TARGET_DIR)/cocos_init/agent_start_script.sh
+	$(INSTALL) -D -m 0644 $(@D)/init/systemd/cocos-agent.service $(TARGET_DIR)/usr/lib/systemd/system/cocos-agent.service
+	$(INSTALL) -D -m 0755 $(@D)/init/systemd/agent_start_script.sh $(TARGET_DIR)/cocos/agent_start_script.sh
 endef
 
 $(eval $(golang-package))

hal/linux/package/wasmedge/Config.in

@@ -1,6 +0,0 @@
-config BR2_PACKAGE_WASMEDGE
-    bool "wasmedge"
-	  default y
-    help
-      Wasmedge is a standalone runtime for WebAssembly.
-      https://wasmedge.org/docs/

hal/linux/package/wasmedge/wasmedge.mk

@@ -1,8 +0,0 @@
-WASMEDGE_DOWNLOAD_URL = https://raw.githubusercontent.com/WasmEdge/WasmEdge/master/utils/install.sh
-
-define WASMEDGE_INSTALL_TARGET_CMDS
-    curl -sSf $(WASMEDGE_DOWNLOAD_URL) | bash -s -- -p $(TARGET_DIR)/usr
-    echo "source /usr/env" >> $(TARGET_DIR)/etc/profile
-endef
-
-$(eval $(generic-package))

init/systemd/agent_setup.sh

@@ -1,25 +0,0 @@
-#!/bin/sh
-
-MOUNT_POINT="/cocos"
-
-# IFACES are all network interfaces excluding lo (LOOPBACK) and sit interfaces 
-IFACES=$(ip link show | grep -vE 'LOOPBACK|sit*' | awk -F': ' '{print $2}')
-
-# This for loop brings up all network interfaces in IFACES and dhclient obtains an IP address for the every interface
-for IFACE in $IFACES; do
-    STATE=$(ip link show $IFACE | grep DOWN)
-    if [ -n "$STATE" ]; then
-        ip link set $IFACE up
-    fi
-
-    IP_ADDR=$(ip addr show $IFACE | grep 'inet ')
-    if [ -z "$IP_ADDR" ]; then
-        dhclient $IFACE
-    fi
-done
-
-if [ ! -d "$MOUNT_POINT" ]; then
-    mkdir -p $MOUNT_POINT
-fi
-
-mount -t ramfs ramfs $MOUNT_POINT

init/systemd/agent_start_script.sh

@@ -1,27 +1,21 @@
 #!/bin/sh
 
-# Change the docker.service file to allow the Docker to run in RAM
-mkdir -p /etc/systemd/system/docker.service.d
+# The variable ETH_IFACE contains the name the systemd gave to the network interface. 
+# The systemd configures the name based on the QEMU parameters. 
+# The parts of the name enp0s2 mean:
+#  et - ethernet card. It means this is the ethernet interface.
+#  p - means that the interface is connected to a PCI bus.
+#  0 - the interface is connected to bus 0.
+#  s2 -the interface is connected to slot 2.
 
-# Create or overwrite the override.conf file with the new Environment variable
-tee /etc/systemd/system/docker.service.d/override.conf > /dev/null <<EOF
-[Service]
-Environment=DOCKER_RAMDISK=true
-EOF
+# The variable ETH_IFACE value must match the name configured through QEMU parameters for the network device. 
+# The bus number and slot number are configured through QEMU device parameters, parameters
+# addr (for slot number), and bus (for bus number).
+ETH_IFACE=enp0s2
 
-systemctl daemon-reload
-
-NUM_OF_PERMITED_IFACE=1
-
-NUM_OF_IFACE=$(ip route | grep -Eo 'dev [a-z0-9]+' | awk '{ print $2 }' | sort | uniq | wc -l)
-
-if [ $NUM_OF_IFACE -gt $NUM_OF_PERMITED_IFACE ]; then
-    echo "More then one network interface in the VM"
-    exit 1
-fi
-
-DEFAULT_IFACE=$(route | grep '^default' | grep -o '[^ ]*$')
-AGENT_GRPC_HOST=$(ip -4 addr show $DEFAULT_IFACE | grep inet | awk '{print $2}' | cut -d/ -f1)
+ip link set dev $ETH_IFACE up
+dhclient $ETH_IFACE
+AGENT_GRPC_HOST=$(ip -4 addr show $ETH_IFACE | grep inet | awk '{print $2}' | cut -d/ -f1)
 
 export AGENT_GRPC_HOST
 

init/systemd/cocos-agent.service

@@ -1,18 +1,15 @@
 [Unit]
 Description=Cocos AI agent
 After=network.target
-Before=docker.service
 
 [Service]
-WorkingDirectory=/cocos
 StandardOutput=file:/var/log/cocos/agent.stdout
 StandardError=file:/var/log/cocos/agent.stderr
 
 Environment=AGENT_GRPC_PORT=7002
 Environment=AGENT_LOG_LEVEL=info
 
-ExecStartPre=/cocos_init/agent_setup.sh
-ExecStart=/cocos_init/agent_start_script.sh
+ExecStart=/cocos/agent_start_script.sh
 
 [Install]
 WantedBy=default.target

internal/env/doc.go

@@ -0,0 +1,6 @@
+// Copyright (c) Ultraviolet
+// SPDX-License-Identifier: Apache-2.0
+
+// Package env contains utility tools for handling
+// environment-based service configuration.
+package env

internal/env/parser.go

@@ -0,0 +1,38 @@
+// Copyright (c) Ultraviolet
+// SPDX-License-Identifier: Apache-2.0
+package env
+
+import "github.com/caarlos0/env/v7"
+
+type Options struct {
+	// Environment keys and values that will be accessible for the service
+	Environment map[string]string
+
+	// TagName specifies another tagname to use rather than the default env
+	TagName string
+
+	// RequiredIfNoDef automatically sets all env as required if they do not declare 'envDefault'
+	RequiredIfNoDef bool
+
+	// OnSet allows to run a function when a value is set
+	OnSet env.OnSetFn
+
+	// Prefix define a prefix for each key
+	Prefix string
+}
+
+func Parse(v interface{}, opts ...Options) error {
+	var actOpts []env.Options
+
+	for _, opt := range opts {
+		actOpts = append(actOpts, env.Options{
+			Environment:     opt.Environment,
+			TagName:         opt.TagName,
+			RequiredIfNoDef: opt.RequiredIfNoDef,
+			OnSet:           opt.OnSet,
+			Prefix:          opt.Prefix,
+		})
+	}
+
+	return env.Parse(v, actOpts...)
+}

internal/file.go

@@ -3,12 +3,9 @@
 package internal
 
 import (
-	"encoding/hex"
 	"io"
 	"os"
 	"path/filepath"
-
-	"golang.org/x/crypto/sha3"
 )
 
 // CopyFile copies a file from srcPath to dstPath.
@@ -49,37 +46,3 @@ func DeleteFilesInDir(dirPath string) error {
 
 	return nil
 }
-
-// Checksum calculates the SHA3-256 checksum of the file or directory at path.
-func Checksum(path string) ([]byte, error) {
-	file, err := os.Stat(path)
-	if err != nil {
-		return nil, err
-	}
-
-	if file.IsDir() {
-		f, err := ZipDirectoryToMemory(path)
-		if err != nil {
-			return nil, err
-		}
-		sum := sha3.Sum256(f)
-		return sum[:], nil
-	} else {
-		f, err := os.ReadFile(path)
-		if err != nil {
-			return nil, err
-		}
-
-		sum := sha3.Sum256(f)
-		return sum[:], nil
-	}
-}
-
-// ChecksumHex calculates the SHA3-256 checksum of the file or directory at path and returns it as a hex-encoded string.
-func ChecksumHex(path string) (string, error) {
-	sum, err := Checksum(path)
-	if err != nil {
-		return "", err
-	}
-	return hex.EncodeToString(sum), nil
-}

internal/jaeger/doc.go

@@ -0,0 +1,4 @@
+// Copyright (c) Ultraviolet
+// SPDX-License-Identifier: Apache-2.0
+
+package jaeger

internal/jaeger/provider.go

@@ -0,0 +1,80 @@
+// Copyright (c) Ultraviolet
+// SPDX-License-Identifier: Apache-2.0
+package jaeger
+
+import (
+	"context"
+	"errors"
+	"net/url"
+
+	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/exporters/otlp/otlptrace"
+	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
+	"go.opentelemetry.io/otel/propagation"
+	"go.opentelemetry.io/otel/sdk/resource"
+	"go.opentelemetry.io/otel/sdk/trace"
+	semconv "go.opentelemetry.io/otel/semconv/v1.21.0"
+)
+
+var (
+	errNoURL                     = errors.New("URL is empty")
+	errNoSvcName                 = errors.New("Service Name is empty")
+	errUnsupportedTraceURLScheme = errors.New("unsupported tracing url scheme")
+)
+
+// NewProvider initializes Jaeger TraceProvider.
+func NewProvider(ctx context.Context, svcName, jaegerurl, instanceID string) (*trace.TracerProvider, error) {
+	if jaegerurl == "" {
+		return nil, errNoURL
+	}
+
+	if svcName == "" {
+		return nil, errNoSvcName
+	}
+
+	jurl, err := url.Parse(jaegerurl)
+	if err != nil {
+		return nil, err
+	}
+
+	var exporter *otlptrace.Exporter
+	switch jurl.Scheme {
+	case "http":
+		exporter, err = otlptracehttp.New(ctx, otlptracehttp.WithEndpoint(jurl.Host), otlptracehttp.WithURLPath(jurl.Path), otlptracehttp.WithInsecure())
+		if err != nil {
+			return nil, err
+		}
+	case "https":
+		exporter, err = otlptracehttp.New(ctx, otlptracehttp.WithEndpoint(jurl.Host), otlptracehttp.WithURLPath(jurl.Path))
+		if err != nil {
+			return nil, err
+		}
+	default:
+		return nil, errUnsupportedTraceURLScheme
+	}
+
+	attributes := []attribute.KeyValue{
+		semconv.ServiceNameKey.String(svcName),
+		attribute.String("host.id", instanceID),
+	}
+
+	hostAttr, err := resource.New(ctx, resource.WithHost(), resource.WithOSDescription(), resource.WithContainer())
+	if err != nil {
+		return nil, err
+	}
+	attributes = append(attributes, hostAttr.Attributes()...)
+
+	tp := trace.NewTracerProvider(
+		trace.WithSampler(trace.AlwaysSample()),
+		trace.WithBatcher(exporter),
+		trace.WithResource(resource.NewWithAttributes(
+			semconv.SchemaURL,
+			attributes...,
+		)),
+	)
+	otel.SetTracerProvider(tp)
+	otel.SetTextMapPropagator(propagation.TraceContext{})
+
+	return tp, nil
+}

internal/logger/protohandler.go

@@ -40,47 +40,19 @@ func (h *handler) Enabled(_ context.Context, l slog.Level) bool {
 
 // Handle implements slog.Handler.
 func (h *handler) Handle(_ context.Context, r slog.Record) error {
-	message := r.Message
-	timestamp := timestamppb.New(r.Time)
-	level := r.Level.String()
+	agentLog := manager.ClientStreamMessage{Message: &manager.ClientStreamMessage_AgentLog{AgentLog: &manager.AgentLog{
+		Timestamp: timestamppb.New(r.Time),
+		Message:   r.Message,
+		Level:     r.Level.String(),
+	}}}
 
-	// Calculate the number of chunks
-	chunkSize := 500
-	numChunks := (len(message) + chunkSize - 1) / chunkSize
-
-	for i := 0; i < numChunks; i++ {
-		start := i * chunkSize
-		end := start + chunkSize
-		if end > len(message) {
-			end = len(message)
-		}
-
-		// Create a chunk of the message
-		chunk := message[start:end]
-
-		// Create the agent log with the chunk
-		agentLog := manager.ClientStreamMessage{
-			Message: &manager.ClientStreamMessage_AgentLog{
-				AgentLog: &manager.AgentLog{
-					Timestamp: timestamp,
-					Message:   chunk,
-					Level:     level,
-				},
-			},
-		}
-
-		// Marshal the chunk to protobuf
-		b, err := proto.Marshal(&agentLog)
-		if err != nil {
-			return err
-		}
-
-		// Write the chunk to the writer
-		if _, err := h.w.Write(b); err != nil {
-			return err
-		}
+	b, err := proto.Marshal(&agentLog)
+	if err != nil {
+		return err
+	}
+	if _, err := h.w.Write(b); err != nil {
+		return err
 	}
-
 	return nil
 }
 

internal/metrics.go

@@ -0,0 +1,27 @@
+// Copyright (c) Ultraviolet
+// SPDX-License-Identifier: Apache-2.0
+package internal
+
+import (
+	kitprometheus "github.com/go-kit/kit/metrics/prometheus"
+	stdprometheus "github.com/prometheus/client_golang/prometheus"
+)
+
+// MakeMetrics returns an instance of metrics.
+func MakeMetrics(namespace, subsystem string) (*kitprometheus.Counter, *kitprometheus.Summary) {
+	counter := kitprometheus.NewCounterFrom(stdprometheus.CounterOpts{
+		Namespace: namespace,
+		Subsystem: subsystem,
+		Name:      "request_count",
+		Help:      "Number of requests received.",
+	}, []string{"method"})
+	latency := kitprometheus.NewSummaryFrom(stdprometheus.SummaryOpts{
+		Namespace:  namespace,
+		Subsystem:  subsystem,
+		Objectives: map[float64]float64{0.5: 0.05, 0.9: 0.01, 0.99: 0.001},
+		Name:       "request_latency_microseconds",
+		Help:       "Total duration of requests in microseconds.",
+	}, []string{"method"})
+
+	return counter, latency
+}

internal/server/grpc/grpc.go

@@ -5,58 +5,36 @@ package grpc
 
 import (
 	"context"
-	"crypto/ecdsa"
-	"crypto/elliptic"
-	"crypto/rand"
 	"crypto/tls"
 	"crypto/x509"
-	"crypto/x509/pkix"
-	"encoding/asn1"
-	"encoding/pem"
 	"fmt"
 	"log/slog"
-	"math/big"
 	"net"
 	"os"
 	"time"
 
-	"github.com/google/go-sev-guest/client"
-	agentgrpc "github.com/ultravioletrs/cocos/agent/api/grpc"
-	"github.com/ultravioletrs/cocos/agent/auth"
 	"github.com/ultravioletrs/cocos/internal/server"
 	"go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc"
-	"golang.org/x/crypto/sha3"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials"
 	"google.golang.org/grpc/credentials/insecure"
 )
 
 const (
-	stopWaitTime  = 5 * time.Second
-	organization  = "Ultraviolet"
-	country       = "Serbia"
-	province      = ""
-	locality      = "Belgrade"
-	streetAddress = "Bulevar Arsenija Carnojevica 103"
-	postalCode    = "11000"
-	notAfterYear  = 1
-	notAfterMonth = 0
-	notAfterDay   = 0
+	stopWaitTime = 5 * time.Second
 )
 
 type Server struct {
 	server.BaseServer
 	server          *grpc.Server
 	registerService serviceRegister
-	quoteProvider   client.QuoteProvider
-	authSvc         auth.Authenticator
 }
 
 type serviceRegister func(srv *grpc.Server)
 
 var _ server.Server = (*Server)(nil)
 
-func New(ctx context.Context, cancel context.CancelFunc, name string, config server.Config, registerService serviceRegister, logger *slog.Logger, qp client.QuoteProvider, authSvc auth.Authenticator) server.Server {
+func New(ctx context.Context, cancel context.CancelFunc, name string, config server.Config, registerService serviceRegister, logger *slog.Logger) server.Server {
 	listenFullAddress := fmt.Sprintf("%s:%s", config.Host, config.Port)
 	return &Server{
 		BaseServer: server.BaseServer{
@@ -68,8 +46,6 @@ func New(ctx context.Context, cancel context.CancelFunc, name string, config ser
 			Logger:  logger,
 		},
 		registerService: registerService,
-		quoteProvider:   qp,
-		authSvc:         authSvc,
 	}
 }
 
@@ -79,12 +55,6 @@ func (s *Server) Start() error {
 		grpc.StatsHandler(otelgrpc.NewServerHandler()),
 	}
 
-	if s.authSvc != nil {
-		unary, stream := agentgrpc.NewAuthInterceptor(s.authSvc)
-		grpcServerOptions = append(grpcServerOptions, grpc.UnaryInterceptor(unary))
-		grpcServerOptions = append(grpcServerOptions, grpc.StreamInterceptor(stream))
-	}
-
 	listener, err := net.Listen("tcp", s.Address)
 	if err != nil {
 		return fmt.Errorf("failed to listen on port %s: %w", s.Address, err)
@@ -92,24 +62,6 @@ func (s *Server) Start() error {
 	creds := grpc.Creds(insecure.NewCredentials())
 
 	switch {
-	case s.Config.AttestedTLS:
-		certificateBytes, privateKeyBytes, err := generateCertificatesForATLS(s.quoteProvider)
-		if err != nil {
-			return fmt.Errorf("failed to create certificate: %w", err)
-		}
-
-		certificate, err := tls.X509KeyPair(certificateBytes, privateKeyBytes)
-		if err != nil {
-			return fmt.Errorf("falied due to invalid key pair: %w", err)
-		}
-
-		tlsConfig := &tls.Config{
-			ClientAuth:   tls.NoClientCert,
-			Certificates: []tls.Certificate{certificate},
-		}
-
-		creds = grpc.Creds(credentials.NewTLS(tlsConfig))
-		s.Logger.Info(fmt.Sprintf("%s service gRPC server listening at %s with Attested TLS", s.Name, s.Address))
 	case s.Config.CertFile != "" || s.Config.KeyFile != "":
 		certificate, err := loadX509KeyPair(s.Config.CertFile, s.Config.KeyFile)
 		if err != nil {
@@ -227,68 +179,3 @@ func loadX509KeyPair(certfile, keyfile string) (tls.Certificate, error) {
 	}
 	return tls.X509KeyPair(cert, key)
 }
-
-func generateCertificatesForATLS(qp client.QuoteProvider) ([]byte, []byte, error) {
-	curve := elliptic.P256()
-	privateKey, err := ecdsa.GenerateKey(curve, rand.Reader)
-	if err != nil {
-		return nil, nil, fmt.Errorf("failed to generate private/public key: %w", err)
-	}
-
-	publicKeyBytes, err := x509.MarshalPKIXPublicKey(&privateKey.PublicKey)
-	if err != nil {
-		return nil, nil, fmt.Errorf("failed to marshal the public key: %w", err)
-	}
-
-	// The Attestation Report will be added as an X.509 certificate extension
-	attestationReport, err := qp.GetRawQuote(sha3.Sum512(publicKeyBytes))
-	if err != nil {
-		return nil, nil, fmt.Errorf("failed to fetch the attestation report: %w", err)
-	}
-
-	certTemplate := &x509.Certificate{
-		SerialNumber: big.NewInt(202403311),
-		Subject: pkix.Name{
-			Organization:  []string{organization},
-			Country:       []string{country},
-			Province:      []string{province},
-			Locality:      []string{locality},
-			StreetAddress: []string{streetAddress},
-			PostalCode:    []string{postalCode},
-		},
-		NotBefore:             time.Now(),
-		NotAfter:              time.Now().AddDate(notAfterYear, notAfterMonth, notAfterDay),
-		KeyUsage:              x509.KeyUsageDigitalSignature,
-		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
-		BasicConstraintsValid: true,
-		ExtraExtensions: []pkix.Extension{
-			{
-				Id:       asn1.ObjectIdentifier{1, 2, 3, 4, 5, 6},
-				Critical: false,
-				Value:    attestationReport,
-			},
-		},
-	}
-
-	certDERBytes, err := x509.CreateCertificate(rand.Reader, certTemplate, certTemplate, &privateKey.PublicKey, privateKey)
-	if err != nil {
-		return nil, nil, fmt.Errorf("failed to create certificate: %w", err)
-	}
-
-	certBytes := pem.EncodeToMemory(&pem.Block{
-		Type:  "CERTIFICATE",
-		Bytes: certDERBytes,
-	})
-
-	privateKeyBytes, err := x509.MarshalPKCS8PrivateKey(privateKey)
-	if err != nil {
-		return nil, nil, fmt.Errorf("failed to marshal the private key: %w", err)
-	}
-
-	keyBytes := pem.EncodeToMemory(&pem.Block{
-		Type:  "PRIVATE KEY",
-		Bytes: privateKeyBytes,
-	})
-
-	return certBytes, keyBytes, nil
-}

internal/server/server.go

@@ -17,13 +17,12 @@ type Server interface {
 }
 
 type Config struct {
-	Host         string `env:"HOST"               envDefault:""`
-	Port         string `env:"PORT"               envDefault:""`
-	CertFile     string `env:"SERVER_CERT"        envDefault:""`
-	KeyFile      string `env:"SERVER_KEY"         envDefault:""`
-	ServerCAFile string `env:"SERVER_CA_CERTS"    envDefault:""`
-	ClientCAFile string `env:"CLIENT_CA_CERTS"    envDefault:""`
-	AttestedTLS  bool   `env:"ATTESTED_TLS"       envDefault:"false"`
+	Host         string `env:"HOST"            envDefault:""`
+	Port         string `env:"PORT"            envDefault:""`
+	CertFile     string `env:"SERVER_CERT"     envDefault:""`
+	KeyFile      string `env:"SERVER_KEY"      envDefault:""`
+	ServerCAFile string `env:"SERVER_CA_CERTS" envDefault:""`
+	ClientCAFile string `env:"CLIENT_CA_CERTS" envDefault:""`
 }
 
 type BaseServer struct {

internal/zip.go

@@ -1,102 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package internal
-
-import (
-	"archive/zip"
-	"bytes"
-	"io"
-	"os"
-	"path/filepath"
-)
-
-func ZipDirectoryToMemory(sourceDir string) ([]byte, error) {
-	buf := new(bytes.Buffer)
-	zipWriter := zip.NewWriter(buf)
-
-	err := filepath.Walk(sourceDir, func(path string, info os.FileInfo, err error) error {
-		if err != nil {
-			return err
-		}
-
-		if info.IsDir() {
-			return nil
-		}
-
-		relPath, err := filepath.Rel(sourceDir, path)
-		if err != nil {
-			return err
-		}
-
-		zipHeader, err := zip.FileInfoHeader(info)
-		if err != nil {
-			return err
-		}
-		zipHeader.Name = relPath
-
-		zipWriterEntry, err := zipWriter.CreateHeader(zipHeader)
-		if err != nil {
-			return err
-		}
-
-		fileToZip, err := os.Open(path)
-		if err != nil {
-			return err
-		}
-		defer fileToZip.Close()
-
-		_, err = io.Copy(zipWriterEntry, fileToZip)
-		return err
-	})
-	if err != nil {
-		zipWriter.Close()
-		return nil, err
-	}
-
-	if err := zipWriter.Close(); err != nil {
-		return nil, err
-	}
-
-	return buf.Bytes(), nil
-}
-
-func UnzipFromMemory(zipData []byte, targetDir string) error {
-	reader := bytes.NewReader(zipData)
-	zipReader, err := zip.NewReader(reader, int64(len(zipData)))
-	if err != nil {
-		return err
-	}
-
-	for _, file := range zipReader.File {
-		filePath := filepath.Join(targetDir, file.Name)
-
-		if file.FileInfo().IsDir() {
-			if err := os.MkdirAll(filePath, os.ModePerm); err != nil {
-				return err
-			}
-			continue
-		}
-
-		if err := os.MkdirAll(filepath.Dir(filePath), os.ModePerm); err != nil {
-			return err
-		}
-
-		srcFile, err := file.Open()
-		if err != nil {
-			return err
-		}
-		defer srcFile.Close()
-
-		dstFile, err := os.Create(filePath)
-		if err != nil {
-			return err
-		}
-		defer dstFile.Close()
-
-		if _, err := io.Copy(dstFile, srcFile); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}

manager/README.md

@@ -6,60 +6,17 @@ Manager service provides a barebones gRPC API and Service interface implementati
 
 The service is configured using the environment variables from the following table. Note that any unset variables will be replaced with their default values.
 
-| Variable                                  | Description                                                                                                      | Default                      |
-| ----------------------------------------- | ---------------------------------------------------------------------------------------------------------------- | ---------------------------- |
-| COCOS_JAEGER_URL                          | The URL for the Jaeger tracing endpoint.                                                                         | http://localhost:4318        |
-| COCOS_JAEGER_TRACE_RATIO                  | The ratio of traces to sample.                                                                                   | 1.0                          |
-| MANAGER_INSTANCE_ID                       | The instance ID for the manager service.                                                                         |                              |
-| MANAGER_BACKEND_MEASUREMENT_BINARY        | The file path for the backend measurement binary.                                                                | ../../build                  |
-| MANAGER_GRPC_CLIENT_CERT                  | The file path for the client certificate.                                                                        |                              |
-| MANAGER_GRPC_CLIENT_KEY                   | The file path for the client private key.                                                                        |                              |
-| MANAGER_GRPC_SERVER_CA_CERTS              | The file path for the server CA certificate(s).                                                                  |                              |
-| MANAGER_GRPC_URL                          | The URL for the gRPC endpoint.                                                                                   | localhost:7001               |
-| MANAGER_GRPC_TIMEOUT                      | The timeout for gRPC requests.                                                                                   | 60s                          |
-| MANAGER_INSTANCE_ID                       | Manager service instance ID                                                                                      |                              |
-| MANAGER_QEMU_MEMORY_SIZE                  | The total memory size for the virtual machine. Can be specified in a human-readable format like "2048M" or "4G". | 2048M                        |
-| MANAGER_QEMU_MEMORY_SLOTS                 | The number of memory slots for the virtual machine.                                                              | 5                            |
-| MANAGER_QEMU_MAX_MEMORY                   | The maximum memory size for the virtual machine. Can be specified in a human-readable format like "30G".         | 30G                          |
-| MANAGER_QEMU_OVMF_CODE_IF                 | The interface type for the OVMF code.                                                                            | pflash                       |
-| MANAGER_QEMU_OVMF_CODE_FORMAT             | The format of the OVMF code file.                                                                                | raw                          |
-| MANAGER_QEMU_OVMF_CODE_UNIT               | The unit number for the OVMF code.                                                                               | 0                            |
-| MANAGER_QEMU_OVMF_CODE_FILE               | The file path for the OVMF code.                                                                                 | /usr/share/OVMF/OVMF_CODE.fd |
-| MANAGER_QEMU_OVMF_CODE_READONLY           | Whether the OVMF code should be read-only.                                                                       | on                           |
-| MANAGER_QEMU_OVMF_VARS_IF                 | The interface type for the OVMF variables.                                                                       | pflash                       |
-| MANAGER_QEMU_OVMF_VARS_FORMAT             | The format of the OVMF variables file.                                                                           | raw                          |
-| MANAGER_QEMU_OVMF_VARS_UNIT               | The unit number for the OVMF variables.                                                                          | 1                            |
-| MANAGER_QEMU_OVMF_VARS_FILE               | The file path for the OVMF variables.                                                                            | /usr/share/OVMF/OVMF_VARS.fd |
-| MANAGER_QEMU_NETDEV_ID                    | The ID for the network device.                                                                                   | vmnic                        |
-| MANAGER_QEMU_HOST_FWD_AGENT               | The port number for the host forward agent.                                                                      | 7020                         |
-| MANAGER_QEMU_GUEST_FWD_AGENT              | The port number for the guest forward agent.                                                                     | 7002                         |
-| MANAGER_QEMU_VIRTIO_NET_PCI_DISABLE_LEGACY | Whether to disable the legacy PCI device.                                                                       | on                           |
-| MANAGER_QEMU_VIRTIO_NET_PCI_IOMMU_PLATFORM | Whether to enable the IOMMU platform for the virtio-net PCI device.                                             | true                         |
-| MANAGER_QEMU_VIRTIO_NET_PCI_ADDR           | The PCI address for the virtio-net PCI device.                                                                  | 0x2                          |
-| MANAGER_QEMU_VIRTIO_NET_PCI_ROMFILE        | The file path for the ROM image for the virtio-net PCI device.                                                  |                              |
-| MANAGER_QEMU_DISK_IMG_KERNEL_FILE          | The file path for the kernel image.                                                                             | img/bzImage                  |
-| MANAGER_QEMU_DISK_IMG_ROOTFS_FILE          | The file path for the root filesystem image.                                                                    | img/rootfs.cpio.gz           |
-| MANAGER_QEMU_SEV_ID                        | The ID for the Secure Encrypted Virtualization (SEV) device.                                                    | sev0                         |
-| MANAGER_QEMU_SEV_CBITPOS                   | The position of the C-bit in the physical address.                                                              | 51                           |
-| MANAGER_QEMU_SEV_REDUCED_PHYS_BITS         | The number of reduced physical address bits for SEV.                                                            | 1                            |
-| MANAGER_QEMU_HOST_DATA                     | Additional data for the SEV host.                                                                               |                              |
-| MANAGER_QEMU_VSOCK_ID                      | The ID for the virtual socket device.                                                                           | vhost-vsock-pci0             |
-| MANAGER_QEMU_VSOCK_GUEST_CID               | The guest-side CID (Context ID) for the virtual socket device.                                                  | 3                            |
-| MANAGER_QEMU_VSOCK_VNC                     | Whether to enable the virtual socket device for VNC.                                                            | 0                            |
-| MANAGER_QEMU_BIN_PATH                      | The file path for the QEMU binary.                                                                              | qemu-system-x86_64           |
-| MANAGER_QEMU_USE_SUDO                      | Whether to use sudo to run QEMU.                                                                                | false                        |
-| MANAGER_QEMU_ENABLE_SEV                    | Whether to enable Secure Encrypted Virtualization (SEV).                                                        | false                        |
-| MANAGER_QEMU_ENABLE_SEV_SNP                | Whether to enable Secure Nested Paging (SEV-SNP).                                                               | true                         |
-| MANAGER_QEMU_ENABLE_KVM                    | Whether to enable the Kernel-based Virtual Machine (KVM) acceleration.                                          | true                         |
-| MANAGER_QEMU_MACHINE                       | The machine type for QEMU.                                                                                      | q35                          |
-| MANAGER_QEMU_CPU                           | The CPU model for QEMU.                                                                                         | EPYC                         |
-| MANAGER_QEMU_SMP_COUNT                     | The number of virtual CPUs.                                                                                     | 4                            |
-| MANAGER_QEMU_SMP_MAXCPUS                   | The maximum number of virtual CPUs.                                                                             | 64                           |
-| MANAGER_QEMU_MEM_ID                        | The ID for the memory device.                                                                                   | ram1                         |
-| MANAGER_QEMU_KERNEL_HASH                   | Whether to enable kernel hash verification.                                                                     | false                        |
-| MANAGER_QEMU_NO_GRAPHIC                    | Whether to disable the graphical display.                                                                       | true                         |
-| MANAGER_QEMU_MONITOR                       | The type of monitor to use.                                                                                     | pty                          |
-| MANAGER_QEMU_HOST_FWD_RANGE                | The range of host ports to forward.                                                                             | 6100-6200                    |
+| Variable                      | Description                                              | Default                           |
+| ----------------------------- | -------------------------------------------------------- | --------------------------------- |
+| MANAGER_LOG_LEVEL             | Log level for manager service (debug, info, warn, error) | info                              |
+| MANAGER_GRPC_HOST             | Manager service gRPC host                                |                                   |
+| MANAGER_GRPC_PORT             | Manager service gRPC port                                | 7001                              |
+| MANAGER_GRPC_SERVER_CERT      | Path to server certificate in pem format                 |                                   |
+| MANAGER_GRPC_SERVER_KEY       | Path to server key in pem format                         |                                   |
+| MANAGER_GRPC_SERVER_CA_CERTS  | Path to gRPC server CA certificate                       |                                   |
+| MANAGER_GRPC_CLIENT_CA_CERTS  | Path to gRPC client CA certificate                       |                                   |
+| COCOS_JAEGER_URL              | Jaeger server URL                                        | http://localhost:14268/api/traces |
+| MANAGER_INSTANCE_ID           | Manager service instance ID                              |                                   |
 
 ## Setup
 
@@ -84,7 +41,7 @@ sudo apt update
 sudo apt install qemu-kvm
 ```
 
-Create `img` directory in `cmd/manager`.
+Create `img` directory in `cmd/manager`. Create `tmp` directory in `cmd/manager`.
 
 #### Add Vsock
 The necessary kernel modules must be loaded on the hypervisor. To check if `vhost_vsock` is loaded run:
@@ -187,7 +144,7 @@ NB: we set environment variables that we will use in the shell process where we
 
 ## Deployment
 
-To start the service, execute the following shell script (note a server needs to be running see  [here](../test/computations/README.md)):
+To start the service, execute the following shell script (note a server needs to be running see  [here](../test/manager-server/README.md)):
 
 ```bash
 # Download the latest version of the service
@@ -219,8 +176,6 @@ MANAGER_QEMU_SEV_CBITPOS=51 \
 
 The kernel hash feature might not work with the current build of OVMF and QEMU. If so, build the host kernel, QEMU, and OVMF from the [AMD SEV GitHub](https://github.com/AMDESE/AMDSEV/tree/snp-latest) repository.
 
-To build the OVMF with the kernel hash capability, we must build the AmdSev package of OVMF. The result of the build should be a single `OVMF.fd` file (unlike the regular two OVFM files). The OVMF package is located at `OvmfPkg/AmdSev/AmdSevX64.dsc`.
-
 To enable [AMD SEV-SNP](https://www.amd.com/en/developer/sev.html) support, start manager like this 
 
 ```sh
@@ -230,7 +185,7 @@ MANAGER_QEMU_ENABLE_SEV=false \
 MANAGER_QEMU_ENABLE_SEV_SNP=true \
 MANAGER_QEMU_SEV_CBITPOS=51 \
 MANAGER_QEMU_BIN_PATH=<path to QEMU binary> \
-MANAGER_QEMU_QEMU_OVMF_CODE_FILE=<path to OVMF.fd Amd Sev built package> \
+MANAGER_QEMU_QEMU_OVMF_CODE_FILE=<path to OVMF Amd Sev built package> \
 ./build/cocos-manager
 ```
 
@@ -248,10 +203,10 @@ MANAGER_QEMU_KERNEL_HASH=true \
 
 ### Verifying VM launch
 
-NB: To verify that the manager successfully launched the VM, you need to open three terminals on the same machine. In one terminal, you need to launch the computations server by executing (with the environment variables of choice):
+NB: To verify that the manager successfully launched the VM, you need to open three terminals on the same machine. In one terminal, you need to launch the Manager test server by executing (with the environment variables of choice):
 
 ```bash
-go run ./test/computations/main.go <dataset path> <algo path>
+go run ./test/manager-server/main.go
 ```
 
 and in the second the manager by executing (with the environment variables of choice):
@@ -260,7 +215,7 @@ and in the second the manager by executing (with the environment variables of ch
 go run ./cmd/manager/main.go
 ```
 
-Ensure that the Manager can connect to the Manager test server by setting the MANAGER_GRPC_PORT with the port value of the Manager test server. In the last terminal, you can run the verification commands.
+Ensure that the Manager can connect to the Manager test server by setting the MANAGER_GRPC_PORT with the port value of the Manager test server. The Manager test server is listening on the default value of the MANAGER_GRPC_PORT. In the last one, you can run the verification commands.
 
 To verify that the manager launched the VM successfully, run the following command:
 

manager/api/grpc/client.go

@@ -3,19 +3,11 @@
 package grpc
 
 import (
-	"bytes"
 	"context"
 
-	"github.com/absmach/magistrala/pkg/errors"
 	"github.com/ultravioletrs/cocos/manager"
 	pkgmanager "github.com/ultravioletrs/cocos/pkg/manager"
 	"golang.org/x/sync/errgroup"
-	"google.golang.org/protobuf/proto"
-)
-
-var (
-	errTerminationFromServer = errors.New("server requested client termination")
-	errCorruptedManifest     = errors.New("received manifest may be corrupted")
 )
 
 type ManagerClient struct {
@@ -33,82 +25,33 @@ func NewClient(stream pkgmanager.ManagerService_ProcessClient, svc manager.Servi
 	}
 }
 
-func (client ManagerClient) Process(ctx context.Context, cancel context.CancelFunc) error {
+func (client ManagerClient) Process(ctx context.Context) error {
 	eg, ctx := errgroup.WithContext(ctx)
 
 	eg.Go(func() error {
-		var runReqBuffer bytes.Buffer
 		for {
 			req, err := client.stream.Recv()
 			if err != nil {
 				return err
 			}
-
-			switch mes := req.Message.(type) {
-			case *pkgmanager.ServerStreamMessage_RunReqChunks:
-				if len(mes.RunReqChunks.Data) == 0 {
-					var runReq pkgmanager.ComputationRunReq
-					if err = proto.Unmarshal(runReqBuffer.Bytes(), &runReq); err != nil {
-						return errors.Wrap(err, errCorruptedManifest)
-					}
-					port, err := client.svc.Run(ctx, &runReq)
-					if err != nil {
-						return err
-					}
-					runRes := &pkgmanager.ClientStreamMessage_RunRes{
-						RunRes: &pkgmanager.RunResponse{
-							AgentPort:     port,
-							ComputationId: runReq.Id,
-						},
-					}
-					if err := client.stream.Send(&pkgmanager.ClientStreamMessage{Message: runRes}); err != nil {
-						return err
-					}
-				}
-				if _, err := runReqBuffer.Write(mes.RunReqChunks.Data); err != nil {
-					return err
-				}
-
-			case *pkgmanager.ServerStreamMessage_TerminateReq:
-				cancel()
-				return errors.Wrap(errTerminationFromServer, errors.New(mes.TerminateReq.Message))
-			case *pkgmanager.ServerStreamMessage_StopComputation:
-				msg := &pkgmanager.ClientStreamMessage_StopComputationRes{StopComputationRes: &pkgmanager.StopComputationResponse{
-					ComputationId: mes.StopComputation.ComputationId,
-				}}
-				if err := client.svc.Stop(ctx, mes.StopComputation.ComputationId); err != nil {
-					msg.StopComputationRes.Message = err.Error()
-				}
-				if err := client.stream.Send(&pkgmanager.ClientStreamMessage{Message: msg}); err != nil {
-					return err
-				}
-			case *pkgmanager.ServerStreamMessage_BackendInfoReq:
-				res, err := client.svc.FetchBackendInfo()
-				if err != nil {
-					return err
-				}
-				info := &pkgmanager.ClientStreamMessage_BackendInfo{BackendInfo: &pkgmanager.BackendInfo{
-					Info: res,
-					Id:   mes.BackendInfoReq.Id,
-				}}
-				if err := client.stream.Send(&pkgmanager.ClientStreamMessage{Message: info}); err != nil {
-					return err
-				}
+			port, err := client.svc.Run(ctx, req)
+			if err != nil {
+				return err
+			}
+			runRes := &pkgmanager.ClientStreamMessage_RunRes{RunRes: &pkgmanager.RunResponse{AgentPort: port, ComputationId: req.Id}}
+			if err := client.stream.Send(&pkgmanager.ClientStreamMessage{Message: runRes}); err != nil {
+				return err
 			}
 		}
 	})
 
 	eg.Go(func() error {
-		for {
-			select {
-			case <-ctx.Done():
-				return nil
-			case mes := <-client.responses:
-				if err := client.stream.Send(mes); err != nil {
-					return err
-				}
+		for mes := range client.responses {
+			if err := client.stream.Send(mes); err != nil {
+				return err
 			}
 		}
+		return nil
 	})
 
 	return eg.Wait()

manager/api/grpc/server.go

@@ -3,101 +3,60 @@
 package grpc
 
 import (
-	"bytes"
-	"errors"
-	"io"
+	"context"
 
 	"github.com/ultravioletrs/cocos/pkg/manager"
 	"golang.org/x/sync/errgroup"
-	"google.golang.org/grpc/credentials"
 	"google.golang.org/grpc/peer"
-	"google.golang.org/protobuf/proto"
 )
 
-var (
-	_                manager.ManagerServiceServer = (*grpcServer)(nil)
-	ErrUnexpectedMsg                              = errors.New("unknown message type")
-)
-
-const bufferSize = 1024 * 1024 // 1 MB
-
 type grpcServer struct {
 	manager.UnimplementedManagerServiceServer
 	incoming chan *manager.ClientStreamMessage
 	svc      Service
+	ctx      context.Context
 }
 
 type Service interface {
-	Run(ipAddress string, runReqChan chan *manager.ServerStreamMessage, authInfo credentials.AuthInfo)
+	Run(ipAddress string, runReqChan chan *manager.ComputationRunReq)
 }
 
 // NewServer returns new AuthServiceServer instance.
-func NewServer(incoming chan *manager.ClientStreamMessage, svc Service) manager.ManagerServiceServer {
+func NewServer(ctx context.Context, incoming chan *manager.ClientStreamMessage, svc Service) manager.ManagerServiceServer {
 	return &grpcServer{
 		incoming: incoming,
 		svc:      svc,
+		ctx:      ctx,
 	}
 }
 
 func (s *grpcServer) Process(stream manager.ManagerService_ProcessServer) error {
-	runReqChan := make(chan *manager.ServerStreamMessage)
-	client, ok := peer.FromContext(stream.Context())
-	if ok {
-		go s.svc.Run(client.Addr.String(), runReqChan, client.AuthInfo)
-	}
-	eg, ctx := errgroup.WithContext(stream.Context())
-
+	eg, _ := errgroup.WithContext(s.ctx)
+	runReqChan := make(chan *manager.ComputationRunReq)
 	eg.Go(func() error {
 		for {
 			req, err := stream.Recv()
 			if err != nil {
 				return err
 			}
+			if _, ok := req.Message.(*manager.ClientStreamMessage_Whoami); ok {
+				client, ok := peer.FromContext(stream.Context())
+				if ok {
+					s.svc.Run(client.Addr.String(), runReqChan)
+				}
+			}
 
 			s.incoming <- req
 		}
 	})
 
 	eg.Go(func() error {
-		for {
-			select {
-			case <-ctx.Done():
-				return nil
-			case req := <-runReqChan:
-				switch msg := req.Message.(type) {
-				case *manager.ServerStreamMessage_RunReq:
-					data, err := proto.Marshal(msg.RunReq)
-					if err != nil {
-						return err
-					}
-					dataBuffer := bytes.NewBuffer(data)
-					buf := make([]byte, bufferSize)
-					for {
-						n, err := dataBuffer.Read(buf)
-						chunk := &manager.ServerStreamMessage{
-							Message: &manager.ServerStreamMessage_RunReqChunks{
-								RunReqChunks: &manager.RunReqChunks{
-									Data: buf[:n],
-								},
-							},
-						}
-
-						if err := stream.Send(chunk); err != nil {
-							return err
-						}
-
-						if err == io.EOF {
-							break
-						}
-					}
-
-				default:
-					if err := stream.Send(req); err != nil {
-						return err
-					}
-				}
+		for runReq := range runReqChan {
+			if err := stream.Send(runReq); err != nil {
+				return err
 			}
 		}
+		return nil
 	})
 	return eg.Wait()
 }

manager/api/logging.go

@@ -41,28 +41,6 @@ func (lm *loggingMiddleware) Run(ctx context.Context, mc *pkgmanager.Computation
 	return lm.svc.Run(ctx, mc)
 }
 
-func (lm *loggingMiddleware) Stop(ctx context.Context, computationID string) (err error) {
-	defer func(begin time.Time) {
-		message := fmt.Sprintf("Method Stop for computation took %s to complete", time.Since(begin))
-		if err != nil {
-			lm.logger.Warn(fmt.Sprintf("%s with error: %s.", message, err))
-			return
-		}
-		lm.logger.Info(message)
-	}(time.Now())
-
-	return lm.svc.Stop(ctx, computationID)
-}
-
 func (lm *loggingMiddleware) RetrieveAgentEventsLogs() {
 	lm.svc.RetrieveAgentEventsLogs()
 }
-
-func (lm *loggingMiddleware) FetchBackendInfo() ([]byte, error) {
-	defer func(begin time.Time) {
-		message := fmt.Sprintf("Method FetchBackendInfo took %s to complete", time.Since(begin))
-		lm.logger.Info(message)
-	}(time.Now())
-
-	return lm.svc.FetchBackendInfo()
-}

manager/api/metrics.go

@@ -42,24 +42,6 @@ func (ms *metricsMiddleware) Run(ctx context.Context, mc *pkgmanager.Computation
 	return ms.svc.Run(ctx, mc)
 }
 
-func (ms *metricsMiddleware) Stop(ctx context.Context, computationID string) error {
-	defer func(begin time.Time) {
-		ms.counter.With("method", "Stop").Add(1)
-		ms.latency.With("method", "Stop").Observe(time.Since(begin).Seconds())
-	}(time.Now())
-
-	return ms.svc.Stop(ctx, computationID)
-}
-
 func (ms *metricsMiddleware) RetrieveAgentEventsLogs() {
 	ms.svc.RetrieveAgentEventsLogs()
 }
-
-func (ms *metricsMiddleware) FetchBackendInfo() ([]byte, error) {
-	defer func(begin time.Time) {
-		ms.counter.With("method", "FetchBackendInfo").Add(1)
-		ms.latency.With("method", "FetchBackendInfo").Observe(time.Since(begin).Seconds())
-	}(time.Now())
-
-	return ms.svc.FetchBackendInfo()
-}

manager/backend_info.go

@@ -1,29 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-
-//go:build !embed
-// +build !embed
-
-package manager
-
-import (
-	"fmt"
-	"os"
-	"os/exec"
-)
-
-func (ms *managerService) FetchBackendInfo() ([]byte, error) {
-	cmd := exec.Command("sudo", fmt.Sprintf("%s/backend_info", ms.backendMeasurementBinaryPath), "--policy", "1966081")
-
-	_, err := cmd.Output()
-	if err != nil {
-		return nil, err
-	}
-
-	f, err := os.ReadFile("./backend_info.json")
-	if err != nil {
-		return nil, err
-	}
-
-	return f, nil
-}

manager/backend_info_embed.go

@@ -1,13 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-
-//go:build embed
-// +build embed
-
-package manager
-
-import backendinfo "github.com/ultravioletrs/cocos/scripts/backend_info"
-
-func (ms *managerService) FetchBackendInfo() ([]byte, error) {
-	return backendinfo.BackendInfo, nil
-}

manager/manager.proto

@@ -10,20 +10,10 @@ package manager;
 option go_package = "./manager";
 
 service ManagerService {
-  rpc Process(stream ClientStreamMessage) returns (stream ServerStreamMessage) {}
+  rpc Process(stream ClientStreamMessage) returns (stream ComputationRunReq) {}
 }
 
-message Terminate {
-  string message = 1;
-}
-
-message StopComputation {
-  string computation_id = 1;
-}
-
-message StopComputationResponse {
-  string computation_id = 1;
-  string message = 2;
+message WhoAmI {
 }
 
 message RunResponse{
@@ -31,11 +21,6 @@ message RunResponse{
   string computation_id = 2;
 }
 
-message BackendInfo{
-  bytes info = 1;
-  string id = 2;
-}
-
 message AgentEvent {
   string event_type = 1;
 	google.protobuf.Timestamp timestamp = 2;
@@ -54,55 +39,33 @@ message AgentLog {
 
 message ClientStreamMessage {
   oneof message {
-    AgentLog agent_log = 1;
-    AgentEvent agent_event = 2;
-    RunResponse run_res = 3;
-    BackendInfo backendInfo = 4;
-    StopComputationResponse stopComputationRes = 5;
+    WhoAmI whoami = 1;
+    AgentLog agent_log = 2;
+    AgentEvent agent_event = 3;
+    RunResponse run_res = 4;
   }
 }
 
-message ServerStreamMessage {
-  oneof message {
-    RunReqChunks runReqChunks = 1;
-    ComputationRunReq runReq = 2;
-    Terminate terminateReq = 3;
-    StopComputation stopComputation = 4;
-    BackendInfoReq backendInfoReq = 5;
-  }
-}
-
-message RunReqChunks {
-  bytes data = 1;
-}
-
 message ComputationRunReq {
   string id = 1;
   string name = 2;
   string description = 3;
   repeated Dataset datasets = 4;
-  Algorithm algorithm = 5;
-  repeated ResultConsumer result_consumers = 6;
+  repeated Algorithm algorithms = 5;
+  repeated string result_consumers = 6;
   AgentConfig agent_config = 7;
 }
 
-message BackendInfoReq {
-  string id = 1;
-}
-
-message ResultConsumer {
-  bytes userKey = 1;
-}
-
 message Dataset {
-  bytes hash = 1; // should be sha3.Sum256, 32 byte length.
-  bytes userKey = 2;
-  string filename = 3;
+  string provider = 1;
+  string id = 2;
+  bytes hash = 3; // should be sha3.Sum256, 32 byte length.
 }
 
 message Algorithm {
-  bytes hash = 1; // should be sha3.Sum256, 32 byte length.
-  bytes userKey = 2;
+  string provider = 1;
+  string id = 2;
+  bytes hash = 3; // should be sha3.Sum256, 32 byte length.
 }
 
 message AgentConfig {
@@ -113,6 +76,4 @@ message AgentConfig {
   string client_ca_file = 5;
   string server_ca_file = 6;
   string log_level = 7;
-  bool   attested_tls = 8;
 }
-

manager/manager_test.go

@@ -1,68 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package manager_test
-
-import (
-	"bytes"
-	"context"
-	"testing"
-
-	"github.com/ultravioletrs/cocos/pkg/manager"
-	"google.golang.org/grpc"
-	"google.golang.org/protobuf/proto"
-)
-
-func TestProcess(t *testing.T) {
-	ctx := context.Background()
-	conn, err := grpc.DialContext(ctx, "bufnet", grpc.WithContextDialer(bufDialer), grpc.WithInsecure())
-	if err != nil {
-		t.Fatalf("Failed to dial bufnet: %v", err)
-	}
-	defer conn.Close()
-
-	client := manager.NewManagerServiceClient(conn)
-	stream, err := client.Process(ctx)
-	if err != nil {
-		t.Fatalf("Process failed: %v", err)
-	}
-
-	var data bytes.Buffer
-	for {
-		msg, err := stream.Recv()
-		if err != nil {
-			t.Fatalf("Failed to receive ServerStreamMessage: %v", err)
-		}
-
-		switch m := msg.Message.(type) {
-		case *manager.ServerStreamMessage_TerminateReq:
-			if m.TerminateReq.Message != "test terminate" {
-				t.Fatalf("Unexpected terminate message: %v", m.TerminateReq.Message)
-			}
-		case *manager.ServerStreamMessage_RunReqChunks:
-			if len(m.RunReqChunks.Data) == 0 {
-				var runReq manager.ComputationRunReq
-				if err = proto.Unmarshal(data.Bytes(), &runReq); err != nil {
-					t.Fatalf("Failed to create run request: %v", err)
-				}
-
-				runRes := &manager.ClientStreamMessage_AgentLog{
-					AgentLog: &manager.AgentLog{
-						Message:       "test log",
-						ComputationId: "comp1",
-						Level:         "DEBUG",
-					},
-				}
-				if runReq.Id != "1" || runReq.Name != "sample computation" || runReq.Description != "sample description" {
-					t.Fatalf("Unexpected run request message: %v", &runReq)
-				}
-				if err := stream.Send(&manager.ClientStreamMessage{Message: runRes}); err != nil {
-					t.Fatalf("Failed to send ClientStreamMessage: %v", err)
-				}
-				return
-			}
-			data.Write(m.RunReqChunks.Data)
-		default:
-			t.Fatalf("Unexpected message type: %T", m)
-		}
-	}
-}

manager/qemu/config.go

@@ -8,24 +8,24 @@ import (
 )
 
 type MemoryConfig struct {
-	Size  string `env:"MEMORY_SIZE"  envDefault:"2048M"`
+	Size  string `env:"MEMORY_SIZE" envDefault:"2048M"`
 	Slots int    `env:"MEMORY_SLOTS" envDefault:"5"`
-	Max   string `env:"MAX_MEMORY"   envDefault:"30G"`
+	Max   string `env:"MAX_MEMORY" envDefault:"30G"`
 }
 
 type OVMFCodeConfig struct {
-	If       string `env:"OVMF_CODE_IF"       envDefault:"pflash"`
-	Format   string `env:"OVMF_CODE_FORMAT"   envDefault:"raw"`
-	Unit     int    `env:"OVMF_CODE_UNIT"     envDefault:"0"`
-	File     string `env:"OVMF_CODE_FILE"     envDefault:"/usr/share/OVMF/OVMF_CODE.fd"`
+	If       string `env:"OVMF_CODE_IF" envDefault:"pflash"`
+	Format   string `env:"OVMF_CODE_FORMAT" envDefault:"raw"`
+	Unit     int    `env:"OVMF_CODE_UNIT" envDefault:"0"`
+	File     string `env:"OVMF_CODE_FILE" envDefault:"/usr/share/OVMF/OVMF_CODE.fd"`
 	ReadOnly string `env:"OVMF_CODE_READONLY" envDefault:"on"`
 }
 
 type OVMFVarsConfig struct {
-	If     string `env:"OVMF_VARS_IF"     envDefault:"pflash"`
+	If     string `env:"OVMF_VARS_IF" envDefault:"pflash"`
 	Format string `env:"OVMF_VARS_FORMAT" envDefault:"raw"`
-	Unit   int    `env:"OVMF_VARS_UNIT"   envDefault:"1"`
-	File   string `env:"OVMF_VARS_FILE"   envDefault:"/usr/share/OVMF/OVMF_VARS.fd"`
+	Unit   int    `env:"OVMF_VARS_UNIT" envDefault:"1"`
+	File   string `env:"OVMF_VARS_FILE" envDefault:"/usr/share/OVMF/OVMF_VARS.fd"`
 }
 
 type NetDevConfig struct {
@@ -37,7 +37,7 @@ type NetDevConfig struct {
 type VirtioNetPciConfig struct {
 	DisableLegacy string `env:"VIRTIO_NET_PCI_DISABLE_LEGACY" envDefault:"on"`
 	IOMMUPlatform bool   `env:"VIRTIO_NET_PCI_IOMMU_PLATFORM" envDefault:"true"`
-	Addr          string `env:"VIRTIO_NET_PCI_ADDR"           envDefault:"0x2"`
+	Addr          string `env:"VIRTIO_NET_PCI_ADDR" envDefault:"0x2"`
 	ROMFile       string `env:"VIRTIO_NET_PCI_ROMFILE"`
 }
 
@@ -47,32 +47,32 @@ type DiskImgConfig struct {
 }
 
 type SevConfig struct {
-	ID              string `env:"SEV_ID"                envDefault:"sev0"`
-	CBitPos         int    `env:"SEV_CBITPOS"           envDefault:"51"`
+	ID              string `env:"SEV_ID" envDefault:"sev0"`
+	CBitPos         int    `env:"SEV_CBITPOS" envDefault:"51"`
 	ReducedPhysBits int    `env:"SEV_REDUCED_PHYS_BITS" envDefault:"1"`
-	HostData        string `env:"HOST_DATA" envDefault:""`
 }
 
 type VSockConfig struct {
 	ID       string `env:"VSOCK_ID"        envDefault:"vhost-vsock-pci0"`
 	GuestCID int    `env:"VSOCK_GUEST_CID" envDefault:"3"`
-	Vnc      int    `env:"VSOCK_VNC"       envDefault:"0"`
+	vnc      int    `env:"VSOCK_VNC"       envDefault:"0"`
 }
 
 type Config struct {
-	QemuBinPath  string `env:"BIN_PATH"       envDefault:"qemu-system-x86_64"`
-	UseSudo      bool   `env:"USE_SUDO"       envDefault:"false"`
-	EnableSEV    bool   `env:"ENABLE_SEV"     envDefault:"false"`
+	QemuBinPath  string `env:"BIN_PATH" envDefault:"qemu-system-x86_64"`
+	TmpFileLoc   string `env:"TMP_FILE_LOC" envDefault:"tmp"`
+	UseSudo      bool   `env:"USE_SUDO" envDefault:"false"`
+	EnableSEV    bool   `env:"ENABLE_SEV" envDefault:"false"`
 	EnableSEVSNP bool   `env:"ENABLE_SEV_SNP" envDefault:"true"`
 
 	EnableKVM bool `env:"ENABLE_KVM" envDefault:"true"`
 
 	// machine, CPU, RAM
-	Machine  string `env:"MACHINE"     envDefault:"q35"`
-	CPU      string `env:"CPU"         envDefault:"EPYC"`
-	SMPCount int    `env:"SMP_COUNT"   envDefault:"4"`
+	Machine  string `env:"MACHINE" envDefault:"q35"`
+	CPU      string `env:"CPU" envDefault:"EPYC"`
+	SMPCount int    `env:"SMP_COUNT" envDefault:"4"`
 	MaxCPUs  int    `env:"SMP_MAXCPUS" envDefault:"64"`
-	MemID    string `env:"MEM_ID"      envDefault:"ram1"`
+	MemID    string `env:"MEM_ID" envDefault:"ram1"`
 	MemoryConfig
 
 	// Kernel hash
@@ -97,13 +97,10 @@ type Config struct {
 
 	// display
 	NoGraphic bool   `env:"NO_GRAPHIC" envDefault:"true"`
-	Monitor   string `env:"MONITOR"    envDefault:"pty"`
-
-	// ports
-	HostFwdRange string `env:"HOST_FWD_RANGE" envDefault:"6100-6200"`
+	Monitor   string `env:"MONITOR" envDefault:"pty"`
 }
 
-func (config Config) ConstructQemuArgs() []string {
+func constructQemuArgs(config Config) []string {
 	args := []string{}
 
 	// virtualization
@@ -160,7 +157,7 @@ func (config Config) ConstructQemuArgs() []string {
 			config.VirtioNetPciConfig.ROMFile))
 
 	args = append(args, "-device", fmt.Sprintf("vhost-vsock-pci,id=%s,guest-cid=%d", config.VSockConfig.ID, config.VSockConfig.GuestCID))
-	args = append(args, "-vnc", fmt.Sprintf(":%d", config.Vnc))
+	args = append(args, "-vnc", fmt.Sprintf(":%d", config.vnc))
 
 	if config.EnableSEVSNP {
 		args = append(args, "-object",
@@ -173,21 +170,16 @@ func (config Config) ConstructQemuArgs() []string {
 	}
 
 	args = append(args, "-kernel", config.DiskImgConfig.KernelFile)
-	args = append(args, "-append", strconv.Quote("quiet console=null rootfstype=ramfs"))
+	args = append(args, "-append", strconv.Quote("earlyprintk=serial console=ttyS0"))
 	args = append(args, "-initrd", config.DiskImgConfig.RootFsFile)
 
 	// SEV
 	if config.EnableSEV || config.EnableSEVSNP {
 		sevType := "sev-guest"
 		kernelHash := ""
-		hostData := ""
 
 		if config.EnableSEVSNP {
 			sevType = "sev-snp-guest"
-
-			if config.SevConfig.HostData != "" {
-				hostData = fmt.Sprintf(",host-data=%s", config.SevConfig.HostData)
-			}
 		}
 
 		if config.KernelHash {
@@ -195,13 +187,12 @@ func (config Config) ConstructQemuArgs() []string {
 		}
 
 		args = append(args, "-object",
-			fmt.Sprintf("%s,id=%s,cbitpos=%d,reduced-phys-bits=%d%s%s",
+			fmt.Sprintf("%s,id=%s,cbitpos=%d,reduced-phys-bits=%d%s",
 				sevType,
 				config.SevConfig.ID,
 				config.SevConfig.CBitPos,
 				config.SevConfig.ReducedPhysBits,
-				kernelHash,
-				hostData))
+				kernelHash))
 
 		args = append(args, "-machine",
 			fmt.Sprintf("memory-encryption=%s", config.SevConfig.ID))

manager/qemu/qemu.go

@@ -0,0 +1,91 @@
+// Copyright (c) Ultraviolet
+// SPDX-License-Identifier: Apache-2.0
+package qemu
+
+import (
+	"context"
+	"fmt"
+	"os/exec"
+
+	"github.com/gofrs/uuid"
+	"github.com/ultravioletrs/cocos/internal"
+)
+
+const (
+	firmwareVars = "OVMF_VARS"
+	KernelFile   = "bzImage"
+	rootfsFile   = "rootfs.cpio"
+)
+
+func CreateVM(ctx context.Context, cfg Config) (*exec.Cmd, error) {
+	// Create unique emu device identifiers.
+	id, err := uuid.NewV4()
+	if err != nil {
+		return &exec.Cmd{}, err
+	}
+	qemuCfg := cfg
+	qemuCfg.NetDevConfig.ID = fmt.Sprintf("%s-%s", qemuCfg.NetDevConfig.ID, id)
+	qemuCfg.SevConfig.ID = fmt.Sprintf("%s-%s", qemuCfg.SevConfig.ID, id)
+
+	// Copy firmware vars file.
+	srcFile := qemuCfg.OVMFVarsConfig.File
+	dstFile := fmt.Sprintf("%s/%s-%s.fd", cfg.TmpFileLoc, firmwareVars, id)
+	err = internal.CopyFile(srcFile, dstFile)
+	if err != nil {
+		return &exec.Cmd{}, err
+	}
+	qemuCfg.OVMFVarsConfig.File = dstFile
+
+	// Copy img files.
+	srcFile = qemuCfg.DiskImgConfig.KernelFile
+	dstFile = fmt.Sprintf("%s/%s-%s", cfg.TmpFileLoc, KernelFile, id)
+	err = internal.CopyFile(srcFile, dstFile)
+	if err != nil {
+		return &exec.Cmd{}, err
+	}
+	qemuCfg.DiskImgConfig.KernelFile = dstFile
+
+	srcFile = qemuCfg.DiskImgConfig.RootFsFile
+	dstFile = fmt.Sprintf("%s/%s-%s.gz", cfg.TmpFileLoc, rootfsFile, id)
+	err = internal.CopyFile(srcFile, dstFile)
+	if err != nil {
+		return &exec.Cmd{}, err
+	}
+	qemuCfg.DiskImgConfig.RootFsFile = dstFile
+
+	exe, args, err := ExecutableAndArgs(qemuCfg)
+	if err != nil {
+		return &exec.Cmd{}, err
+	}
+	cmd, err := runQemuVM(exe, args)
+	if err != nil {
+		return cmd, err
+	}
+
+	return cmd, nil
+}
+
+func ExecutableAndArgs(cfg Config) (string, []string, error) {
+	exe, err := exec.LookPath(cfg.QemuBinPath)
+	if err != nil {
+		return "", nil, err
+	}
+
+	args := constructQemuArgs(cfg)
+
+	if cfg.UseSudo {
+		args = append([]string{exe}, args...)
+		exe = "sudo"
+	}
+
+	return exe, args, nil
+}
+
+func runQemuVM(exe string, args []string) (*exec.Cmd, error) {
+	cmd, err := internal.RunCmdStart(exe, args...)
+	if err != nil {
+		return nil, err
+	}
+
+	return cmd, nil
+}

manager/qemu/vm.go

@@ -1,75 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package qemu
-
-import (
-	"fmt"
-	"os/exec"
-
-	"github.com/gofrs/uuid"
-	"github.com/ultravioletrs/cocos/manager/vm"
-	"github.com/ultravioletrs/cocos/pkg/manager"
-)
-
-const (
-	firmwareVars = "OVMF_VARS"
-	KernelFile   = "bzImage"
-	rootfsFile   = "rootfs.cpio"
-)
-
-type qemuVM struct {
-	config        Config
-	cmd           *exec.Cmd
-	logsChan      chan *manager.ClientStreamMessage
-	computationId string
-}
-
-func NewVM(config interface{}, logsChan chan *manager.ClientStreamMessage, computationId string) vm.VM {
-	return &qemuVM{
-		config:        config.(Config),
-		logsChan:      logsChan,
-		computationId: computationId,
-	}
-}
-
-func (v *qemuVM) Start() error {
-	// Create unique qemu device identifiers
-	id, err := uuid.NewV4()
-	if err != nil {
-		return err
-	}
-	qemuCfg := v.config
-	qemuCfg.NetDevConfig.ID = fmt.Sprintf("%s-%s", qemuCfg.NetDevConfig.ID, id)
-	qemuCfg.SevConfig.ID = fmt.Sprintf("%s-%s", qemuCfg.SevConfig.ID, id)
-
-	exe, args, err := v.executableAndArgs()
-	if err != nil {
-		return err
-	}
-
-	v.cmd = exec.Command(exe, args...)
-	v.cmd.Stdout = &vm.Stdout{LogsChan: v.logsChan, ComputationId: v.computationId}
-	v.cmd.Stderr = &vm.Stderr{LogsChan: v.logsChan, ComputationId: v.computationId}
-
-	return v.cmd.Start()
-}
-
-func (v *qemuVM) Stop() error {
-	return v.cmd.Process.Kill()
-}
-
-func (v *qemuVM) executableAndArgs() (string, []string, error) {
-	exe, err := exec.LookPath(v.config.QemuBinPath)
-	if err != nil {
-		return "", nil, err
-	}
-
-	args := v.config.ConstructQemuArgs()
-
-	if v.config.UseSudo {
-		args = append([]string{exe}, args...)
-		exe = "sudo"
-	}
-
-	return exe, args, nil
-}

manager/qemu/vm_test.go

@@ -1,39 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package qemu
-
-import (
-	"os/exec"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/ultravioletrs/cocos/pkg/manager"
-)
-
-func TestNewVM(t *testing.T) {
-	config := Config{}
-	logsChan := make(chan *manager.ClientStreamMessage)
-	computationId := "test-computation"
-
-	nvm := NewVM(config, logsChan, computationId)
-
-	assert.NotNil(t, nvm)
-	assert.IsType(t, &qemuVM{}, nvm)
-}
-
-func TestVM_Stop(t *testing.T) {
-	// Setup
-	v := &qemuVM{
-		cmd: exec.Command("sleep", "1"),
-	}
-
-	err := v.cmd.Start()
-	assert.NoError(t, err)
-
-	// Test
-	err = v.Stop()
-
-	// Assert
-	assert.NoError(t, err)
-	assert.Error(t, v.cmd.Wait()) // Process should have been killed
-}

manager/service.go

@@ -4,22 +4,17 @@ package manager
 
 import (
 	"context"
-	"encoding/base64"
 	"encoding/json"
 	"fmt"
 	"log/slog"
 	"net"
-	"regexp"
 	"strconv"
-	"sync"
 
 	"github.com/absmach/magistrala/pkg/errors"
 	"github.com/cenkalti/backoff/v4"
 	"github.com/ultravioletrs/cocos/agent"
 	"github.com/ultravioletrs/cocos/manager/qemu"
-	"github.com/ultravioletrs/cocos/manager/vm"
 	"github.com/ultravioletrs/cocos/pkg/manager"
-	"golang.org/x/crypto/sha3"
 	"google.golang.org/protobuf/types/known/timestamppb"
 )
 
@@ -41,9 +36,6 @@ var (
 	ErrFailedToAllocatePort = errors.New("failed to allocate free port on host")
 
 	errInvalidHashLength = errors.New("hash must be of byte length 32")
-
-	// ErrFailedToCalculateHash indicates that agent computation returned an error while calculating the hash of the computation.
-	ErrFailedToCalculateHash = errors.New("error while calculating the hash of the computation")
 )
 
 // Service specifies an API that must be fulfilled by the domain service
@@ -51,54 +43,37 @@ var (
 type Service interface {
 	// Run create a computation.
 	Run(ctx context.Context, c *manager.ComputationRunReq) (string, error)
-	// Stop stops a computation.
-	Stop(ctx context.Context, computationID string) error
 	// RetrieveAgentEventsLogs Retrieve and forward agent logs and events via vsock.
 	RetrieveAgentEventsLogs()
-	// FetchBackendInfo measures and fetches the backend information.
-	FetchBackendInfo() ([]byte, error)
 }
 
 type managerService struct {
-	qemuCfg                      qemu.Config
-	backendMeasurementBinaryPath string
-	logger                       *slog.Logger
-	agents                       map[int]string // agent map of vsock cid to computationID.
-	eventsChan                   chan *manager.ClientStreamMessage
-	vms                          map[string]vm.VM
-	vmFactory                    vm.Provider
-	portRangeMin                 int
-	portRangeMax                 int
+	qemuCfg    qemu.Config
+	logger     *slog.Logger
+	agents     map[int]string // agent map of vsock cid to computationID.
+	eventsChan chan *manager.ClientStreamMessage
 }
 
 var _ Service = (*managerService)(nil)
 
 // New instantiates the manager service implementation.
-func New(cfg qemu.Config, backendMeasurementBinPath string, logger *slog.Logger, eventsChan chan *manager.ClientStreamMessage, vmFactory vm.Provider) (Service, error) {
-	start, end, err := decodeRange(cfg.HostFwdRange)
-	if err != nil {
-		return nil, err
-	}
+func New(qemuCfg qemu.Config, logger *slog.Logger, eventsChan chan *manager.ClientStreamMessage) Service {
 	ms := &managerService{
-		qemuCfg:                      cfg,
-		logger:                       logger,
-		agents:                       make(map[int]string),
-		vms:                          make(map[string]vm.VM),
-		eventsChan:                   eventsChan,
-		vmFactory:                    vmFactory,
-		backendMeasurementBinaryPath: backendMeasurementBinPath,
-		portRangeMin:                 start,
-		portRangeMax:                 end,
+		qemuCfg:    qemuCfg,
+		logger:     logger,
+		agents:     make(map[int]string),
+		eventsChan: eventsChan,
 	}
-	return ms, nil
+	return ms
 }
 
 func (ms *managerService) Run(ctx context.Context, c *manager.ComputationRunReq) (string, error) {
 	ms.publishEvent("vm-provision", c.Id, "starting", json.RawMessage{})
 	ac := agent.Computation{
-		ID:          c.Id,
-		Name:        c.Name,
-		Description: c.Description,
+		ID:              c.Id,
+		Name:            c.Name,
+		Description:     c.Description,
+		ResultConsumers: c.ResultConsumers,
 		AgentConfig: agent.AgentConfig{
 			Port:         c.AgentConfig.Port,
 			Host:         c.AgentConfig.Host,
@@ -109,114 +84,63 @@ func (ms *managerService) Run(ctx context.Context, c *manager.ComputationRunReq)
 			LogLevel:     c.AgentConfig.LogLevel,
 		},
 	}
-	ac.Algorithm = agent.Algorithm{Hash: [hashLength]byte(c.Algorithm.Hash), UserKey: c.Algorithm.UserKey}
-
+	for _, algo := range c.Algorithms {
+		if len(algo.Hash) != hashLength {
+			ms.publishEvent("vm-provision", c.Id, "failed", json.RawMessage{})
+			return "", errInvalidHashLength
+		}
+		ac.Algorithms = append(ac.Algorithms, agent.Algorithm{ID: algo.Id, Provider: algo.Provider, Hash: [hashLength]byte(algo.Hash)})
+	}
 	for _, data := range c.Datasets {
 		if len(data.Hash) != hashLength {
 			ms.publishEvent("vm-provision", c.Id, "failed", json.RawMessage{})
 			return "", errInvalidHashLength
 		}
-		ac.Datasets = append(ac.Datasets, agent.Dataset{Hash: [hashLength]byte(data.Hash), UserKey: data.UserKey, Filename: data.Filename})
+		ac.Datasets = append(ac.Datasets, agent.Dataset{ID: data.Id, Provider: data.Provider, Hash: [hashLength]byte(data.Hash)})
 	}
 
-	for _, rc := range c.ResultConsumers {
-		ac.ResultConsumers = append(ac.ResultConsumers, agent.ResultConsumer{UserKey: rc.UserKey})
-	}
-
-	agentPort, err := getFreePort(ms.portRangeMin, ms.portRangeMax)
+	agentPort, err := getFreePort()
 	if err != nil {
 		ms.publishEvent("vm-provision", c.Id, "failed", json.RawMessage{})
 		return "", errors.Wrap(ErrFailedToAllocatePort, err)
 	}
 	ms.qemuCfg.HostFwdAgent = agentPort
 
-	ch, err := computationHash(ac)
-	if err != nil {
-		ms.publishEvent("vm-provision", c.Id, "failed", json.RawMessage{})
-		return "", errors.Wrap(ErrFailedToCalculateHash, err)
-	}
-
-	// Define host-data value of QEMU for SEV-SNP, with a base64 encoding of the computation hash.
-	ms.qemuCfg.SevConfig.HostData = base64.StdEncoding.EncodeToString(ch[:])
-
-	cvm := ms.vmFactory(ms.qemuCfg, ms.eventsChan, c.Id)
 	ms.publishEvent("vm-provision", c.Id, "in-progress", json.RawMessage{})
-	if err = cvm.Start(); err != nil {
+	if _, err = qemu.CreateVM(ctx, ms.qemuCfg); err != nil {
 		ms.publishEvent("vm-provision", c.Id, "failed", json.RawMessage{})
 		return "", err
 	}
-	ms.vms[c.Id] = cvm
 
 	ms.agents[ms.qemuCfg.VSockConfig.GuestCID] = c.Id
 
 	err = backoff.Retry(func() error {
-		return cvm.SendAgentConfig(ac)
+		return SendAgentConfig(uint32(ms.qemuCfg.VSockConfig.GuestCID), ac)
 	}, backoff.NewExponentialBackOff())
 	if err != nil {
 		return "", err
 	}
 	ms.qemuCfg.VSockConfig.GuestCID++
-	ms.qemuCfg.VSockConfig.Vnc++
 
 	ms.publishEvent("vm-provision", c.Id, "complete", json.RawMessage{})
 	return fmt.Sprint(ms.qemuCfg.HostFwdAgent), nil
 }
 
-func (ms *managerService) Stop(ctx context.Context, computationID string) error {
-	cvm, ok := ms.vms[computationID]
-	if !ok {
-		defer ms.publishEvent("stop-computation", computationID, "failed", json.RawMessage{})
-		return ErrNotFound
-	}
-	if err := cvm.Stop(); err != nil {
-		defer ms.publishEvent("stop-computation", computationID, "failed", json.RawMessage{})
-		return err
-	}
-	delete(ms.vms, computationID)
-	defer ms.publishEvent("stop-computation", computationID, "complete", json.RawMessage{})
-	return nil
-}
-
-func getFreePort(minPort, maxPort int) (int, error) {
-	if checkPortisFree(minPort) {
-		return minPort, nil
-	}
-
-	var wg sync.WaitGroup
-	portCh := make(chan int, maxPort-minPort+1)
-
-	for port := minPort; port <= maxPort; port++ {
-		wg.Add(1)
-		go func(p int) {
-			defer wg.Done()
-
-			if checkPortisFree(p) {
-				portCh <- p
-			}
-		}(port)
-	}
-
-	go func() {
-		wg.Wait()
-		close(portCh)
-	}()
-
-	select {
-	case port := <-portCh:
-		return port, nil
-	default:
-		return 0, fmt.Errorf("failed to find free port in range %d-%d", minPort, maxPort)
-	}
-}
-
-func checkPortisFree(port int) bool {
-	listener, err := net.Listen("tcp", fmt.Sprintf(":%d", port))
+func getFreePort() (int, error) {
+	listener, err := net.Listen("tcp", "")
 	if err != nil {
-		return false
+		return 0, err
 	}
 	defer listener.Close()
-
-	return true
+	_, portStr, err := net.SplitHostPort(listener.Addr().String())
+	if err != nil {
+		return 0, err
+	}
+	port, err := strconv.Atoi(portStr)
+	if err != nil {
+		return 0, err
+	}
+	return port, nil
 }
 
 func (ms *managerService) publishEvent(event, cmpID, status string, details json.RawMessage) {
@@ -233,36 +157,3 @@ func (ms *managerService) publishEvent(event, cmpID, status string, details json
 		},
 	}
 }
-
-func computationHash(ac agent.Computation) ([32]byte, error) {
-	jsonData, err := json.Marshal(ac)
-	if err != nil {
-		return [32]byte{}, err
-	}
-
-	return sha3.Sum256(jsonData), nil
-}
-
-func decodeRange(input string) (int, int, error) {
-	re := regexp.MustCompile(`(\d+)-(\d+)`)
-	matches := re.FindStringSubmatch(input)
-	if len(matches) != 3 {
-		return 0, 0, fmt.Errorf("invalid input format: %s", input)
-	}
-
-	start, err := strconv.Atoi(matches[1])
-	if err != nil {
-		return 0, 0, err
-	}
-
-	end, err := strconv.Atoi(matches[2])
-	if err != nil {
-		return 0, 0, err
-	}
-
-	if start > end {
-		return 0, 0, fmt.Errorf("invalid range: %d-%d", start, end)
-	}
-
-	return start, end, nil
-}

manager/service_test.go

@@ -1,247 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package manager
-
-import (
-	"context"
-	"encoding/json"
-	"log/slog"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/require"
-	"github.com/ultravioletrs/cocos/manager/qemu"
-	"github.com/ultravioletrs/cocos/manager/vm"
-	"github.com/ultravioletrs/cocos/manager/vm/mocks"
-	"github.com/ultravioletrs/cocos/pkg/manager"
-)
-
-func TestNew(t *testing.T) {
-	cfg := qemu.Config{
-		HostFwdRange: "6000-6100",
-	}
-	logger := slog.Default()
-	eventsChan := make(chan *manager.ClientStreamMessage)
-	vmf := new(mocks.Provider)
-
-	service, err := New(cfg, "", logger, eventsChan, vmf.Execute)
-	require.NoError(t, err)
-
-	assert.NotNil(t, service)
-	assert.IsType(t, &managerService{}, service)
-}
-
-func TestRun(t *testing.T) {
-	vmf := new(mocks.Provider)
-	vmMock := new(mocks.VM)
-	vmf.On("Execute", mock.Anything, mock.Anything, mock.Anything).Return(vmMock)
-	tests := []struct {
-		name          string
-		req           *manager.ComputationRunReq
-		vmStartError  error
-		expectedError error
-	}{
-		{
-			name: "Successful run",
-			req: &manager.ComputationRunReq{
-				Id:   "test-computation",
-				Name: "Test Computation",
-				Algorithm: &manager.Algorithm{
-					Hash: make([]byte, hashLength),
-				},
-				AgentConfig: &manager.AgentConfig{},
-			},
-			vmStartError:  nil,
-			expectedError: nil,
-		},
-		{
-			name: "VM start failure",
-			req: &manager.ComputationRunReq{
-				Id:   "test-computation",
-				Name: "Test Computation",
-				Algorithm: &manager.Algorithm{
-					Hash: make([]byte, hashLength),
-				},
-				AgentConfig: &manager.AgentConfig{},
-			},
-			vmStartError:  assert.AnError,
-			expectedError: assert.AnError,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if tt.vmStartError == nil {
-				vmMock.On("Start").Return(nil).Once()
-			} else {
-				vmMock.On("Start").Return(tt.vmStartError).Once()
-			}
-
-			vmMock.On("SendAgentConfig", mock.Anything).Return(nil)
-
-			qemuCfg := qemu.Config{
-				VSockConfig: qemu.VSockConfig{
-					GuestCID: 3,
-					Vnc:      5900,
-				},
-			}
-			logger := slog.Default()
-			eventsChan := make(chan *manager.ClientStreamMessage, 10)
-
-			ms := &managerService{
-				qemuCfg:    qemuCfg,
-				logger:     logger,
-				agents:     make(map[int]string),
-				vms:        make(map[string]vm.VM),
-				eventsChan: eventsChan,
-				vmFactory:  vmf.Execute,
-			}
-
-			ctx := context.Background()
-
-			port, err := ms.Run(ctx, tt.req)
-
-			if tt.expectedError != nil {
-				assert.Error(t, err)
-				assert.ErrorIs(t, err, tt.expectedError)
-				assert.Empty(t, port)
-			} else {
-				assert.NoError(t, err)
-				assert.NotEmpty(t, port)
-				assert.Len(t, ms.vms, 1)
-				assert.Len(t, ms.agents, 1)
-			}
-
-			vmf.AssertExpectations(t)
-
-			for len(eventsChan) > 0 {
-				<-eventsChan
-			}
-		})
-	}
-}
-
-func TestStop(t *testing.T) {
-	vmf := new(mocks.Provider)
-	vmMock := new(mocks.VM)
-	vmf.On("Execute", mock.Anything, mock.Anything, mock.Anything).Return(vmMock)
-
-	tests := []struct {
-		name           string
-		computationID  string
-		vmStopError    error
-		expectedError  error
-		initialVMCount int
-	}{
-		{
-			name:           "Successful stop",
-			computationID:  "existing-computation",
-			vmStopError:    nil,
-			expectedError:  nil,
-			initialVMCount: 1,
-		},
-		{
-			name:           "Non-existent computation",
-			computationID:  "non-existent-computation",
-			vmStopError:    nil,
-			expectedError:  ErrNotFound,
-			initialVMCount: 0,
-		},
-		{
-			name:           "VM stop error",
-			computationID:  "error-computation",
-			vmStopError:    assert.AnError,
-			expectedError:  assert.AnError,
-			initialVMCount: 1,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			logger := slog.Default()
-			eventsChan := make(chan *manager.ClientStreamMessage, 10)
-			ms := &managerService{
-				logger:     logger,
-				vms:        make(map[string]vm.VM),
-				eventsChan: eventsChan,
-			}
-			vmMock := new(mocks.VM)
-
-			if tt.vmStopError == nil {
-				vmMock.On("Stop").Return(nil).Once()
-			} else {
-				vmMock.On("Stop").Return(assert.AnError).Once()
-			}
-
-			if tt.initialVMCount > 0 {
-				ms.vms[tt.computationID] = vmMock
-			}
-
-			err := ms.Stop(context.Background(), tt.computationID)
-
-			if tt.expectedError != nil {
-				assert.Error(t, err)
-				assert.ErrorIs(t, err, tt.expectedError)
-			} else {
-				assert.NoError(t, err)
-				assert.Len(t, ms.vms, 0)
-			}
-
-			for len(eventsChan) > 0 {
-				<-eventsChan
-			}
-		})
-	}
-}
-
-func TestGetFreePort(t *testing.T) {
-	port, err := getFreePort(6000, 6100)
-
-	assert.NoError(t, err)
-	assert.Greater(t, port, 0)
-}
-
-func TestPublishEvent(t *testing.T) {
-	tests := []struct {
-		name          string
-		event         string
-		computationID string
-		status        string
-		details       json.RawMessage
-	}{
-		{
-			name:          "Standard event",
-			event:         "test-event",
-			computationID: "test-computation",
-			status:        "test-status",
-			details:       nil,
-		},
-		{
-			name:          "Event with details",
-			event:         "detailed-event",
-			computationID: "detailed-computation",
-			status:        "detailed-status",
-			details:       json.RawMessage(`{"key": "value"}`),
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			eventsChan := make(chan *manager.ClientStreamMessage, 1)
-			ms := &managerService{
-				eventsChan: eventsChan,
-			}
-
-			ms.publishEvent(tt.event, tt.computationID, tt.status, tt.details)
-
-			assert.Len(t, eventsChan, 1)
-			event := <-eventsChan
-			assert.Equal(t, tt.event, event.GetAgentEvent().EventType)
-			assert.Equal(t, tt.computationID, event.GetAgentEvent().ComputationId)
-			assert.Equal(t, tt.status, event.GetAgentEvent().Status)
-			assert.Equal(t, "manager", event.GetAgentEvent().Originator)
-			assert.Equal(t, tt.details, json.RawMessage(event.GetAgentEvent().Details))
-		})
-	}
-}

manager/setup_test.go

@@ -1,126 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package manager_test
-
-import (
-	"context"
-	"crypto/rand"
-	"crypto/rsa"
-	"crypto/x509"
-	"encoding/pem"
-	"log/slog"
-	"net"
-	"os"
-	"testing"
-	"time"
-
-	mglog "github.com/absmach/magistrala/logger"
-	managergrpc "github.com/ultravioletrs/cocos/manager/api/grpc"
-	"github.com/ultravioletrs/cocos/pkg/manager"
-	"golang.org/x/crypto/sha3"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/credentials"
-	"google.golang.org/grpc/test/bufconn"
-)
-
-const (
-	bufSize    = 1024 * 1024
-	keyBitSize = 4096
-)
-
-var (
-	lis         *bufconn.Listener
-	algoPath    = "../test/manual/algo/lin_reg.py"
-	dataPath    = "../test/manual/data/iris.csv"
-	attestedTLS = false
-)
-
-type svc struct {
-	logger *slog.Logger
-	t      *testing.T
-}
-
-func TestMain(m *testing.M) {
-	logger := mglog.NewMock()
-
-	lis = bufconn.Listen(bufSize)
-	s := grpc.NewServer()
-
-	manager.RegisterManagerServiceServer(s, managergrpc.NewServer(make(chan *manager.ClientStreamMessage, 1), &svc{logger: logger}))
-	go func() {
-		if err := s.Serve(lis); err != nil {
-			panic(err)
-		}
-	}()
-
-	code := m.Run()
-
-	s.Stop()
-	lis.Close()
-	os.Exit(code)
-}
-
-func bufDialer(context.Context, string) (net.Conn, error) {
-	return lis.Dial()
-}
-
-func (s *svc) Run(ipAddress string, runReqChan chan *manager.ServerStreamMessage, authInfo credentials.AuthInfo) {
-	privKey, err := rsa.GenerateKey(rand.Reader, keyBitSize)
-	if err != nil {
-		s.t.Fatalf("Error generating public key: %v", err)
-	}
-
-	pubKey, err := x509.MarshalPKIXPublicKey(&privKey.PublicKey)
-	if err != nil {
-		s.t.Fatalf("Error marshalling public key: %v", err)
-	}
-
-	pubPemBytes := pem.EncodeToMemory(&pem.Block{
-		Type:  "PUBLIC KEY",
-		Bytes: pubKey,
-	})
-
-	go func() {
-		time.Sleep(time.Millisecond * 100)
-		runReqChan <- &manager.ServerStreamMessage{
-			Message: &manager.ServerStreamMessage_TerminateReq{
-				TerminateReq: &manager.Terminate{Message: "test terminate"},
-			},
-		}
-	}()
-
-	go func() {
-		time.Sleep(time.Millisecond * 100)
-		algo, err := os.ReadFile(algoPath)
-		if err != nil {
-			s.t.Fatalf("failed to read algorithm file: %s", err)
-			return
-		}
-		data, err := os.ReadFile(dataPath)
-		if err != nil {
-			s.t.Fatalf("failed to read data file: %s", err)
-			return
-		}
-
-		pubPem, _ := pem.Decode(pubPemBytes)
-		algoHash := sha3.Sum256(algo)
-		dataHash := sha3.Sum256(data)
-		runReqChan <- &manager.ServerStreamMessage{
-			Message: &manager.ServerStreamMessage_RunReq{
-				RunReq: &manager.ComputationRunReq{
-					Id:              "1",
-					Name:            "sample computation",
-					Description:     "sample description",
-					Datasets:        []*manager.Dataset{{Hash: dataHash[:], UserKey: pubPem.Bytes}},
-					Algorithm:       &manager.Algorithm{Hash: algoHash[:], UserKey: pubPem.Bytes},
-					ResultConsumers: []*manager.ResultConsumer{{UserKey: pubPem.Bytes}},
-					AgentConfig: &manager.AgentConfig{
-						Port:        "7002",
-						LogLevel:    "debug",
-						AttestedTls: attestedTLS,
-					},
-				},
-			},
-		}
-	}()
-}

manager/tracing/tracing.go

@@ -29,20 +29,6 @@ func (tm *tracingMiddleware) Run(ctx context.Context, mc *pkgmanager.Computation
 	return tm.svc.Run(ctx, mc)
 }
 
-func (tm *tracingMiddleware) Stop(ctx context.Context, computationID string) error {
-	ctx, span := tm.tracer.Start(ctx, "stop")
-	defer span.End()
-
-	return tm.svc.Stop(ctx, computationID)
-}
-
 func (tm *tracingMiddleware) RetrieveAgentEventsLogs() {
 	tm.svc.RetrieveAgentEventsLogs()
 }
-
-func (tm *tracingMiddleware) FetchBackendInfo() ([]byte, error) {
-	_, span := tm.tracer.Start(context.Background(), "fetch_backend_info")
-	defer span.End()
-
-	return tm.svc.FetchBackendInfo()
-}

manager/vm/logging.go

@@ -1,133 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package vm
-
-import (
-	"bytes"
-	"errors"
-	"io"
-
-	"github.com/ultravioletrs/cocos/pkg/manager"
-	"google.golang.org/protobuf/types/known/timestamppb"
-)
-
-var (
-	_                      io.Writer = &Stdout{}
-	_                      io.Writer = &Stderr{}
-	ErrFailedToSendMessage           = errors.New("failed to send message to channel")
-	ErrPanicRecovered                = errors.New("panic recovered: channel may be closed")
-)
-
-const bufSize = 1024
-
-type Stdout struct {
-	LogsChan      chan *manager.ClientStreamMessage
-	ComputationId string
-}
-
-// safeSend safely sends a message to the channel and returns an error on failure.
-func safeSend(ch chan *manager.ClientStreamMessage, msg *manager.ClientStreamMessage) (err error) {
-	defer func() {
-		if r := recover(); r != nil {
-			// Recover from panic if the channel is closed
-			err = ErrPanicRecovered
-		}
-	}()
-	select {
-	case ch <- msg:
-		return nil
-	default:
-		// Channel is full or closed
-		return ErrFailedToSendMessage
-	}
-}
-
-// Write implements io.Writer.
-func (s *Stdout) Write(p []byte) (n int, err error) {
-	inBuf := bytes.NewBuffer(p)
-
-	buf := make([]byte, bufSize)
-
-	for {
-		n, err := inBuf.Read(buf)
-		if err != nil {
-			if err == io.EOF {
-				break
-			}
-			return len(p) - inBuf.Len(), err
-		}
-
-		msg := &manager.ClientStreamMessage{
-			Message: &manager.ClientStreamMessage_AgentLog{
-				AgentLog: &manager.AgentLog{
-					Message:       string(buf[:n]),
-					ComputationId: s.ComputationId,
-					Level:         "debug",
-					Timestamp:     timestamppb.Now(),
-				},
-			},
-		}
-
-		if err := safeSend(s.LogsChan, msg); err != nil {
-			return len(p) - inBuf.Len(), err
-		}
-	}
-
-	return len(p), nil
-}
-
-type Stderr struct {
-	LogsChan      chan *manager.ClientStreamMessage
-	ComputationId string
-}
-
-// Write implements io.Writer.
-func (s *Stderr) Write(p []byte) (n int, err error) {
-	inBuf := bytes.NewBuffer(p)
-
-	buf := make([]byte, bufSize)
-
-	for {
-		n, err := inBuf.Read(buf)
-		if err != nil {
-			if err == io.EOF {
-				break
-			}
-			return len(p) - inBuf.Len(), err
-		}
-
-		msg := &manager.ClientStreamMessage{
-			Message: &manager.ClientStreamMessage_AgentLog{
-				AgentLog: &manager.AgentLog{
-					Message:       string(buf[:n]),
-					ComputationId: s.ComputationId,
-					Level:         "error",
-					Timestamp:     timestamppb.Now(),
-				},
-			},
-		}
-
-		if err := safeSend(s.LogsChan, msg); err != nil {
-			return len(p) - inBuf.Len(), err
-		}
-	}
-
-	// Ensure vm-provision failure message is sent
-	eventMsg := &manager.ClientStreamMessage{
-		Message: &manager.ClientStreamMessage_AgentEvent{
-			AgentEvent: &manager.AgentEvent{
-				ComputationId: s.ComputationId,
-				EventType:     "vm-provision",
-				Timestamp:     timestamppb.Now(),
-				Originator:    "manager",
-				Status:        "failed",
-			},
-		},
-	}
-
-	if err := safeSend(s.LogsChan, eventMsg); err != nil {
-		return len(p), err
-	}
-
-	return len(p), nil
-}

manager/vm/logging_test.go

@@ -1,171 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package vm
-
-import (
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/ultravioletrs/cocos/pkg/manager"
-)
-
-func TestStdoutWrite(t *testing.T) {
-	tests := []struct {
-		name           string
-		input          string
-		expectedWrites int
-	}{
-		{
-			name:           "Single write within buffer size",
-			input:          "Hello, World!",
-			expectedWrites: 1,
-		},
-		{
-			name:           "Multiple writes within buffer size",
-			input:          "This is a longer message that will be split into multiple writes.",
-			expectedWrites: 1,
-		},
-		{
-			name:           "Large write exceeding buffer size",
-			input:          string(make([]byte, bufSize*2+1)),
-			expectedWrites: 3,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			logsChan := make(chan *manager.ClientStreamMessage, 10)
-			s := &Stdout{
-				LogsChan:      logsChan,
-				ComputationId: "test-computation",
-			}
-
-			n, err := s.Write([]byte(tt.input))
-
-			assert.NoError(t, err)
-			assert.Equal(t, len(tt.input), n)
-
-			var receivedWrites int
-			for i := 0; i < tt.expectedWrites; i++ {
-				select {
-				case msg := <-logsChan:
-					receivedWrites++
-					agentLog := msg.GetAgentLog()
-					assert.NotNil(t, agentLog)
-					assert.Equal(t, "test-computation", agentLog.ComputationId)
-					assert.Equal(t, "debug", agentLog.Level)
-					assert.NotEmpty(t, agentLog.Message)
-					assert.NotNil(t, agentLog.Timestamp)
-				case <-time.After(time.Second):
-					t.Fatal("Timed out waiting for log message")
-				}
-			}
-
-			assert.Equal(t, tt.expectedWrites, receivedWrites)
-		})
-	}
-}
-
-func TestStderrWrite(t *testing.T) {
-	tests := []struct {
-		name           string
-		input          string
-		expectedWrites int
-	}{
-		{
-			name:           "Single write within buffer size",
-			input:          "Error: Something went wrong",
-			expectedWrites: 1,
-		},
-		{
-			name:           "Multiple writes within buffer size",
-			input:          "This is a longer error message that will be split into multiple writes.",
-			expectedWrites: 1,
-		},
-		{
-			name:           "Large write exceeding buffer size",
-			input:          string(make([]byte, bufSize*2)),
-			expectedWrites: 3,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			logsChan := make(chan *manager.ClientStreamMessage, 10)
-			s := &Stderr{
-				LogsChan:      logsChan,
-				ComputationId: "test-computation",
-			}
-
-			n, err := s.Write([]byte(tt.input))
-
-			assert.NoError(t, err)
-			assert.Equal(t, len(tt.input), n)
-
-			var receivedWrites int
-			for i := 0; i < tt.expectedWrites; i++ {
-				select {
-				case msg := <-logsChan:
-					receivedWrites++
-					switch msg.Message.(type) {
-					case *manager.ClientStreamMessage_AgentLog:
-						agentLog := msg.GetAgentLog()
-						assert.NotNil(t, agentLog)
-						assert.Equal(t, "test-computation", agentLog.ComputationId)
-						assert.Equal(t, "error", agentLog.Level)
-						assert.NotEmpty(t, agentLog.Message)
-						assert.NotNil(t, agentLog.Timestamp)
-					case *manager.ClientStreamMessage_AgentEvent:
-						agentEvent := msg.GetAgentEvent()
-						assert.NotNil(t, agentEvent)
-						assert.Equal(t, "test-computation", agentEvent.ComputationId)
-						assert.Equal(t, "vm-provision", agentEvent.EventType)
-						assert.Equal(t, "failed", agentEvent.Status)
-						assert.NotNil(t, agentEvent.Timestamp)
-					}
-				case <-time.After(time.Second):
-					t.Fatal("Timed out waiting for log message")
-				}
-			}
-
-			assert.Equal(t, tt.expectedWrites, receivedWrites)
-		})
-	}
-}
-
-func TestStdoutWriteErrorHandling(t *testing.T) {
-	logsChan := make(chan *manager.ClientStreamMessage, 1)
-	s := &Stdout{
-		LogsChan:      logsChan,
-		ComputationId: "test-computation",
-	}
-
-	// Test with a closed channel to simulate an error condition
-	close(logsChan)
-
-	message := []byte("This should fail")
-	n, err := s.Write(message)
-
-	assert.Error(t, err)
-	assert.Equal(t, len(message), n)
-	assert.Equal(t, ErrPanicRecovered, err)
-}
-
-func TestStderrWriteErrorHandling(t *testing.T) {
-	logsChan := make(chan *manager.ClientStreamMessage, 1)
-	s := &Stderr{
-		LogsChan:      logsChan,
-		ComputationId: "test-computation",
-	}
-
-	// Test with a closed channel to simulate an error condition
-	close(logsChan)
-
-	message := []byte("This should fail")
-	n, err := s.Write(message)
-
-	assert.Error(t, err)
-	assert.Equal(t, len(message), n)
-	assert.Equal(t, ErrPanicRecovered, err)
-}