NOISSUE - Fix Algo Path (#216)

* fix(algorithm): fix running binary algorithm

This is the error
```
"algorithm": executable file not found in $PATH
```

* fix(algorithm): get absolute filepath for all algorithms

Signed-off-by: Rodney Osodo <socials@rodneyosodo.com>

* fix(lint): fix linting errors

* refactor: simplify algorithm filename

Signed-off-by: Rodney Osodo <socials@rodneyosodo.com>

---------

Signed-off-by: Rodney Osodo <socials@rodneyosodo.com>

.env

@@ -0,0 +1,28 @@
+## Jaeger
+COCOS_JAEGER_PORT=6831
+COCOS_JAEGER_FRONTEND=16686
+COCOS_JAEGER_COLLECTOR=14268
+COCOS_JAEGER_CONFIGS=5778
+COCOS_JAEGER_URL=http://jaeger:4318
+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_GRPC_PORT=7003
+MANAGER_GRPC_SERVER_CERT=""
+MANAGER_GRPC_SERVER_KEY=""
+AGENT_GRPC_URL="localhost:7002"
+AGENT_GRPC_TIMEOUT=""
+AGENT_GRPC_CA_CERTS=""
+AGENT_GRPC_CLIENT_TLS=""
+MANAGER_INSTANCE_ID=""
+MANAGER_LOG_LEVEL=debug
+MANAGER_QEMU_USE_SUDO=false
+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

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,49 @@
+name: Bug Report
+description: File a bug/issue report. Make sure to search to see if an issue already exists for the bug you encountered.
+title: "Bug: <title>"
+labels: ["bug", "needs-review", "help wanted"]
+body:
+  - type: textarea
+    attributes:
+      label: What were you trying to achieve?
+      description: A clear and concise description of what the bug is.
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: What are the expected results?
+      description: A concise description of what you expected to happen.
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: What are the received results?
+      description: A concise description of what you received.
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Steps To Reproduce
+      description: What are the steps to reproduce the issue?
+      placeholder: |
+        1. In this environment...
+        2. With this config...
+        3. Run '...'
+        4. See error...
+    validations:
+      required: false
+  - type: textarea
+    attributes:
+      label: In what environment did you encounter the issue?
+      description: A concise description of the environment you encountered the issue in.
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Additional information you deem important
+      description: |
+        Links? References? Anything that will give us more context about the issue you are encountering!
+
+        Tip: You can attach images or log files by clicking this area to highlight it and then dragging files in.
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1 @@
+blank_issues_enabled: false

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,36 @@
+name: Feature Request
+description: File a feature request. Make sure to search to see if a request already exists for the feature you are requesting.
+title: "Feature: <title>"
+labels: ["enchancement", "needs-review"]
+body:
+  - type: textarea
+    attributes:
+      label: Is your feature request related to a problem? Please describe.
+      description: A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Describe the feature you are requesting, as well as the possible use case(s) for it.
+      description: A clear and concise description of what you want to happen.
+    validations:
+      required: true
+  - type: dropdown
+    attributes:
+      label: Indicate the importance of this feature to you.
+      description: This will help us prioritize the feature request.
+      options:
+        - Must-have
+        - Should-have
+        - Nice-to-have
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Anything else?
+      description: |
+        Links? References? Anything that will give us more context about the feature that you are requesting.
+
+        Tip: You can attach images or log files by clicking this area to highlight it and then dragging files in.
+    validations:
+      required: false

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,66 @@
+<!--
+
+Pull request title should be `COCOS-XXX - description` or `NOISSUE - description` where XXX is ID of the issue that this PR relate to.
+Please review the [CONTRIBUTING.md](https://github.com/ultravioletrs/cocos/blob/master/CONTRIBUTING.md) file for detailed contributing guidelines.
+
+For Work In Progress Pull Requests, please use the Draft PR feature, see https://github.blog/2019-02-14-introducing-draft-pull-requests/ for further details.
+
+For a timely review/response, please avoid force-pushing additional commits if your PR already received reviews or comments.
+
+- Provide tests for your changes.
+- Use descriptive commit messages.
+- Comment your code where appropriate.
+- Squash your commits
+- Update any related documentation.
+-->
+
+# What type of PR is this?
+
+<!--This represents the type of PR you are submitting.
+
+For example:
+This is a bug fix because it fixes the following issue: #1234
+This is a feature because it adds the following functionality: ...
+This is a refactor because it changes the following functionality: ...
+This is a documentation update because it updates the following documentation: ...
+This is a dependency update because it updates the following dependencies: ...
+This is an optimization because it improves the following functionality: ...
+-->
+
+## What does this do?
+
+<!--
+Please provide a brief description of what this PR is intended to do.
+Include List any changes that modify/break current functionality.
+-->
+
+## Which issue(s) does this PR fix/relate to?
+
+<!--
+For pull requests that relate or close an issue, please include them below.  We like to follow [Github's guidance on linking issues to pull requests](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue).
+
+For example having the text: "Resolves #1234" would connect the current pull request to issue 1234.  And when we merge the pull request, Github will automatically close the issue.
+-->
+
+- Related Issue #
+- Resolves #
+
+## Have you included tests for your changes?
+
+<!--If you have not included tests, please explain why.
+For example:
+Yes, I have included tests for my changes.
+No, I have not included tests because I do not know how to.
+-->
+
+## Did you document any new/modified feature?
+
+<!--If you have not included documentation, please explain why.
+For example:
+Yes, I have updated the documentation for the new feature.
+No, I have not updated the documentation because I do not know how to.
+-->
+
+### Notes
+
+<!--Please provide any additional information you feel is important.-->

.github/workflows/checkproto.yaml

@@ -0,0 +1,82 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - "manager/manager.proto"
+      - "pkg/manager/*.pb.go"
+      - "agent/agent.proto"
+      - "agent/*.pb.go"
+  pull_request:
+    branches:
+      - main
+    paths:
+      - "manager/manager.proto"
+      - "pkg/manager/*.pb.go"
+      - "agent/agent.proto"
+      - "agent/*.pb.go"
+
+jobs:
+  checkproto:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: 1.22.x
+
+      - name: Set up protoc
+        run: |
+          PROTOC_VERSION=27.2
+          PROTOC_GEN_VERSION=v1.34.2
+          PROTOC_GRPC_VERSION=v1.4.0
+
+          # Download and install protoc
+          PROTOC_ZIP=protoc-$PROTOC_VERSION-linux-x86_64.zip
+          curl -0L -o $PROTOC_ZIP https://github.com/protocolbuffers/protobuf/releases/download/v$PROTOC_VERSION/$PROTOC_ZIP
+          unzip -o $PROTOC_ZIP -d protoc3
+          sudo mv protoc3/bin/* /usr/local/bin/
+          sudo mv protoc3/include/* /usr/local/include/
+          rm -rf $PROTOC_ZIP protoc3
+
+          # Install protoc-gen-go and protoc-gen-go-grpc
+          go install google.golang.org/protobuf/cmd/protoc-gen-go@$PROTOC_GEN_VERSION
+          go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@$PROTOC_GRPC_VERSION
+
+          # Add protoc to the PATH
+          export PATH=$PATH:/usr/local/bin/protoc
+
+      - name: Set up Cocos-AI
+        run: |
+          # Rename .pb.go files to .pb.go.tmp to prevent conflicts
+          for p in $(ls pkg/manager/*.pb.go); do
+            mv $p $p.tmp
+          done
+
+          for p in $(ls agent/*.pb.go); do
+            mv $p $p.tmp
+          done
+
+          # Generate Go files from protobuf definitions
+          make protoc
+
+          # Compare generated Go files with the original ones
+          for p in $(ls pkg/manager/*.pb.go); do
+            if ! cmp -s $p $p.tmp; then
+              echo "Proto file and generated Go file $p are out of sync!"
+              exit 1
+            fi
+          done
+
+          for p in $(ls agent/*.pb.go); do
+            if ! cmp -s $p $p.tmp; then
+              echo "Proto file and generated Go file $p are out of sync!"
+              exit 1
+            fi
+          done

.github/workflows/go.yaml

@@ -1,39 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-    branches: [main]
-
-jobs:
-  test:
-    strategy:
-      matrix:
-        go-version: [1.19.x]
-        os: [ubuntu-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-
-    - name: Install Go
-      uses: actions/setup-go@v3
-      with:
-        go-version: ${{ matrix.go-version }}
-
-    - name: Checkout code
-      uses: actions/checkout@v2
-    
-    - name: Run go vet
-      run: go vet ./...
-
-    - name: golangci-lint
-      uses: golangci/golangci-lint-action@v3
-      with:
-        version: latest
-        args: --no-config --disable-all --enable gosimple --enable govet --enable unused --enable deadcode --timeout 3m
-  
-    - name: Build
-      run: go build -v ./...
-    
-    - name: Run tests
-      run: go test -mod=vendor -v --race -covermode=atomic -coverprofile cover.out ./...

.github/workflows/hal.yml

@@ -0,0 +1,73 @@
+name: Build and Release
+
+on:
+  push:
+    tags:
+      - '*'
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Update Ubuntu
+      run: |
+        sudo apt-get update
+        sudo apt-get upgrade -y
+    
+    - name: Install Go
+      uses: actions/setup-go@v5
+      with:
+        go-version: 1.22.x
+        cache-dependency-path: "go.sum"
+
+    - name: Checkout cocos
+      uses: actions/checkout@v4
+      with:
+        repository: 'ultravioletrs/cocos'
+        path: cocos
+
+    - name: Checkout buildroot
+      uses: actions/checkout@v4
+      with:
+        repository: 'buildroot/buildroot'
+        path: buildroot
+
+    - name: Build
+      run: |
+        cd buildroot
+        make BR2_EXTERNAL=../cocos/hal/linux cocos_defconfig
+        make
+
+    - name: Create Release
+      id: create_release
+      uses: actions/create-release@latest
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        tag_name: ${{ github.ref }}
+        release_name: Release ${{ github.ref }}
+        draft: false
+        prerelease: false
+
+    - name: Upload Release Asset
+      id: upload-release-kernel
+      uses: actions/upload-release-asset@latest
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.create_release.outputs.upload_url }}
+        asset_path: ./buildroot/output/images/bzImage
+        asset_name: bzImage
+        asset_content_type: application/octet-stream
+
+    - name: Upload Release Asset
+      id: upload-release-rootfs
+      uses: actions/upload-release-asset@latest
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.create_release.outputs.upload_url }}
+        asset_path: ./buildroot/output/images/rootfs.cpio.gz
+        asset_name: rootfs.cpio.gz
+        asset_content_type: application/gzip

.github/workflows/main.yaml

@@ -0,0 +1,34 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  ci:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: 1.22.x
+
+      - name: golangci-lint
+        uses: golangci/golangci-lint-action@v6
+        with:
+          version: v1.59.1
+
+      - name: Build
+        run: |
+          make
+
+      - name: Run tests
+        run: go test -v --race -covermode=atomic -coverprofile cover.out ./...

.gitignore

@@ -1 +1,12 @@
 build
+
+build
+cmd/manager/img
+
+.cov
+
+*.pem
+
+dist/
+results.zip
+*.spec

.golangci.yaml

@@ -0,0 +1,80 @@
+run:
+  timeout: 3m
+
+issues:
+  max-issues-per-linter: 10
+  max-same-issues: 10
+
+linters-settings:
+  importas:
+    no-unaliased: true
+    no-extra-aliases: false
+    alias:
+      - pkg: github.com/absmach/magistrala/logger
+        alias: mglog
+
+  gocritic:
+    enabled-checks:
+      - dupImport
+      - importShadow
+      - httpNoBody
+      - paramTypeCombine
+      - emptyStringTest
+      - builtinShadow
+      - exposedSyncMutex
+    disabled-checks:
+      - appendAssign
+    enabled-tags:
+      - diagnostic
+    disabled-tags:
+      - performance
+      - style
+      - experimental
+      - opinionated
+  stylecheck:
+    checks: ["-ST1000", "-ST1003", "-ST1020", "-ST1021", "-ST1022"]
+  goheader:
+    template: |-
+      Copyright (c) Ultraviolet
+      SPDX-License-Identifier: Apache-2.0
+
+linters:
+  disable-all: true
+  enable:
+    - importas
+    - gocritic
+    - gosimple
+    - errcheck
+    - govet
+    - unused
+    - goconst
+    - godot
+    - godox
+    - ineffassign
+    - misspell
+    - stylecheck
+    - whitespace
+    - gci
+    - gofmt
+    - goimports
+    - loggercheck
+    - goheader
+    - asasalint
+    - asciicheck
+    - bidichk
+    - contextcheck
+    - decorder
+    - dogsled
+    - errchkjson
+    - errname
+    - execinquery
+    - exportloopref
+    - ginkgolinter
+    - gocheckcompilerdirectives
+    - gofumpt
+    - goprintffuncname
+    - importas
+    - makezero
+    - mirror
+    - nakedret
+    - dupword

CONTRIBUTING.md

@@ -1,11 +1,11 @@
-# Contributing to Mainflux
+# Contributing to CoCos
 
-The following is a set of guidelines to contribute to Mainflux and its libraries, which are
-hosted on the [Mainflux Organization](https://github.com/mainflux) on GitHub.
+The following is a set of guidelines to contribute to CoCos and its libraries, which are
+hosted on the [Ultraviolet Organization](https://github.com/ultravioletrs) on GitHub.
 
 This project adheres to the [Contributor Covenant 1.2](http://contributor-covenant.org/version/1/2/0).
 By participating, you are expected to uphold this code. Please report unacceptable behavior to
-[abuse@mainflux.com](mailto:abuse@mainflux.com).
+[abuse@ultraviolet.rs](mailto:abuse@ultraviolet.rs).
 
 ## Reporting issues
 
@@ -13,7 +13,7 @@ Reporting issues are a great way to contribute to the project. We are perpetuall
 thorough bug report.
 
 Before raising a new issue, check [our issue
-list](https://github.com/mainflux/mainflux/issues) to determine if it already contains the
+list](https://github.com/ultravioletrs/cocos/issues) to determine if it already contains the
 problem that you are facing.
 
 A good bug report shouldn't leave others needing to chase you for more information. Please be as detailed as possible. The following questions might serve as a template for writing a detailed
@@ -41,23 +41,23 @@ To contribute to the project, [fork](https://help.github.com/articles/fork-a-rep
 clone your fork repository, and configure the remotes:
 
 ```
-git clone https://github.com/<your-username>/mainflux.git
-cd mainflux
-git remote add upstream https://github.com/mainflux/mainflux.git
+git clone https://github.com/<your-username>/cocos.git
+cd cocos
+git remote add upstream https://github.com/ultravioletrs/cocos.git
 ```
 
 If your cloned repository is behind the upstream commits, then get the latest changes from upstream:
 
 ```
 git checkout master
-git pull --rebase upstream master
+git pull --rebase upstream main
 ```
 
-Create a new topic branch from `master` using the naming convention `MF-[issue-number]`
+Create a new topic branch from `master` using the naming convention `COCOS-[issue-number]`
 to help us keep track of your contribution scope:
 
 ```
-git checkout -b MF-[issue-number]
+git checkout -b COCOS-[issue-number]
 ```
 
 Commit your changes in logical chunks. When you are ready to commit, make sure
@@ -74,13 +74,13 @@ and `user.email` git configs, you can sign your commit automatically with `git c
 Locally merge (or rebase) the upstream development branch into your topic branch:
 
 ```
-git pull --rebase upstream master
+git pull --rebase upstream main
 ```
 
 Push your topic branch up to your fork:
 
 ```
-git push origin MF-[issue-number]
+git push origin COCOS-[issue-number]
 ```
 
 [Open a Pull Request](https://help.github.com/articles/using-pull-requests/) with a clear title

LICENSE

@@ -1,6 +1,7 @@
+
                                  Apache License
                            Version 2.0, January 2004
-                        http://www.apache.org/licenses/
+                        https://www.apache.org/licenses/
 
    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
 
@@ -175,24 +176,13 @@
 
    END OF TERMS AND CONDITIONS
 
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
+   Copyright 2015-2020 Mainflux
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at
 
-       http://www.apache.org/licenses/LICENSE-2.0
+       https://www.apache.org/licenses/LICENSE-2.0
 
    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,

Makefile

@@ -1,81 +1,36 @@
-COCOS_DOCKER_IMAGE_NAME_PREFIX ?= cocos
 BUILD_DIR = build
-SERVICES = computations datasets
-DOCKERS = $(addprefix docker_,$(SERVICES))
-DOCKERS_DEV = $(addprefix docker_dev_,$(SERVICES))
+SERVICES = manager agent cli
+BACKEND_INFO = backend_info
 CGO_ENABLED ?= 0
 GOARCH ?= amd64
-VERSION ?= $(shell git describe --abbrev=0 --tags)
+VERSION ?= $(shell git describe --abbrev=0 --tags --always)
 COMMIT ?= $(shell git rev-parse HEAD)
 TIME ?= $(shell date +%F_%T)
+EMBED_ENABLED ?= 0
 
 define compile_service
 	CGO_ENABLED=$(CGO_ENABLED) GOOS=$(GOOS) GOARCH=$(GOARCH) GOARM=$(GOARM) \
-	go build -mod=vendor -ldflags "-s -w \
-	-X 'github.com/ultravioletrs/cocos/internal/http.BuildTime=$(TIME)' \
-	-X 'github.com/ultravioletrs/cocos/internal/http.Version=$(VERSION)' \
-	-X 'github.com/ultravioletrs/cocos/internal/http.Commit=$(COMMIT)'" \
+	go build -ldflags "-s -w \
+	-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
 
-define make_docker
-	$(eval svc=$(subst docker_,,$(1)))
-
-	docker build \
-		--no-cache \
-		--build-arg SVC=$(svc) \
-		--build-arg GOARCH=$(GOARCH) \
-		--build-arg GOARM=$(GOARM) \
-		--build-arg VERSION=$(VERSION) \
-		--build-arg COMMIT=$(COMMIT) \
-		--build-arg TIME=$(TIME) \
-		--tag=$(COCOS_DOCKER_IMAGE_NAME_PREFIX)/$(svc) \
-		-f docker/Dockerfile .
-endef
-
-define make_docker_dev
-	$(eval svc=$(subst docker_dev_,,$(1)))
-
-	docker build \
-		--no-cache \
-		--build-arg SVC=$(svc) \
-		--tag=$(COCOS_DOCKER_IMAGE_NAME_PREFIX)/$(svc) \
-		-f docker/Dockerfile.dev ./build
-endef
+.PHONY: all $(SERVICES) $(BACKEND_INFO)
 
 all: $(SERVICES)
 
-.PHONY: all $(SERVICES) dockers dockers_dev latest release
-
-clean:
-	rm -rf ${BUILD_DIR}
-
-cleandocker:
-	# Stops containers and removes containers, networks, volumes, and images created by up
-	docker-compose -f docker/docker-compose.yml down --rmi all -v --remove-orphans
-
-ifdef pv
-	# Remove unused volumes
-	docker volume ls -f name=$(MF_DOCKER_IMAGE_NAME_PREFIX) -f dangling=true -q | xargs -r docker volume rm
-endif
-
-install:
-	cp ${BUILD_DIR}/* $(GOBIN)
-
-test:
-	go test -mod=vendor -v -race -count 1 -tags test $(shell go list ./... | grep -v 'vendor\|cmd')
-
 $(SERVICES):
-	$(call compile_service,$(@))
+	$(call compile_service,$@)
 
-$(DOCKERS):
-	$(call make_docker,$(@),$(GOARCH))
+$(BACKEND_INFO):
+	$(MAKE) -C ./scripts/backend_info
 
-$(DOCKERS_DEV):
-	$(call make_docker_dev,$(@))
+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
 
-dockers: $(DOCKERS)
-dockers_dev: $(DOCKERS_DEV)
-
-run:
-	docker-compose -f docker/docker-compose.yml up
+mocks:
+	go generate ./...

README.md

@@ -7,62 +7,55 @@ 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 algorithms.
+while guaranteeing the privacy and security of the data and the algorithm.
 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.
 
-## Install
-The following prerequisites are needed to run Cocos:
+## Features
 
-- [Docker](https://docs.docker.com/install/)
-- [Docker compose](https://docs.docker.com/compose/install/)
+Cocos AI is implementing the following features:
 
-### Build Docker Images
-Currenty, there is no Docker registry, so Cocos images must be built by hand:
-```
-make dockers
-```
-
-For this you might be needing to setup DNS servers in your `/etc/resolf.conf` as explained
-[here](https://github.com/docker/cli/issues/2618) (i.e. add Google's `nameserver 8.8.8.8`).
-
-### Run Composition
-
-Once the images are built (`docker images` command should show you `cocos/computations` and `cocos/datasets`),
-composition can be run:
-
-```bash
-docker-compose -f docker/docker-compose.yml up
-```
-
-This will bring up the Cocos docker services and interconnect them. This command can also be executed using the project's included Makefile:
-
-```bash
-make run
-```
+- 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
 
-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:
+Clone the repo and create binaries:
 
 ```bash
-make cli
-./build/cocos-cli version
+git clone git@github.com:ultravioletrs/cocos.git
+make
 ```
 
-Additional details on using the CLI can be found in the [CLI documentation](https://docs.mainflux.io/cli).
+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.
 
 ## Documentation
 
-Official documentation is hosted at [Cocos official docs page][docs]. Documentation is auto-generated, checkout the instructions on [official docs repository](https://github.com/cocos/docs).
+Project documentation is hosted at [Cocos AI official docs page][docs].
+
+Documentation is generated from the [docs repository](https://github.com/ultravioletrs/docs).
 
 ## License
-Cocos AI is a proprietary product created by Ultraviolet company.
+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/ultraviolet/cocos/releases
+[rel]: https://github.com/ultravioletrs/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

agent/README.md

@@ -0,0 +1,39 @@
+# Agent
+
+Agent service provides a barebones HTTP and gRPC API and Service interface implementation for the development of the agent service.
+
+## Configuration
+
+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                        |
+| ----------------------------- | ------------------------------------------------------ | ------------------------------ |
+| AGENT_LOG_LEVEL               | Log level for agent service (debug, info, warn, error) | info                           |
+| AGENT_GRPC_HOST               | Agent service gRPC host                                | ""                             |
+| AGENT_GRPC_PORT               | Agent service gRPC port                                | 7002                           |
+| AGENT_GRPC_SERVER_CERT        | Path to gRPC server certificate in pem format          | ""                             |
+| 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                     | ""                             |
+
+
+## Deployment
+
+To start the service outside of the container, execute the following shell script:
+
+```bash
+# Download the latest version of the service
+git clone git@github.com:ultravioletrs/cocos.git
+
+cd cocos
+
+# Compile the service
+make agent
+
+# Run the service
+./build/cocos-agent
+```
+
+## Usage
+
+For more information about service capabilities and its usage, please check out the [README documentation](../README.md).

agent/agent.pb.go

@@ -0,0 +1,596 @@
+// Copyright (c) Ultraviolet
+// SPDX-License-Identifier: Apache-2.0
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.34.2
+// 	protoc        v5.27.2
+// source: agent/agent.proto
+
+package agent
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+type AlgoRequest struct {
+	state         protoimpl.MessageState
+	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"`
+}
+
+func (x *AlgoRequest) Reset() {
+	*x = AlgoRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_agent_agent_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *AlgoRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AlgoRequest) ProtoMessage() {}
+
+func (x *AlgoRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_agent_agent_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use AlgoRequest.ProtoReflect.Descriptor instead.
+func (*AlgoRequest) Descriptor() ([]byte, []int) {
+	return file_agent_agent_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *AlgoRequest) GetAlgorithm() []byte {
+	if x != nil {
+		return x.Algorithm
+	}
+	return nil
+}
+
+func (x *AlgoRequest) GetRequirements() []byte {
+	if x != nil {
+		return x.Requirements
+	}
+	return nil
+}
+
+type AlgoResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *AlgoResponse) Reset() {
+	*x = AlgoResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_agent_agent_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *AlgoResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AlgoResponse) ProtoMessage() {}
+
+func (x *AlgoResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_agent_agent_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use AlgoResponse.ProtoReflect.Descriptor instead.
+func (*AlgoResponse) Descriptor() ([]byte, []int) {
+	return file_agent_agent_proto_rawDescGZIP(), []int{1}
+}
+
+type DataRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	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"`
+}
+
+func (x *DataRequest) Reset() {
+	*x = DataRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_agent_agent_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *DataRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DataRequest) ProtoMessage() {}
+
+func (x *DataRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_agent_agent_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use DataRequest.ProtoReflect.Descriptor instead.
+func (*DataRequest) Descriptor() ([]byte, []int) {
+	return file_agent_agent_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *DataRequest) GetDataset() []byte {
+	if x != nil {
+		return x.Dataset
+	}
+	return nil
+}
+
+func (x *DataRequest) GetFilename() string {
+	if x != nil {
+		return x.Filename
+	}
+	return ""
+}
+
+type DataResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *DataResponse) Reset() {
+	*x = DataResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_agent_agent_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *DataResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DataResponse) ProtoMessage() {}
+
+func (x *DataResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_agent_agent_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use DataResponse.ProtoReflect.Descriptor instead.
+func (*DataResponse) Descriptor() ([]byte, []int) {
+	return file_agent_agent_proto_rawDescGZIP(), []int{3}
+}
+
+type ResultRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *ResultRequest) Reset() {
+	*x = ResultRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_agent_agent_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ResultRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ResultRequest) ProtoMessage() {}
+
+func (x *ResultRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_agent_agent_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ResultRequest.ProtoReflect.Descriptor instead.
+func (*ResultRequest) Descriptor() ([]byte, []int) {
+	return file_agent_agent_proto_rawDescGZIP(), []int{4}
+}
+
+type ResultResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	File []byte `protobuf:"bytes,1,opt,name=file,proto3" json:"file,omitempty"`
+}
+
+func (x *ResultResponse) Reset() {
+	*x = ResultResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_agent_agent_proto_msgTypes[5]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ResultResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ResultResponse) ProtoMessage() {}
+
+func (x *ResultResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_agent_agent_proto_msgTypes[5]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ResultResponse.ProtoReflect.Descriptor instead.
+func (*ResultResponse) Descriptor() ([]byte, []int) {
+	return file_agent_agent_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *ResultResponse) GetFile() []byte {
+	if x != nil {
+		return x.File
+	}
+	return nil
+}
+
+type AttestationRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	ReportData []byte `protobuf:"bytes,1,opt,name=report_data,json=reportData,proto3" json:"report_data,omitempty"` // Should be of length 64.
+}
+
+func (x *AttestationRequest) Reset() {
+	*x = AttestationRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_agent_agent_proto_msgTypes[6]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *AttestationRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AttestationRequest) ProtoMessage() {}
+
+func (x *AttestationRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_agent_agent_proto_msgTypes[6]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use AttestationRequest.ProtoReflect.Descriptor instead.
+func (*AttestationRequest) Descriptor() ([]byte, []int) {
+	return file_agent_agent_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *AttestationRequest) GetReportData() []byte {
+	if x != nil {
+		return x.ReportData
+	}
+	return nil
+}
+
+type AttestationResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	File []byte `protobuf:"bytes,1,opt,name=file,proto3" json:"file,omitempty"`
+}
+
+func (x *AttestationResponse) Reset() {
+	*x = AttestationResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_agent_agent_proto_msgTypes[7]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *AttestationResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AttestationResponse) ProtoMessage() {}
+
+func (x *AttestationResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_agent_agent_proto_msgTypes[7]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use AttestationResponse.ProtoReflect.Descriptor instead.
+func (*AttestationResponse) Descriptor() ([]byte, []int) {
+	return file_agent_agent_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *AttestationResponse) GetFile() []byte {
+	if x != nil {
+		return x.File
+	}
+	return nil
+}
+
+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,
+	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,
+	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,
+}
+
+var (
+	file_agent_agent_proto_rawDescOnce sync.Once
+	file_agent_agent_proto_rawDescData = file_agent_agent_proto_rawDesc
+)
+
+func file_agent_agent_proto_rawDescGZIP() []byte {
+	file_agent_agent_proto_rawDescOnce.Do(func() {
+		file_agent_agent_proto_rawDescData = protoimpl.X.CompressGZIP(file_agent_agent_proto_rawDescData)
+	})
+	return file_agent_agent_proto_rawDescData
+}
+
+var file_agent_agent_proto_msgTypes = make([]protoimpl.MessageInfo, 8)
+var file_agent_agent_proto_goTypes = []any{
+	(*AlgoRequest)(nil),         // 0: agent.AlgoRequest
+	(*AlgoResponse)(nil),        // 1: agent.AlgoResponse
+	(*DataRequest)(nil),         // 2: agent.DataRequest
+	(*DataResponse)(nil),        // 3: agent.DataResponse
+	(*ResultRequest)(nil),       // 4: agent.ResultRequest
+	(*ResultResponse)(nil),      // 5: agent.ResultResponse
+	(*AttestationRequest)(nil),  // 6: agent.AttestationRequest
+	(*AttestationResponse)(nil), // 7: agent.AttestationResponse
+}
+var file_agent_agent_proto_depIdxs = []int32{
+	0, // 0: agent.AgentService.Algo:input_type -> agent.AlgoRequest
+	2, // 1: agent.AgentService.Data:input_type -> agent.DataRequest
+	4, // 2: agent.AgentService.Result:input_type -> agent.ResultRequest
+	6, // 3: agent.AgentService.Attestation:input_type -> agent.AttestationRequest
+	1, // 4: agent.AgentService.Algo:output_type -> agent.AlgoResponse
+	3, // 5: agent.AgentService.Data:output_type -> agent.DataResponse
+	5, // 6: agent.AgentService.Result:output_type -> agent.ResultResponse
+	7, // 7: agent.AgentService.Attestation:output_type -> agent.AttestationResponse
+	4, // [4:8] is the sub-list for method output_type
+	0, // [0:4] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_agent_agent_proto_init() }
+func file_agent_agent_proto_init() {
+	if File_agent_agent_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_agent_agent_proto_msgTypes[0].Exporter = func(v any, i int) any {
+			switch v := v.(*AlgoRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_agent_agent_proto_msgTypes[1].Exporter = func(v any, i int) any {
+			switch v := v.(*AlgoResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_agent_agent_proto_msgTypes[2].Exporter = func(v any, i int) any {
+			switch v := v.(*DataRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_agent_agent_proto_msgTypes[3].Exporter = func(v any, i int) any {
+			switch v := v.(*DataResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_agent_agent_proto_msgTypes[4].Exporter = func(v any, i int) any {
+			switch v := v.(*ResultRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_agent_agent_proto_msgTypes[5].Exporter = func(v any, i int) any {
+			switch v := v.(*ResultResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_agent_agent_proto_msgTypes[6].Exporter = func(v any, i int) any {
+			switch v := v.(*AttestationRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_agent_agent_proto_msgTypes[7].Exporter = func(v any, i int) any {
+			switch v := v.(*AttestationResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_agent_agent_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   8,
+			NumExtensions: 0,
+			NumServices:   1,
+		},
+		GoTypes:           file_agent_agent_proto_goTypes,
+		DependencyIndexes: file_agent_agent_proto_depIdxs,
+		MessageInfos:      file_agent_agent_proto_msgTypes,
+	}.Build()
+	File_agent_agent_proto = out.File
+	file_agent_agent_proto_rawDesc = nil
+	file_agent_agent_proto_goTypes = nil
+	file_agent_agent_proto_depIdxs = nil
+}

agent/agent.proto

@@ -0,0 +1,44 @@
+// Copyright (c) Ultraviolet
+// SPDX-License-Identifier: Apache-2.0
+
+syntax = "proto3";
+
+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 Attestation(AttestationRequest) returns (AttestationResponse) {}
+}
+
+message AlgoRequest {
+  bytes algorithm = 1;
+  bytes requirements = 2;
+}
+
+message AlgoResponse {}
+
+message DataRequest {
+  bytes dataset = 1;
+  string filename = 2;
+}
+
+message DataResponse {}
+
+message ResultRequest {
+}
+
+message ResultResponse {
+  bytes file = 1;
+}
+
+message AttestationRequest {
+  bytes report_data = 1; // Should be of length 64.
+}
+
+message AttestationResponse {
+  bytes file = 1;
+}

agent/agent_grpc.pb.go

@@ -0,0 +1,323 @@
+// Copyright (c) Ultraviolet
+// SPDX-License-Identifier: Apache-2.0
+
+// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+// versions:
+// - protoc-gen-go-grpc v1.4.0
+// - protoc             v5.27.2
+// source: agent/agent.proto
+
+package agent
+
+import (
+	context "context"
+	grpc "google.golang.org/grpc"
+	codes "google.golang.org/grpc/codes"
+	status "google.golang.org/grpc/status"
+)
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+// Requires gRPC-Go v1.62.0 or later.
+const _ = grpc.SupportPackageIsVersion8
+
+const (
+	AgentService_Algo_FullMethodName        = "/agent.AgentService/Algo"
+	AgentService_Data_FullMethodName        = "/agent.AgentService/Data"
+	AgentService_Result_FullMethodName      = "/agent.AgentService/Result"
+	AgentService_Attestation_FullMethodName = "/agent.AgentService/Attestation"
+)
+
+// AgentServiceClient is the client API for AgentService service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type 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)
+	Attestation(ctx context.Context, in *AttestationRequest, opts ...grpc.CallOption) (*AttestationResponse, error)
+}
+
+type agentServiceClient struct {
+	cc grpc.ClientConnInterface
+}
+
+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...)
+	if err != nil {
+		return nil, err
+	}
+	x := &agentServiceAlgoClient{ClientStream: stream}
+	return x, 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...)
+	if err != nil {
+		return nil, err
+	}
+	x := &agentServiceDataClient{ClientStream: stream}
+	return x, 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...)
+	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
+}
+
+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...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// AgentServiceServer is the server API for AgentService service.
+// All implementations must embed UnimplementedAgentServiceServer
+// for forward compatibility
+type AgentServiceServer interface {
+	Algo(AgentService_AlgoServer) error
+	Data(AgentService_DataServer) error
+	Result(*ResultRequest, AgentService_ResultServer) error
+	Attestation(context.Context, *AttestationRequest) (*AttestationResponse, error)
+	mustEmbedUnimplementedAgentServiceServer()
+}
+
+// UnimplementedAgentServiceServer must be embedded to have forward compatible implementations.
+type UnimplementedAgentServiceServer struct {
+}
+
+func (UnimplementedAgentServiceServer) Algo(AgentService_AlgoServer) error {
+	return 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) Result(*ResultRequest, AgentService_ResultServer) error {
+	return 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")
+}
+func (UnimplementedAgentServiceServer) mustEmbedUnimplementedAgentServiceServer() {}
+
+// UnsafeAgentServiceServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to AgentServiceServer will
+// result in compilation errors.
+type UnsafeAgentServiceServer interface {
+	mustEmbedUnimplementedAgentServiceServer()
+}
+
+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 {
+		return nil, err
+	}
+	return m, nil
+}
+
+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 {
+		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
+	}
+	return srv.(AgentServiceServer).Result(m, &agentServiceResultServer{ServerStream: stream})
+}
+
+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_Attestation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AttestationRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(AgentServiceServer).Attestation(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: AgentService_Attestation_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(AgentServiceServer).Attestation(ctx, req.(*AttestationRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+// AgentService_ServiceDesc is the grpc.ServiceDesc for AgentService service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var AgentService_ServiceDesc = grpc.ServiceDesc{
+	ServiceName: "agent.AgentService",
+	HandlerType: (*AgentServiceServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			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,
+		},
+	},
+	Metadata: "agent/agent.proto",
+}

agent/algorithm/algorithm.go

@@ -0,0 +1,49 @@
+// 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

@@ -0,0 +1,47 @@
+// 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

@@ -0,0 +1,170 @@
+// 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

@@ -0,0 +1,73 @@
+// 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

@@ -0,0 +1,85 @@
+// 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

@@ -0,0 +1,97 @@
+// 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

@@ -0,0 +1,82 @@
+// 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

@@ -0,0 +1,53 @@
+// 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/doc.go

@@ -0,0 +1,6 @@
+// Copyright (c) Ultraviolet
+// SPDX-License-Identifier: Apache-2.0
+
+// Package api contains API-related concerns: endpoint definitions, middlewares
+// and all resource representations.
+package api

agent/api/grpc/doc.go

@@ -0,0 +1,5 @@
+// Copyright (c) Ultraviolet
+// SPDX-License-Identifier: Apache-2.0
+
+// Package grpc contains implementation of kit service gRPC API.
+package grpc

agent/api/grpc/endpoint.go

@@ -0,0 +1,80 @@
+// Copyright (c) Ultraviolet
+// SPDX-License-Identifier: Apache-2.0
+package grpc
+
+import (
+	"context"
+
+	"github.com/go-kit/kit/endpoint"
+	"github.com/ultravioletrs/cocos/agent"
+)
+
+func algoEndpoint(svc agent.Service) endpoint.Endpoint {
+	return func(ctx context.Context, request interface{}) (interface{}, error) {
+		req := request.(algoReq)
+
+		if err := req.validate(); err != nil {
+			return algoRes{}, err
+		}
+
+		algo := agent.Algorithm{Algorithm: req.Algorithm, Requirements: req.Requirements}
+
+		err := svc.Algo(ctx, algo)
+		if err != nil {
+			return algoRes{}, err
+		}
+
+		return algoRes{}, nil
+	}
+}
+
+func dataEndpoint(svc agent.Service) endpoint.Endpoint {
+	return func(ctx context.Context, request interface{}) (interface{}, error) {
+		req := request.(dataReq)
+
+		if err := req.validate(); err != nil {
+			return dataRes{}, err
+		}
+
+		dataset := agent.Dataset{Dataset: req.Dataset, Filename: req.Filename}
+
+		err := svc.Data(ctx, dataset)
+		if err != nil {
+			return dataRes{}, err
+		}
+
+		return dataRes{}, nil
+	}
+}
+
+func resultEndpoint(svc agent.Service) endpoint.Endpoint {
+	return func(ctx context.Context, request interface{}) (interface{}, error) {
+		req := request.(resultReq)
+
+		if err := req.validate(); err != nil {
+			return resultRes{}, err
+		}
+		file, err := svc.Result(ctx)
+		if err != nil {
+			return resultRes{}, err
+		}
+
+		return resultRes{File: file}, nil
+	}
+}
+
+func attestationEndpoint(svc agent.Service) endpoint.Endpoint {
+	return func(ctx context.Context, request interface{}) (interface{}, error) {
+		req := request.(attestationReq)
+
+		if err := req.validate(); err != nil {
+			return attestationRes{}, err
+		}
+		file, err := svc.Attestation(ctx, req.ReportData)
+		if err != nil {
+			return attestationRes{}, err
+		}
+
+		return attestationRes{File: file}, nil
+	}
+}

agent/api/grpc/interceptors.go

@@ -0,0 +1,74 @@
+// 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

@@ -0,0 +1,152 @@
+// 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

@@ -0,0 +1,46 @@
+// Copyright (c) Ultraviolet
+// SPDX-License-Identifier: Apache-2.0
+package grpc
+
+import (
+	"errors"
+)
+
+type algoReq struct {
+	Algorithm    []byte `protobuf:"bytes,1,opt,name=algorithm,proto3" json:"algorithm,omitempty"`
+	Requirements []byte
+}
+
+func (req algoReq) validate() error {
+	if len(req.Algorithm) == 0 {
+		return errors.New("algorithm binary is required")
+	}
+	return nil
+}
+
+type dataReq struct {
+	Dataset  []byte `protobuf:"bytes,1,opt,name=dataset,proto3" json:"dataset,omitempty"`
+	Filename string
+}
+
+func (req dataReq) validate() error {
+	if len(req.Dataset) == 0 {
+		return errors.New("dataset CSV file is required")
+	}
+	return nil
+}
+
+type resultReq struct{}
+
+func (req resultReq) validate() error {
+	// No request parameters to validate, so no validation logic needed
+	return nil
+}
+
+type attestationReq struct {
+	ReportData [64]byte
+}
+
+func (req attestationReq) validate() error {
+	return nil
+}

agent/api/grpc/responses.go

@@ -0,0 +1,15 @@
+// Copyright (c) Ultraviolet
+// SPDX-License-Identifier: Apache-2.0
+package grpc
+
+type algoRes struct{}
+
+type dataRes struct{}
+
+type resultRes struct {
+	File []byte `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
+}
+
+type attestationRes struct {
+	File []byte
+}

agent/api/grpc/server.go

@@ -0,0 +1,187 @@
+// Copyright (c) Ultraviolet
+// SPDX-License-Identifier: Apache-2.0
+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
+	result      grpc.Handler
+	attestation grpc.Handler
+	agent.UnimplementedAgentServiceServer
+}
+
+// NewServer returns new AgentServiceServer instance.
+func NewServer(svc agent.Service) agent.AgentServiceServer {
+	return &grpcServer{
+		algo: grpc.NewServer(
+			algoEndpoint(svc),
+			decodeAlgoRequest,
+			encodeAlgoResponse,
+		),
+		data: grpc.NewServer(
+			dataEndpoint(svc),
+			decodeDataRequest,
+			encodeDataResponse,
+		),
+		result: grpc.NewServer(
+			resultEndpoint(svc),
+			decodeResultRequest,
+			encodeResultResponse,
+		),
+		attestation: grpc.NewServer(
+			attestationEndpoint(svc),
+			decodeAttestationRequest,
+			encodeAttestationResponse,
+		),
+	}
+}
+
+func decodeAlgoRequest(_ context.Context, grpcReq interface{}) (interface{}, error) {
+	req := grpcReq.(*agent.AlgoRequest)
+
+	return algoReq{
+		Algorithm:    req.Algorithm,
+		Requirements: req.Requirements,
+	}, nil
+}
+
+func encodeAlgoResponse(_ context.Context, response interface{}) (interface{}, error) {
+	return &agent.AlgoResponse{}, nil
+}
+
+func decodeDataRequest(_ context.Context, grpcReq interface{}) (interface{}, error) {
+	req := grpcReq.(*agent.DataRequest)
+
+	return dataReq{
+		Dataset:  req.Dataset,
+		Filename: req.Filename,
+	}, nil
+}
+
+func encodeDataResponse(_ context.Context, response interface{}) (interface{}, error) {
+	return &agent.DataResponse{}, nil
+}
+
+func decodeResultRequest(_ context.Context, grpcReq interface{}) (interface{}, error) {
+	return resultReq{}, nil
+}
+
+func encodeResultResponse(_ context.Context, response interface{}) (interface{}, error) {
+	res := response.(resultRes)
+	return &agent.ResultResponse{
+		File: res.File,
+	}, nil
+}
+
+func decodeAttestationRequest(_ context.Context, grpcReq interface{}) (interface{}, error) {
+	req := grpcReq.(*agent.AttestationRequest)
+	if len(req.ReportData) != agent.ReportDataSize {
+		return nil, errors.New("malformed report data, expect 64 bytes")
+	}
+	return attestationReq{ReportData: [agent.ReportDataSize]byte(req.ReportData)}, nil
+}
+
+func encodeAttestationResponse(_ context.Context, response interface{}) (interface{}, error) {
+	res := response.(attestationRes)
+	return &agent.AttestationResponse{
+		File: res.File,
+	}, 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})
+	if err != nil {
+		return err
+	}
+	ar := res.(*agent.AlgoResponse)
+	return stream.SendAndClose(ar)
+}
+
+// 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})
+	if err != nil {
+		return err
+	}
+	ar := res.(*agent.DataResponse)
+	return stream.SendAndClose(ar)
+}
+
+func (s *grpcServer) Result(req *agent.ResultRequest, stream agent.AgentService_ResultServer) error {
+	_, res, err := s.result.ServeGRPC(stream.Context(), req)
+	if err != nil {
+		return 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
+}
+
+func (s *grpcServer) Attestation(ctx context.Context, req *agent.AttestationRequest) (*agent.AttestationResponse, error) {
+	_, res, err := s.attestation.ServeGRPC(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+	rr := res.(*agent.AttestationResponse)
+	return rr, nil
+}

agent/api/logging.go

@@ -0,0 +1,80 @@
+// Copyright (c) Ultraviolet
+// SPDX-License-Identifier: Apache-2.0
+
+//go:build !test
+// +build !test
+
+package api
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+	"time"
+
+	"github.com/ultravioletrs/cocos/agent"
+)
+
+var _ agent.Service = (*loggingMiddleware)(nil)
+
+type loggingMiddleware struct {
+	logger *slog.Logger
+	svc    agent.Service
+}
+
+// LoggingMiddleware adds logging facilities to the core service.
+func LoggingMiddleware(svc agent.Service, logger *slog.Logger) agent.Service {
+	return &loggingMiddleware{logger, svc}
+}
+
+func (lm *loggingMiddleware) Algo(ctx context.Context, algorithm agent.Algorithm) (err error) {
+	defer func(begin time.Time) {
+		message := fmt.Sprintf("Method Algo 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(fmt.Sprintf("%s without errors", message))
+	}(time.Now())
+
+	return lm.svc.Algo(ctx, algorithm)
+}
+
+func (lm *loggingMiddleware) Data(ctx context.Context, dataset agent.Dataset) (err error) {
+	defer func(begin time.Time) {
+		message := fmt.Sprintf("Method Data 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(fmt.Sprintf("%s without errors", message))
+	}(time.Now())
+
+	return lm.svc.Data(ctx, dataset)
+}
+
+func (lm *loggingMiddleware) Result(ctx context.Context) (response []byte, err error) {
+	defer func(begin time.Time) {
+		message := fmt.Sprintf("Method Result 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(fmt.Sprintf("%s without errors", message))
+	}(time.Now())
+
+	return lm.svc.Result(ctx)
+}
+
+func (lm *loggingMiddleware) Attestation(ctx context.Context, reportData [agent.ReportDataSize]byte) (response []byte, err error) {
+	defer func(begin time.Time) {
+		message := fmt.Sprintf("Method Attestation 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(fmt.Sprintf("%s without errors", message))
+	}(time.Now())
+
+	return lm.svc.Attestation(ctx, reportData)
+}

agent/api/metrics.go

@@ -0,0 +1,69 @@
+// Copyright (c) Ultraviolet
+// SPDX-License-Identifier: Apache-2.0
+
+//go:build !test
+// +build !test
+
+package api
+
+import (
+	"context"
+	"time"
+
+	"github.com/go-kit/kit/metrics"
+	"github.com/ultravioletrs/cocos/agent"
+)
+
+var _ agent.Service = (*metricsMiddleware)(nil)
+
+type metricsMiddleware struct {
+	counter metrics.Counter
+	latency metrics.Histogram
+	svc     agent.Service
+}
+
+// MetricsMiddleware instruments core service by tracking request count and
+// latency.
+func MetricsMiddleware(svc agent.Service, counter metrics.Counter, latency metrics.Histogram) agent.Service {
+	return &metricsMiddleware{
+		counter: counter,
+		latency: latency,
+		svc:     svc,
+	}
+}
+
+func (ms *metricsMiddleware) Algo(ctx context.Context, algorithm agent.Algorithm) error {
+	defer func(begin time.Time) {
+		ms.counter.With("method", "algo").Add(1)
+		ms.latency.With("method", "algo").Observe(time.Since(begin).Seconds())
+	}(time.Now())
+
+	return ms.svc.Algo(ctx, algorithm)
+}
+
+func (ms *metricsMiddleware) Data(ctx context.Context, dataset agent.Dataset) error {
+	defer func(begin time.Time) {
+		ms.counter.With("method", "data").Add(1)
+		ms.latency.With("method", "data").Observe(time.Since(begin).Seconds())
+	}(time.Now())
+
+	return ms.svc.Data(ctx, dataset)
+}
+
+func (ms *metricsMiddleware) Result(ctx context.Context) ([]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)
+}
+
+func (ms *metricsMiddleware) Attestation(ctx context.Context, reportData [agent.ReportDataSize]byte) ([]byte, error) {
+	defer func(begin time.Time) {
+		ms.counter.With("method", "attestation").Add(1)
+		ms.latency.With("method", "attestation").Observe(time.Since(begin).Seconds())
+	}(time.Now())
+
+	return ms.svc.Attestation(ctx, reportData)
+}

agent/auth/auth.go

@@ -0,0 +1,174 @@
+// 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

@@ -0,0 +1,158 @@
+// 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

@@ -0,0 +1,88 @@
+// Copyright (c) Ultraviolet
+// SPDX-License-Identifier: Apache-2.0
+package agent
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"google.golang.org/grpc/metadata"
+)
+
+var _ fmt.Stringer = (*Datasets)(nil)
+
+type AgentConfig struct {
+	LogLevel     string `json:"log_level"`
+	Host         string `json:"host"`
+	Port         string `json:"port"`
+	CertFile     string `json:"cert_file"`
+	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"`
+}
+
+func (d *Datasets) String() string {
+	dat, err := json.Marshal(d)
+	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"`
+}
+
+type Datasets []Dataset
+
+type Algorithm struct {
+	Algorithm    []byte   `json:"-"`
+	Hash         [32]byte `json:"hash,omitempty"`
+	UserKey      []byte   `json:"user_key,omitempty"`
+	Requirements []byte   `json:"-"`
+}
+
+type ManifestIndexKey struct{}
+
+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
+	}
+
+	return vals[0] == "true"
+}
+
+func DecompressToContext(ctx context.Context, decompress bool) context.Context {
+	return metadata.AppendToOutgoingContext(ctx, DecompressKey, fmt.Sprintf("%t", decompress))
+}

agent/doc.go

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

agent/events/events.go

@@ -0,0 +1,69 @@
+// Copyright (c) Ultraviolet
+// SPDX-License-Identifier: Apache-2.0
+package events
+
+import (
+	"encoding/json"
+	"time"
+
+	"github.com/mdlayher/vsock"
+	"github.com/ultravioletrs/cocos/pkg/manager"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/types/known/timestamppb"
+)
+
+type service struct {
+	service       string
+	computationID string
+	conn          *vsock.Conn
+}
+
+type AgentEvent struct {
+	EventType     string          `json:"event_type"`
+	Timestamp     time.Time       `json:"timestamp"`
+	ComputationID string          `json:"computation_id,omitempty"`
+	Details       json.RawMessage `json:"details,omitempty"`
+	Originator    string          `json:"originator"`
+	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
+}
+
+func New(svc, computationID string, sockPort uint32) (Service, error) {
+	conn, err := vsock.Dial(vsock.Host, sockPort, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &service{
+		service:       svc,
+		computationID: computationID,
+		conn:          conn,
+	}, nil
+}
+
+func (s *service) SendEvent(event, status string, details json.RawMessage) error {
+	body := manager.ClientStreamMessage{Message: &manager.ClientStreamMessage_AgentEvent{AgentEvent: &manager.AgentEvent{
+		EventType:     event,
+		Timestamp:     timestamppb.Now(),
+		ComputationId: s.computationID,
+		Originator:    s.service,
+		Status:        status,
+		Details:       details,
+	}}}
+	protoBody, err := proto.Marshal(&body)
+	if err != nil {
+		return err
+	}
+	if _, err := s.conn.Write(protoBody); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (s *service) Close() error {
+	return s.conn.Close()
+}

agent/events/mocks/events.go

@@ -0,0 +1,67 @@
+// 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

@@ -0,0 +1,129 @@
+// 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

@@ -0,0 +1,63 @@
+// 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

@@ -0,0 +1,38 @@
+// 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

@@ -0,0 +1,13 @@
+// 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

@@ -0,0 +1,325 @@
+// Copyright (c) Ultraviolet
+// SPDX-License-Identifier: Apache-2.0
+
+package agent
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"log/slog"
+	"os"
+	"path/filepath"
+	"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"
+	"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
+)
+
+var (
+	// ErrMalformedEntity indicates malformed entity specification (e.g.
+	// invalid username or password).
+	ErrMalformedEntity = errors.New("malformed entity specification")
+	// 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")
+)
+
+// 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)
+	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.
+}
+
+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 {
+	svc := &agentService{
+		sm:            NewStateMachine(logger, cmp),
+		eventSvc:      eventSvc,
+		quoteProvider: quoteProvider,
+	}
+
+	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[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)
+	return svc
+}
+
+func (as *agentService) Algo(ctx context.Context, algo Algorithm) error {
+	if as.sm.GetState() != receivingAlgorithm {
+		return ErrStateNotReady
+	}
+	if as.algorithm != nil {
+		return ErrAllManifestItemsReceived
+	}
+
+	hash := sha3.Sum256(algo.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()
+		}
+		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 err := os.Mkdir(algorithm.DatasetsDir, 0o755); err != nil {
+		return fmt.Errorf("error creating datasets directory: %v", err)
+	}
+
+	if as.algorithm != nil {
+		as.sm.SendEvent(algorithmReceived)
+	}
+
+	return nil
+}
+
+func (as *agentService) Data(ctx context.Context, dataset Dataset) error {
+	if as.sm.GetState() != receivingData {
+		return ErrStateNotReady
+	}
+	if len(as.computation.Datasets) == 0 {
+		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
+		}
+	}
+
+	if !matched {
+		return ErrUndeclaredDataset
+	}
+
+	if len(as.computation.Datasets) == 0 {
+		as.sm.SendEvent(dataReceived)
+	}
+
+	return nil
+}
+
+func (as *agentService) Result(ctx context.Context) ([]byte, error) {
+	if as.sm.GetState() != resultsReady && as.sm.GetState() != failed {
+		return []byte{}, ErrResultsNotReady
+	}
+	if len(as.computation.ResultConsumers) == 0 {
+		return []byte{}, ErrAllResultsConsumed
+	}
+	index, ok := IndexFromContext(ctx)
+	if !ok {
+		return []byte{}, ErrUndeclaredConsumer
+	}
+	as.computation.ResultConsumers = slices.Delete(as.computation.ResultConsumers, index, index+1)
+
+	if len(as.computation.ResultConsumers) == 0 && as.sm.GetState() == resultsReady {
+		as.sm.SendEvent(resultsConsumed)
+	}
+
+	return as.result, as.runError
+}
+
+func (as *agentService) Attestation(ctx context.Context, reportData [ReportDataSize]byte) ([]byte, error) {
+	rawQuote, err := as.quoteProvider.GetRawQuote(reportData)
+	if err != nil {
+		return []byte{}, err
+	}
+
+	return rawQuote, nil
+}
+
+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()))
+		}
+	}()
+
+	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)
+	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
+}
+
+func (as *agentService) publishEvent(status string, details json.RawMessage) func() {
+	return func() {
+		if err := as.eventSvc.SendEvent(as.sm.State.String(), status, details); err != nil {
+			as.sm.logger.Warn(err.Error())
+		}
+	}
+}

agent/state.go

@@ -0,0 +1,131 @@
+// Copyright (c) Ultraviolet
+// SPDX-License-Identifier: Apache-2.0
+package agent
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+	"sync"
+)
+
+//go:generate stringer -type=state
+type state uint8
+
+const (
+	idle state = iota
+	receivingManifest
+	receivingAlgorithm
+	receivingData
+	running
+	resultsReady
+	complete
+	failed
+)
+
+type event uint8
+
+const (
+	start event = iota
+	manifestReceived
+	algorithmReceived
+	dataReceived
+	runComplete
+	resultsConsumed
+	runFailed
+)
+
+// StateMachine represents the state machine.
+type StateMachine struct {
+	mu             sync.Mutex
+	State          state
+	EventChan      chan event
+	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 {
+	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[receivingManifest] = make(map[event]state)
+	sm.Transitions[receivingManifest][manifestReceived] = receivingAlgorithm
+
+	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[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
+
+	return sm
+}
+
+// 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]
+			if valid {
+				sm.State = nextState
+				sm.logger.Debug(fmt.Sprintf("Transition: %v -> %v\n", sm.State, nextState))
+			} else {
+				sm.logger.Error(fmt.Sprintf("Invalid transition: %v -> ???\n", sm.State))
+			}
+			sm.mu.Unlock()
+
+			sm.mu.Lock()
+			stateFunc, exists := sm.StateFunctions[sm.State]
+			sm.mu.Unlock()
+			if exists {
+				go stateFunc()
+			}
+		case <-ctx.Done():
+			return
+		}
+	}
+}
+
+// SendEvent sends an event to the state machine.
+func (sm *StateMachine) SendEvent(event event) {
+	sm.EventChan <- event
+}
+
+func (sm *StateMachine) GetState() state {
+	sm.mu.Lock()
+	defer sm.mu.Unlock()
+	return sm.State
+}
+
+func (sm *StateMachine) SetState(state state) {
+	sm.mu.Lock()
+	defer sm.mu.Unlock()
+	sm.State = state
+}

agent/state_string.go

@@ -0,0 +1,30 @@
+// Code generated by "stringer -type=state"; DO NOT EDIT.
+
+package agent
+
+import "strconv"
+
+func _() {
+	// An "invalid array index" compiler error signifies that the constant values have changed.
+	// Re-run the stringer command to generate them again.
+	var x [1]struct{}
+	_ = x[idle-0]
+	_ = x[receivingManifest-1]
+	_ = x[receivingAlgorithm-2]
+	_ = x[receivingData-3]
+	_ = x[running-4]
+	_ = x[resultsReady-5]
+	_ = x[complete-6]
+	_ = x[failed-7]
+}
+
+const _state_name = "idlereceivingManifestreceivingAlgorithmreceivingDatarunningresultsReadycompletefailed"
+
+var _state_index = [...]uint8{0, 4, 21, 39, 52, 59, 71, 79, 85}
+
+func (i state) String() string {
+	if 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

@@ -0,0 +1,72 @@
+// Copyright (c) Ultraviolet
+// SPDX-License-Identifier: Apache-2.0
+package agent
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	mglog "github.com/absmach/magistrala/logger"
+)
+
+var cmp = Computation{
+	Datasets: []Dataset{
+		{
+			Dataset: []byte("test"),
+			UserKey: []byte("test"),
+		},
+	},
+}
+
+func TestStateMachineTransitions(t *testing.T) {
+	cases := []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},
+	}
+
+	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)
+			ctx, cancel := context.WithCancel(context.Background())
+			go func() {
+				sm.Start(ctx)
+			}()
+			sm.wg.Wait()
+			sm.SetState(tc.fromState)
+
+			sm.SendEvent(tc.event)
+
+			if sm.GetState() != tc.expected {
+				t.Errorf("Expected state %v after the event, but got %v", tc.expected, sm.GetState())
+			}
+			close(sm.EventChan)
+			cancel()
+		})
+	}
+}
+
+func TestStateMachineInvalidTransition(t *testing.T) {
+	sm := NewStateMachine(mglog.NewMock(), cmp)
+	ctx, cancel := context.WithCancel(context.Background())
+	go sm.Start(ctx)
+
+	sm.SetState(idle)
+
+	sm.SendEvent(dataReceived)
+
+	if sm.State != idle {
+		t.Errorf("State should not change on an invalid event, but got %v", sm.State)
+	}
+	cancel()
+}

api/computations.yml

@@ -1,471 +0,0 @@
-openapi: 3.0.1
-info:
-  title: Computations service
-  description: HTTP API for managing computations
-  version: "1.0.0"
-
-paths:
-  /computations:
-    post:
-      summary: Add new computation
-      description: |
-        Adds new computation to the list of computations owned by user identified using
-        the provided access token.
-      tags:
-        - computations
-      requestBody:
-        $ref: "#/components/requestBodies/ComputationCreateReq"
-      responses:
-        '201':
-          $ref: "#/components/responses/ComputationRes"
-        '400':
-          description: Failed due to malformed JSON.
-        '401':
-          description: Missing or invalid access token provided.
-        '409':
-          description: Entity already exist.
-        '415':
-          description: Missing or invalid content type.
-        '422':
-          description: Database can't process request.
-        '500':
-          $ref: "#/components/responses/ServiceError"
-    get:
-      summary: Retrieves computations
-      description: |
-        Retrieves a list of computations. Due to performance concerns, data
-        is retrieved in subsets. The API user must ensure that the entire
-        dataset is consumed either by making subsequent requests, or by
-        increasing the subset size of the initial request.
-      tags:
-        - computations
-      parameters:
-        - $ref: "#/components/parameters/Limit"
-        - $ref: "#/components/parameters/Offset"
-        - $ref: "#/components/parameters/Name"
-        - $ref: "#/components/parameters/Order"
-        - $ref: "#/components/parameters/Direction"
-        - $ref: "#/components/parameters/Metadata"
-      responses:
-        '200':
-          $ref: "#/components/responses/ComputationsPageRes"
-        '400':
-          description: Failed due to malformed query parameters.
-        '401':
-          description: Missing or invalid access token provided.
-        '404':
-          description: A non-existent entity request.
-        '422':
-          description: Database can't process request.
-        '500':
-          $ref: "#/components/responses/ServiceError"
-  /computations/search:
-    post:
-      summary: Search and retrieves computations
-      description: |
-        Retrieves a list of computations with name and metadata filtering.
-        Due to performance concerns, data is retrieved in subsets.
-        The API user must ensure that the entire
-        dataset is consumed either by making subsequent requests, or by
-        increasing the subset size of the initial request.
-      tags:
-        - computations
-      requestBody:
-        $ref: "#/components/requestBodies/ComputationsSearchReq"
-      responses:
-        '200':
-          $ref: "#/components/responses/ComputationsPageRes"
-        '400':
-          description: Failed due to malformed query parameters.
-        '401':
-          description: Missing or invalid access token provided.
-        '404':
-          description: A non-existent entity request.
-        '422':
-          description: Unprocessable Entity
-        '500':
-          $ref: "#/components/responses/ServiceError"
-  /computations/{Id}:
-    get:
-      summary: Retrieves computation info
-      tags:
-        - computation
-      parameters:
-        - $ref: "#/components/parameters/Id"
-      responses:
-        '200':
-          $ref: "#/components/responses/ComputationRes"
-        '401':
-          description: Missing or invalid access token provided.
-        '404':
-          description: Computation does not exist.
-        '422':
-          description: Database can't process request.
-        '500':
-          $ref: "#/components/responses/ServiceError"
-    put:
-      summary: Updates computation info
-      description: |
-        Update is performed by replacing the current resource data with values
-        provided in a request payload.
-      tags:
-        - computations
-      parameters:
-        - $ref: "#/components/parameters/Id"
-      requestBody:
-        $ref: "#/components/requestBodies/ComputationUpdateReq"
-      responses:
-        '200':
-          description: Computation updated.
-        '400':
-          description: Failed due to malformed JSON.
-        '401':
-          description: Missing or invalid access token provided.
-        '404':
-          description: Computation does not exist.
-        '415':
-          description: Missing or invalid content type.
-        '500':
-          $ref: "#/components/responses/ServiceError"
-    delete:
-      summary: Removes a computation
-      description: |
-        Removes a computation.
-      tags:
-        - computation
-      parameters:
-        - $ref: "#/components/parameters/Id"
-      responses:
-        '204':
-          description: Computation removed.
-        '400':
-          description: Failed due to malformed ID.
-        '401':
-          description: Missing or invalid access token provided.
-        '500':
-          $ref: "#/components/responses/ServiceError"
-  
-components:
-  schemas:
-    Key:
-      type: string
-      format: uuid
-      description: |
-        Computation key that is used for computation auth. If there is
-        not one provided service will generate one in UUID
-        format.
-    Identity:
-      type: object
-      properties:
-        id:
-          type: string
-          format: uuid
-          description: Computation unique identifier. This can be either
-            provided by the user or left blank. If the user provides a UUID,
-            it would be validated. If there is not one provided then
-            the service will generate one in UUID format.
-    ComputationReqSchema:
-      type: object
-      properties:
-        name:
-          type: string
-          description: Free-form name.
-        description:
-          type: string
-          description: Free-form description
-        datasets:
-          type: array
-          description: An array of datasets.
-          minItems: 0
-          uniqueItems: true
-          items:
-            type: string
-        algorithms:
-          type: array
-          description: An array of algorithms.
-          minItems: 1
-          uniqueItems: true
-          items:
-            type: string
-        startTime:
-          type: number
-          description: Start timestamp of the computations
-        endTime:
-          type: number
-          description: End of the computation
-        status:
-          type: string
-          description: Current status of the computation
-        owner:
-          type: string
-          description: ID of the user who started computation
-        datasetProviders:
-          type: array
-          description: List of IDs of users who provided datasets
-          minItems: 0
-          uniqueItems: true
-          items:
-            type: string
-        algorithmProviders:
-          type: array
-          description: List of IDs of users who provided algorithms
-          minItems: 1
-          uniqueItems: true
-          items:
-            type: string
-        ttl:
-          type: number
-          description: Period for computation to live in an inactive state
-        metadata:
-          type: object
-          description: Arbitrary, object-encoded data.
-    ComputationsReqSchema:
-      type: object
-      properties:
-        name:
-          type: string
-          description: Name filter. Filtering is performed as a case-insensitive partial match.
-        metadata:
-          type: object
-          description: Metadata filter. Filtering is performed matching the parameter with metadata on top level. Parameter is json.
-        total:
-          type: integer
-          description: Total number of items.
-        offset:
-          type: integer
-          description: Number of items to skip during retrieval.
-          default: 0
-          minimum: 0
-        limit:
-          type: integer
-          description: Size of the subset to retrieve.
-          default: 10
-          maximum: 100
-          minimum: 1
-        order:
-          type: string
-          description: Order type.
-          default: id
-          enum:
-            - name
-            - id
-        dir:
-          type: string
-          description: Order direction.
-          default: desc
-          enum:
-            - asc
-            - desc
-    ComputationResSchema:
-      type: object
-      properties:
-        id:
-          type: string
-          format: uuid
-          description: Unique identifier generated by the service.
-        name:
-          type: string
-          description: Free-form name.
-        key:
-          type: string
-          format: uuid
-          description: Auto-generated access key.
-        metadata:
-          type: object
-          description: Arbitrary, object-encoded data.
-      required:
-        - id
-        - type
-        - key
-    ComputationsPage:
-      type: object
-      properties:
-        computations:
-          type: array
-          minItems: 0
-          uniqueItems: true
-          items:
-            $ref: "#/components/schemas/ComputationResSchema"
-        total:
-          type: integer
-          description: Total number of items.
-        offset:
-          type: integer
-          description: Number of items to skip during retrieval.
-        limit:
-          type: integer
-          description: Maximum number of items to return in one page.
-      required:
-        - computations
-  parameters:
-    Id:
-      name: Id
-      description: Unique identifier.
-      in: path
-      schema:
-        type: string
-        format: uuid
-      required: true
-    Limit:
-      name: limit
-      description: Size of the subset to retrieve.
-      in: query
-      schema:
-        type: integer
-        default: 10
-        maximum: 100
-        minimum: 1
-      required: false
-    Offset:
-      name: offset
-      description: Number of items to skip during retrieval.
-      in: query
-      schema:
-        type: integer
-        default: 0
-        minimum: 0
-      required: false
-    Name:
-      name: name
-      description: Name filter. Filtering is performed as a case-insensitive partial match.
-      in: query
-      schema:
-        type: string
-      required: false
-    Order:
-      name: order
-      description: Order type.
-      in: query
-      schema:
-        type: string
-        default: id
-        enum:
-          - name
-          - id
-      required: false
-    Direction:
-      name: dir
-      description: Order direction.
-      in: query
-      schema:
-        type: string
-        default: desc
-        enum:
-          - asc
-          - desc
-      required: false
-    Metadata:
-      name: metadata
-      description: Metadata filter. Filtering is performed matching the parameter with metadata on top level. Parameter is json.
-      in: query
-      required: false
-      schema:
-        type: object
-        additionalProperties: {}
-
-  requestBodies:
-    ComputationCreateReq:
-      description: JSON-formatted document describing the new computaton.
-      required: true
-      content:
-        application/json:
-          schema:
-           $ref: "#/components/schemas/ComputationReqSchema"
-    ComputationsCreateReq:
-      description: JSON-formatted document describing the new computation.
-      required: true
-      content:
-        application/json:
-          schema:
-            type: object
-            properties:
-              key:
-                $ref: "#/components/schemas/Key"
-              computations:
-                type: array
-                items:
-                  $ref: "#/components/schemas/ComputationsReqSchema"
-    ComputationUpdateReq:
-      description: Arbitrary, object-encoded data.
-      required: true
-      content:
-        application/json:
-          schema:
-            type: object
-            properties:
-              name:
-                type: string
-                description: Free-form name.
-              metadata:
-                type: object
-    ComputationsSearchReq:
-      description: JSON-formatted document describing search parameters.
-      required: true
-      content:
-        application/json:
-          schema:
-           $ref: "#/components/schemas/ComputationReqSchema"
-    KeyUpdateReq:
-      required: true
-      description: JSON containing computations.
-      content:
-        application/json:
-          schema:
-            type: object
-            properties:
-              key:
-                type: string
-                format: uuid
-                description: Computation key that is used for computation auth.
-  responses:
-    CreateComputationRes:
-      description: Computation registered.
-      headers:
-        Location:
-          content:
-            text/plain:
-              schema:
-                type: string
-                description: Created computation's relative URL.
-                example: /computations/{id}
-    ComputationRes:
-      description: Data retrieved.
-      content:
-        application/json:
-          schema:
-            $ref: "#/components/schemas/ComputationResSchema"
-    ComputationsPageRes:
-      description: Data retrieved.
-      content:
-        application/json:
-          schema:
-            $ref: "#/components/schemas/ComputationsPage"
-    IdentityRes:
-      description: ID returned.
-      content:
-        application/json:
-          schema:
-            $ref: "#/components/schemas/Identity"
-    ServiceError:
-      description: Unexpected server-side error occurred.
-      content:
-        application/json:
-          schema:
-            type: string
-            format: byte
-    HealthRes:
-      description: Service Health Check.
-      content:
-        application/json:
-          schema:
-            $ref: "./schemas/HealthInfo.yml"
-
-  securitySchemes:
-    bearerAuth:
-      type: http
-      scheme: bearer
-      bearerFormat: JWT
-      description: |
-        * Users access: "Authorization: Bearer <user_token>"
-security:
-  - bearerAuth: []

api/datasets.yml

@@ -1,446 +0,0 @@
-openapi: 3.0.1
-info:
-  title: Datasets service
-  description: HTTP API for managing datasets
-  version: "1.0.0"
-
-paths:
-  /datasets:
-    post:
-      summary: Add new dataset
-      description: |
-        Adds new dataset to the list of datasets owned by user identified using
-        the provided access token.
-      tags:
-        - datasets
-      requestBody:
-        $ref: "#/components/requestBodies/DatasetCreateReq"
-      responses:
-        '201':
-          $ref: "#/components/responses/DatasetRes"
-        '400':
-          description: Failed due to malformed JSON.
-        '401':
-          description: Missing or invalid access token provided.
-        '409':
-          description: Entity already exist.
-        '415':
-          description: Missing or invalid content type.
-        '422':
-          description: Database can't process request.
-        '500':
-          $ref: "#/components/responses/ServiceError"
-    get:
-      summary: Retrieves datasets
-      description: |
-        Retrieves a list of datasets. Due to performance concerns, data
-        is retrieved in subsets. The API user must ensure that the entire
-        dataset is consumed either by making subsequent requests, or by
-        increasing the subset size of the initial request.
-      tags:
-        - datasets
-      parameters:
-        - $ref: "#/components/parameters/Limit"
-        - $ref: "#/components/parameters/Offset"
-        - $ref: "#/components/parameters/Name"
-        - $ref: "#/components/parameters/Order"
-        - $ref: "#/components/parameters/Direction"
-        - $ref: "#/components/parameters/Metadata"
-      responses:
-        '200':
-          $ref: "#/components/responses/DatasetsPageRes"
-        '400':
-          description: Failed due to malformed query parameters.
-        '401':
-          description: Missing or invalid access token provided.
-        '404':
-          description: A non-existent entity request.
-        '422':
-          description: Database can't process request.
-        '500':
-          $ref: "#/components/responses/ServiceError"
-  /datasets/search:
-    post:
-      summary: Search and retrieves datasets
-      description: |
-        Retrieves a list of datasets with name and metadata filtering.
-        Due to performance concerns, data is retrieved in subsets.
-        The API user must ensure that the entire
-        dataset is consumed either by making subsequent requests, or by
-        increasing the subset size of the initial request.
-      tags:
-        - datasets
-      requestBody:
-        $ref: "#/components/requestBodies/DatasetsSearchReq"
-      responses:
-        '200':
-          $ref: "#/components/responses/DatasetsPageRes"
-        '400':
-          description: Failed due to malformed query parameters.
-        '401':
-          description: Missing or invalid access token provided.
-        '404':
-          description: A non-existent entity request.
-        '422':
-          description: Unprocessable Entity
-        '500':
-          $ref: "#/components/responses/ServiceError"
-  /datasets/{Id}:
-    get:
-      summary: Retrieves dataset info
-      tags:
-        - dataset
-      parameters:
-        - $ref: "#/components/parameters/Id"
-      responses:
-        '200':
-          $ref: "#/components/responses/DatasetRes"
-        '401':
-          description: Missing or invalid access token provided.
-        '404':
-          description: Dataset does not exist.
-        '422':
-          description: Database can't process request.
-        '500':
-          $ref: "#/components/responses/ServiceError"
-    put:
-      summary: Updates dataset info
-      description: |
-        Update is performed by replacing the current resource data with values
-        provided in a request payload.
-      tags:
-        - datasets
-      parameters:
-        - $ref: "#/components/parameters/Id"
-      requestBody:
-        $ref: "#/components/requestBodies/DatasetUpdateReq"
-      responses:
-        '200':
-          description: dataset updated.
-        '400':
-          description: Failed due to malformed JSON.
-        '401':
-          description: Missing or invalid access token provided.
-        '404':
-          description: Dataset does not exist.
-        '415':
-          description: Missing or invalid content type.
-        '500':
-          $ref: "#/components/responses/ServiceError"
-    delete:
-      summary: Removes a dataset
-      description: |
-        Removes a dataset.
-      tags:
-        - dataset
-      parameters:
-        - $ref: "#/components/parameters/Id"
-      responses:
-        '204':
-          description: Dataset removed.
-        '400':
-          description: Failed due to malformed ID.
-        '401':
-          description: Missing or invalid access token provided.
-        '500':
-          $ref: "#/components/responses/ServiceError"
-  
-components:
-  schemas:
-    DatasetReqSchema:
-      type: object
-      properties:
-        name:
-          type: string
-          description: Free-form name.
-        description:
-          type: string
-          description: Free-form description
-        datasets:
-          type: array
-          description: An array of datasets.
-          minItems: 0
-          uniqueItems: true
-          items:
-            type: string
-        algorithms:
-          type: array
-          description: An array of algorithms.
-          minItems: 1
-          uniqueItems: true
-          items:
-            type: string
-        startTime:
-          type: number
-          description: Start timestamp of the datasets
-        endTime:
-          type: number
-          description: End of the dataset
-        status:
-          type: string
-          description: Current status of the dataset
-        owner:
-          type: string
-          description: ID of the user who started dataset
-        datasetProviders:
-          type: array
-          description: List of IDs of users who provided datasets
-          minItems: 0
-          uniqueItems: true
-          items:
-            type: string
-        algorithmProviders:
-          type: array
-          description: List of IDs of users who provided algorithms
-          minItems: 1
-          uniqueItems: true
-          items:
-            type: string
-        ttl:
-          type: number
-          description: Period for dataset to live in an inactive state
-        metadata:
-          type: object
-          description: Arbitrary, object-encoded data.
-    DatasetsReqSchema:
-      type: object
-      properties:
-        name:
-          type: string
-          description: Name filter. Filtering is performed as a case-insensitive partial match.
-        metadata:
-          type: object
-          description: Metadata filter. Filtering is performed matching the parameter with metadata on top level. Parameter is json.
-        total:
-          type: integer
-          description: Total number of items.
-        offset:
-          type: integer
-          description: Number of items to skip during retrieval.
-          default: 0
-          minimum: 0
-        limit:
-          type: integer
-          description: Size of the subset to retrieve.
-          default: 10
-          maximum: 100
-          minimum: 1
-        order:
-          type: string
-          description: Order type.
-          default: id
-          enum:
-            - name
-            - id
-        dir:
-          type: string
-          description: Order direction.
-          default: desc
-          enum:
-            - asc
-            - desc
-    DatasetResSchema:
-      type: object
-      properties:
-        id:
-          type: string
-          format: uuid
-          description: Unique identifier generated by the service.
-        name:
-          type: string
-          description: Free-form name.
-        key:
-          type: string
-          format: uuid
-          description: Auto-generated access key.
-        metadata:
-          type: object
-          description: Arbitrary, object-encoded data.
-      required:
-        - id
-        - type
-        - key
-    DatasetsPage:
-      type: object
-      properties:
-        datasets:
-          type: array
-          minItems: 0
-          uniqueItems: true
-          items:
-            $ref: "#/components/schemas/DatasetResSchema"
-        total:
-          type: integer
-          description: Total number of items.
-        offset:
-          type: integer
-          description: Number of items to skip during retrieval.
-        limit:
-          type: integer
-          description: Maximum number of items to return in one page.
-      required:
-        - datasets
-  parameters:
-    Id:
-      name: Id
-      description: Unique identifier.
-      in: path
-      schema:
-        type: string
-        format: uuid
-      required: true
-    Limit:
-      name: limit
-      description: Size of the subset to retrieve.
-      in: query
-      schema:
-        type: integer
-        default: 10
-        maximum: 100
-        minimum: 1
-      required: false
-    Offset:
-      name: offset
-      description: Number of items to skip during retrieval.
-      in: query
-      schema:
-        type: integer
-        default: 0
-        minimum: 0
-      required: false
-    Name:
-      name: name
-      description: Name filter. Filtering is performed as a case-insensitive partial match.
-      in: query
-      schema:
-        type: string
-      required: false
-    Order:
-      name: order
-      description: Order type.
-      in: query
-      schema:
-        type: string
-        default: id
-        enum:
-          - name
-          - id
-      required: false
-    Direction:
-      name: dir
-      description: Order direction.
-      in: query
-      schema:
-        type: string
-        default: desc
-        enum:
-          - asc
-          - desc
-      required: false
-    Metadata:
-      name: metadata
-      description: Metadata filter. Filtering is performed matching the parameter with metadata on top level. Parameter is json.
-      in: query
-      required: false
-      schema:
-        type: object
-        additionalProperties: {}
-
-  requestBodies:
-    DatasetCreateReq:
-      description: JSON-formatted document describing the new dataset.
-      required: true
-      content:
-        application/json:
-          schema:
-           $ref: "#/components/schemas/DatasetReqSchema"
-    DatasetsCreateReq:
-      description: JSON-formatted document describing the new dataset.
-      required: true
-      content:
-        application/json:
-          schema:
-            type: object
-            properties:
-              datasets:
-                type: array
-                items:
-                  $ref: "#/components/schemas/DatasetsReqSchema"
-    DatasetUpdateReq:
-      description: Arbitrary, object-encoded data.
-      required: true
-      content:
-        application/json:
-          schema:
-            type: object
-            properties:
-              name:
-                type: string
-                description: Free-form name.
-              metadata:
-                type: object
-    DatasetsSearchReq:
-      description: JSON-formatted document describing search parameters.
-      required: true
-      content:
-        application/json:
-          schema:
-           $ref: "#/components/schemas/DatasetReqSchema"
-    KeyUpdateReq:
-      required: true
-      description: JSON containing datasets.
-      content:
-        application/json:
-          schema:
-            type: object
-            properties:
-              key:
-                type: string
-                format: uuid
-                description: Thing key that is used for thing auth.
-  responses:
-    CreateDatasetRes:
-      description: Dataset registered.
-      headers:
-        Location:
-          content:
-            text/plain:
-              schema:
-                type: string
-                description: Created dataset's relative URL.
-                example: /datasets/{id}
-    DatasetRes:
-      description: Data retrieved.
-      content:
-        application/json:
-          schema:
-            $ref: "#/components/schemas/DatasetResSchema"
-    DatasetsPageRes:
-      description: Data retrieved.
-      content:
-        application/json:
-          schema:
-            $ref: "#/components/schemas/DatasetsPage"
-    ServiceError:
-      description: Unexpected server-side error occurred.
-      content:
-        application/json:
-          schema:
-            type: string
-            format: byte
-    HealthRes:
-      description: Service Health Check.
-      content:
-        application/json:
-          schema:
-            $ref: "./schemas/HealthInfo.yml"
-
-  securitySchemes:
-    bearerAuth:
-      type: http
-      scheme: bearer
-      bearerFormat: JWT
-      description: |
-        * Users access: "Authorization: Bearer <user_token>"
-security:
-  - bearerAuth: []

api/examples/CoCoS.postman_collection.json

@@ -1,84 +0,0 @@
-{
-	"info": {
-		"_postman_id": "5ed31077-ca87-496e-9b98-b8793ce7c5d2",
-		"name": "CoCoS",
-		"schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
-	},
-	"item": [
-		{
-			"name": "Create Computation",
-			"request": {
-				"method": "POST",
-				"header": [],
-				"body": {
-					"mode": "raw",
-					"raw": "{\n    \"name\": \"Calculate salary\",\n    \"description\": \"my test computation\",\n    \"ttl\": 1243\n}",
-					"options": {
-						"raw": {
-							"language": "json"
-						}
-					}
-				},
-				"url": {
-					"raw": "http://localhost:9000/computations",
-					"protocol": "http",
-					"host": [
-						"localhost"
-					],
-					"port": "9000",
-					"path": [
-						"computations"
-					]
-				}
-			},
-			"response": []
-		},
-		{
-			"name": "View Computation",
-			"request": {
-				"method": "GET",
-				"header": [],
-				"url": {
-					"raw": "http://localhost:9000/computations/c89b53d3-c088-4b5a-addd-51a90ea94325",
-					"protocol": "http",
-					"host": [
-						"localhost"
-					],
-					"port": "9000",
-					"path": [
-						"computations",
-						"c89b53d3-c088-4b5a-addd-51a90ea94325"
-					]
-				}
-			},
-			"response": []
-		}
-	],
-	"event": [
-		{
-			"listen": "prerequest",
-			"script": {
-				"type": "text/javascript",
-				"exec": [
-					""
-				]
-			}
-		},
-		{
-			"listen": "test",
-			"script": {
-				"type": "text/javascript",
-				"exec": [
-					""
-				]
-			}
-		}
-	],
-	"variable": [
-		{
-			"key": "jwt",
-			"value": "",
-			"type": "string"
-		}
-	]
-}

attestation.go

@@ -0,0 +1,12 @@
+// 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

@@ -0,0 +1,102 @@
+# 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.
+
+## Build
+
+From the project root:
+
+```bash
+make cli
+```
+
+## Usage
+
+#### 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>'
+```
+
+#### 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>'
+```
+##### Flags
+- --config: Path to a JSON file containing the validation configuration. This can be used to override individual flags.
+- --report_data: Hex-encoded string representing the attestation report data. (Required for the validate command)
+- --host_data: Hex-encoded string representing the expected HOST_DATA field.
+- --family_id: Hex-encoded string representing the expected FAMILY_ID field.
+- --image_id: Hex-encoded string representing the expected IMAGE_ID field.
+- --report_id: Hex-encoded string representing the expected REPORT_ID field.
+- --report_id_ma: Hex-encoded string representing the expected REPORT_ID_MA field.
+- --measurement: Hex-encoded string representing the expected MEASUREMENT field.
+- --chip_id: Hex-encoded string representing the expected CHIP_ID field.
+- --minimum_tcb: Minimum acceptable value for CURRENT_TCB, COMMITTED_TCB, and REPORTED_TCB.
+- --minimum_launch_tcb: Minimum acceptable value for LAUNCH_TCB.
+- --minimum_guest_svn: Minimum acceptable SnpPolicy.
+- --minimum_build: Minimum 8-bit build number for AMD-SP firmware.
+- --check_crl: Download and check the CRL for revoked certificates (default: false).
+- --disallow_network: If true, disallows network downloads for verification (default: false).
+- --timeout: Duration to continue retrying failed HTTP requests (default: 2 minutes).
+- --max_retry_delay: Maximum duration to wait between HTTP request retries (default: 30 seconds).
+- --require_author_key: Require that AUTHOR_KEY_EN is set to 1 (default: false).
+- --require_id_block: Require that the VM was launched with an ID_BLOCK signed by a trusted key (default: false).
+- --permit_provisional_software: Allow provisional firmware (default: false).
+- --platform_info: Maximum acceptable PLATFORM_INFO field bit-wise (optional).
+- --minimum_version: Minimum AMD-SP firmware API version (major.minor) (optional).
+- --trusted_author_keys: Paths to x.509 certificates of trusted author keys (optional).
+- --trusted_author_key_hashes: Hex-encoded SHA-384 hashes of trusted author keys (optional).
+- --trusted_id_keys: Paths to x.509 certificates of trusted identity keys (optional).
+- --trusted_id_key_hashes: Hex-encoded SHA-384 hashes of trusted identity keys (optional).
+- --product: AMD product name for the chip that generated the attestation report (optional).
+- --stepping: Machine stepping for the chip that generated the attestation report (optional).
+- --CA_bundles_paths: Paths to CA bundles for the AMD product (optional).
+- --CA_bundles: PEM format CA bundles for the AMD product (optional).
+
+#### Upload Algorithm
+
+To upload an algorithm, use the following command:
+
+```bash
+./build/cocos-cli algo /path/to/algorithm <private_key_file_path>
+```
+
+##### 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>
+```
+
+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>
+```

cli/algorithms.go

@@ -0,0 +1,86 @@
+// Copyright (c) Ultraviolet
+// SPDX-License-Identifier: Apache-2.0
+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{
+		Use:     "algo",
+		Short:   "Upload an algorithm binary",
+		Example: "algo <algo_file> <private_key_file_path>",
+		Args:    cobra.ExactArgs(2),
+		Run: func(cmd *cobra.Command, args []string) {
+			algorithmFile := args[0]
+
+			log.Println("Uploading algorithm file:", 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,
+			}
+
+			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)
+			}
+
+			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

@@ -0,0 +1,663 @@
+// Copyright (c) Ultraviolet
+// SPDX-License-Identifier: Apache-2.0
+package cli
+
+import (
+	"encoding/hex"
+	"fmt"
+	"log"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	"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"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+	"github.com/ultravioletrs/cocos/agent"
+	"google.golang.org/protobuf/encoding/protojson"
+	"google.golang.org/protobuf/types/known/wrapperspb"
+)
+
+const (
+	defaultMinimumTcb       = 0
+	defaultMinimumLaunchTcb = 0
+	defaultMinimumGuestSvn  = 0
+	defaultGuestPolicy      = 0x0000000000030000
+	defaultMinimumBuild     = 0
+	defaultCheckCrl         = false
+	defaultTimeout          = 2 * time.Minute
+	defaultMaxRetryDelay    = 30 * time.Second
+	defaultRequireAuthor    = false
+	defaultRequireIdBlock   = false
+	defaultMinVersion       = "0.0"
+	size16                  = 16
+	size32                  = 32
+	size48                  = 48
+	size64                  = 64
+	attestationFilePath     = "attestation.bin"
+	sevProductNameMilan     = "Milan"
+	sevProductNameGenoa     = "Genoa"
+	exampleJSONConfig       = `
+	{
+		"rootOfTrust":{
+		   "product":"test_product",
+		   "cabundlePaths":[
+			  "test_cabundlePaths"
+		   ],
+		   "cabundles":[
+			  "test_Cabundles"
+		   ],
+		   "checkCrl":true,
+		   "disallowNetwork":true
+		},
+		"policy":{
+		   "minimumGuestSvn":1,
+		   "policy":"1",
+		   "familyId":"AQIDBAUGBwgJCgsMDQ4PEA==",
+		   "imageId":"AQIDBAUGBwgJCgsMDQ4PEA==",
+		   "vmpl":0,
+		   "minimumTcb":"1",
+		   "minimumLaunchTcb":"1",
+		   "platformInfo":"1",
+		   "requireAuthorKey":true,
+		   "reportData":"J+60aXs8btm8VcGgaJYURGeNCu0FIyWMFXQ7ZUlJDC0FJGJizJsOzDIXgQ75UtPC+Zqe0A3dvnnf5VEeQ61RTg==",
+		   "measurement":"8s78ewoX7Xkfy1qsgVnkZwLDotD768Nqt6qTL5wtQOxHsLczipKM6bhDmWiHLdP4",
+		   "hostData":"GSvLKpfu59Y9QOF6vhq0vQsOIvb4+5O/UOHLGLBTkdw=",
+		   "reportId":"GSvLKpfu59Y9QOF6vhq0vQsOIvb4+5O/UOHLGLBTkdw=",
+		   "reportIdMa":"GSvLKpfu59Y9QOF6vhq0vQsOIvb4+5O/UOHLGLBTkdw=",
+		   "chipId":"J+60aXs8btm8VcGgaJYURGeNCu0FIyWMFXQ7ZUlJDC0FJGJizJsOzDIXgQ75UtPC+Zqe0A3dvnnf5VEeQ61RTg==",
+		   "minimumBuild":1,
+		   "minimumVersion":"0.90",
+		   "permitProvisionalFirmware":true,
+		   "requireIdBlock":true,
+		   "trustedAuthorKeys":[
+			  "GSvLKpfu59Y9QOF6vhq0vQsOIvb4+5O/UOHLGLBTkdw="
+		   ],
+		   "trustedAuthorKeyHashes":[
+			  "GSvLKpfu59Y9QOF6vhq0vQsOIvb4+5O/UOHLGLBTkdw="
+		   ],
+		   "trustedIdKeys":[
+			  "GSvLKpfu59Y9QOF6vhq0vQsOIvb4+5O/UOHLGLBTkdw="
+		   ],
+		   "trustedIdKeyHashes":[
+			  "GSvLKpfu59Y9QOF6vhq0vQsOIvb4+5O/UOHLGLBTkdw="
+		   ],
+		   "product":{
+			  "name":"SEV_PRODUCT_MILAN",
+			  "stepping":1,
+			  "machineStepping":1
+		   }
+		}
+	}
+	`
+)
+
+var (
+	cfg                 = check.Config{Policy: &check.Policy{}, RootOfTrust: &check.RootOfTrust{}}
+	cfgString           string
+	timeout             time.Duration
+	maxRetryDelay       time.Duration
+	platformInfo        string
+	stepping            string
+	trustedAuthorKeys   []string
+	trustedAuthorHashes []string
+	trustedIdKeys       []string
+	trustedIdKeyHashes  []string
+	attestationFile     string
+	attestation         []byte
+	empty16             = [size16]byte{}
+	empty32             = [size32]byte{}
+	empty64             = [size64]byte{}
+	defaultReportIdMa   = []byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
+)
+
+func (cli *CLI) NewAttestationCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:   "attestation [command]",
+		Short: "Get and validate attestations",
+		Run: func(cmd *cobra.Command, args []string) {
+			fmt.Printf("Get and validate attestations\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) 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>",
+		Args:    cobra.ExactArgs(1),
+		Run: func(cmd *cobra.Command, args []string) {
+			log.Println("Getting attestation")
+
+			reportData, err := hex.DecodeString(args[0])
+			if err != nil {
+				log.Fatalf("attestation validation and verification failed with error: %s", err)
+			}
+			if len(reportData) != agent.ReportDataSize {
+				log.Fatalf("report data must be a hex encoded string of length %d bytes", agent.ReportDataSize)
+			}
+
+			result, err := cli.agentSDK.Attestation(cmd.Context(), [agent.ReportDataSize]byte(reportData))
+			if err != nil {
+				log.Fatalf("Error retrieving attestation: %v", err)
+			}
+
+			if err = os.WriteFile(attestationFilePath, result, 0o644); err != nil {
+				log.Fatalf("Error saving attestation result: %v", err)
+			}
+
+			log.Println("Attestation result retrieved and saved successfully!")
+		},
+	}
+}
+
+func (cli *CLI) NewValidateAttestationValidationCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "validate",
+		Short:   "Validate and verify attestation information. The report is provided as a file path.",
+		Example: "validate <attestation_report_file_path>",
+		Args:    cobra.ExactArgs(1),
+		Run: func(cmd *cobra.Command, args []string) {
+			log.Println("Checking attestation")
+
+			attestationFile = string(args[0])
+
+			if err := parseConfig(); err != nil {
+				log.Fatalf("attestation validation and verification failed with error: %s", err)
+			}
+			if err := parseHashes(); err != nil {
+				log.Fatalf("attestation validation and verification failed with error: %s", err)
+			}
+			if err := parseFiles(); err != nil {
+				log.Fatalf("attestation validation and verification failed with error: %s", err)
+			}
+			// This format is the attestation report in AMD's specified ABI format, immediately
+			// followed by the certificate table bytes.
+			if len(attestation) < abi.ReportSize {
+				log.Fatalf("attestation contents too small (0x%x bytes). Want at least 0x%x bytes", len(attestation), abi.ReportSize)
+			}
+			if err := parseUints(); err != nil {
+				log.Fatalf("attestation validation and verification failed with error: %s", err)
+			}
+			cfg.Policy.Vmpl = wrapperspb.UInt32(0)
+
+			if err := validateInput(); err != nil {
+				log.Fatalf("attestation validation and verification failed with error: %s", err)
+			}
+
+			if err := verifyAndValidateAttestation(attestation); err != nil {
+				log.Fatalf("attestation validation and verification failed with error: %s", err)
+			}
+			log.Println("Attestation validation and verification is successful!")
+		},
+	}
+	cmd.Flags().StringVar(
+		&cfgString,
+		"config",
+		"",
+		"Serialized json check.Config protobuf. This will overwrite individual flags. Unmarshalled as json. Example: "+exampleJSONConfig,
+	)
+	cmd.Flags().BytesHexVar(
+		&cfg.Policy.HostData,
+		"host_data",
+		empty32[:],
+		"The expected HOST_DATA field as a hex string. Must encode 32 bytes. Unchecked if unset.",
+	)
+	cmd.Flags().BytesHexVar(
+		&cfg.Policy.ReportData,
+		"report_data",
+		empty64[:],
+		"The expected REPORT_DATA field as a hex string. Must encode 64 bytes. Must be set.",
+	)
+	cmd.Flags().BytesHexVar(
+		&cfg.Policy.FamilyId,
+		"family_id",
+		empty16[:],
+		"The expected FAMILY_ID field as a hex string. Must encode 16 bytes. Unchecked if unset.",
+	)
+	cmd.Flags().BytesHexVar(
+		&cfg.Policy.ImageId,
+		"image_id",
+		empty16[:],
+		"The expected IMAGE_ID field as a hex string. Must encode 16 bytes. Unchecked if unset.",
+	)
+	cmd.Flags().BytesHexVar(
+		&cfg.Policy.ReportId,
+		"report_id",
+		nil,
+		"The expected REPORT_ID field as a hex string. Must encode 32 bytes. Unchecked if unset.",
+	)
+	cmd.Flags().BytesHexVar(
+		&cfg.Policy.ReportIdMa,
+		"report_id_ma",
+		defaultReportIdMa,
+		"The expected REPORT_ID_MA field as a hex string. Must encode 32 bytes. Unchecked if unset.",
+	)
+	cmd.Flags().BytesHexVar(
+		&cfg.Policy.Measurement,
+		"measurement",
+		nil,
+		"The expected MEASUREMENT field as a hex string. Must encode 48 bytes. Unchecked if unset.",
+	)
+	cmd.Flags().BytesHexVar(
+		&cfg.Policy.ChipId,
+		"chip_id",
+		nil,
+		"The expected MEASUREMENT field as a hex string. Must encode 48 bytes. Unchecked if unset.",
+	)
+	cmd.Flags().Uint64Var(
+		&cfg.Policy.MinimumTcb,
+		"minimum_tcb",
+		defaultMinimumTcb,
+		"The minimum acceptable value for CURRENT_TCB, COMMITTED_TCB, and REPORTED_TCB.",
+	)
+	cmd.Flags().Uint64Var(
+		&cfg.Policy.MinimumLaunchTcb,
+		"minimum_lauch_tcb",
+		defaultMinimumLaunchTcb,
+		"The minimum acceptable value for LAUNCH_TCB.",
+	)
+	cmd.Flags().Uint64Var(
+		&cfg.Policy.Policy,
+		"guest_policy",
+		defaultGuestPolicy,
+		"The most acceptable guest SnpPolicy.",
+	)
+	cmd.Flags().Uint32Var(
+		&cfg.Policy.MinimumGuestSvn,
+		"minimum_guest_svn",
+		defaultMinimumGuestSvn,
+		"The most acceptable GUEST_SVN.",
+	)
+	cmd.Flags().Uint32Var(
+		&cfg.Policy.MinimumBuild,
+		"minimum_build",
+		defaultMinimumBuild,
+		"The 8-bit minimum build number for AMD-SP firmware",
+	)
+	cmd.Flags().BoolVar(
+		&cfg.RootOfTrust.CheckCrl,
+		"check_crl",
+		defaultCheckCrl,
+		"Download and check the CRL for revoked certificates.",
+	)
+	cmd.Flags().DurationVar(
+		&timeout,
+		"timeout",
+		defaultTimeout,
+		"Duration to continue to retry failed HTTP requests.",
+	)
+	cmd.Flags().DurationVar(
+		&maxRetryDelay,
+		"max_retry_delay",
+		defaultMaxRetryDelay,
+		"Maximum Duration to wait between HTTP request retries.",
+	)
+	cmd.Flags().BoolVar(
+		&cfg.Policy.RequireAuthorKey,
+		"require_author_key",
+		defaultRequireAuthor,
+		"Require that AUTHOR_KEY_EN is 1.",
+	)
+	cmd.Flags().BoolVar(
+		&cfg.Policy.RequireIdBlock,
+		"require_id_block",
+		defaultRequireIdBlock,
+		"Require that the VM was launch with an ID_BLOCK signed by a trusted id key or author key",
+	)
+	cmd.Flags().StringVar(
+		&platformInfo,
+		"platform_info",
+		"",
+		"The maximum acceptable PLATFORM_INFO field bit-wise. May be empty or a 64-bit unsigned integer",
+	)
+	cmd.Flags().StringVar(
+		&cfg.Policy.MinimumVersion,
+		"minimum_version",
+		defaultMinVersion,
+		"Minimum AMD-SP firmware API version (major.minor). Each number must be 8-bit non-negative.",
+	)
+	cmd.Flags().StringArrayVar(
+		&trustedAuthorKeys,
+		"trusted_author_keys",
+		[]string{},
+		"Paths to x.509 certificates of trusted author keys",
+	)
+	cmd.Flags().StringArrayVar(
+		&trustedAuthorHashes,
+		"trusted_author_key_hashes",
+		[]string{},
+		"Hex-encoded SHA-384 hash values of trusted author keys in AMD public key format",
+	)
+	cmd.Flags().StringArrayVar(
+		&trustedIdKeys,
+		"trusted_id_keys",
+		[]string{},
+		"Paths to x.509 certificates of trusted author keys",
+	)
+	cmd.Flags().StringArrayVar(
+		&trustedIdKeyHashes,
+		"trusted_id_key_hashes",
+		[]string{},
+		"Hex-encoded SHA-384 hash values of trusted identity keys in AMD public key format",
+	)
+	cmd.Flags().StringVar(
+		&cfg.RootOfTrust.ProductLine,
+		"product",
+		"",
+		"The AMD product name for the chip that generated the attestation report.",
+	)
+	cmd.Flags().StringVar(
+		&stepping,
+		"stepping",
+		"",
+		"The machine stepping for the chip that generated the attestation report. Default unchecked.",
+	)
+	cmd.Flags().StringArrayVar(
+		&cfg.RootOfTrust.CabundlePaths,
+		"CA_bundles_paths",
+		[]string{},
+		"Paths to CA bundles for the AMD product. Must be in PEM format, ASK, then ARK certificates. If unset, uses embedded root certificates.",
+	)
+	cmd.Flags().StringArrayVar(
+		&cfg.RootOfTrust.Cabundles,
+		"CA_bundles",
+		[]string{},
+		"PEM format CA bundles for the AMD product. Combined with contents of cabundle_paths.",
+	)
+
+	if err := cmd.MarkFlagRequired("report_data"); err != nil {
+		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
+}
+
+func verifyAndValidateAttestation(attestation []byte) error {
+	sopts, err := verify.RootOfTrustToOptions(cfg.RootOfTrust)
+	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.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])
+	if err != nil {
+		return err
+	}
+	if err = verify.SnpAttestation(attestationPB, sopts); err != nil {
+		return err
+	}
+	opts, err := validate.PolicyToOptions(cfg.Policy)
+	if err != nil {
+		return err
+	}
+	if err = validate.SnpAttestation(attestationPB, opts); err != nil {
+		return err
+	}
+	return nil
+}
+
+// parseConfig decodes config passed as json for check.Config struct.
+// example
+/* {
+	"rootOfTrust":{
+		"product":"test_product",
+		"cabundlePaths":[
+		   "test_cabundlePaths"
+		],
+		"cabundles":[
+		   "test_Cabundles"
+		],
+		"checkCrl":true,
+		"disallowNetwork":true
+	 },
+	 "policy":{
+		"minimumGuestSvn":1,
+		"policy":"1",
+		"familyId":"AQIDBAUGBwgJCgsMDQ4PEA==",
+		"imageId":"AQIDBAUGBwgJCgsMDQ4PEA==",
+		"vmpl":0,
+		"minimumTcb":"1",
+		"minimumLaunchTcb":"1",
+		"platformInfo":"1",
+		"requireAuthorKey":true,
+		"reportData":"J+60aXs8btm8VcGgaJYURGeNCu0FIyWMFXQ7ZUlJDC0FJGJizJsOzDIXgQ75UtPC+Zqe0A3dvnnf5VEeQ61RTg==",
+		"measurement":"8s78ewoX7Xkfy1qsgVnkZwLDotD768Nqt6qTL5wtQOxHsLczipKM6bhDmWiHLdP4",
+		"hostData":"GSvLKpfu59Y9QOF6vhq0vQsOIvb4+5O/UOHLGLBTkdw=",
+		"reportId":"GSvLKpfu59Y9QOF6vhq0vQsOIvb4+5O/UOHLGLBTkdw=",
+		"reportIdMa":"GSvLKpfu59Y9QOF6vhq0vQsOIvb4+5O/UOHLGLBTkdw=",
+		"chipId":"J+60aXs8btm8VcGgaJYURGeNCu0FIyWMFXQ7ZUlJDC0FJGJizJsOzDIXgQ75UtPC+Zqe0A3dvnnf5VEeQ61RTg==",
+		"minimumBuild":1,
+		"minimumVersion":"0.90",
+		"permitProvisionalFirmware":true,
+		"requireIdBlock":true,
+		"trustedAuthorKeys":[
+		   "GSvLKpfu59Y9QOF6vhq0vQsOIvb4+5O/UOHLGLBTkdw="
+		],
+		"trustedAuthorKeyHashes":[
+		   "GSvLKpfu59Y9QOF6vhq0vQsOIvb4+5O/UOHLGLBTkdw="
+		],
+		"trustedIdKeys":[
+		   "GSvLKpfu59Y9QOF6vhq0vQsOIvb4+5O/UOHLGLBTkdw="
+		],
+		"trustedIdKeyHashes":[
+		   "GSvLKpfu59Y9QOF6vhq0vQsOIvb4+5O/UOHLGLBTkdw="
+		],
+		"product":{
+		   "name":"SEV_PRODUCT_MILAN",
+		   "stepping":1,
+		   "machineStepping":1
+		}
+	 }
+  }*/
+func parseConfig() error {
+	if cfgString == "" {
+		return nil
+	}
+	if err := protojson.Unmarshal([]byte(cfgString), &cfg); err != nil {
+		return err
+	}
+	// Populate fields that should not be nil
+	if cfg.RootOfTrust == nil {
+		cfg.RootOfTrust = &check.RootOfTrust{}
+	}
+	if cfg.Policy == nil {
+		cfg.Policy = &check.Policy{}
+	}
+	return nil
+}
+
+func parseHashes() error {
+	for _, hash := range trustedAuthorHashes {
+		hashBytes, err := hex.DecodeString(hash)
+		if err != nil {
+			return err
+		}
+		cfg.Policy.TrustedAuthorKeyHashes = append(cfg.Policy.TrustedAuthorKeyHashes, hashBytes)
+	}
+	for _, hash := range trustedIdKeyHashes {
+		hashBytes, err := hex.DecodeString(hash)
+		if err != nil {
+			return err
+		}
+		cfg.Policy.TrustedIdKeyHashes = append(cfg.Policy.TrustedIdKeyHashes, hashBytes)
+	}
+	return nil
+}
+
+func parseFiles() error {
+	file, err := os.ReadFile(attestationFile)
+	if err != nil {
+		return err
+	}
+	attestation = file
+	for _, path := range trustedAuthorKeys {
+		file, err := os.ReadFile(path)
+		if err != nil {
+			return err
+		}
+		cfg.Policy.TrustedAuthorKeys = append(cfg.Policy.TrustedAuthorKeys, file)
+	}
+	for _, path := range trustedIdKeys {
+		file, err := os.ReadFile(path)
+		if err != nil {
+			return err
+		}
+		cfg.Policy.TrustedIdKeys = append(cfg.Policy.TrustedIdKeys, file)
+	}
+	return nil
+}
+
+func parseUints() error {
+	if stepping != "" {
+		if base := getBase(stepping); base == 10 {
+			num, err := strconv.ParseUint(stepping, getBase(stepping), 8)
+			if err != nil {
+				return err
+			}
+			cfg.Policy.Product.MachineStepping = wrapperspb.UInt32(uint32(num))
+		} else {
+			num, err := strconv.ParseUint(stepping[2:], base, 8)
+			if err != nil {
+				return err
+			}
+			cfg.Policy.Product.MachineStepping = wrapperspb.UInt32(uint32(num))
+		}
+	}
+	if platformInfo != "" {
+		if base := getBase(platformInfo); base == 10 {
+			num, err := strconv.ParseUint(platformInfo, getBase(platformInfo), 8)
+			if err != nil {
+				return err
+			}
+			cfg.Policy.PlatformInfo = wrapperspb.UInt64(num)
+		} else {
+			num, err := strconv.ParseUint(platformInfo[2:], base, 8)
+			if err != nil {
+				return err
+			}
+			cfg.Policy.PlatformInfo = wrapperspb.UInt64(num)
+		}
+	}
+	return nil
+}
+
+func getBase(val string) int {
+	switch {
+	case strings.HasPrefix(val, "0x"):
+		return 16
+	case strings.HasPrefix(val, "0o"):
+		return 8
+	case strings.HasPrefix(val, "0b"):
+		return 2
+	default:
+		return 10
+	}
+}
+
+func validateInput() error {
+	if len(cfg.RootOfTrust.CabundlePaths) != 0 || len(cfg.RootOfTrust.Cabundles) != 0 && cfg.RootOfTrust.Product == "" {
+		return fmt.Errorf("product name must be set if CA bundles are provided")
+	}
+
+	if err := validateFieldLength("report_data", cfg.Policy.ReportData, size64); err != nil {
+		return err
+	}
+	if err := validateFieldLength("host_data", cfg.Policy.HostData, size32); err != nil {
+		return err
+	}
+	if err := validateFieldLength("family_id", cfg.Policy.FamilyId, size16); err != nil {
+		return err
+	}
+	if err := validateFieldLength("image_id", cfg.Policy.ImageId, size16); err != nil {
+		return err
+	}
+	if err := validateFieldLength("report_id", cfg.Policy.ReportId, size32); err != nil {
+		return err
+	}
+	if err := validateFieldLength("report_id_ma", cfg.Policy.ReportIdMa, size32); err != nil {
+		return err
+	}
+	if err := validateFieldLength("measurement", cfg.Policy.Measurement, size48); err != nil {
+		return err
+	}
+	if err := validateFieldLength("chip_id", cfg.Policy.ChipId, size64); err != nil {
+		return err
+	}
+	for _, hash := range cfg.Policy.TrustedAuthorKeyHashes {
+		if err := validateFieldLength("trusted_author_key_hash", hash, size48); err != nil {
+			return err
+		}
+	}
+	for _, hash := range cfg.Policy.TrustedIdKeyHashes {
+		if err := validateFieldLength("trusted_id_key_hash", hash, size48); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func validateFieldLength(fieldName string, field []byte, expectedLength int) error {
+	if field != nil && len(field) != expectedLength {
+		return fmt.Errorf("%s length should be at least %d bytes long", fieldName, expectedLength)
+	}
+	return nil
+}

cli/backend_info.go

@@ -0,0 +1,144 @@
+// 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

@@ -0,0 +1,69 @@
+// 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

@@ -0,0 +1,29 @@
+// 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

@@ -0,0 +1,103 @@
+// Copyright (c) Ultraviolet
+// SPDX-License-Identifier: Apache-2.0
+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{
+		Use:     "data",
+		Short:   "Upload a dataset",
+		Example: "data <dataset_path> <private_key_file_path>",
+		Args:    cobra.ExactArgs(2),
+		Run: func(cmd *cobra.Command, args []string) {
+			datasetPath := args[0]
+
+			log.Println("Uploading dataset:", datasetPath)
+
+			f, err := os.Stat(datasetPath)
+			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),
+			}
+
+			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 {
+				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

@@ -0,0 +1,128 @@
+// 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

@@ -0,0 +1,46 @@
+// Copyright (c) Ultraviolet
+// SPDX-License-Identifier: Apache-2.0
+package cli
+
+import (
+	"encoding/pem"
+	"log"
+	"os"
+
+	"github.com/spf13/cobra"
+)
+
+const resultFilePath = "results.zip"
+
+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),
+		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)
+			if err != nil {
+				log.Fatalf("Error retrieving computation result: %v", err)
+			}
+
+			if err := os.WriteFile(resultFilePath, result, 0o644); err != nil {
+				log.Fatalf("Error saving computation result to %s: %v", resultFilePath, err)
+			}
+
+			log.Println("Computation result retrieved and saved successfully!")
+		},
+	}
+}

cli/sdk.go

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

cmd/agent/main.go

@@ -0,0 +1,160 @@
+// Copyright (c) Ultraviolet
+// SPDX-License-Identifier: Apache-2.0
+package main
+
+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"
+	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"
+)
+
+const (
+	svcName        = "agent"
+	defSvcGRPCPort = "7002"
+)
+
+func main() {
+	ctx, cancel := context.WithCancel(context.Background())
+	g, ctx := errgroup.WithContext(ctx)
+
+	cfg, err := readConfig()
+	if err != nil {
+		log.Fatalf("failed to read agent configuration from vsock %s", err.Error())
+	}
+
+	conn, err := vsock.Dial(vsock.Host, manager.ManagerVsockPort, nil)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer conn.Close()
+
+	var level slog.Level
+	if err := level.UnmarshalText([]byte(cfg.AgentConfig.LogLevel)); err != nil {
+		log.Println(err)
+		return
+	}
+	handler := agentlogger.NewProtoHandler(conn, &slog.HandlerOptions{Level: level})
+	logger := slog.New(handler)
+
+	eventSvc, err := events.New(svcName, cfg.ID, manager.ManagerVsockPort)
+	if err != nil {
+		logger.Error(fmt.Sprintf("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)
+
+	grpcServerConfig := server.Config{
+		Port:         cfg.AgentConfig.Port,
+		Host:         cfg.AgentConfig.Host,
+		CertFile:     cfg.AgentConfig.CertFile,
+		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)
+
+	g.Go(func() error {
+		return gs.Start()
+	})
+
+	g.Go(func() error {
+		return server.StopHandler(ctx, cancel, logger, svcName, gs)
+	})
+
+	if err := g.Wait(); err != nil {
+		logger.Error(fmt.Sprintf("%s service terminated: %s", svcName, err))
+	}
+}
+
+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)
+
+	svc = api.LoggingMiddleware(svc, logger)
+	counter, latency := prometheus.MakeMetrics(svcName, "api")
+	svc = api.MetricsMiddleware(svc, counter, latency)
+
+	return svc
+}
+
+func readConfig() (agent.Computation, error) {
+	l, err := vsock.Listen(qemu.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]...)
+	}
+
+	ac := agent.Computation{
+		AgentConfig: agent.AgentConfig{},
+	}
+	if err := json.Unmarshal(buffer, &ac); err != nil {
+		return agent.Computation{}, err
+	}
+	if ac.AgentConfig.LogLevel == "" {
+		ac.AgentConfig.LogLevel = "info"
+	}
+	if ac.AgentConfig.Port == "" {
+		ac.AgentConfig.Port = defSvcGRPCPort
+	}
+	return ac, nil
+}

