}

func DetectGPUVendors() ([]GPUVendor, error) {
	var vendors []GPUVendor
	gpu, err := ghw.GPU()
	if err != nil {
		return nil, err
	}

	for _, card := range gpu.GraphicsCards {
		deviceInfo := card.DeviceInfo
		if deviceInfo != nil {
			class := deviceInfo.Class
			if class != nil {
				className := strings.ToLower(class.Name)

					vendor := card.DeviceInfo.Vendor
					if vendor != nil {
						if strings.Contains(strings.ToLower(vendor.Name), "nvidia") {
							vendors = append(vendors, NVIDIA)
						}
						if strings.Contains(strings.ToLower(vendor.Name), "amd") {
							vendors = append(vendors, AMD)

							vendors = append(vendors, NVIDIA)
						}
						if strings.Contains(strings.ToLower(vendor.Name), "amd") {
							vendors = append(vendors, AMD)
						}
					}
				}

)

func Check_gpu() ([]models.Gpu, error) {
	var gpu_info []models.Gpu
	vendors, err := DetectGPUVendors()
	if err != nil {
		return nil, fmt.Errorf("unable to detect GPU Vendor: %v", err)
	}
	foundNVIDIA, foundAMD := false, false
	for _, vendor := range vendors {
		switch vendor {
		case NVIDIA:
			if !foundNVIDIA {
				var gpu models.Gpu
				info, err := GetNVIDIAGPUInfo()

// by the user and the sum of resources usage for every services, virtual machines, plugins
// and any other process started by DMS on the user's machine.
func calcFreeResources(gormDB *gorm.DB, cpuInfo []cpu.InfoStat) (models.FreeResources, error) {
	vms, err := queryRunningVMs(gormDB)
	if err != nil {
		return models.FreeResources{},
			fmt.Errorf("Error querying running VMs: %w", err)
	}

	conts, err := queryRunningConts(gormDB)
	if err != nil {
		return models.FreeResources{},
			fmt.Errorf("Error querying running containers: %w", err)
	}

}

func GetAMDGPUInfo() ([]GPUInfo, error) {
	cmd := exec.Command("rocm-smi", "--showid", "--showproductname", "--showmeminfo", "vram")

	output, err := cmd.CombinedOutput()
	if err != nil {
		return nil, fmt.Errorf("AMD ROCm not installed, initialized, or configured (reboot recommended for newly installed AMD GPU Drivers): %s", err)
	}

	outputStr := string(output)

	gpuName := regexp.MustCompile(`Card series:\s+([^\n]+)`)
	total := regexp.MustCompile(`Total Memory \(B\):\s+(\d+)`)
	used := regexp.MustCompile(`Total Used Memory \(B\):\s+(\d+)`)

}

func GetNVIDIAGPUInfo() ([]GPUInfo, error) {
	// Initialize NVML
	ret := nvml.Init()
	if ret != nvml.SUCCESS {
		return nil, fmt.Errorf("NVIDIA Management Library not installed, initialized or configured (reboot recommended for newly installed NVIDIA GPU drivers): %s", nvml.ErrorString(ret))
	}
	defer nvml.Shutdown()

	// Get the number of GPU devices
	deviceCount, ret := nvml.DeviceGetCount()
	if ret != nvml.SUCCESS {
		return nil, fmt.Errorf("failed to get device count: %s", nvml.ErrorString(ret))
	}

}

func Onboard(ctx context.Context, capacity models.CapacityForNunet) (*models.Metadata, error) {
	configPath := config.GetConfig().General.MetadataPath
	configExist, err := AFS.DirExists(configPath)
	if err != nil {
		return nil, fmt.Errorf("could not check if config directory exists: %w", err)
	}
	if !configExist {
		return nil, fmt.Errorf("config directory does not exist: %w", err)
	}

	hostname, _ := os.Hostname()

	totalCpu := resources.GetTotalProvisioned().CPU

}

func Onboard(ctx context.Context, capacity models.CapacityForNunet) (*models.Metadata, error) {
	configPath := config.GetConfig().General.MetadataPath
	configExist, err := AFS.DirExists(configPath)
	if err != nil {
		return nil, fmt.Errorf("could not check if config directory exists: %w", err)
	}
	if !configExist {
		return nil, fmt.Errorf("config directory does not exist: %w", err)
	}

	hostname, _ := os.Hostname()

	totalCpu := resources.GetTotalProvisioned().CPU

}

func ResourceConfig(ctx context.Context, capacity models.CapacityForNunet) (*models.Metadata, error) {
	onboarded, err := utils.IsOnboarded()
	if err != nil {
		return nil, fmt.Errorf("could not check onboard status: %w", err)
	}
	if !onboarded {
		return nil, fmt.Errorf("machine is not onboarded")
	}

	err = validateCapacityForNunet(capacity)
	if err != nil {
		return nil, fmt.Errorf("could not validate capacity data: %w", err)
	}

}

func Offboard(ctx context.Context, force bool) error {
	onboarded, err := utils.IsOnboarded()
	if err != nil && !force {
		return fmt.Errorf("could not retrieve onboard status: %w", err)
	} else if err != nil && force {
		zlog.Sugar().Errorf("problem with onboarding state: %v", err)
		zlog.Info("continuing with offboarding because forced")
	}

	if !onboarded {
		return fmt.Errorf("machine is not onboarded")
	}

)

func GpuComparator(l, r interface{}, preference ...Preference) models.Comparison {
	// comparator for GPU type

	// we want to reason about the inner fields of the GPU type and how they compare between left and right
	// in the future we may want to pass custom preference parameters to the ComplexComparator
	// for now it is probably best to hardcode them;

	// validate input type
	_, lok := l.(models.GPU)
	_, rok := r.(models.GPU)
	if !lok || !rok {
		return models.Error
	}

)

func LocalitiesComparator(lraw interface{}, rraw interface{}, preference ...Preference) models.Comparison {
	// simplified version of Localities comparator
	// which is simply a slice of Locality type;
	// we do not have separate type defined for Localities
	// it takes preference variable where comparison Preference is defined
	// this is the first method that is used to take Preference variable into account
	// left represent machine capabilities;
	// right represent required capabilities;

	// validate input type
	_, lrawok := lraw.([]models.Locality)
	_, rrawok := rraw.([]models.Locality)
	if !lrawok || !rrawok {

)

func GPUsComparator(lraw, rraw interface{}, preference ...Preference) models.Comparison {
	// comparator for GPUs type which is just a slice of GPU types:
	// left represent machine capabilities;
	// right represent required capabilities;
	// we need to check if for ech GPU on the right there exist a matching GPU on the left...
    // (since given slices are not ordered...)

	// validate input type
	_, lrawok := lraw.([]models.GPU)
	_, rrawok := rraw.([]models.GPU)
	if !lrawok || !rrawok {
		return models.Error
	}

)

func LibraryComparator(lraw, rraw interface{}, preference ...Preference) models.Comparison {
	// comparator for single Library type:
	// left represent machine capabilities;
	// right represent required capabilities;

	// validate input type
	_, lrawok := lraw.(models.Library)
	_, rrawok := rraw.(models.Library)
	if !lrawok || !rrawok {
		return models.Error
	}	

	l := lraw.(models.Library)

)

func LibrariesComparator(lraw, rraw interface{}, preference ...Preference) models.Comparison {
	// comparator for Libraries slices (of different lengths) of Library types:
	// left represent machine capabilities;
	// right represent required capabilities;

	// validate input type
	_, lrawok := lraw.([]models.Library)
	_, rrawok := rraw.([]models.Library)
	if !lrawok || !rrawok {
		return models.Error
	}	

	l := lraw.([]models.Library)

)

func ExecutionResourcesComparator(l, r interface{}, preference ...Preference) models.Comparison {
	// comparator for models.ExecutionResources type
	// Current implementation of the type has four fields: CPU, Memory, Disk, GPUs
	// we consider that all fields have to be 'Better' or 'Equal' 
	// for the comparison to be 'Better' or 'Equal'
	// else we return 'Worse'

	// validate input type
	_, lok := l.(models.ExecutionResources)
	_, rok := r.(models.ExecutionResources)
	if !lok || !rok {
		return models.Error
	}

}

func returnBestMatch(dimension []models.Comparison) (models.Comparison, int) {

	// while i feel that there could be some weird matrix sorting algorithm that could be used here
	// i can't think of any right now, so i will just iterate over the matrix and return matches
	// in somewhat manual way

	for i, v := range dimension {
		if v == models.Equal {
			return v, i // selecting an equal match is the most efficient match
		}
	}
	for i, v := range dimension {
		if v == models.Better {

// newActor returns a new actor based on the given arguments.
func newActor(parentActorAddress *ActorAddrInfo, hostID string, net network.Network, actorRegistry *ActorRegistry, factory *ActorFactory) (*Actor, error) {
	if hostID == "" {
		return nil, errors.New("host id is empty")

// SendMessage sends a message to another actor.
func (a *Actor) SendMessage(ctx context.Context, destination *ActorAddrInfo, m *Message) error {
	if !destination.Valid() {
		return errors.New("destination actor addr info is invalid")
	}

	if m == nil {
		return errors.New("message is invalid")
	}

	// get the multiaddress of a host by resolving the hostid
	addresses, err := a.network.ResolveAddress(ctx, destination.HostID)
	if err != nil {
		return fmt.Errorf("failed to send message to actor %s: %v", destination.HostID, err)

}

func MakeRequest(c *gin.Context, client *http.Client, uri string, body []byte, errMsg string) error {
	// set the HTTP method, url, and request body
	req, err := http.NewRequest(http.MethodPut, uri, bytes.NewBuffer(body))

// ExtractTarGzToPath extracts a tar.gz file to a specified path
func ExtractTarGzToPath(tarGzFilePath, extractedPath string) error {
	// Ensure the target directory exists; create it if it doesn't.
	if err := os.MkdirAll(extractedPath, os.ModePerm); err != nil {
		return fmt.Errorf("error creating target directory: %v", err)
	}

	tarGzFile, err := os.Open(tarGzFilePath)
	if err != nil {
		return fmt.Errorf("error opening tar.gz file: %v", err)
	}
	defer tarGzFile.Close()

	gzipReader, err := gzip.NewReader(tarGzFile)

// ExtractTarGzToPath extracts a tar.gz file to a specified path
func ExtractTarGzToPath(tarGzFilePath, extractedPath string) error {
	// Ensure the target directory exists; create it if it doesn't.
	if err := os.MkdirAll(extractedPath, os.ModePerm); err != nil {
		return fmt.Errorf("error creating target directory: %v", err)
	}

	tarGzFile, err := os.Open(tarGzFilePath)
	if err != nil {
		return fmt.Errorf("error opening tar.gz file: %v", err)
	}
	defer tarGzFile.Close()

	gzipReader, err := gzip.NewReader(tarGzFile)

// Package docs Code generated by swaggo/swag. DO NOT EDIT
package docs

import "github.com/swaggo/swag"

const docTemplate = `{
    "schemes": {{ marshal .Schemes }},
    "swagger": "2.0",
    "info": {
        "description": "{{escape .Description}}",
        "title": "{{.Title}}",
        "termsOfService": "https://nunet.io/tos",
        "contact": {

// Validate validates an item placed into the dht.
func (d dhtValidator) Validate(key string, value []byte) error {
	// empty value is considered deleting an item from the dht
	if len(value) == 0 {
		return nil
	}

	if !strings.HasPrefix(key, d.customNamespace) {
		return errors.New("invalid key namespace")
	}

	// verify signature
	var envelope commonproto.Advertisement
	err := proto.Unmarshal(value, &envelope)

package libp2p

import (
	"context"

	"bufio"
	"bytes"
	"crypto/sha256"
	"encoding/binary"
	"errors"
	"fmt"
	"io"
	"strings"

// TODO-suggestion: maybe we should call it something else like Libp2pPeer,
// Libp2pHost or just Peer (callers would use libp2p.Peer...)
type Libp2p struct {
	Host              host.Host
	DHT               *dht.IpfsDHT
	PS                peerstore.Peerstore
	pubsub            *pubsub.PubSub
	pubsubTopics      map[string]*pubsub.Topic
	topicSubscription map[string]*pubsub.Subscription
	topicMux          sync.RWMutex

	// a list of peers discovered by discovery
	discoveredPeers []peer.AddrInfo
	discovery       libp2pdiscovery.Discovery

// OpenStream opens a stream to a remote address and returns the stream for the caller to handle.
func (l *Libp2p) OpenStream(ctx context.Context, addr string, messageType models.MessageType) (network.Stream, error) {
	maddr, err := multiaddr.NewMultiaddr(addr)
	if err != nil {
		return nil, fmt.Errorf("invalid multiaddress: %w", err)
	}

	peerInfo, err := peer.AddrInfoFromP2pAddr(maddr)
	if err != nil {
		return nil, fmt.Errorf("could not resolve peer info: %w", err)
	}

	if err := l.Host.Connect(ctx, *peerInfo); err != nil {
		return nil, fmt.Errorf("failed to connect to peer: %w", err)

// TODO (Return error once): something that was confusing me when using this method is that the error is
// returned twice if any. Once as a field of PingResult and one as a return value.
func (l *Libp2p) Ping(ctx context.Context, peerIDAddress string, timeout time.Duration) (models.PingResult, error) {
	// avoid dial to self attempt
	if peerIDAddress == l.Host.ID().String() {
		err := errors.New("can't ping self")
		return models.PingResult{Success: false, Error: err}, err
	}

	pingCtx, cancel := context.WithTimeout(ctx, timeout)
	defer cancel()

	remotePeer, err := peer.Decode(peerIDAddress)
	if err != nil {
		return models.PingResult{}, err

// ResolveAddress resolves the address by given a peer id.
func (l *Libp2p) ResolveAddress(ctx context.Context, id string) ([]string, error) {
	pid, err := peer.Decode(id)
	if err != nil {
		return nil, fmt.Errorf("failed to resolve invalid peer: %w", err)
	}

	// resolve ourself
	if l.Host.ID().String() == id {
		multiAddrs, err := l.GetMultiaddr()
		if err != nil {
			return nil, fmt.Errorf("failed to resolve self: %w", err)
		}
		resolved := make([]string, len(multiAddrs))

// Query return all the advertisements in the network related to a key.
// The network is queried to find providers for the given key, and peers which we aren't connected to can be retrieved.
func (l *Libp2p) Query(ctx context.Context, key string) ([]*commonproto.Advertisement, error) {
	if key == "" {
		return nil, errors.New("advertisement key is empty")
	}

	customCID, err := createCIDFromKey(key)
	if err != nil {
		return nil, fmt.Errorf("failed to create cid for key %s: %w", key, err)
	}

	addrInfo, err := l.DHT.FindProviders(ctx, customCID)
	if err != nil {
		return nil, fmt.Errorf("failed to find providers for key %s: %w", key, err)

// Advertise given data and a key pushes the data to the dht.
func (l *Libp2p) Advertise(ctx context.Context, key string, data []byte) error {
	if key == "" {
		return errors.New("advertisement key is empty")
	}

	pubKeyBytes, err := l.getPublicKey()
	if err != nil {
		return fmt.Errorf("failed to get public key: %w", err)
	}

	envelope := &commonproto.Advertisement{
		PeerId:    l.Host.ID().String(),
		Timestamp: time.Now().Unix(),

}

func (l *Libp2p) sendMessage(ctx context.Context, addr string, msg models.MessageEnvelope) error {
	peerAddr, err := multiaddr.NewMultiaddr(addr)
	if err != nil {
		return fmt.Errorf("invalid multiaddr %s: %v", addr, err)
	}

	peerInfo, err := peer.AddrInfoFromP2pAddr(peerAddr)
	if err != nil {
		return fmt.Errorf("failed to get peer info %s: %v", addr, err)
	}

	// we are delivering a message to ourself
	// we should use the handler to send the message to the handler directly which has been previously registered.

// generateSwarmKey generates a new swarm key, storing it within
// `<nunet_config_dir>/swarm.key`.
func generateSwarmKey(fs afero.Fs) (pnet.PSK, error) {
	priv, _, err := crypto.GenerateKeyPair(crypto.Secp256k1, 256)
	if err != nil {
		return nil, err
	}

	privBytes, err := crypto.MarshalPrivateKey(priv)
	if err != nil {
		return nil, err
	}
	encodedKey := base64.StdEncoding.EncodeToString(privBytes)

	swarmKeyWithCodec := fmt.Sprintf("/key/swarm/psk/1.0.0/\n/base64/\n%s\n", encodedKey)

}

func makeAddrsFactory(announce []string, appendAnnouce []string, noAnnounce []string) func([]multiaddr.Multiaddr) []multiaddr.Multiaddr {
	var err error                     // To assign to the slice in the for loop
	existing := make(map[string]bool) // To avoid duplicates

	annAddrs := make([]multiaddr.Multiaddr, len(announce))
	for i, addr := range announce {
		annAddrs[i], err = multiaddr.NewMultiaddr(addr)
		if err != nil {
			return nil
		}
		existing[addr] = true
	}

}

func makeAddrsFactory(announce []string, appendAnnouce []string, noAnnounce []string) func([]multiaddr.Multiaddr) []multiaddr.Multiaddr {
	var err error                     // To assign to the slice in the for loop
	existing := make(map[string]bool) // To avoid duplicates

	annAddrs := make([]multiaddr.Multiaddr, len(announce))
	for i, addr := range announce {
		annAddrs[i], err = multiaddr.NewMultiaddr(addr)
		if err != nil {
			return nil
		}
		existing[addr] = true
	}

// NewHost returns a new libp2p host with dht and other related settings.
func NewHost(ctx context.Context, config *models.Libp2pConfig, fs afero.Fs) (host.Host, *dht.IpfsDHT, *pubsub.PubSub, error) {
	var idht *dht.IpfsDHT
	connmgr, err := connmgr.NewConnManager(
		100,
		400,
		connmgr.WithGracePeriod(time.Duration(config.GracePeriodMs)*time.Millisecond),
	)
	if err != nil {
		return nil, nil, nil, err
	}

	filter := multiaddr.NewFilters()
	for _, s := range defaultServerFilters {

// NewHost returns a new libp2p host with dht and other related settings.
func NewHost(ctx context.Context, config *models.Libp2pConfig, fs afero.Fs) (host.Host, *dht.IpfsDHT, *pubsub.PubSub, error) {
	var idht *dht.IpfsDHT
	connmgr, err := connmgr.NewConnManager(
		100,
		400,
		connmgr.WithGracePeriod(time.Duration(config.GracePeriodMs)*time.Millisecond),
	)
	if err != nil {
		return nil, nil, nil, err
	}

	filter := multiaddr.NewFilters()
	for _, s := range defaultServerFilters {

// NewHost returns a new libp2p host with dht and other related settings.
func NewHost(ctx context.Context, config *models.Libp2pConfig, fs afero.Fs) (host.Host, *dht.IpfsDHT, *pubsub.PubSub, error) {
	var idht *dht.IpfsDHT
	connmgr, err := connmgr.NewConnManager(
		100,
		400,
		connmgr.WithGracePeriod(time.Duration(config.GracePeriodMs)*time.Millisecond),
	)
	if err != nil {
		return nil, nil, nil, err
	}

	filter := multiaddr.NewFilters()
	for _, s := range defaultServerFilters {

// be careful if managing files with `os` (the volume controller might be
// using an in-memory one)
func (s *S3Storage) Download(ctx context.Context, sourceSpecs *models.SpecConfig) (
	models.StorageVolume, error) {
	var storageVol models.StorageVolume

	source, err := DecodeInputSpec(sourceSpecs)
	if err != nil {
		return models.StorageVolume{}, err
	}

	storageVol, err = s.volController.CreateVolume(storage.VolumeSourceS3)
	if err != nil {
		return models.StorageVolume{}, fmt.Errorf("failed to create storage volume: %v", err)
	}

// be careful if managing files with `os` (the volume controller might be
// using an in-memory one)
func (s *S3Storage) Upload(ctx context.Context, vol models.StorageVolume,
	destinationSpecs *models.SpecConfig) error {

	target, err := DecodeInputSpec(destinationSpecs)
	if err != nil {
		return fmt.Errorf("failed to decode input spec: %v", err)
	}

	sanitizedKey := sanitizeKey(target.Key)

	// set file system to act upon based on the volume controller implementation
	var fs afero.Fs
	if basicVolController, ok := s.volController.(*basic_controller.BasicVolumeController); ok {

// SetupVolControllerTestSuite sets up a volume controller with 0-n volumes given a base path.
// If volumes are inputed, directories will be created and volumes will be stored in the database
func SetupVolControllerTestSuite(t *testing.T, basePath string,
	volumes map[string]*models.StorageVolume) (*VolControllerTestSuiteHelper, error) {

	tempDir, err := os.MkdirTemp("", "clover-test-*")
	if err != nil {
		return nil, fmt.Errorf("failed to create temp directory: %w", err)
	}

	db, err := repositories_clover.NewDB(tempDir, []string{"storage_volume"})
	if err != nil {
		os.RemoveAll(tempDir)
		return nil, fmt.Errorf("failed to open clover db: %w", err)
	}

// Add adds the resources of the given Capability to the current Capability
func (c *Capability) Add(cap Capability) error {
	// Executors
	for _, executor := range cap.Executors {
		if !c.Executors.Contains(executor) {
			c.Executors = append(c.Executors, executor)
		}
	}

	// JobTypes
	for _, jobType := range cap.JobTypes {
		if !c.JobTypes.Contains(jobType) {
			c.JobTypes = append(c.JobTypes, jobType)
		}

// Subtract subtracts the resources of the given Capability from the current Capability
func (c *Capability) Subtract(cap Capability) error {
	// Executors
	// No Subtract operation for Executors

	// JobTypes
	// No Subtract operation for JobTypes

	// Resources
	if c.Resources.CPU < cap.Resources.CPU {
		return errors.New("CPU resources are not enough")
	}

	if c.Resources.Memory < cap.Resources.Memory {

// Add adds the resources of the given Capability to the current Capability
func (c *Capability) Add(cap Capability) error {
	// Executors
	for _, executor := range cap.Executors {
		if !c.Executors.Contains(executor) {
			c.Executors = append(c.Executors, executor)
		}
	}

	// JobTypes
	for _, jobType := range cap.JobTypes {
		if !c.JobTypes.Contains(jobType) {
			c.JobTypes = append(c.JobTypes, jobType)
		}

}

func (g *GPU) Equal(gg *GPU) bool {
	if g.Index != gg.Index {
		return false
	}
	if g.Name != gg.Name {
		return false
	}
	if g.Vendor != gg.Vendor {
		return false
	}
	if g.PCIAddress != gg.PCIAddress {
		return false
	}

// CreateContainer creates a new Docker container with the specified configuration.
func (c *Client) CreateContainer(
	ctx context.Context,
	config *container.Config,
	hostConfig *container.HostConfig,
	networkingConfig *network.NetworkingConfig,
	platform *v1.Platform,
	name string,
) (string, error) {
	_, err := c.PullImage(ctx, config.Image)

// DecodeSpec decodes a spec config into a docker engine spec
// It converts the params into a docker EngineSpec struct and validates it
func DecodeSpec(spec *models.SpecConfig) (EngineSpec, error) {
	if !spec.IsType(models.ExecutorTypeDocker) {
		return EngineSpec{}, fmt.Errorf(
			"invalid docker engine type. expected %s, but recieved: %s",
			models.ExecutorTypeDocker,
			spec.Type,
		)
	}

	inputParams := spec.Params
	if inputParams == nil {
		return EngineSpec{}, fmt.Errorf("invalid docker engine params: params cannot be nil")
	}

// run starts the container and handles its execution lifecycle.
func (h *executionHandler) run(ctx context.Context) {
	h.running.Store(true)
	defer func() {
		if err := h.destroy(DestroyTimeout); err != nil {
			zlog.Sugar().Warnf("failed to destroy container: %v\n", err)
		}
		h.running.Store(false)
		close(h.waitCh)
	}()

	if err := h.client.StartContainer(ctx, h.containerID); err != nil {
		h.result = models.NewFailedExecutionResult(fmt.Errorf("failed to start container: %v", err))
		return

// run starts the container and handles its execution lifecycle.
func (h *executionHandler) run(ctx context.Context) {
	h.running.Store(true)
	defer func() {
		if err := h.destroy(DestroyTimeout); err != nil {
			zlog.Sugar().Warnf("failed to destroy container: %v\n", err)
		}
		h.running.Store(false)
		close(h.waitCh)
	}()

	if err := h.client.StartContainer(ctx, h.containerID); err != nil {
		h.result = models.NewFailedExecutionResult(fmt.Errorf("failed to start container: %v", err))
		return

// DestroyVM destroys the Firecracker VM.
func (c *Client) DestroyVM(
	ctx context.Context,
	m *firecracker.Machine,
	timeout time.Duration,
) error {
	// Remove the socket file.
	defer os.Remove(m.Cfg.SocketPath)

	// Get the PID of the Firecracker process and shut down the VM.
	// If the process is still running after the timeout, kill it.
	pid, _ := m.PID()
	c.ShutdownVM(ctx, m)

// FindVM finds a Firecracker VM by its socket path.
// This implementation checks if the VM is running by sending a request to the Firecracker API.
func (c *Client) FindVM(ctx context.Context, socketPath string) (*firecracker.Machine, error) {
	// Check if the socket file exists.
	if _, err := os.Stat(socketPath); err != nil {
		return nil, fmt.Errorf("VM with socket path %v not found", socketPath)
	}

	// Create a new Firecracker machine instance.
	cmd := firecracker.VMCommandBuilder{}.WithSocketPath(socketPath).Build(ctx)
	machine, err := firecracker.NewMachine(
		ctx,
		firecracker.Config{SocketPath: socketPath},
		firecracker.WithProcessRunner(cmd),
	)

// DecodeSpec decodes a spec config into a firecracker engine spec
// It converts the params into a firecracker EngineSpec struct and validates it
func DecodeSpec(spec *models.SpecConfig) (EngineSpec, error) {
	if !spec.IsType(models.ExecutorTypeFirecracker) {
		return EngineSpec{}, fmt.Errorf(
			"invalid firecracker engine type. expected %s, but recieved: %s",
			models.ExecutorTypeFirecracker,
			spec.Type,
		)
	}

	inputParams := spec.Params
	if inputParams == nil {
		return EngineSpec{}, fmt.Errorf("invalid firecracker engine params: params cannot be nil")
	}

// XXX NewChatJoinCmd and NewChatStartCmd are similar, consider refactoring
func NewChatJoinCmd(utilsService backend.Utility, wsClient backend.WebSocketClient) *cobra.Command {
	return &cobra.Command{
		Use:     "join",
		Short:   "Join open chat stream",
		Example: "nunet chat join <chatID>",
		Long:    "",
		RunE: func(cmd *cobra.Command, args []string) error {
			chatList, err := utilsService.ResponseBody(nil, "GET", "/api/v1/peers/chat", "", nil)
			if err != nil {
				return fmt.Errorf("could not obtain incoming chats list: %w", err)
			}

			err = validateJoinChatInput(args, chatList)

)

func NewOnboardCmd(net backend.NetworkManager, utilsService backend.Utility) *cobra.Command {
	cmd := &cobra.Command{
		Use:     "onboard",
		Short:   "Onboard current machine to NuNet",
		PreRunE: isDMSRunning(net),
		RunE: func(cmd *cobra.Command, args []string) error {
			memory, _ := cmd.Flags().GetInt64("memory")
			cpu, _ := cmd.Flags().GetInt64("cpu")
			channel, _ := cmd.Flags().GetString("nunet-channel")
			address, _ := cmd.Flags().GetString("address")
			ntxPrice, _ := cmd.Flags().GetFloat64("ntx-price")
			local, _ := cmd.Flags().GetBool("local-enable")
			cardano, _ := cmd.Flags().GetBool("cardano")

)

func NewOnboardCmd(net backend.NetworkManager, utilsService backend.Utility) *cobra.Command {
	cmd := &cobra.Command{
		Use:     "onboard",
		Short:   "Onboard current machine to NuNet",
		PreRunE: isDMSRunning(net),
		RunE: func(cmd *cobra.Command, args []string) error {
			memory, _ := cmd.Flags().GetInt64("memory")
			cpu, _ := cmd.Flags().GetInt64("cpu")
			channel, _ := cmd.Flags().GetString("nunet-channel")
			address, _ := cmd.Flags().GetString("address")
			ntxPrice, _ := cmd.Flags().GetFloat64("ntx-price")
			local, _ := cmd.Flags().GetBool("local-enable")
			cardano, _ := cmd.Flags().GetBool("cardano")

)

func NewOnboardCmd(net backend.NetworkManager, utilsService backend.Utility) *cobra.Command {
	cmd := &cobra.Command{
		Use:     "onboard",
		Short:   "Onboard current machine to NuNet",
		PreRunE: isDMSRunning(net),
		RunE: func(cmd *cobra.Command, args []string) error {
			memory, _ := cmd.Flags().GetInt64("memory")
			cpu, _ := cmd.Flags().GetInt64("cpu")
			channel, _ := cmd.Flags().GetString("nunet-channel")
			address, _ := cmd.Flags().GetString("address")
			ntxPrice, _ := cmd.Flags().GetFloat64("ntx-price")
			local, _ := cmd.Flags().GetBool("local-enable")
			cardano, _ := cmd.Flags().GetBool("cardano")

)

func NewWalletNewCmd(wallet backend.WalletManager) *cobra.Command {
	cmd := &cobra.Command{
		Use:   "new",
		Short: "Create new wallet",
		RunE: func(cmd *cobra.Command, args []string) error {
			eth, _ := cmd.Flags().GetBool("ethereum")
			ada, _ := cmd.Flags().GetBool("cardano")

			var pair *models.BlockchainAddressPrivKey
			var err error

			// limit wallet creation to one at a time
			if ada && eth {

)

func NewPeerListCmd(utilsService backend.Utility) *cobra.Command {
	cmd := &cobra.Command{
		Use:   "list",
		Short: "Display list of peers in the network",
		Long:  ``,
		RunE: func(cmd *cobra.Command, args []string) error {
			err := checkOnboarded(utilsService)
			if err != nil {
				return err
			}

			dhtFlag, _ := cmd.Flags().GetBool("dht")

)

func NewCapacityCmd(net backend.NetworkManager, resources backend.ResourceManager, utilsService backend.Utility) *cobra.Command {
	cmd := &cobra.Command{
		Use:     "capacity",
		Short:   "Display capacity of device resources",
		Long:    `Retrieve capacity of the machine, onboarded or available amount of resources`,
		PreRunE: isDMSRunning(net),
		RunE: func(cmd *cobra.Command, args []string) error {
			onboarded, _ := cmd.Flags().GetBool("onboarded")
			full, _ := cmd.Flags().GetBool("full")
			available, _ := cmd.Flags().GetBool("available")

			// flagCombination stores the bitwise value of combined flags
			var flagCombination int

)

func NewCapacityCmd(net backend.NetworkManager, resources backend.ResourceManager, utilsService backend.Utility) *cobra.Command {
	cmd := &cobra.Command{
		Use:     "capacity",
		Short:   "Display capacity of device resources",
		Long:    `Retrieve capacity of the machine, onboarded or available amount of resources`,
		PreRunE: isDMSRunning(net),
		RunE: func(cmd *cobra.Command, args []string) error {
			onboarded, _ := cmd.Flags().GetBool("onboarded")
			full, _ := cmd.Flags().GetBool("full")
			available, _ := cmd.Flags().GetBool("available")

			// flagCombination stores the bitwise value of combined flags
			var flagCombination int

)

func NewCapacityCmd(net backend.NetworkManager, resources backend.ResourceManager, utilsService backend.Utility) *cobra.Command {
	cmd := &cobra.Command{
		Use:     "capacity",
		Short:   "Display capacity of device resources",
		Long:    `Retrieve capacity of the machine, onboarded or available amount of resources`,
		PreRunE: isDMSRunning(net),
		RunE: func(cmd *cobra.Command, args []string) error {
			onboarded, _ := cmd.Flags().GetBool("onboarded")
			full, _ := cmd.Flags().GetBool("full")
			available, _ := cmd.Flags().GetBool("available")

			// flagCombination stores the bitwise value of combined flags
			var flagCombination int

}

func runDockerContainer(cli *client.Client, ctx context.Context, options ContainerOptions) error {
	if options.Image == "" {
		return fmt.Errorf("image name cannot be empty")
	}

	config := &container.Config{
		Image:      options.Image,
		Entrypoint: options.Entrypoint,
		Cmd:        options.Command,
		Tty:        true,
	}

	hostConfig := &container.HostConfig{}

}

func runDockerContainer(cli *client.Client, ctx context.Context, options ContainerOptions) error {
	if options.Image == "" {
		return fmt.Errorf("image name cannot be empty")
	}

	config := &container.Config{
		Image:      options.Image,
		Entrypoint: options.Entrypoint,
		Cmd:        options.Command,
		Tty:        true,
	}

	hostConfig := &container.HostConfig{}

var logCmd *cobra.Command

func NewLogCmd(net backend.NetworkManager, fs backend.FileSystem, journal backend.Logger) *cobra.Command {
	return &cobra.Command{
		Use:     "log",
		Short:   "Gather all logs into a tarball. COMMAND MUST RUN AS ROOT WITH SUDO",
		PreRunE: isDMSRunning(net),
		RunE: func(cmd *cobra.Command, args []string) error {
			dmsLogDir := filepath.Join(logDir, "dms-log")

			fmt.Fprintln(cmd.OutOrStdout(), "Collecting logs...")

			err := fs.MkdirAll(dmsLogDir, 0777)
			if err != nil {
				return fmt.Errorf("cannot create dms-log directory: %w", err)

var logCmd *cobra.Command

func NewLogCmd(net backend.NetworkManager, fs backend.FileSystem, journal backend.Logger) *cobra.Command {
	return &cobra.Command{
		Use:     "log",
		Short:   "Gather all logs into a tarball. COMMAND MUST RUN AS ROOT WITH SUDO",
		PreRunE: isDMSRunning(net),
		RunE: func(cmd *cobra.Command, args []string) error {
			dmsLogDir := filepath.Join(logDir, "dms-log")

			fmt.Fprintln(cmd.OutOrStdout(), "Collecting logs...")

			err := fs.MkdirAll(dmsLogDir, 0777)
			if err != nil {
				return fmt.Errorf("cannot create dms-log directory: %w", err)

var resourceConfigCmd = NewResourceConfigCmd(networkService, utilsService)

func NewResourceConfigCmd(net backend.NetworkManager, utilsService backend.Utility) *cobra.Command {
	cmd := &cobra.Command{
		Use:     "resource-config",
		Short:   "Update configuration of onboarded device",
		PreRunE: isDMSRunning(net),
		RunE: func(cmd *cobra.Command, args []string) error {
			memory, _ := cmd.Flags().GetInt64("memory")
			cpu, _ := cmd.Flags().GetInt64("cpu")
			ntxPrice, _ := cmd.Flags().GetFloat64("ntx-price")

			// check for both flags values
			if memory == 0 || cpu == 0 || ntxPrice < 0 {
				cmd.Help()

var chatStartCmd = NewChatStartCmd(p2pService, utilsService, webSocketClient)

func NewChatStartCmd(p2pService backend.PeerManager, utilsService backend.Utility, wsClient backend.WebSocketClient) *cobra.Command {
	return &cobra.Command{
		Use:     "start",
		Short:   "Start chat with a peer",
		Example: "nunet chat start <peerID>",
		RunE: func(cmd *cobra.Command, args []string) error {
			log.SetOutput(cmd.OutOrStderr())

			err := validateStartChatInput(p2pService, args)
			if err != nil {
				return fmt.Errorf("start chat failed: %w", err)
			}

			for {
				select {
				case <-exit:
					fmt.Println("signal: interrupt")
					return
				default:
					// clear screen (not reliable, maybe implement something ncurses-like for future)
					fmt.Print("\033[H\033[2J")

					fmt.Println("========== NuNet GPU Status ==========")
					fmt.Println("========== GPU Utilization ==========")
					for _, a := range amdGPUs {
						fmt.Printf("%d AMD %s: %d%%\n", a.index, a.name(), a.utilizationRate())
					}

// setOnboardData takes all onboarding parameters and marshal them into JSON
func setOnboardData(memory int64, cpu int64, ntxPrice float64, channel, address string, cardano, serverMode, isAvailable bool) ([]byte, error) {
	reserved := models.CapacityForNunet{
		Memory:            memory,

// printMetadata takes models.Metadata struct as input and display it in YAML-like format for better readability
func printMetadata(w io.Writer, metadata *models.Metadata) {
	fmt.Fprintln(w, "metadata:")

	if metadata.Name != "" {
		fmt.Fprintf(w, "  name: %s\n", metadata.Name)
	}

	if metadata.UpdateTimestamp != 0 {
		fmt.Fprintf(w, "  update_timestamp: %d\n", metadata.UpdateTimestamp)
	}

	if metadata.Resource.MemoryMax != 0 || metadata.Resource.TotalCore != 0 || metadata.Resource.CPUMax != 0 {
		fmt.Fprintln(w, "  resource:")

// printMetadata takes models.Metadata struct as input and display it in YAML-like format for better readability
func printMetadata(w io.Writer, metadata *models.Metadata) {
	fmt.Fprintln(w, "metadata:")

	if metadata.Name != "" {
		fmt.Fprintf(w, "  name: %s\n", metadata.Name)
	}

	if metadata.UpdateTimestamp != 0 {
		fmt.Fprintf(w, "  update_timestamp: %d\n", metadata.UpdateTimestamp)
	}

	if metadata.Resource.MemoryMax != 0 || metadata.Resource.TotalCore != 0 || metadata.Resource.CPUMax != 0 {
		fmt.Fprintln(w, "  resource:")

// END

func validateJoinChatInput(args []string, chatList []byte) error {
	var chatID int
	var err error

	if len(args) == 0 || args[0] == "" {
		return fmt.Errorf("no chat ID specified")
	} else if len(args) > 1 {
		return fmt.Errorf("unable to join multiple chats")
	} else {
		chatID, err = strconv.Atoi(args[0])
		if err != nil {
			return fmt.Errorf("argument is not integer")
		}

// getDHTPeers fetches API to retrieve info from DHT peers
func getDHTPeers(utilsService backend.Utility) ([]string, error) {
	var dhtSlice []string

	bodyDht, err := utilsService.ResponseBody(nil, "GET", "/api/v1/peers/dht", "", nil)
	if err != nil {
		return nil, fmt.Errorf("cannot get response body: %w", err)
	}

	errMsg, err := jsonparser.GetString(bodyDht, "error")
	if err == nil {
		return nil, fmt.Errorf(errMsg)
	}
	msg, err := jsonparser.GetString(bodyDht, "message")

// getBootstrapPeers fetches API to retrieve data from bootstrap peers
func getBootstrapPeers(writer io.Writer, utilsService backend.Utility) ([]string, error) {
	var bootSlice []string

	bodyBoot, err := utilsService.ResponseBody(nil, "GET", "/api/v1/peers", "", nil)
	if err != nil {
		return nil, fmt.Errorf("unable to get response body: %w", err)
	}

	errMsg, err := jsonparser.GetString(bodyBoot, "error")
	if err == nil {
		return nil, fmt.Errorf(errMsg)
	}
	msg, err := jsonparser.GetString(bodyBoot, "message")

	// MemoryType represents the type of GPU memory, e.g., "GDDR6", "HBM2"
	// TODO: may be removed as it may be too specific for our case
	MemoryType string

type Disk struct {
	// Model represents the disk model, e.g., "Samsung 970 EVO Plus", "Western Digital Blue SN550"
	// TODO: may be removed as Disk models will be usually irrelevant, right?
	Model string

	// Vendor represents the disk manufacturer, e.g., "Samsung", "Western Digital"
	// TODO: may be removed as Disk vendors will be usually irrelevant, right?
	Vendor string

	// Read speed in bytes per second
	// TODO: may be removed as it may be too specific for our case
	ReadSpeed uint64
	// Write speed in bytes per second

	ReadSpeed uint64
	// Write speed in bytes per second
	// TODO: may be removed as it may be too specific for our case
	WriteSpeed uint64
}

// fetches the max clock speed of a single core
// XXX: Assuming all cores have the same clock speed
func hz_per_cpu() float64 {
	cores, _ := cpu.Info()

		CpuNo:             int(numCores),
		CpuHz:             resources.Hz_per_cpu(),
		PriceCpu:          0, // TODO: Get price of CPU
		Ram:               int(capacity.Memory),
		PriceRam:          0, // TODO: Get price of RAM

		PriceCpu:          0, // TODO: Get price of CPU
		Ram:               int(capacity.Memory),
		PriceRam:          0, // TODO: Get price of RAM
		Vcpu:              int(math.Floor((float64(capacity.CPU)) / resources.Hz_per_cpu())),
		Disk:              0,

	}

	// TODO: START NETWORKING AND OTHER WORKERS FOR THE NODE
	return nil, errors.New("NOT YET IMPLEMENTED")

	db.ConnectDatabase()

	// XXX: wait for server to start properly before sending requests below
	// TODO: should be removed
	time.Sleep(time.Second * 5)

	// XXX: wait for server to start properly before sending requests below
	// TODO: should be removed
	time.Sleep(time.Second * 5)

func Compare(l, r interface{}, preference ...Preference) models.Comparison {

	// TODO: it would be better to pass a pointer as this is a global structure
	var comparatorMap = initComparatorMap()
	

		result = models.Worse

		// TODO: this comparator does not take into account options when several job types are available and several job types are required
		// in the same data structure; this is why the test fails;
	}

	var result models.Comparison
	result = models.Error // error is the default value
	// TODO: implement the comparison logic for the Capability type
	// after all the fields are implemented
	return result

// Deleted now because dependencies such as the docker package have been replaced with executor/docker
func SanityCheck(gormDB *gorm.DB) {
	// TODO: sanity check of DMS last exit and correction of invalid states

	resources.CalcFreeResAndUpdateDB()

echo "Looking for old versions of nunet-dms ..."

# XXX this can be removed once the new "nunet" binary has been in use for sometime
if [ -f "/usr/bin/nunet-dms" ];then
    rm -f /usr/bin/nunet-dms

		}

		// TODO(skylar): See if inline datum is present
		if input.DatumFile != "" {
			args = append(args, "--tx-in-inline-datum-present")

	span.SetAttributes(attribute.String("URL", "/run/request-service"))

	// TODO: Uncomment after refactor.
	// kLogger.Info("Handle request service", span)
	// END

	// }
	c.AbortWithStatusJSON(500, gin.H{"error": "DeploymentRequestHandler not implemented"})
	// TODO: Original func did not return a success response. Should we return it?
}

//	@Router			/run/checkpoints [get]
func ListCheckpointHandler(c *gin.Context) {
	// TODO: Remove this section after refactor.
	checkpoints := checkpoint{}
	err := errors.New("non existant import path")

func getCustomCorsConfig() cors.Config {
	config := defaultConfig()
	// FIXME: This is a security concern.
	config.AllowOrigins = []string{"http://localhost:9991", "http://localhost:9992"}
	return config

//	@Router			/device/status [get]
func DeviceStatusHandler(c *gin.Context) {
	// TODO: handle this after refactor
	// status, err := libp2p.DeviceStatus()
	// if err != nil {

	}

	// TODO: handle this after refactor
	// err = libp2p.ChangeDeviceStatus(status.IsAvailable)
	// if err != nil {

func (dhtValidator) Select(_ string, _ [][]byte) (int, error) { return 0, nil }

// TODO remove the below when network package is fully implemented
// UpdateKadDHT is a stub
func (l *Libp2p) UpdateKadDHT() {

// Libp2p contains the configuration for a Libp2p instance.
//
// TODO-suggestion: maybe we should call it something else like Libp2pPeer,
// Libp2pHost or just Peer (callers would use libp2p.Peer...)
type Libp2p struct {

// New creates a libp2p instance.
//
// TODO-Suggestion: move models.Libp2pConfig to here for better readability.
// Unless there is a reason to keep within models.
func New(config *models.Libp2pConfig, fs afero.Fs) (*Libp2p, error) {

	err = l.advertiseForRendezvousDiscovery(context)
	if err != nil {
		// TODO: the error might be misleading as a peer can normally work well if an error
		// is returned here (e.g.: the error is yielded in tests even though all tests pass).
		zlog.Sugar().Errorf("failed to start network with randevouz discovery: %v", err)

// Ping the remote address. The remote address is the encoded peer id which will be decoded and used here.
//
// TODO (Return error once): something that was confusing me when using this method is that the error is
// returned twice if any. Once as a field of PingResult and one as a return value.
func (l *Libp2p) Ping(ctx context.Context, peerIDAddress string, timeout time.Duration) (models.PingResult, error) {

	var advertisements []*commonproto.Advertisement
	for _, v := range addrInfo {
		// TODO: use go routines to get the values in parallel.
		bytesAdvertisement, err := l.DHT.GetValue(ctx, l.getCustomNamespace(key, v.ID.String()))
		if err != nil {

*/

// TODO-pnet-1: we shouldn't handle configuration paths here, a general configuration path
// should be provided by /internal/config.go
func getBasePath(fs afero.Fs) (string, error) {

// If a swarm key is not found, generate a new one.
//
// TODO-ask: should we continue to generate a new swarm key if one is not found?
// Or we should enforce the user to use some cmd/API rpc to generate a new one?
func configureSwarmKey(fs afero.Fs) (pnet.PSK, error) {

	}

	// TODO-ask: should we return psk fingerprint?
	return psk, nil
}

	swarmKeyWithCodec := fmt.Sprintf("/key/swarm/psk/1.0.0/\n/base64/\n%s\n", encodedKey)

	// TODO-pnet-1
	nunetDir, err := getBasePath(fs)
	if err != nil {

)

// TODO: pass the logger to the constructor and remove from here
var (
	zlog    *otelzap.Logger

// NewNetwork returns a new network given the configuration.
func NewNetwork(netConfig *models.NetworkConfig, fs afero.Fs) (Network, error) {
	// TODO: probable additional params to receive: DB, FileSystem
	if netConfig == nil {
		return nil, errors.New("network configuration is nil")

		return []s3Object{}, fmt.Errorf("failed to retrieve object metadata: %v", err)
	}
	// TODO-minor: validate checksum if provided

	if strings.HasPrefix(*headObjectOut.ContentType, "application/x-directory") {

// NewDefaultVolumeController returns a new instance of BasicVolumeController
//
// TODO-BugFix [path]: volBasePath might not end with `/`, causing errors when calling methods.
// We need to validate it using the `path` library or just verifying the string.
func NewDefaultVolumeController(repo repositories.StorageVolumeRepository, volBasePath string, fs afero.Fs) (*BasicVolumeController, error) {

// where `name` is random.
//
// TODO-maybe [withName]: allow callers to specify custom name for path
func (vc *BasicVolumeController) CreateVolume(volSource storage.VolumeSource, opts ...storage.CreateVolOpt) (models.StorageVolume, error) {
	vol := models.StorageVolume{

// It optionally can also set the CID and mark the volume as private.
//
// TODO-maybe [CID]: maybe calculate CID of every volume in case WithCID opt is not provided
func (vc *BasicVolumeController) LockVolume(pathToVol string, opts ...storage.LockVolOpt) error {
	query := vc.repo.GetQuery()

// WithCID sets the CID of a given volume if already calculated
//
// TODO [validate]: check if CID provided is valid
func WithCID(cid string) storage.LockVolOpt {
	return func(v *models.StorageVolume) {

// ListVolumes returns a list of all storage volumes stored on the database
//
// TODO [filter]: maybe add opts to filter results by certain values
func (vc *BasicVolumeController) ListVolumes() ([]models.StorageVolume, error) {
	volumes, err := vc.repo.FindAll(context.Background(), vc.repo.GetQuery())

// GetSize returns the size of a volume
// TODO-minor: identify which measurement type will be used
func (vc *BasicVolumeController) GetSize(identifier string, idType storage.IDType) (int64, error) {
	query := vc.repo.GetQuery()

}

// TODO-minor: compiler-time check for interface implementation
var _ storage.VolumeController = (*BasicVolumeController)(nil)

// VolumeController is used to manage storage volumes.
//
// TODO-maybe: is the interface too big? We may have to split it?
type VolumeController interface {
	// CreateVolume creates a directory where data can be stored, and returns a StorageVolume

	// One of the opts may be a CID. Or the implementation might handle the CID calculation
	//
	// TODO-maybe: after volume is locked, callers should not be able to write data to it.
	LockVolume(pathToVol string, opts ...LockVolOpt) error

	// GetSize returns the size of a volume
	// TODO-minor: identify which measurement type will be used
	GetSize(identifier string, idType IDType) (int64, error)

	GetSize(identifier string, idType IDType) (int64, error)

	// TODO-maybe: encrypt/decrypt method might move to an unique EncryptVolume/DecryptVolume interfaces
	// or something else.
	//  - Warning: if moved, EncryptionType field of StorageVolume must be updated somehow by the new interface

	MessageHashAction    string
	Action               string
	// TODO: Add ContainerType field

}

// created using the VolumeController, there will be no data in it by default.
//
// TODO-maybe [job]: should volumes be related to a job or []job?
//
// TODO-maybe: most of the fields should be private, callers shouldn't be able to altere

// TODO-maybe [job]: should volumes be related to a job or []job?
//
// TODO-maybe: most of the fields should be private, callers shouldn't be able to altere
// the state of the volume except when using certain methods
type StorageVolume struct {

	// EncryptionType might be checked first if needed)
	//
	// TODO-maybe [type]: maybe it should be of type cid.CID
	CID string

	// Size is the size of the storage volume
	//
	// TODO-maybe: if relying on a size field, we would have to be more careful
	// how state is being mutated (and they shouldn't be by the caller)
	//  - Size might be calculated only when locking the volume also

// Warning: this is just a draft. And it might be moved to an Encryption package
//
// TODO: it must support encryption of files/directories, otherwise we have to
// create another interface for the usecase
type Encryptor interface {

// Warning: this is just a draft. And it might be moved to an Encryption package
//
// TODO: it must support decryption of files/directories, otherwise we have to
// create another interface for the usecase
type Decryptor interface {

)

// TODO: Consider comments in this thread: https://gitlab.com/nunet/device-management-service/-/merge_requests/356#note_1997854443
// TODO: Consider comments in this thread: https://gitlab.com/nunet/device-management-service/-/merge_requests/356#note_1997875361

// TODO: Consider comments in this thread: https://gitlab.com/nunet/device-management-service/-/merge_requests/356#note_1997854443
// TODO: Consider comments in this thread: https://gitlab.com/nunet/device-management-service/-/merge_requests/356#note_1997875361

// 'left' means 'this object' and 'right' means 'the supplied other object'; 

)

// XXX NewChatJoinCmd and NewChatStartCmd are similar, consider refactoring
func NewChatJoinCmd(utilsService backend.Utility, wsClient backend.WebSocketClient) *cobra.Command {
	return &cobra.Command{

func (p *P2P) ClearIncomingChatRequests() error {
	log.Println("WARNING: Bypassing ClearIncomingChatRequests() in libp2p.go")
	// TODO: Uncomment after refactoring
	// return libp2p.ClearIncomingChatRequests()
	// END

}

// TODO: Handle this after refactor
// getIncomingChatList unmarshal response body from API request into
// libp2p.OpenStream slice and return list of chats

type Job struct {
	LogUpdateInterval int    `mapstructure:"log_update_interval"` // in minutes
	TargetPeer        string `mapstructure:"target_peer"`         // specific peer to send deployment requests to - XXX probably not a good idea. Remove after testing stage.
	CleanupInterval   int    `mapstructure:"cleanup_interval"` // docker container and images clean up interval in days
}

type Job struct {
	LogUpdateInterval int    `mapstructure:"log_update_interval"` // in minutes
	TargetPeer        string `mapstructure:"target_peer"`         // specific peer to send deployment requests to - XXX probably not a good idea. Remove after testing stage.
	CleanupInterval   int    `mapstructure:"cleanup_interval"`    // docker container and images clean up interval in days
}