cmd/cli/main.go

@@ -0,0 +1,135 @@
+// Copyright (c) Ultraviolet
+// SPDX-License-Identifier: Apache-2.0
+package main
+
+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/pkg/clients/grpc"
+	"github.com/ultravioletrs/cocos/pkg/clients/grpc/agent"
+	"github.com/ultravioletrs/cocos/pkg/sdk"
+)
+
+const (
+	svcName            = "cli"
+	envPrefixAgentGRPC = "AGENT_GRPC_"
+	completion         = "completion"
+	filePermision      = 0o755
+	cocosDirectory     = ".cocos"
+)
+
+type config struct {
+	LogLevel string `env:"AGENT_LOG_LEVEL" envDefault:"info"`
+}
+
+func main() {
+	var cfg config
+	if err := env.Parse(&cfg); err != nil {
+		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 {
+		logger.Error(fmt.Sprintf("failed to load %s gRPC client configuration : %s", svcName, err))
+		return
+	}
+
+	agentGRPCClient, agentClient, err := agent.NewAgentClient(agentGRPCConfig)
+	if err != nil {
+		logger.Error(err.Error())
+		return
+	}
+	defer agentGRPCClient.Close()
+
+	agentSDK := sdk.NewAgentSDK(logger, agentClient)
+
+	cliSVC := cli.New(agentSDK)
+
+	rootCmd := &cobra.Command{
+		Use:   "cocos-cli [command]",
+		Short: "CLI application for CoCos Service API",
+		Run: func(cmd *cobra.Command, args []string) {
+			fmt.Printf("CLI application for CoCos Service API\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())
+		},
+	}
+
+	keysCmd := cliSVC.NewKeysCmd()
+	attestationCmd := cliSVC.NewAttestationCmd()
+	backendCmd := cliSVC.NewBackendCmd()
+
+	// Agent Commands
+	rootCmd.AddCommand(cliSVC.NewAlgorithmCmd())
+	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))
+
+	// 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())
+
+	if err := rootCmd.Execute(); err != nil {
+		logger.Error(fmt.Sprintf("Command execution failed: %s", err))
+		return
+	}
+}

cmd/computations/main.go

@@ -1,208 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"log"
-	"os"
-	"strconv"
-	"time"
-
-	"github.com/mainflux/mainflux"
-	"github.com/mainflux/mainflux/logger"
-	"github.com/mainflux/mainflux/pkg/uuid"
-	"github.com/opentracing/opentracing-go"
-	jconfig "github.com/uber/jaeger-client-go/config"
-	"github.com/ultravioletrs/clients"
-	authapi "github.com/ultravioletrs/clients/api/grpc"
-	"github.com/ultravioletrs/cocos/computations"
-	"github.com/ultravioletrs/cocos/computations/api/api"
-	"github.com/ultravioletrs/cocos/computations/postgres"
-	"github.com/ultravioletrs/cocos/internal/db"
-	"github.com/ultravioletrs/cocos/internal/env"
-	"github.com/ultravioletrs/cocos/internal/errors"
-	"github.com/ultravioletrs/cocos/internal/http"
-	"golang.org/x/sync/errgroup"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/credentials"
-)
-
-const (
-	defLogLevel      = "debug"
-	defDBHost        = "localhost"
-	defDBPort        = "5432"
-	defDBUser        = "cocos"
-	defDBPass        = "cocos"
-	defDB            = "computations"
-	defDBSSLMode     = "disable"
-	defDBSSLCert     = ""
-	defDBSSLKey      = ""
-	defDBSSLRootCert = ""
-	defHTTPPort      = "9000"
-	defServerCert    = ""
-	defServerKey     = ""
-
-	defJaegerURL   = ""
-	defAuthTLS     = "false"
-	defAuthCACerts = ""
-	defAuthURL     = "localhost:8181"
-	defAuthTimeout = "1s"
-
-	envLogLevel      = "COCOS_COMPUTATIONS_LOG_LEVEL"
-	envDBHost        = "COCOS_COMPUTATIONS_DB_HOST"
-	envDBPort        = "COCOS_COMPUTATIONS_DB_PORT"
-	envDBUser        = "COCOS_COMPUTATIONS_DB_USER"
-	envDBPass        = "COCOS_COMPUTATIONS_DB_PASS"
-	envDB            = "COCOS_COMPUTATIONS_DB"
-	envDBSSLMode     = "COCOS_COMPUTATIONS_DB_SSL_MODE"
-	envDBSSLCert     = "COCOS_COMPUTATIONS_DB_SSL_CERT"
-	envDBSSLKey      = "COCOS_COMPUTATIONS_DB_SSL_KEY"
-	envDBSSLRootCert = "COCOS_COMPUTATIONS_DB_SSL_ROOT_CERT"
-	envHTTPPort      = "COCOS_COMPUTATIONS_HTTP_PORT"
-	envServerCert    = "COCOS_COMPUTATIONS_SERVER_CERT"
-	envServerKey     = "COCOS_COMPUTATIONS_SERVER_KEY"
-
-	envJaegerURL   = "MF_JAEGER_URL"
-	envAuthTLS     = "COCOS_COMPUTATIONS_AUTH_CLIENT_TLS"
-	envAuthCACerts = "COCOS_COMPUTATIONS_AUTH_CA_CERTS"
-	envAuthURL     = "COCOS_COMPUTATIONS_AUTH_GRPC_URL"
-	envAuthTimeout = "COCOS_COMPUTATIONS_AUTH_GRPC_TIMEOUT"
-)
-
-const svcName = "Computations"
-
-type config struct {
-	logLevel    string
-	dbConfig    db.Config
-	httpPort    string
-	serverCert  string
-	serverKey   string
-	jaegerURL   string
-	authTLS     bool
-	authCACerts string
-	authURL     string
-	authTimeout time.Duration
-}
-
-func loadConfig() config {
-	authTimeout, err := time.ParseDuration(mainflux.Env(envAuthTimeout, defAuthTimeout))
-	if err != nil {
-		log.Fatalf("Invalid %s value: %s", envAuthTimeout, err.Error())
-	}
-
-	tls, err := strconv.ParseBool(mainflux.Env(envAuthTLS, defAuthTLS))
-	if err != nil {
-		log.Fatalf("Invalid value passed for %s\n", envAuthTLS)
-	}
-
-	dbConfig := db.Config{
-		Host:        env.Load(envDBHost, defDBHost),
-		Port:        env.Load(envDBPort, defDBPort),
-		User:        env.Load(envDBUser, defDBUser),
-		Pass:        env.Load(envDBPass, defDBPass),
-		Name:        env.Load(envDB, defDB),
-		SSLMode:     env.Load(envDBSSLMode, defDBSSLMode),
-		SSLCert:     env.Load(envDBSSLCert, defDBSSLCert),
-		SSLKey:      env.Load(envDBSSLKey, defDBSSLKey),
-		SSLRootCert: env.Load(envDBSSLRootCert, defDBSSLRootCert),
-		Migrations:  postgres.Migrations,
-	}
-	return config{
-		dbConfig:    dbConfig,
-		authTLS:     tls,
-		authTimeout: authTimeout,
-		logLevel:    env.Load(envLogLevel, defLogLevel),
-		httpPort:    env.Load(envHTTPPort, defHTTPPort),
-		serverCert:  env.Load(envServerCert, defServerCert),
-		serverKey:   env.Load(envServerKey, defServerKey),
-		authCACerts: env.Load(envAuthCACerts, defAuthCACerts),
-		jaegerURL:   env.Load(envJaegerURL, defJaegerURL),
-		authURL:     env.Load(envAuthURL, defAuthURL),
-	}
-}
-
-func main() {
-	cfg := loadConfig()
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	g, ctx := errgroup.WithContext(ctx)
-	l, err := logger.New(os.Stdout, cfg.logLevel)
-	if err != nil {
-		log.Fatalf(err.Error())
-	}
-	db, err := db.Connect(cfg.dbConfig)
-	if err != nil {
-		log.Fatalf(err.Error())
-	}
-	authTracer, closer := initJaeger("auth", cfg.jaegerURL, l)
-	defer closer.Close()
-
-	auth, close := connectToAuth(cfg, authTracer, l)
-	if close != nil {
-		defer close()
-	}
-
-	repo := postgres.NewRepository(db)
-	idp := uuid.New()
-	svc := computations.NewService(repo, idp, auth)
-	svc = api.LoggingMiddleware(svc, l)
-	h := api.MakeHandler(svc, nil, l)
-
-	g.Go(func() error {
-		return http.StartServer(ctx, svcName, cfg.httpPort, cfg.serverCert, cfg.serverKey, h, l)
-	})
-	g.Go(errors.Handle(svcName, l, ctx, cancel))
-	if err := g.Wait(); err != nil {
-		l.Error(fmt.Sprintf("%s service terminated: %s", svcName, err))
-	}
-}
-
-func initJaeger(svcName, url string, logger logger.Logger) (opentracing.Tracer, io.Closer) {
-	if url == "" {
-		return opentracing.NoopTracer{}, ioutil.NopCloser(nil)
-	}
-
-	tracer, closer, err := jconfig.Configuration{
-		ServiceName: svcName,
-		Sampler: &jconfig.SamplerConfig{
-			Type:  "const",
-			Param: 1,
-		},
-		Reporter: &jconfig.ReporterConfig{
-			LocalAgentHostPort: url,
-			LogSpans:           true,
-		},
-	}.NewTracer()
-	if err != nil {
-		logger.Error(fmt.Sprintf("Failed to init Jaeger: %s", err))
-		os.Exit(1)
-	}
-
-	return tracer, closer
-}
-
-func connectToAuth(cfg config, tracer opentracing.Tracer, logger logger.Logger) (clients.AuthServiceClient, func() error) {
-	var opts []grpc.DialOption
-	if cfg.authTLS {
-		if cfg.authCACerts != "" {
-			tpc, err := credentials.NewClientTLSFromFile(cfg.authCACerts, "")
-			if err != nil {
-				logger.Error(fmt.Sprintf("Failed to create tls credentials: %s", err))
-				os.Exit(1)
-			}
-			opts = append(opts, grpc.WithTransportCredentials(tpc))
-		}
-	} else {
-		opts = append(opts, grpc.WithInsecure())
-		logger.Info("gRPC communication is not encrypted")
-	}
-
-	conn, err := grpc.Dial(cfg.authURL, opts...)
-	if err != nil {
-		logger.Error(fmt.Sprintf("Failed to connect to auth service: %s", err))
-		os.Exit(1)
-	}
-	return authapi.NewClient(tracer, conn, cfg.authTimeout), conn.Close
-}

cmd/datasets/main.go

@@ -1,141 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"log"
-	"os"
-	"strconv"
-	"time"
-
-	"github.com/mainflux/mainflux"
-	"github.com/mainflux/mainflux/logger"
-	"github.com/mainflux/mainflux/pkg/uuid"
-	"github.com/ultravioletrs/cocos/datasets"
-	"github.com/ultravioletrs/cocos/datasets/api"
-	"github.com/ultravioletrs/cocos/datasets/postgres"
-	"github.com/ultravioletrs/cocos/internal/db"
-	"github.com/ultravioletrs/cocos/internal/env"
-	"github.com/ultravioletrs/cocos/internal/errors"
-	"github.com/ultravioletrs/cocos/internal/http"
-	"golang.org/x/sync/errgroup"
-)
-
-const (
-	defLogLevel      = "debug"
-	defDBHost        = "localhost"
-	defDBPort        = "5432"
-	defDBUser        = "cocos"
-	defDBPass        = "cocos"
-	defDB            = "datasets"
-	defDBSSLMode     = "disable"
-	defDBSSLCert     = ""
-	defDBSSLKey      = ""
-	defDBSSLRootCert = ""
-	defHTTPPort      = "9001"
-	defServerCert    = ""
-	defServerKey     = ""
-
-	defAuthTLS     = "false"
-	defAuthCACerts = ""
-	defAuthURL     = "localhost:8181"
-	defAuthTimeout = "1s"
-
-	envLogLevel      = "COCOS_DATASETS_LOG_LEVEL"
-	envDBHost        = "COCOS_DATASETS_DB_HOST"
-	envDBPort        = "COCOS_DATASETS_DB_PORT"
-	envDBUser        = "COCOS_DATASETS_DB_USER"
-	envDBPass        = "COCOS_DATASETS_DB_PASS"
-	envDB            = "COCOS_DATASETS_DB"
-	envDBSSLMode     = "COCOS_DATASETS_DB_SSL_MODE"
-	envDBSSLCert     = "COCOS_DATASETS_DB_SSL_CERT"
-	envDBSSLKey      = "COCOS_DATASETS_DB_SSL_KEY"
-	envDBSSLRootCert = "COCOS_DATASETS_DB_SSL_ROOT_CERT"
-	envHTTPPort      = "COCOS_DATASETS_HTTP_PORT"
-	envServerCert    = "COCOS_DATASETS_SERVER_CERT"
-	envServerKey     = "COCOS_DATASETS_SERVER_KEY"
-
-	envAuthTLS     = "COCOS_DATASETS_AUTH_CLIENT_TLS"
-	envAuthCACerts = "COCOS_DATASETS_AUTH_CA_CERTS"
-	envAuthURL     = "COCOS_DATASETS_AUTH_GRPC_URL"
-	envAuthTimeout = "COCOS_DATASETS_AUTH_GRPC_TIMEOUT"
-)
-
-const svcName = "Datasets"
-
-type config struct {
-	logLevel    string
-	dbConfig    db.Config
-	httpPort    string
-	serverCert  string
-	serverKey   string
-	authTLS     bool
-	authCACerts string
-	authURL     string
-	authTimeout time.Duration
-}
-
-func loadConfig() config {
-	authTimeout, err := time.ParseDuration(mainflux.Env(envAuthTimeout, defAuthTimeout))
-	if err != nil {
-		log.Fatalf("Invalid %s value: %s", envAuthTimeout, err.Error())
-	}
-
-	tls, err := strconv.ParseBool(mainflux.Env(envAuthTLS, defAuthTLS))
-	if err != nil {
-		log.Fatalf("Invalid value passed for %s\n", envAuthTLS)
-	}
-
-	dbConfig := db.Config{
-		Host:        env.Load(envDBHost, defDBHost),
-		Port:        env.Load(envDBPort, defDBPort),
-		User:        env.Load(envDBUser, defDBUser),
-		Pass:        env.Load(envDBPass, defDBPass),
-		Name:        env.Load(envDB, defDB),
-		SSLMode:     env.Load(envDBSSLMode, defDBSSLMode),
-		SSLCert:     env.Load(envDBSSLCert, defDBSSLCert),
-		SSLKey:      env.Load(envDBSSLKey, defDBSSLKey),
-		SSLRootCert: env.Load(envDBSSLRootCert, defDBSSLRootCert),
-		Migrations:  postgres.Migrations,
-	}
-	return config{
-		dbConfig:    dbConfig,
-		authTLS:     tls,
-		authTimeout: authTimeout,
-		logLevel:    env.Load(envLogLevel, defLogLevel),
-		httpPort:    env.Load(envHTTPPort, defHTTPPort),
-		serverCert:  env.Load(envServerCert, defServerCert),
-		serverKey:   env.Load(envServerKey, defServerKey),
-		authCACerts: env.Load(envAuthCACerts, defAuthCACerts),
-		authURL:     env.Load(envAuthURL, defAuthURL),
-	}
-}
-
-func main() {
-	cfg := loadConfig()
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	g, ctx := errgroup.WithContext(ctx)
-	l, err := logger.New(os.Stdout, cfg.logLevel)
-	if err != nil {
-		log.Fatalf(err.Error())
-	}
-	db, err := db.Connect(cfg.dbConfig)
-	if err != nil {
-		log.Fatalf(err.Error())
-	}
-
-	repo := postgres.NewRepository(db)
-	idp := uuid.New()
-	svc := datasets.NewService(repo, idp)
-	svc = api.LoggingMiddleware(svc, l)
-	h := api.MakeHandler(svc, nil, l)
-
-	g.Go(func() error {
-		return http.StartServer(ctx, svcName, cfg.httpPort, cfg.serverCert, cfg.serverKey, h, l)
-	})
-	g.Go(errors.Handle(svcName, l, ctx, cancel))
-	if err := g.Wait(); err != nil {
-		l.Error(fmt.Sprintf("%s service terminated: %s", svcName, err))
-	}
-}

cmd/manager/main.go

@@ -0,0 +1,135 @@
+// Copyright (c) Ultraviolet
+// SPDX-License-Identifier: Apache-2.0
+
+package main
+
+import (
+	"context"
+	"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/manager"
+	"github.com/ultravioletrs/cocos/manager/api"
+	managerapi "github.com/ultravioletrs/cocos/manager/api/grpc"
+	"github.com/ultravioletrs/cocos/manager/qemu"
+	"github.com/ultravioletrs/cocos/manager/tracing"
+	"github.com/ultravioletrs/cocos/pkg/clients/grpc"
+	managergrpc "github.com/ultravioletrs/cocos/pkg/clients/grpc/manager"
+	pkgmanager "github.com/ultravioletrs/cocos/pkg/manager"
+	"go.opentelemetry.io/otel/trace"
+	"golang.org/x/sync/errgroup"
+)
+
+const (
+	svcName       = "manager"
+	envPrefixGRPC = "MANAGER_GRPC_"
+	envPrefixQemu = "MANAGER_QEMU_"
+)
+
+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"`
+}
+
+func main() {
+	ctx, cancel := context.WithCancel(context.Background())
+	g, ctx := errgroup.WithContext(ctx)
+
+	var cfg config
+	if err := env.Parse(&cfg); err != nil {
+		log.Fatalf("failed to load %s configuration : %s", svcName, err)
+	}
+
+	logger, err := mglog.New(os.Stdout, cfg.LogLevel)
+	if err != nil {
+		log.Fatalf(err.Error())
+	}
+
+	if cfg.InstanceID == "" {
+		if cfg.InstanceID, err = uuid.New().ID(); 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)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to init Jaeger: %s", err))
+	}
+	defer func() {
+		if err := tp.Shutdown(ctx); err != nil {
+			logger.Error(fmt.Sprintf("Error shutting down tracer provider: %v", err))
+		}
+	}()
+	tracer := tp.Tracer(svcName)
+
+	qemuCfg := qemu.Config{}
+	if err := env.ParseWithOptions(&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, " "))
+
+	managerGRPCConfig := grpc.Config{}
+	if err := env.ParseWithOptions(&managerGRPCConfig, env.Options{Prefix: envPrefixGRPC}); err != nil {
+		logger.Error(fmt.Sprintf("failed to load %s gRPC client configuration : %s", svcName, err))
+		return
+	}
+
+	managerGRPCClient, managerClient, err := managergrpc.NewManagerClient(managerGRPCConfig)
+	if err != nil {
+		logger.Error(err.Error())
+		return
+	}
+	defer managerGRPCClient.Close()
+
+	pc, err := managerClient.Process(ctx)
+	if err != nil {
+		logger.Error(err.Error())
+		return
+	}
+
+	eventsChan := make(chan *pkgmanager.ClientStreamMessage)
+	svc, err := newService(logger, tracer, qemuCfg, eventsChan, cfg.BackendMeasurementBinary)
+	if err != nil {
+		logger.Error(err.Error())
+		return
+	}
+
+	mc := managerapi.NewClient(pc, svc, eventsChan)
+
+	g.Go(func() error {
+		return mc.Process(ctx, cancel)
+	})
+
+	if err := g.Wait(); err != nil {
+		logger.Error(fmt.Sprintf("%s service terminated: %s", svcName, err))
+	}
+}
+
+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
+	}
+	go svc.RetrieveAgentEventsLogs()
+	svc = api.LoggingMiddleware(svc, logger)
+	counter, latency := prometheus.MakeMetrics(svcName, "api")
+	svc = api.MetricsMiddleware(svc, counter, latency)
+	svc = tracing.New(svc, tracer)
+
+	return svc, nil
+}

cmd/manager/start_VM.sh

@@ -0,0 +1,62 @@
+#!/bin/bash
+
+# Set your default values for sudo and sev
+sudo_option=false
+sev_option=false
+
+# Parse command line arguments
+while [[ $# -gt 0 ]]; do
+    key="$1"
+
+    case $key in
+        --sudo)
+            sudo_option=true
+            shift
+            ;;
+        --sev)
+            sev_option=true
+            shift
+            ;;
+        *)
+            echo "Unknown option: $key"
+            exit 1
+            ;;
+    esac
+done
+
+build_qemu_command() {
+    local qemu_command="/usr/bin/qemu-system-x86_64 -enable-kvm -machine q35 -cpu EPYC -smp 4,maxcpus=64 -m 2048M,slots=5,maxmem=30G -drive if=pflash,format=raw,unit=0,file=$MANAGER_QEMU_OVMF_CODE_FILE,readonly=on -drive if=pflash,format=raw,unit=1,file=img/OVMF_VARS.fd -device virtio-scsi-pci,id=scsi,disable-legacy=on,iommu_platform=true -drive file=img/focal-server-cloudimg-amd64.img,if=none,id=disk0,format=qcow2 -device scsi-hd,drive=disk0 -netdev user,id=vmnic,hostfwd=tcp::2222-:22,hostfwd=tcp::9301-:9031,hostfwd=tcp::7020-:7002 -device virtio-net-pci,disable-legacy=on,iommu_platform=true,netdev=vmnic,romfile= -nographic -monitor pty"
+
+    if [ "$sev_option" = true ]; then
+        qemu_command="$qemu_command -object sev-guest,id=sev0,cbitpos=51,reduced-phys-bits=1 -machine memory-encryption=sev0"
+    fi
+
+    echo "$qemu_command"
+}
+
+if [ ! -f "img/OVMF_VARS.fd" ]; then
+    cp "$MANAGER_QEMU_OVMF_VARS_FILE" "img/OVMF_VARS.fd"
+    echo "Copied $MANAGER_QEMU_OVMF_VARS_FILE to img/OVMF_VARS.fd"
+else
+    echo "img/OVMF_VARS.fd already exists. No need to copy."
+fi
+
+echo "Launching VM ..."
+
+qemu_command=$(build_qemu_command)
+echo "$qemu_command"
+
+echo "Mapping CTRL-C to CTRL-]"
+stty intr ^]
+
+if [ "$sudo_option" = true ]; then
+    # Split the command and arguments into an array; << operator is known as a "here string"
+    IFS=" " read -r -a qemu_command_array <<< "$qemu_command"
+    # Treat each element in the array as a separate word, preserving spaces within each element
+    sudo "${qemu_command_array[@]}"
+else
+    $qemu_command
+fi
+
+# Restore the mapping
+stty intr ^c

cmd/manager/xml/dom.xml

@@ -0,0 +1,62 @@
+<domain type="kvm">
+  <name>QEmu-alpine-standard-x86_64</name>
+  <uuid>c7a5fdbd-cdaf-9455-926a-d65c16db1809</uuid>
+  <metadata>
+    <libosinfo:libosinfo xmlns:libosinfo="http://libosinfo.org/xmlns/libvirt/domain/1.0">
+      <libosinfo:os id="http://alpinelinux.org/alpinelinux/3.15"/>
+    </libosinfo:libosinfo>
+  </metadata>
+  <memory unit="KiB">4194304</memory>
+  <currentMemory unit="KiB">4194304</currentMemory>
+  <vcpu placement="static">1</vcpu>
+  <os>
+    <type arch="x86_64" machine="q35">hvm</type>
+    <bootmenu enable="yes"/>
+    <loader readonly="yes" type="pflash">/usr/share/OVMF/OVMF_CODE.fd</loader>
+    <nvram template='/usr/share/OVMF/OVMF_VARS.fd'>./img/OVMF_VARS.fd</nvram>
+    <!-- <boot dev='hd'/> -->
+  </os>
+  <features>
+    <acpi/>
+    <apic/>
+    <vmport state="off"/>
+  </features>
+  <cpu mode="host-passthrough" check="none" migratable="on"/>
+  <clock offset="utc">
+    <timer name="rtc" tickpolicy="catchup"/>
+    <timer name="pit" tickpolicy="delay"/>
+    <timer name="hpet" present="no"/>
+  </clock>
+  <on_poweroff>destroy</on_poweroff>
+  <on_reboot>restart</on_reboot>
+  <on_crash>destroy</on_crash>
+  <pm>
+    <suspend-to-mem enabled="no"/>
+    <suspend-to-disk enabled="no"/>
+  </pm>
+  <devices>
+    <emulator>/usr/bin/qemu-system-x86_64</emulator>
+    <disk type="file" device="disk">
+      <driver name="qemu" type="qcow2" discard="unmap"/>
+      <source file="./img/focal-server-cloudimg-amd64.qcow2"/>
+      <target dev="vda" bus="virtio"/>
+      <address type="pci" domain="0x0000" bus="0x04" slot="0x00" function="0x0"/>
+      <boot order="1"/>
+    </disk>
+    <graphics type="spice" autoport="yes">
+      <listen type="address"/>
+      <image compression="off"/>
+    </graphics>
+    <video>
+      <model type="qxl" ram="65536" vram="65536" vgamem="16384" heads="1" primary="yes"/>
+      <address type="pci" domain="0x0000" bus="0x00" slot="0x01" function="0x0"/>
+    </video>
+    <interface type="network">
+      <mac address="52:54:00:03:7b:5f"/>
+      <source network="default"/>
+      <model type="virtio"/>
+      <address type="pci" domain="0x0000" bus="0x01" slot="0x00" function="0x0"/>
+    </interface>
+  </devices>
+
+</domain>

cmd/manager/xml/pool.xml

@@ -0,0 +1,6 @@
+<pool type="dir">
+<name>virtimages</name>
+<target>
+  <path>./img</path>
+</target>
+</pool>

cmd/manager/xml/vol.xml

@@ -0,0 +1,15 @@
+<volume>
+<name>boot.img</name>
+<allocation>0</allocation>
+<capacity unit="G">1</capacity>
+<target>
+  <format type="qcow2"/>
+  <path>./img/boot.img</path>
+  <permissions>
+	<owner>107</owner>
+	<group>107</group>
+	<mode>0744</mode>
+	<label>virt_image_t</label>
+  </permissions>
+</target>
+</volume>

computations/api/api/doc.go

@@ -1,4 +0,0 @@
-// Package api contains API-related concerns: endpoint
-// definitions, middlewares, and all resource representations.
-
-package api

computations/api/api/endpoint.go

@@ -1,106 +0,0 @@
-package api
-
-import (
-	"context"
-
-	"github.com/go-kit/kit/endpoint"
-	"github.com/mainflux/mainflux/pkg/errors"
-	"github.com/ultravioletrs/cocos/computations"
-)
-
-func create(svc computations.Service) endpoint.Endpoint {
-	return func(ctx context.Context, request interface{}) (interface{}, error) {
-		req := request.(createReq)
-		if err := req.validate(); err != nil {
-			return createRes{}, err
-		}
-		cid, err := svc.CreateComputation(ctx, req.token, req.computation)
-		if err != nil {
-			return createRes{}, err
-		}
-		ret := createRes{
-			ID:      cid,
-			created: true,
-		}
-		return ret, nil
-	}
-}
-
-func view(svc computations.Service) endpoint.Endpoint {
-	return func(ctx context.Context, request interface{}) (interface{}, error) {
-		req := request.(viewReq)
-		if err := req.validate(); err != nil {
-			return viewRes{}, err
-		}
-		computation, err := svc.ViewComputation(ctx, req.token, req.id)
-		if err != nil {
-			return createRes{}, err
-		}
-		ret := viewRes{
-			Computation: computation,
-		}
-
-		return ret, nil
-	}
-}
-
-func list(svc computations.Service) endpoint.Endpoint {
-	return func(ctx context.Context, request interface{}) (interface{}, error) {
-		req := request.(listReq)
-		if err := req.validate(); err != nil {
-			return listRes{}, err
-		}
-		res, err := svc.ListComputations(ctx, req.token, req.meta)
-		if err != nil {
-			return listRes{}, err
-		}
-		ret := listRes{
-			Page: res,
-		}
-		return ret, nil
-	}
-}
-
-func update(svc computations.Service) endpoint.Endpoint {
-	return func(ctx context.Context, request interface{}) (interface{}, error) {
-		req := request.(updateReq)
-		if err := req.validate(); err != nil {
-			return nil, err
-		}
-
-		computation := computations.Computation{
-			ID:          req.id,
-			Name:        req.Name,
-			Description: req.Description,
-			Metadata:    req.Metadata,
-		}
-
-		if err := svc.UpdateComputation(ctx, req.token, computation); err != nil {
-			return nil, err
-		}
-
-		res := createRes{ID: req.id, created: false}
-		return res, nil
-	}
-}
-
-func remove(svc computations.Service) endpoint.Endpoint {
-	return func(ctx context.Context, request interface{}) (interface{}, error) {
-		req := request.(viewReq)
-
-		err := req.validate()
-		if err == errors.ErrNotFound {
-			return removeRes{}, nil
-		}
-
-		if err != nil {
-			return nil, err
-		}
-
-		if err := svc.RemoveComputation(ctx, req.token, req.id); err != nil {
-			return nil, err
-		}
-
-		return removeRes{}, nil
-	}
-}

computations/api/api/logging.go

@@ -1,84 +0,0 @@
-//go:build !test
-
-package api
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	log "github.com/mainflux/mainflux/logger"
-	"github.com/ultravioletrs/cocos/computations"
-)
-
-var _ computations.Service = (*loggingMiddleware)(nil)
-
-type loggingMiddleware struct {
-	logger log.Logger
-	svc    computations.Service
-}
-
-// LoggingMiddleware adds logging facilities to the core service.
-func LoggingMiddleware(svc computations.Service, logger log.Logger) computations.Service {
-	return &loggingMiddleware{logger, svc}
-}
-
-func (lm *loggingMiddleware) CreateComputation(ctx context.Context, token string, computation computations.Computation) (id string, err error) {
-	defer func(begin time.Time) {
-		message := fmt.Sprintf("Method create_computation for user %s took %s to complete", token, time.Since(begin))
-		if err != nil {
-			lm.logger.Warn(fmt.Sprintf("%s with error: %s.", message, err))
-			return
-		}
-		lm.logger.Info(fmt.Sprintf("%s without errors.", message))
-	}(time.Now())
-	return lm.svc.CreateComputation(ctx, token, computation)
-}
-
-func (lm *loggingMiddleware) ViewComputation(ctx context.Context, token, id string) (c computations.Computation, err error) {
-	defer func(begin time.Time) {
-		message := fmt.Sprintf("Method view_computation for user %s took %s to complete", token, time.Since(begin))
-		if err != nil {
-			lm.logger.Warn(fmt.Sprintf("%s with error: %s.", message, err))
-			return
-		}
-		lm.logger.Info(fmt.Sprintf("%s without errors.", message))
-	}(time.Now())
-	return lm.svc.ViewComputation(ctx, token, id)
-}
-
-func (lm *loggingMiddleware) ListComputations(ctx context.Context, token string, meta computations.PageMetadata) (page computations.Page, err error) {
-	defer func(begin time.Time) {
-		message := fmt.Sprintf("Method list_computations for user %s took %s to complete", token, time.Since(begin))
-		if err != nil {
-			lm.logger.Warn(fmt.Sprintf("%s with error: %s.", message, err))
-			return
-		}
-		lm.logger.Info(fmt.Sprintf("%s without errors.", message))
-	}(time.Now())
-	return lm.svc.ListComputations(ctx, token, meta)
-}
-
-func (lm *loggingMiddleware) UpdateComputation(ctx context.Context, token string, computation computations.Computation) (err error) {
-	defer func(begin time.Time) {
-		message := fmt.Sprintf("Method update_computation for user %s took %s to complete", token, time.Since(begin))
-		if err != nil {
-			lm.logger.Warn(fmt.Sprintf("%s with error: %s.", message, err))
-			return
-		}
-		lm.logger.Info(fmt.Sprintf("%s without errors.", message))
-	}(time.Now())
-	return lm.svc.UpdateComputation(ctx, token, computation)
-}
-
-func (lm *loggingMiddleware) RemoveComputation(ctx context.Context, token, id string) (err error) {
-	defer func(begin time.Time) {
-		message := fmt.Sprintf("Method remove_computation for user %s took %s to complete", token, time.Since(begin))
-		if err != nil {
-			lm.logger.Warn(fmt.Sprintf("%s with error: %s.", message, err))
-			return
-		}
-		lm.logger.Info(fmt.Sprintf("%s without errors.", message))
-	}(time.Now())
-	return lm.svc.RemoveComputation(ctx, token, id)
-}

computations/api/api/metrics.go

@@ -1,68 +0,0 @@
-//go:build !test
-
-package api
-
-import (
-	"context"
-	"time"
-
-	"github.com/go-kit/kit/metrics"
-	"github.com/ultravioletrs/cocos/computations"
-)
-
-var _ computations.Service = (*metricsMiddleware)(nil)
-
-type metricsMiddleware struct {
-	counter metrics.Counter
-	latency metrics.Histogram
-	svc     computations.Service
-}
-
-// MetricsMiddleware instruments core service by tracking request count and latency.
-func MetricsMiddleware(svc computations.Service, counter metrics.Counter, latency metrics.Histogram) computations.Service {
-	return &metricsMiddleware{
-		counter: counter,
-		latency: latency,
-		svc:     svc,
-	}
-}
-
-func (ms *metricsMiddleware) CreateComputation(ctx context.Context, token string, computation computations.Computation) (string, error) {
-	defer func(begin time.Time) {
-		ms.counter.With("method", "create_computation").Add(1)
-		ms.latency.With("method", "create_computation").Observe(time.Since(begin).Seconds())
-	}(time.Now())
-	return ms.svc.CreateComputation(ctx, token, computation)
-}
-
-func (ms *metricsMiddleware) ViewComputation(ctx context.Context, token, id string) (computations.Computation, error) {
-	defer func(begin time.Time) {
-		ms.counter.With("method", "view_computation").Add(1)
-		ms.latency.With("method", "view_computation").Observe(time.Since(begin).Seconds())
-	}(time.Now())
-	return ms.svc.ViewComputation(ctx, token, id)
-}
-
-func (ms *metricsMiddleware) ListComputations(ctx context.Context, token string, meta computations.PageMetadata) (page computations.Page, err error) {
-	defer func(begin time.Time) {
-		ms.counter.With("method", "list_computations").Add(1)
-		ms.latency.With("method", "list_computations").Observe(time.Since(begin).Seconds())
-	}(time.Now())
-	return ms.svc.ListComputations(ctx, token, meta)
-}
-
-func (ms *metricsMiddleware) UpdateComputation(ctx context.Context, token string, computation computations.Computation) error {
-	defer func(begin time.Time) {
-		ms.counter.With("method", "update_computations").Add(1)
-		ms.latency.With("method", "update_computations").Observe(time.Since(begin).Seconds())
-	}(time.Now())
-	return ms.svc.UpdateComputation(ctx, token, computation)
-}
-
-func (ms *metricsMiddleware) RemoveComputation(ctx context.Context, token, id string) error {
-	defer func(begin time.Time) {
-		ms.counter.With("method", "remove_computation").Add(1)
-		ms.latency.With("method", "remove_computation").Observe(time.Since(begin).Seconds())
-	}(time.Now())
-	return ms.svc.RemoveComputation(ctx, token, id)
-}

computations/api/api/requests.go

@@ -1,42 +0,0 @@
-package api
-
-import "github.com/ultravioletrs/cocos/computations"
-
-type createReq struct {
-	computation computations.Computation
-	token       string
-}
-
-func (req createReq) validate() error {
-	return req.computation.Validate()
-}
-
-type viewReq struct {
-	token string
-	id    string
-}
-
-func (req viewReq) validate() error {
-	return nil
-}
-
-type listReq struct {
-	token string
-	meta  computations.PageMetadata
-}
-
-func (req listReq) validate() error {
-	return nil
-}
-
-type updateReq struct {
-	token       string
-	id          string
-	Name        string                 `json:"name,omitempty"`
-	Description string                 `json:"description,omitempty"`
-	Metadata    map[string]interface{} `json:"metadata,omitempty"`
-}
-
-func (req updateReq) validate() error {
-	return nil
-}

computations/api/api/responses.go

@@ -1,85 +0,0 @@
-package api
-
-import (
-	"fmt"
-	"net/http"
-
-	"github.com/ultravioletrs/cocos/computations"
-)
-
-type createRes struct {
-	ID      string
-	created bool
-}
-
-func (res createRes) Code() int {
-	if res.created {
-		return http.StatusCreated
-	}
-
-	return http.StatusOK
-}
-
-func (res createRes) Headers() map[string]string {
-	if res.created {
-		return map[string]string{
-			"Location": fmt.Sprintf("/computations/%s", res.ID),
-		}
-	}
-
-	return map[string]string{}
-}
-
-func (res createRes) Empty() bool {
-	return true
-}
-
-type viewRes struct {
-	computations.Computation
-}
-
-func (res viewRes) Code() int {
-	return http.StatusOK
-}
-
-func (res viewRes) Headers() map[string]string {
-	return map[string]string{}
-}
-
-func (res viewRes) Empty() bool {
-	return false
-}
-
-type errorRes struct {
-	Err string `json:"error"`
-}
-
-type listRes struct {
-	computations.Page
-}
-
-func (res listRes) Code() int {
-	return http.StatusOK
-}
-
-func (res listRes) Headers() map[string]string {
-	return map[string]string{}
-}
-
-func (res listRes) Empty() bool {
-	return false
-}
-
-type removeRes struct{}
-
-func (res removeRes) Code() int {
-	return http.StatusNoContent
-}
-
-func (res removeRes) Headers() map[string]string {
-	return map[string]string{}
-}
-
-func (res removeRes) Empty() bool {
-	return true
-}

computations/api/api/transport.go

@@ -1,201 +0,0 @@
-package api
-
-import (
-	"context"
-	"encoding/json"
-	"net/http"
-	"strings"
-
-	kithttp "github.com/go-kit/kit/transport/http"
-	"github.com/go-zoo/bone"
-	"github.com/mainflux/mainflux"
-	log "github.com/mainflux/mainflux/logger"
-	"github.com/mainflux/mainflux/pkg/errors"
-	opentracing "github.com/opentracing/opentracing-go"
-	"github.com/prometheus/client_golang/prometheus/promhttp"
-	"github.com/ultravioletrs/cocos/computations"
-	"github.com/ultravioletrs/cocos/internal/apiutil"
-	httputil "github.com/ultravioletrs/cocos/internal/http"
-)
-
-const (
-	contentType  = "application/json"
-	offsetKey    = "offset"
-	limitKey     = "limit"
-	orderKey     = "order"
-	dirKey       = "dir"
-	metadataKey  = "metadata"
-	defOffset    = 0
-	defLimit     = 10
-	bearerPrefix = "Bearer "
-)
-
-// MakeHandler returns a HTTP handler for API endpoints.
-func MakeHandler(svc computations.Service, tracer opentracing.Tracer, logger log.Logger) http.Handler {
-	opts := []kithttp.ServerOption{
-		kithttp.ServerErrorEncoder(apiutil.LoggingErrorEncoder(logger, encodeError)),
-	}
-	mux := bone.New()
-
-	mux.Post("/computations", kithttp.NewServer(
-		// kitot.TraceServer(tracer, "register")(createComputation(svc)),
-		create(svc),
-		decodeCreate,
-		encodeResponse,
-		opts...,
-	))
-
-	mux.Get("/computations", kithttp.NewServer(
-		// kitot.TraceServer(tracer, "register")(createComputation(svc)),
-		list(svc),
-		decodeList,
-		encodeResponse,
-		opts...,
-	))
-
-	mux.Get("/computations/:id", kithttp.NewServer(
-		view(svc),
-		decodeView,
-		encodeResponse,
-		opts...,
-	))
-
-	mux.Put("/computations/:id", kithttp.NewServer(
-		update(svc),
-		decodeUpdate,
-		encodeResponse,
-		opts...,
-	))
-
-	mux.Delete("/computations/:id", kithttp.NewServer(
-		remove(svc),
-		decodeView,
-		encodeResponse,
-		opts...,
-	))
-
-	mux.GetFunc("/health", httputil.Health("computations", "Computation management service"))
-	mux.Handle("/metrics", promhttp.Handler())
-
-	return mux
-}
-
-func decodeCreate(_ context.Context, r *http.Request) (interface{}, error) {
-	req := createReq{
-		token: extractBearerToken(r),
-	}
-	if err := json.NewDecoder(r.Body).Decode(&req.computation); err != nil {
-		return nil, errors.Wrap(errors.ErrMalformedEntity, err)
-	}
-
-	return req, nil
-}
-
-func decodeList(_ context.Context, r *http.Request) (interface{}, error) {
-	o, err := apiutil.ReadUintQuery(r, offsetKey, defOffset)
-	if err != nil {
-		return nil, err
-	}
-
-	l, err := apiutil.ReadUintQuery(r, limitKey, defLimit)
-	if err != nil {
-		return nil, err
-	}
-
-	or, err := apiutil.ReadStringQuery(r, orderKey, "")
-	if err != nil {
-		return nil, err
-	}
-
-	d, err := apiutil.ReadStringQuery(r, dirKey, "")
-	if err != nil {
-		return nil, err
-	}
-
-	m, err := apiutil.ReadMetadataQuery(r, metadataKey, nil)
-	if err != nil {
-		return nil, err
-	}
-	req := listReq{
-
-		token: extractBearerToken(r),
-		meta: computations.PageMetadata{
-			Offset:   o,
-			Limit:    l,
-			Order:    or,
-			Dir:      d,
-			Metadata: m,
-		},
-	}
-
-	return req, nil
-}
-
-func decodeView(_ context.Context, r *http.Request) (interface{}, error) {
-	req := viewReq{
-		token: extractBearerToken(r),
-		id:    bone.GetValue(r, "id"),
-	}
-	return req, nil
-}
-
-func decodeUpdate(_ context.Context, r *http.Request) (interface{}, error) {
-	if !strings.Contains(r.Header.Get("Content-Type"), contentType) {
-		return nil, errors.ErrUnsupportedContentType
-	}
-
-	req := updateReq{
-		token: extractBearerToken(r),
-		id:    bone.GetValue(r, "id"),
-	}
-
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		return nil, errors.Wrap(errors.ErrMalformedEntity, err)
-	}
-
-	return req, nil
-}
-
-func encodeResponse(_ context.Context, w http.ResponseWriter, response interface{}) error {
-	if ar, ok := response.(mainflux.Response); ok {
-		for k, v := range ar.Headers() {
-			w.Header().Set(k, v)
-		}
-		w.Header().Set("Content-Type", contentType)
-		w.WriteHeader(ar.Code())
-
-		if ar.Empty() {
-			return nil
-		}
-	}
-	return json.NewEncoder(w).Encode(response)
-}
-
-func encodeError(_ context.Context, err error, w http.ResponseWriter) {
-	switch {
-	case errors.Contains(err, errors.ErrInvalidQueryParams),
-		errors.Contains(err, errors.ErrMalformedEntity):
-		w.WriteHeader(http.StatusBadRequest)
-	case errors.Contains(err, errors.ErrCreateEntity),
-		errors.Contains(err, errors.ErrUpdateEntity),
-		errors.Contains(err, errors.ErrViewEntity),
-		errors.Contains(err, errors.ErrRemoveEntity):
-		w.WriteHeader(http.StatusInternalServerError)
-	default:
-		w.WriteHeader(http.StatusInternalServerError)
-	}
-	if errorVal, ok := err.(errors.Error); ok {
-		w.Header().Set("Content-Type", contentType)
-		if err := json.NewEncoder(w).Encode(errorRes{Err: errorVal.Msg()}); err != nil {
-			w.WriteHeader(http.StatusInternalServerError)
-		}
-	}
-}
-
-func extractBearerToken(r *http.Request) string {
-	token := r.Header.Get("Authorization")
-	if !strings.HasPrefix(token, bearerPrefix) {
-		return ""
-	}
-	return strings.TrimPrefix(token, bearerPrefix)
-}

computations/computations.go

@@ -1,51 +0,0 @@
-package computations
-
-import (
-	"context"
-	"time"
-)
-
-type Computation struct {
-	ID                 string    `json:"id,omitempty" db:"id"`
-	Name               string    `json:"name,omitempty" db:"name"`
-	Description        string    `json:"description,omitempty" db:"description"`
-	Status             string    `json:"status,omitempty" db:"status"`
-	Owner              string    `json:"owner,omitempty" db:"owner"`
-	StartTime          time.Time `json:"start_time,omitempty" db:"start_time"`
-	EndTime            time.Time `json:"end_time,omitempty" db:"end_time"`
-	Datasets           []string  `json:"datasets,omitempty" db:"datasets"`
-	Algorithms         []string  `json:"algorithms,omitempty" db:"algorithms"`
-	DatasetProviders   []string  `json:"dataset_providers,omitempty" db:"dataset_providers"`
-	AlgorithmProviders []string  `json:"algorithm_providers,omitempty" db:"algorithm_providers"`
-	Ttl                int       `json:"ttl,omitempty" db:"ttl"`
-	Metadata           Metadata  `json:"metadata,omitempty" db:"metadata"`
-}
-
-type Metadata map[string]interface{}
-
-type PageMetadata struct {
-	Total    uint64   `json:"total,omitempty"`
-	Offset   uint64   `json:"offset,omitempty"`
-	Limit    uint64   `json:"limit,omitempty"`
-	Name     string   `json:"name,omitempty"`
-	Order    string   `json:"order,omitempty"`
-	Dir      string   `json:"dir,omitempty"`
-	Metadata Metadata `json:"metadata,omitempty"`
-}
-
-type Page struct {
-	PageMetadata
-	Computations []Computation `json:"computations,omitempty"`
-}
-
-func (c Computation) Validate() error {
-	return nil
-}
-
-type Repository interface {
-	Save(ctx context.Context, c Computation) (string, error)
-	View(ctx context.Context, id string) (Computation, error)
-	RetrieveAll(ctx context.Context, owner string, pm PageMetadata) (Page, error)
-	Update(ctx context.Context, c Computation) error
-	Delete(ctx context.Context, id string) error
-}

computations/doc.go

@@ -1,4 +0,0 @@
-// Package computations contains domain concept definitions
-// needed to support Computations service functionality.
-
-package computations

computations/postgres/computations.go

@@ -1,355 +0,0 @@
-package postgres
-
-import (
-	"context"
-	"database/sql"
-	"encoding/json"
-	"fmt"
-	"strings"
-	"time"
-
-	"github.com/lib/pq"
-	"github.com/mainflux/mainflux/pkg/errors"
-	"github.com/ultravioletrs/cocos/computations"
-	db "github.com/ultravioletrs/cocos/internal/db"
-)
-
-const (
-	errInvalid    = "invalid_text_representation"
-	errTruncation = "string_data_right_truncation"
-	errDuplicate  = "unique_violation"
-)
-
-var _ computations.Repository = (*computationRepo)(nil)
-
-type computationRepo struct {
-	db db.Database
-}
-
-func NewRepository(db db.Database) computations.Repository {
-	return computationRepo{
-		db: db,
-	}
-}
-
-func (repo computationRepo) Save(ctx context.Context, c computations.Computation) (string, error) {
-	q := `INSERT INTO computations (id, name, description, status, owner, start_time, end_time, datasets, algorithms, dataset_providers, algorithm_providers, ttl, metadata)
-	VALUES (:id, :name, :description, :status, :owner, :start_time, :end_time, :datasets, :algorithms, :dataset_providers, :algorithm_providers, :ttl, :metadata) RETURNING id`
-	comp, err := fromComputation(c)
-	if err != nil {
-		return "", err
-	}
-	row, err := repo.db.NamedQueryContext(ctx, q, comp)
-	if err != nil {
-		pqErr, ok := err.(*pq.Error)
-		if ok {
-			switch pqErr.Code.Name() {
-			case errInvalid, errTruncation:
-				return "", errors.Wrap(errors.ErrMalformedEntity, err)
-			case errDuplicate:
-				return "", errors.Wrap(errors.ErrConflict, err)
-			}
-		}
-		return "", errors.Wrap(errors.ErrCreateEntity, err)
-	}
-
-	defer row.Close()
-	row.Next()
-	var id string
-	if err := row.Scan(&id); err != nil {
-		return "", err
-	}
-	return id, nil
-}
-
-func (repo computationRepo) View(ctx context.Context, id string) (computations.Computation, error) {
-	q := `SELECT id, name, description, status, owner, start_time, end_time, datasets, 
-				algorithms, dataset_providers, algorithm_providers, ttl, metadata
-				FROM computations
-				WHERE id = $1`
-
-	c := dbComputation{
-		ID: id,
-	}
-
-	if err := repo.db.QueryRowxContext(ctx, q, id).StructScan(&c); err != nil {
-		if err == sql.ErrNoRows {
-			return computations.Computation{}, errors.Wrap(errors.ErrNotFound, err)
-
-		}
-		return computations.Computation{}, errors.Wrap(errors.ErrViewEntity, err)
-	}
-
-	return toComputation(c)
-}
-
-func (repo computationRepo) RetrieveAll(ctx context.Context, owner string, pm computations.PageMetadata) (computations.Page, error) {
-	nq, name := getNameQuery(pm.Name)
-	oq := getOrderQuery(pm.Order)
-	dq := getDirQuery(pm.Dir)
-	m, mq, err := getMetadataQuery(pm.Metadata)
-	if err != nil {
-		return computations.Page{}, errors.Wrap(errors.ErrViewEntity, err)
-	}
-
-	var query []string
-	if mq != "" {
-		query = append(query, mq)
-	}
-	if nq != "" {
-		query = append(query, nq)
-	}
-
-	var whereClause string
-	if len(query) > 0 {
-		whereClause = fmt.Sprintf(" WHERE %s", strings.Join(query, " AND "))
-	}
-
-	q := `SELECT id, name, description, status, owner, start_time, end_time, datasets, 
-				algorithms, dataset_providers, algorithm_providers, ttl, metadata
-				FROM computations %s
-				ORDER BY %s %s LIMIT :limit OFFSET :offset`
-
-	q = fmt.Sprintf(q, whereClause, oq, dq)
-	params := map[string]interface{}{
-		"owner":    owner,
-		"limit":    pm.Limit,
-		"offset":   pm.Offset,
-		"name":     name,
-		"metadata": m,
-	}
-
-	rows, err := repo.db.NamedQueryContext(ctx, q, params)
-	if err != nil {
-		return computations.Page{}, errors.Wrap(errors.ErrViewEntity, err)
-	}
-	defer rows.Close()
-
-	var items []computations.Computation
-	for rows.Next() {
-		dbc := dbComputation{Owner: owner}
-		if err := rows.StructScan(&dbc); err != nil {
-			return computations.Page{}, errors.Wrap(errors.ErrViewEntity, err)
-		}
-
-		c, err := toComputation(dbc)
-		if err != nil {
-			return computations.Page{}, err
-		}
-
-		items = append(items, c)
-	}
-
-	cq := fmt.Sprintf(`SELECT COUNT(*) FROM computations %s;`, whereClause)
-
-	total, err := repo.total(ctx, cq, params)
-	if err != nil {
-		return computations.Page{}, errors.Wrap(errors.ErrViewEntity, err)
-	}
-
-	page := computations.Page{
-		Computations: items,
-		PageMetadata: computations.PageMetadata{
-			Total:  total,
-			Offset: pm.Offset,
-			Limit:  pm.Limit,
-			Order:  pm.Order,
-			Dir:    pm.Dir,
-		},
-	}
-
-	return page, nil
-}
-
-func (repo computationRepo) Update(ctx context.Context, c computations.Computation) error {
-	q := `UPDATE computations SET name = :name, metadata = :metadata, description = :description WHERE id = :id;`
-	dbcpt, err := toDBComputation(c)
-	if err != nil {
-		return errors.Wrap(errors.ErrUpdateEntity, err)
-	}
-	res, errdb := repo.db.NamedExecContext(ctx, q, dbcpt)
-	if errdb != nil {
-		pqErr, ok := errdb.(*pq.Error)
-		if ok {
-			switch pqErr.Code.Name() {
-			case errInvalid, errTruncation:
-				return errors.Wrap(errors.ErrMalformedEntity, errdb)
-			}
-		}
-		return errors.Wrap(errors.ErrUpdateEntity, errdb)
-
-	}
-
-	cnt, errdb := res.RowsAffected()
-	if errdb != nil {
-		return errors.Wrap(errors.ErrUpdateEntity, errdb)
-	}
-
-	if cnt == 0 {
-		return errors.ErrNotFound
-	}
-
-	return nil
-}
-
-func (repo computationRepo) Delete(ctx context.Context, id string) error {
-	q := `DELETE FROM computations WHERE id = :id`
-
-	c := dbComputation{
-		ID: id,
-	}
-
-	if _, err := repo.db.NamedExecContext(ctx, q, c); err != nil {
-		if err == sql.ErrNoRows {
-			return errors.Wrap(errors.ErrNotFound, err)
-
-		}
-		return errors.Wrap(errors.ErrViewEntity, err)
-	}
-
-	return nil
-}
-
-func (repo computationRepo) total(ctx context.Context, query string, params interface{}) (uint64, error) {
-	rows, err := repo.db.NamedQueryContext(ctx, query, params)
-	if err != nil {
-		return 0, err
-	}
-	defer rows.Close()
-	total := uint64(0)
-	if rows.Next() {
-		if err := rows.Scan(&total); err != nil {
-			return 0, err
-		}
-	}
-	return total, nil
-}
-
-type dbComputation struct {
-	ID                 string         `db:"id"`
-	Name               string         `db:"name"`
-	Description        string         `db:"description"`
-	Status             string         `db:"status"`
-	Owner              string         `db:"owner"`
-	StartTime          time.Time      `db:"start_time"`
-	EndTime            time.Time      `db:"end_time"`
-	Datasets           pq.StringArray `db:"datasets"`
-	Algorithms         pq.StringArray `db:"algorithms"`
-	DatasetProviders   pq.StringArray `db:"dataset_providers"`
-	AlgorithmProviders pq.StringArray `db:"algorithm_providers"`
-	Ttl                int            `db:"ttl"`
-	Metadata           []byte         `db:"metadata"`
-}
-
-func toComputation(c dbComputation) (computations.Computation, error) {
-	var metadata map[string]interface{}
-	if c.Metadata != nil {
-		if err := json.Unmarshal([]byte(c.Metadata), &metadata); err != nil {
-			return computations.Computation{}, errors.Wrap(errors.ErrMalformedEntity, err)
-		}
-	}
-	ret := computations.Computation{
-		ID:                 c.ID,
-		Name:               c.Name,
-		Description:        c.Description,
-		Status:             c.Status,
-		Owner:              c.Owner,
-		StartTime:          c.StartTime,
-		EndTime:            c.EndTime,
-		Datasets:           c.Datasets,
-		Algorithms:         c.Algorithms,
-		DatasetProviders:   c.DatasetProviders,
-		AlgorithmProviders: c.AlgorithmProviders,
-		Ttl:                c.Ttl,
-		Metadata:           metadata,
-	}
-	return ret, nil
-}
-
-func fromComputation(c computations.Computation) (dbComputation, error) {
-	metadata := []byte("{}")
-	if len(c.Metadata) > 0 {
-		b, err := json.Marshal(c.Metadata)
-		if err != nil {
-			return dbComputation{}, errors.Wrap(errors.ErrMalformedEntity, err)
-		}
-		metadata = b
-	}
-	ret := dbComputation{
-		ID:                 c.ID,
-		Name:               c.Name,
-		Description:        c.Description,
-		Status:             c.Status,
-		Owner:              c.Owner,
-		StartTime:          c.StartTime,
-		EndTime:            c.EndTime,
-		Datasets:           c.Datasets,
-		Algorithms:         c.Algorithms,
-		DatasetProviders:   c.DatasetProviders,
-		AlgorithmProviders: c.AlgorithmProviders,
-		Ttl:                c.Ttl,
-		Metadata:           metadata,
-	}
-	return ret, nil
-}
-
-func getNameQuery(name string) (string, string) {
-	if name == "" {
-		return "", ""
-	}
-	name = fmt.Sprintf(`%%%s%%`, strings.ToLower(name))
-	nq := `LOWER(name) LIKE :name`
-	return nq, name
-}
-
-func getOrderQuery(order string) string {
-	switch order {
-	case "name":
-		return "name"
-	default:
-		return "id"
-	}
-}
-
-func getDirQuery(dir string) string {
-	switch dir {
-	case "asc":
-		return "ASC"
-	default:
-		return "DESC"
-	}
-}
-
-func getMetadataQuery(m computations.Metadata) ([]byte, string, error) {
-	mq := ""
-	mb := []byte("{}")
-	if len(m) > 0 {
-		mq = `metadata @> :metadata`
-
-		b, err := json.Marshal(m)
-		if err != nil {
-			return nil, "", err
-		}
-		mb = b
-	}
-	return mb, mq, nil
-}
-
-func toDBComputation(cpt computations.Computation) (dbComputation, error) {
-	data := []byte("{}")
-	if len(cpt.Metadata) > 0 {
-		b, err := json.Marshal(cpt.Metadata)
-		if err != nil {
-			return dbComputation{}, errors.Wrap(errors.ErrMalformedEntity, err)
-		}
-		data = b
-	}
-
-	return dbComputation{
-		ID:          cpt.ID,
-		Owner:       cpt.Owner,
-		Name:        cpt.Name,
-		Description: cpt.Description,
-		Metadata:    data,
-	}, nil
-}

computations/postgres/doc.go

@@ -1,4 +0,0 @@
-// Package postgres contains repository implementations using
-// PostgreSQL as the underlying database.
-
-package postgres

computations/postgres/init.go

@@ -1,32 +0,0 @@
-package postgres
-
-import migrate "github.com/rubenv/sql-migrate"
-
-var Migrations = &migrate.MemoryMigrationSource{
-	Migrations: []*migrate.Migration{
-		{
-			Id: "computations_1",
-			Up: []string{
-				`CREATE TABLE IF NOT EXISTS computations (
-                    id       				UUID,
-                    owner                   VARCHAR(255),
-                    name                    VARCHAR(1025),
-                    description             text,
-                    status                  VARCHAR(255),
-                    start_time              timestamp NOT NULL,
-                    end_time                timestamp,
-                    datasets                text[],
-                    algorithms              text[],
-                    dataset_providers       text[],
-                    algorithm_providers     text[],
-                    ttl                     integer,
-                    metadata                JSON,
-                    PRIMARY KEY (id, owner)
-                    )`,
-			},
-			Down: []string{
-				"DROP TABLE computations",
-			},
-		},
-	},
-}

computations/service.go

@@ -1,84 +0,0 @@
-package computations
-
-import (
-	"context"
-	"time"
-
-	"github.com/mainflux/mainflux"
-	"github.com/mainflux/mainflux/pkg/errors"
-	"github.com/ultravioletrs/clients"
-)
-
-type Service interface {
-	CreateComputation(ctx context.Context, token string, computation Computation) (string, error)
-	ViewComputation(ctx context.Context, token, id string) (Computation, error)
-	ListComputations(ctx context.Context, token string, meta PageMetadata) (Page, error)
-	UpdateComputation(ctx context.Context, token string, computation Computation) error
-	RemoveComputation(ctx context.Context, token, id string) error
-}
-
-type service struct {
-	repo Repository
-	idp  mainflux.IDProvider
-	auth clients.AuthServiceClient
-}
-
-func NewService(repo Repository, idp mainflux.IDProvider, auth clients.AuthServiceClient) Service {
-	return service{
-		repo: repo,
-		idp:  idp,
-		auth: auth,
-	}
-}
-
-func (svc service) CreateComputation(ctx context.Context, token string, computation Computation) (string, error) {
-	id, err := svc.idp.ID()
-	if err != nil {
-		return "", err
-	}
-	computation.ID = id
-	computation.StartTime = time.Now()
-	return svc.repo.Save(ctx, computation)
-}
-
-func (svc service) ViewComputation(ctx context.Context, token string, id string) (Computation, error) {
-	// Use id as both subject and object as token is currently empty
-	// c_add policy is an example of acceptable policy from clients service.
-	if err := svc.authorize(ctx, id, id, "c_add"); err != nil {
-		return Computation{}, errors.Wrap(errors.ErrAuthentication, err)
-	}
-	return svc.repo.View(ctx, id)
-}
-
-func (svc service) ListComputations(ctx context.Context, token string, meta PageMetadata) (Page, error) {
-	return svc.repo.RetrieveAll(ctx, token, meta)
-}
-
-func (svc service) UpdateComputation(ctx context.Context, token string, computation Computation) error {
-	return svc.repo.Update(ctx, computation)
-}
-
-func (svc service) RemoveComputation(ctx context.Context, token string, id string) error {
-	// Use id as both subject and object as token is currently empty
-	// c_delete policy is an example of acceptable policy from clients service.
-	if err := svc.authorize(ctx, id, id, "c_delete"); err != nil {
-		return errors.Wrap(errors.ErrAuthentication, err)
-	}
-	return svc.repo.Delete(ctx, id)
-}
-
-func (svc service) authorize(ctx context.Context, subject, object, action string) error {
-	req := &clients.AuthorizeReq{
-		Sub: subject,
-		Obj: object,
-		Act: action,
-	}
-	res, err := svc.auth.Authorize(ctx, req)
-	if err != nil {
-		return errors.Wrap(errors.ErrAuthorization, err)
-	}
-	if !res.GetAuthorized() {
-		return errors.ErrAuthorization
-	}
-	return nil
-}

datasets/api/doc.go

@@ -1,4 +0,0 @@
-// Package api contains API-related concerns: endpoint
-// definitions, middlewares, and all resource representations.
-
-package api

datasets/api/endpoint.go

@@ -1,115 +0,0 @@
-package api
-
-import (
-	"context"
-
-	"github.com/go-kit/kit/endpoint"
-	"github.com/ultravioletrs/cocos/datasets"
-)
-
-func createDatasetsEndpoint(svc datasets.Service) endpoint.Endpoint {
-	return func(ctx context.Context, request interface{}) (interface{}, error) {
-		req := request.(createReq)
-
-		id, err := svc.CreateDataset(ctx, req.dataset)
-		if err != nil {
-			return createRes{}, err
-		}
-
-		res := createRes{
-			ID:      id,
-			created: true,
-		}
-
-		return res, nil
-	}
-}
-
-func viewDatasetsEndpoint(svc datasets.Service) endpoint.Endpoint {
-	return func(ctx context.Context, request interface{}) (interface{}, error) {
-		req := request.(viewRequest)
-
-		ds, err := svc.ViewDataset(ctx, req.owner, req.id)
-		if err != nil {
-			return nil, err
-		}
-		res := viewRes{
-			Dataset: ds,
-		}
-		return res, nil
-	}
-}
-
-func listDatasetsEndpoint(svc datasets.Service) endpoint.Endpoint {
-	return func(ctx context.Context, request interface{}) (interface{}, error) {
-		req := request.(listResourcesReq)
-
-		page, err := svc.ListDatasets(ctx, req.owner, req.pageMetadata)
-		if err != nil {
-			return nil, err
-		}
-
-		res := datasetsPageRes{
-			pageRes: pageRes{
-				Total:  page.Total,
-				Offset: page.Offset,
-				Limit:  page.Limit,
-				Order:  page.Order,
-				Dir:    page.Dir,
-			},
-			Datasets: []datasets.Dataset{},
-		}
-		res.Datasets = append(res.Datasets, page.Datasets...)
-
-		return res, nil
-	}
-}
-
-func updateDatasetEndpoint(svc datasets.Service) endpoint.Endpoint {
-	return func(ctx context.Context, request interface{}) (interface{}, error) {
-		req := request.(updateReq)
-
-		dataset := datasets.Dataset{
-			ID:          req.id,
-			Name:        req.Name,
-			Description: req.Description,
-			Metadata:    req.Metadata,
-		}
-
-		if err := svc.UpdateDataset(ctx, dataset); err != nil {
-			return nil, err
-		}
-
-		res := createRes{ID: req.id, created: false}
-		return res, nil
-	}
-}
-
-func uploadDatasetEndpoint(svc datasets.Service) endpoint.Endpoint {
-	return func(ctx context.Context, request interface{}) (interface{}, error) {
-		req := request.(uploadReq)
-
-		if err := req.validate(); err != nil {
-			return nil, err
-		}
-
-		if err := svc.UploadDataset(ctx, req.id, req.owner, req.Payload); err != nil {
-			return nil, err
-		}
-
-		res := createRes{ID: req.id, created: false}
-		return res, nil
-	}
-}
-
-func removeDatasetEndpoint(svc datasets.Service) endpoint.Endpoint {
-	return func(ctx context.Context, request interface{}) (interface{}, error) {
-		req := request.(viewRequest)
-
-		if err := svc.RemoveDataset(ctx, req.id); err != nil {
-			return nil, err
-		}
-
-		return removeRes{}, nil
-	}
-}

datasets/api/logging.go

@@ -1,95 +0,0 @@
-package api
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	log "github.com/mainflux/mainflux/logger"
-
-	"github.com/ultravioletrs/cocos/datasets"
-)
-
-var _ datasets.Service = (*loggingMiddleware)(nil)
-
-type loggingMiddleware struct {
-	logger log.Logger
-	svc    datasets.Service
-}
-
-// LoggingMiddleware adds logging facilities to the core service.
-func LoggingMiddleware(svc datasets.Service, logger log.Logger) datasets.Service {
-	return &loggingMiddleware{logger, svc}
-}
-
-func (lm *loggingMiddleware) CreateDataset(ctx context.Context, dts datasets.Dataset) (id string, err error) {
-	defer func(begin time.Time) {
-		message := fmt.Sprintf("Method create_dataset 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(fmt.Sprintf("%s without errors.", message))
-	}(time.Now())
-	return lm.svc.CreateDataset(ctx, dts)
-}
-
-func (lm *loggingMiddleware) ViewDataset(ctx context.Context, owner, id string) (d datasets.Dataset, err error) {
-	defer func(begin time.Time) {
-		message := fmt.Sprintf("Method view_dataset 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(fmt.Sprintf("%s without errors.", message))
-	}(time.Now())
-	return lm.svc.ViewDataset(ctx, owner, id)
-}
-
-func (lm *loggingMiddleware) ListDatasets(ctx context.Context, owner string, meta datasets.PageMetadata) (page datasets.Page, err error) {
-	defer func(begin time.Time) {
-		message := fmt.Sprintf("Method list_datasets 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(fmt.Sprintf("%s without errors.", message))
-	}(time.Now())
-	return lm.svc.ListDatasets(ctx, owner, meta)
-}
-
-func (lm *loggingMiddleware) UpdateDataset(ctx context.Context, dataset datasets.Dataset) (err error) {
-	defer func(begin time.Time) {
-		message := fmt.Sprintf("Method update_dataset 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(fmt.Sprintf("%s without errors.", message))
-	}(time.Now())
-	return lm.svc.UpdateDataset(ctx, dataset)
-}
-
-func (lm *loggingMiddleware) UploadDataset(ctx context.Context, id, owner string, payload []byte) (err error) {
-	defer func(begin time.Time) {
-		message := fmt.Sprintf("Method upload_dataset 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(fmt.Sprintf("%s without errors.", message))
-	}(time.Now())
-	return lm.svc.UploadDataset(ctx, id, owner, payload)
-}
-
-func (lm *loggingMiddleware) RemoveDataset(ctx context.Context, id string) (err error) {
-	defer func(begin time.Time) {
-		message := fmt.Sprintf("Method remove_dataset 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(fmt.Sprintf("%s without errors.", message))
-	}(time.Now())
-	return lm.svc.RemoveDataset(ctx, id)
-}

datasets/api/metrics.go

@@ -1,74 +0,0 @@
-package api
-
-import (
-	"context"
-	"time"
-
-	"github.com/go-kit/kit/metrics"
-	"github.com/ultravioletrs/cocos/datasets"
-)
-
-var _ datasets.Service = (*metricsMiddleware)(nil)
-
-type metricsMiddleware struct {
-	counter metrics.Counter
-	latency metrics.Histogram
-	svc     datasets.Service
-}
-
-// MetricsMiddleware instruments core service by tracking request count and latency.
-func MetricsMiddleware(svc datasets.Service, counter metrics.Counter, latency metrics.Histogram) datasets.Service {
-	return &metricsMiddleware{
-		counter: counter,
-		latency: latency,
-		svc:     svc,
-	}
-}
-
-func (ms *metricsMiddleware) CreateDataset(ctx context.Context, dts datasets.Dataset) (id string, err error) {
-	defer func(begin time.Time) {
-		ms.counter.With("method", "create_dataset").Add(1)
-		ms.latency.With("method", "create_dataset").Observe(time.Since(begin).Seconds())
-	}(time.Now())
-	return ms.svc.CreateDataset(ctx, dts)
-}
-
-func (ms *metricsMiddleware) ViewDataset(ctx context.Context, owner, id string) (datasets.Dataset, error) {
-	defer func(begin time.Time) {
-		ms.counter.With("method", "view_dataset").Add(1)
-		ms.latency.With("method", "view_dataset").Observe(time.Since(begin).Seconds())
-	}(time.Now())
-	return ms.svc.ViewDataset(ctx, owner, id)
-}
-
-func (ms *metricsMiddleware) ListDatasets(ctx context.Context, owner string, meta datasets.PageMetadata) (page datasets.Page, err error) {
-	defer func(begin time.Time) {
-		ms.counter.With("method", "list_datasets").Add(1)
-		ms.latency.With("method", "list_datasets").Observe(time.Since(begin).Seconds())
-	}(time.Now())
-	return ms.svc.ListDatasets(ctx, owner, meta)
-}
-
-func (ms *metricsMiddleware) UpdateDataset(ctx context.Context, dataset datasets.Dataset) error {
-	defer func(begin time.Time) {
-		ms.counter.With("method", "update_datasets").Add(1)
-		ms.latency.With("method", "update_datasets").Observe(time.Since(begin).Seconds())
-	}(time.Now())
-	return ms.svc.UpdateDataset(ctx, dataset)
-}
-
-func (ms *metricsMiddleware) UploadDataset(ctx context.Context, id, owner string, payload []byte) error {
-	defer func(begin time.Time) {
-		ms.counter.With("method", "update_datasets").Add(1)
-		ms.latency.With("method", "update_datasets").Observe(time.Since(begin).Seconds())
-	}(time.Now())
-	return ms.svc.UploadDataset(ctx, id, owner, payload)
-}
-
-func (ms *metricsMiddleware) RemoveDataset(ctx context.Context, id string) error {
-	defer func(begin time.Time) {
-		ms.counter.With("method", "remove_dataset").Add(1)
-		ms.latency.With("method", "remove_dataset").Observe(time.Since(begin).Seconds())
-	}(time.Now())
-	return ms.svc.RemoveDataset(ctx, id)
-}

datasets/api/requests.go

@@ -1,38 +0,0 @@
-package api
-
-import (
-	"github.com/ultravioletrs/cocos/datasets"
-)
-
-type createReq struct {
-	dataset datasets.Dataset
-	token   string
-}
-
-type listResourcesReq struct {
-	owner        string
-	pageMetadata datasets.PageMetadata
-}
-
-type updateReq struct {
-	id          string
-	Name        string                 `json:"name,omitempty"`
-	Description string                 `json:"description,omitempty"`
-	Metadata    map[string]interface{} `json:"metadata,omitempty"`
-}
-
-type uploadReq struct {
-	owner   string
-	token   string
-	id      string
-	Payload []byte
-}
-
-func (req uploadReq) validate() error {
-	return nil
-}
-
-type viewRequest struct {
-	id    string
-	owner string
-}

datasets/api/responses.go

@@ -1,93 +0,0 @@
-package api
-
-import (
-	"fmt"
-	"net/http"
-
-	"github.com/ultravioletrs/cocos/datasets"
-)
-
-type createRes struct {
-	ID      string
-	created bool
-}
-
-func (res createRes) Code() int {
-	if res.created {
-		return http.StatusCreated
-	}
-
-	return http.StatusOK
-}
-
-func (res createRes) Headers() map[string]string {
-	if res.created {
-		return map[string]string{
-			"Location": fmt.Sprintf("/datasets/%s", res.ID),
-		}
-	}
-	return map[string]string{}
-}
-
-func (res createRes) Empty() bool {
-	return true
-}
-
-type errorRes struct {
-	Err string `json:"error"`
-}
-
-type removeRes struct{}
-
-func (res removeRes) Code() int {
-	return http.StatusNoContent
-}
-
-func (res removeRes) Headers() map[string]string {
-	return map[string]string{}
-}
-
-func (res removeRes) Empty() bool {
-	return true
-}
-
-type viewRes struct {
-	datasets.Dataset
-}
-
-func (res viewRes) Code() int {
-	return http.StatusOK
-}
-
-func (res viewRes) Headers() map[string]string {
-	return map[string]string{}
-}
-
-func (res viewRes) Empty() bool {
-	return false
-}
-
-type datasetsPageRes struct {
-	pageRes
-	Datasets []datasets.Dataset `json:"datasets"`
-}
-
-func (res datasetsPageRes) Code() int {
-	return http.StatusOK
-}
-
-func (res datasetsPageRes) Headers() map[string]string {
-	return map[string]string{}
-}
-
-func (res datasetsPageRes) Empty() bool {
-	return false
-}
-
-type pageRes struct {
-	Total  uint64 `json:"total"`
-	Offset uint64 `json:"offset"`
-	Limit  uint64 `json:"limit"`
-	Order  string `json:"order"`
-	Dir    string `json:"direction"`
-}

datasets/api/transport.go

@@ -1,238 +0,0 @@
-package api
-
-import (
-	"context"
-	"encoding/json"
-	"io/ioutil"
-	"net/http"
-	"strings"
-
-	kithttp "github.com/go-kit/kit/transport/http"
-	"github.com/go-zoo/bone"
-	"github.com/mainflux/mainflux"
-	"github.com/mainflux/mainflux/logger"
-	"github.com/mainflux/mainflux/pkg/errors"
-	"github.com/opentracing/opentracing-go"
-	"github.com/prometheus/client_golang/prometheus/promhttp"
-	"github.com/ultravioletrs/cocos/datasets"
-	"github.com/ultravioletrs/cocos/internal/apiutil"
-	httputil "github.com/ultravioletrs/cocos/internal/http"
-)
-
-const (
-	contentType  = "application/json"
-	offsetKey    = "offset"
-	nameKey      = "name"
-	limitKey     = "limit"
-	orderKey     = "order"
-	dirKey       = "dir"
-	metadataKey  = "metadata"
-	sharedKey    = "shared"
-	defOffset    = 0
-	defLimit     = 10
-	bearerPrefix = "Bearer "
-)
-
-// MakeHandler returns a HTTP handler for API endpoints.
-func MakeHandler(svc datasets.Service, tracer opentracing.Tracer, logger logger.Logger) http.Handler {
-	opts := []kithttp.ServerOption{
-		kithttp.ServerErrorEncoder(apiutil.LoggingErrorEncoder(logger, encodeError)),
-	}
-
-	mux := bone.New()
-
-	mux.Post("/datasets", kithttp.NewServer(
-		createDatasetsEndpoint(svc),
-		decodeCreateDatasets,
-		encodeResponse,
-		opts...,
-	))
-
-	mux.Get("/datasets", kithttp.NewServer(
-		listDatasetsEndpoint(svc),
-		decodeList,
-		encodeResponse,
-		opts...,
-	))
-
-	mux.Get("/datasets/:id", kithttp.NewServer(
-		viewDatasetsEndpoint(svc),
-		decodeView,
-		encodeResponse,
-		opts...,
-	))
-
-	mux.Put("/datasets/:id", kithttp.NewServer(
-		updateDatasetEndpoint(svc),
-		decodeUpdateDataset,
-		encodeResponse,
-		opts...,
-	))
-
-	mux.Patch("/datasets/payload/:id", kithttp.NewServer(
-		uploadDatasetEndpoint(svc),
-		decodeUploadDataset,
-		encodeResponse,
-		opts...,
-	))
-
-	mux.Delete("/datasets/:id", kithttp.NewServer(
-		removeDatasetEndpoint(svc),
-		decodeView,
-		encodeResponse,
-		opts...,
-	))
-
-	mux.GetFunc("/health", httputil.Health("datasets", "Datasets management service"))
-	mux.Handle("/metrics", promhttp.Handler())
-
-	return mux
-}
-
-func decodeCreateDatasets(_ context.Context, r *http.Request) (interface{}, error) {
-	req := createReq{
-		token: extractBearerToken(r),
-	}
-	if err := json.NewDecoder(r.Body).Decode(&req.dataset); err != nil {
-		return nil, errors.Wrap(errors.ErrMalformedEntity, err)
-	}
-
-	return req, nil
-}
-
-func decodeList(_ context.Context, r *http.Request) (interface{}, error) {
-	o, err := apiutil.ReadUintQuery(r, offsetKey, defOffset)
-	if err != nil {
-		return nil, err
-	}
-
-	l, err := apiutil.ReadUintQuery(r, limitKey, defLimit)
-	if err != nil {
-		return nil, err
-	}
-
-	n, err := apiutil.ReadStringQuery(r, nameKey, "")
-	if err != nil {
-		return nil, err
-	}
-
-	or, err := apiutil.ReadStringQuery(r, orderKey, "")
-	if err != nil {
-		return nil, err
-	}
-
-	d, err := apiutil.ReadStringQuery(r, dirKey, "")
-	if err != nil {
-		return nil, err
-	}
-
-	m, err := apiutil.ReadMetadataQuery(r, metadataKey, nil)
-	if err != nil {
-		return nil, err
-	}
-	shared, err := apiutil.ReadBoolQuery(r, sharedKey, false)
-	if err != nil {
-		return nil, err
-	}
-
-	req := listResourcesReq{
-		pageMetadata: datasets.PageMetadata{
-			Offset:              o,
-			Limit:               l,
-			Name:                n,
-			Order:               or,
-			Dir:                 d,
-			Metadata:            m,
-			FetchSharedDatasets: shared,
-		},
-	}
-
-	return req, nil
-}
-
-func decodeView(_ context.Context, r *http.Request) (interface{}, error) {
-	req := viewRequest{
-		id: bone.GetValue(r, "id"),
-	}
-	return req, nil
-}
-
-func decodeUpdateDataset(_ context.Context, r *http.Request) (interface{}, error) {
-	if !strings.Contains(r.Header.Get("Content-Type"), contentType) {
-		return nil, errors.ErrUnsupportedContentType
-	}
-
-	req := updateReq{
-		id: bone.GetValue(r, "id"),
-	}
-
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		return nil, errors.Wrap(errors.ErrMalformedEntity, err)
-	}
-
-	return req, nil
-}
-
-func decodeUploadDataset(_ context.Context, r *http.Request) (interface{}, error) {
-	if !strings.Contains(r.Header.Get("Content-Type"), contentType) {
-		return nil, errors.ErrUnsupportedContentType
-	}
-
-	payload, err := ioutil.ReadAll(r.Body)
-	if err != nil {
-		return nil, errors.ErrMalformedEntity
-	}
-	defer r.Body.Close()
-
-	req := uploadReq{
-		token:   extractBearerToken(r),
-		id:      bone.GetValue(r, "id"),
-		Payload: payload,
-	}
-
-	return req, nil
-}
-
-func encodeResponse(_ context.Context, w http.ResponseWriter, response interface{}) error {
-	if ar, ok := response.(mainflux.Response); ok {
-		for k, v := range ar.Headers() {
-			w.Header().Set(k, v)
-		}
-		w.Header().Set("Content-Type", contentType)
-		w.WriteHeader(ar.Code())
-
-		if ar.Empty() {
-			return nil
-		}
-	}
-	return json.NewEncoder(w).Encode(response)
-}
-
-func encodeError(_ context.Context, err error, w http.ResponseWriter) {
-	switch {
-	case errors.Contains(err, errors.ErrInvalidQueryParams),
-		errors.Contains(err, errors.ErrMalformedEntity):
-		w.WriteHeader(http.StatusBadRequest)
-	case errors.Contains(err, errors.ErrCreateEntity),
-		errors.Contains(err, errors.ErrUpdateEntity),
-		errors.Contains(err, errors.ErrViewEntity),
-		errors.Contains(err, errors.ErrRemoveEntity):
-		w.WriteHeader(http.StatusInternalServerError)
-	default:
-		w.WriteHeader(http.StatusInternalServerError)
-	}
-	if errorVal, ok := err.(errors.Error); ok {
-		w.Header().Set("Content-Type", contentType)
-		if err := json.NewEncoder(w).Encode(errorRes{Err: errorVal.Msg()}); err != nil {
-			w.WriteHeader(http.StatusInternalServerError)
-		}
-	}
-}
-
-func extractBearerToken(r *http.Request) string {
-	token := r.Header.Get("Authorization")
-	if !strings.HasPrefix(token, bearerPrefix) {
-		return ""
-	}
-	return strings.TrimPrefix(token, bearerPrefix)
-}

datasets/datasets.go

@@ -1,65 +0,0 @@
-package datasets
-
-import (
-	"context"
-	"time"
-)
-
-type Dataset struct {
-	ID          string    `json:"id,omitempty" db:"id"`
-	Token       string    `json:"token,omitempty" db:"token"`
-	Name        string    `json:"name,omitempty" db:"name"`
-	Description string    `json:"description,omitempty" db:"description"`
-	Owner       string    `json:"owner,omitempty" db:"owner"`
-	Size        uint64    `json:"size,omitempty" db:"size"`
-	CreatedAt   time.Time `json:"created_at,omitempty" db:"created_at"`
-	UpdatedAt   time.Time `json:"updated_at,omitempty" db:"updated_at"`
-	Location    string    `json:"location,omitempty" db:"location"`
-	Format      string    `json:"format,omitempty" db:"format"`
-	Metadata    Metadata  `json:"metadata,omitempty" db:"metadata"`
-	Path        string    `json:"Path,omitempty" db:"path"`
-}
-
-type Metadata map[string]interface{}
-
-type PageMetadata struct {
-	Total               uint64   `json:"total,omitempty"`
-	Offset              uint64   `json:"offset,omitempty"`
-	Limit               uint64   `json:"limit,omitempty"`
-	Name                string   `json:"name,omitempty"`
-	Order               string   `json:"order,omitempty"`
-	Dir                 string   `json:"dir,omitempty"`
-	Metadata            Metadata `json:"metadata,omitempty"`
-	FetchSharedDatasets bool
-}
-
-type Page struct {
-	PageMetadata
-	Datasets []Dataset `json:"datasets,omitempty"`
-}
-
-func (d Dataset) Validate() error {
-	return nil
-}
-
-// DatasetRepository specifies a dataset persistence API.
-type DatasetRepository interface {
-	// Save persists multiple datasets. Datasets are saved using a transaction. If one dataset
-	// fails then none will be saved. Successful operation is indicated by non-nil
-	// error response.
-	Save(ctx context.Context, dts Dataset) (string, error)
-
-	// RetrieveAll retrieves the subset of datasets owned by the specified user
-	RetrieveByID(ctx context.Context, owner, id string) (Dataset, error)
-
-	// RetrieveAll retrieves the subset of datasets owned by the specified user
-	RetrieveAll(ctx context.Context, owner string, pm PageMetadata) (Page, error)
-
-	// Update performs an update to the existing dataset. A non-nil error is
-	// returned to indicate operation failure.
-	Update(ctx context.Context, d Dataset) error
-
-	// Remove removes the dataset having the provided identifier, that is owned
-	// by the specified user.
-	Delete(ctx context.Context, id string) error
-}

datasets/doc.go

@@ -1,4 +0,0 @@
-// Package dataset contains domain concept definitions
-// needed to support dataset service functionality.
-
-package datasets

datasets/postgres/datasets.go

@@ -1,360 +0,0 @@
-package postgres
-
-import (
-	"context"
-	"database/sql"
-	"encoding/json"
-	"fmt"
-	"strings"
-	"time"
-
-	"github.com/lib/pq"
-	"github.com/mainflux/mainflux/pkg/errors"
-	"github.com/ultravioletrs/cocos/datasets"
-	db "github.com/ultravioletrs/cocos/internal/db"
-)
-
-const (
-	errDuplicate  = "unique_violation"
-	errInvalid    = "invalid_text_representation"
-	errTruncation = "string_data_right_truncation"
-)
-
-var _ datasets.DatasetRepository = (*datasetRepo)(nil)
-
-type datasetRepo struct {
-	db db.Database
-}
-
-// NewRepository returns a new Datasets repository implementation.
-func NewRepository(db db.Database) datasets.DatasetRepository {
-	return datasetRepo{
-		db: db,
-	}
-}
-
-func (repo datasetRepo) Save(ctx context.Context, dataset datasets.Dataset) (string, error) {
-	q := `INSERT INTO datasets (id, owner, name, metadata, description, format, location, created_at, updated_at)
-		  VALUES (:id, :owner, :name, :metadata, :description, :format, :location, :created_at, :updated_at) RETURNING id;`
-
-	ds, err := fromDataset(dataset)
-	if err != nil {
-		return "", errors.Wrap(errors.ErrCreateEntity, err)
-	}
-
-	row, err := repo.db.NamedQueryContext(ctx, q, ds)
-	if err != nil {
-		pqErr, ok := err.(*pq.Error)
-		if ok {
-			switch pqErr.Code.Name() {
-			case errInvalid, errTruncation:
-				return "", errors.Wrap(errors.ErrMalformedEntity, err)
-			case errDuplicate:
-				return "", errors.Wrap(errors.ErrConflict, err)
-			}
-		}
-
-		return "", errors.Wrap(errors.ErrCreateEntity, err)
-	}
-	defer row.Close()
-	row.Next()
-	var id string
-	if err := row.Scan(&id); err != nil {
-		return "", err
-	}
-	return id, nil
-}
-
-func (repo datasetRepo) RetrieveByID(ctx context.Context, owner, id string) (datasets.Dataset, error) {
-	q := `SELECT id, name, owner, metadata, description, location, format, created_at, updated_at FROM datasets WHERE id = $1;`
-
-	dbds := dbDataset{ID: id}
-
-	if err := repo.db.QueryRowxContext(ctx, q, id).StructScan(&dbds); err != nil {
-		pqErr, ok := err.(*pq.Error)
-		if err == sql.ErrNoRows || ok && errInvalid == pqErr.Code.Name() {
-			return datasets.Dataset{}, errors.Wrap(errors.ErrNotFound, err)
-		}
-		return datasets.Dataset{}, errors.Wrap(errors.ErrViewEntity, err)
-	}
-
-	return toDataset(dbds)
-}
-
-func (repo datasetRepo) RetrieveAll(ctx context.Context, owner string, pm datasets.PageMetadata) (datasets.Page, error) {
-	nq, name := NameQuery(pm.Name)
-	oq := OrderQuery(pm.Order)
-	dq := DirQuery(pm.Dir)
-	m, mq, err := MetadataQuery(pm.Metadata)
-	if err != nil {
-		return datasets.Page{}, errors.Wrap(errors.ErrViewEntity, err)
-	}
-
-	var query []string
-	if mq != "" {
-		query = append(query, mq)
-	}
-	if nq != "" {
-		query = append(query, nq)
-	}
-
-	var whereClause string
-	if len(query) > 0 {
-		whereClause = fmt.Sprintf(" WHERE %s", strings.Join(query, " AND "))
-	}
-
-	q := `SELECT id, name, COALESCE(description, '') AS description, owner, created_at,
-	updated_at, location, format, metadata
-				FROM datasets %s
-				ORDER BY %s %s LIMIT :limit OFFSET :offset`
-
-	q = fmt.Sprintf(q, whereClause, oq, dq)
-	params := map[string]interface{}{
-		"owner":    owner,
-		"limit":    pm.Limit,
-		"offset":   pm.Offset,
-		"name":     name,
-		"metadata": m,
-	}
-
-	rows, err := repo.db.NamedQueryContext(ctx, q, params)
-	if err != nil {
-		return datasets.Page{}, errors.Wrap(errors.ErrViewEntity, err)
-	}
-	defer rows.Close()
-
-	var items []datasets.Dataset
-	for rows.Next() {
-		dbd := dbDataset{Owner: owner}
-		if err := rows.StructScan(&dbd); err != nil {
-			return datasets.Page{}, errors.Wrap(errors.ErrViewEntity, err)
-		}
-
-		ds, err := toDataset(dbd)
-		if err != nil {
-			return datasets.Page{}, err
-		}
-		items = append(items, ds)
-	}
-	cq := fmt.Sprintf(`SELECT COUNT(*) FROM datasets %s;`, whereClause)
-
-	total, err := repo.total(ctx, cq, params)
-	if err != nil {
-		return datasets.Page{}, errors.Wrap(errors.ErrViewEntity, err)
-	}
-
-	page := datasets.Page{
-		Datasets: items,
-		PageMetadata: datasets.PageMetadata{
-			Total:  total,
-			Offset: pm.Offset,
-			Limit:  pm.Limit,
-			Order:  pm.Order,
-			Dir:    pm.Dir,
-		},
-	}
-	return page, nil
-}
-
-func (repo datasetRepo) Update(ctx context.Context, d datasets.Dataset) error {
-	q := `UPDATE datasets SET name = :name, metadata = :metadata, description = :description WHERE id = :id;`
-
-	dbdts, err := toDBDataset(d)
-	if err != nil {
-		return errors.Wrap(errors.ErrUpdateEntity, err)
-	}
-	res, errdb := repo.db.NamedExecContext(ctx, q, dbdts)
-	if errdb != nil {
-		pqErr, ok := errdb.(*pq.Error)
-		if ok {
-			switch pqErr.Code.Name() {
-			case errInvalid, errTruncation:
-				return errors.Wrap(errors.ErrMalformedEntity, errdb)
-			}
-		}
-
-		return errors.Wrap(errors.ErrUpdateEntity, errdb)
-	}
-
-	cnt, errdb := res.RowsAffected()
-	if errdb != nil {
-		return errors.Wrap(errors.ErrUpdateEntity, errdb)
-	}
-
-	if cnt == 0 {
-		return errors.ErrNotFound
-	}
-
-	return nil
-}
-
-func (repo datasetRepo) Delete(ctx context.Context, id string) error {
-	q := `DELETE FROM datasets WHERE id = :id`
-
-	ds := dbDataset{
-		ID: id,
-	}
-
-	if _, err := repo.db.NamedExecContext(ctx, q, ds); err != nil {
-		if err == sql.ErrNoRows {
-			return errors.Wrap(errors.ErrNotFound, err)
-
-		}
-		return errors.Wrap(errors.ErrViewEntity, err)
-	}
-
-	return nil
-}
-
-func (repo datasetRepo) total(ctx context.Context, query string, params interface{}) (uint64, error) {
-	rows, err := repo.db.NamedQueryContext(ctx, query, params)
-	if err != nil {
-		return 0, err
-	}
-	defer rows.Close()
-	total := uint64(0)
-	if rows.Next() {
-		if err := rows.Scan(&total); err != nil {
-			return 0, err
-		}
-	}
-	return total, nil
-}
-
-type dbDataset struct {
-	ID          string    `db:"id"`
-	Token       string    `db:"token"`
-	Name        string    `db:"name"`
-	Description string    `db:"description"`
-	Owner       string    `db:"owner"`
-	Size        uint64    `db:"size"`
-	CreatedAt   time.Time `db:"created_at"`
-	UpdatedAt   time.Time `db:"updated_at"`
-	Location    string    `db:"location"`
-	Format      string    `db:"format"`
-	Metadata    []byte    `db:"metadata"`
-	Path        string    `db:"path"`
-}
-
-func toDataset(d dbDataset) (datasets.Dataset, error) {
-	var metadata map[string]interface{}
-	if d.Metadata != nil {
-		if err := json.Unmarshal([]byte(d.Metadata), &metadata); err != nil {
-			return datasets.Dataset{}, errors.Wrap(errors.ErrMalformedEntity, err)
-		}
-	}
-	ret := datasets.Dataset{
-		ID:          d.ID,
-		Token:       d.Token,
-		Name:        d.Name,
-		Description: d.Description,
-		Owner:       d.Owner,
-		Size:        d.Size,
-		CreatedAt:   d.CreatedAt,
-		UpdatedAt:   d.UpdatedAt,
-		Location:    d.Location,
-		Format:      d.Format,
-		Metadata:    metadata,
-		Path:        d.Path,
-	}
-	return ret, nil
-}
-
-func fromDataset(d datasets.Dataset) (dbDataset, error) {
-	metadata := []byte("{}")
-	if len(d.Metadata) > 0 {
-		b, err := json.Marshal(d.Metadata)
-		if err != nil {
-			return dbDataset{}, errors.Wrap(errors.ErrMalformedEntity, err)
-		}
-		metadata = b
-	}
-	ret := dbDataset{
-		ID:          d.ID,
-		Token:       d.Token,
-		Name:        d.Name,
-		Description: d.Description,
-		Owner:       d.Owner,
-		Size:        d.Size,
-		CreatedAt:   d.CreatedAt,
-		UpdatedAt:   d.UpdatedAt,
-		Location:    d.Location,
-		Format:      d.Format,
-		Metadata:    metadata,
-		Path:        d.Path,
-	}
-	return ret, nil
-}
-
-func NameQuery(name string) (string, string) {
-	if name == "" {
-		return "", ""
-	}
-	name = fmt.Sprintf(`%%%s%%`, strings.ToLower(name))
-	nq := `LOWER(name) LIKE :name`
-	return nq, name
-}
-
-func OrderQuery(order string) string {
-	switch order {
-	case "name":
-		return "name"
-	default:
-		return "id"
-	}
-}
-
-func DirQuery(dir string) string {
-	switch dir {
-	case "asc":
-		return "ASC"
-	default:
-		return "DESC"
-	}
-}
-
-func MetadataQuery(m datasets.Metadata) ([]byte, string, error) {
-	mq := ""
-	mb := []byte("{}")
-	if len(m) > 0 {
-		mq = `metadata @> :metadata`
-
-		b, err := json.Marshal(m)
-		if err != nil {
-			return nil, "", err
-		}
-		mb = b
-	}
-	return mb, mq, nil
-}
-
-func (repo datasetRepo) Remove(ctx context.Context, id string) error {
-	dbth := dbDataset{
-		ID: id,
-	}
-	q := `DELETE FROM datasets WHERE id = :id`
-	if _, err := repo.db.NamedExecContext(ctx, q, dbth); err != nil {
-		return errors.Wrap(errors.ErrRemoveEntity, err)
-	}
-	return nil
-}
-
-func toDBDataset(ds datasets.Dataset) (dbDataset, error) {
-	data := []byte("{}")
-	if len(ds.Metadata) > 0 {
-		b, err := json.Marshal(ds.Metadata)
-		if err != nil {
-			return dbDataset{}, errors.Wrap(errors.ErrMalformedEntity, err)
-		}
-		data = b
-	}
-
-	return dbDataset{
-		ID:          ds.ID,
-		Owner:       ds.Owner,
-		Name:        ds.Name,
-		Description: ds.Description,
-		Metadata:    data,
-		Size:        ds.Size,
-	}, nil
-}

datasets/postgres/doc.go

@@ -1,4 +0,0 @@
-// Package dataset contains domain concept definitions
-// needed to support dataset service functionality.
-
-package postgres