Deploy service

cli/.js/src/main/scala/aqua/PlatformOpts.scala

@@ -1,5 +1,6 @@
 package aqua
 
+import aqua.dist.DistOpts
 import aqua.ipfs.IpfsOpts
 import aqua.js.{Meta, Module}
 import cats.effect.ExitCode
@@ -22,6 +23,7 @@ object PlatformOpts extends Logging {
     Opts.subcommand(RunOpts.runCommand[F]) orElse
       Opts.subcommand(KeyPairOpts.createKeypair[F]) orElse
       Opts.subcommand(IpfsOpts.ipfsOpt[F]) orElse
+      Opts.subcommand(DistOpts.deployOpt[F]) orElse
       NetworkOpts.commands[F]
 
   // get path to node modules if there is `aqua-lib` module with `builtin.aqua` in it

cli/.js/src/main/scala/aqua/dist/DistOpts.scala

@@ -0,0 +1,91 @@
+package aqua.dist
+
+import aqua.builder.IPFSUploader
+import aqua.files.AquaFilesIO
+import aqua.io.OutputPrinter
+import aqua.ipfs.js.IpfsApi
+import aqua.js.{Fluence, PeerConfig}
+import aqua.keypair.KeyPairShow.show
+import aqua.model.LiteralModel
+import aqua.raw.value.{LiteralRaw, VarRaw}
+import aqua.run.RunCommand.createKeyPair
+import aqua.run.{GeneralRunOptions, RunCommand, RunConfig, RunOpts}
+import aqua.*
+import aqua.run.RunOpts.{checkDataGetServices, dataFromFileOpt, logger}
+import aqua.types.ScalarType
+import cats.data.Validated.{invalid, invalidNec, valid, validNec, validNel}
+import cats.data.*
+import cats.effect.kernel.Async
+import cats.effect.{Concurrent, ExitCode, Resource, Sync}
+import cats.syntax.applicative.*
+import cats.syntax.apply.*
+import cats.syntax.flatMap.*
+import cats.syntax.functor.*
+import cats.syntax.show.*
+import cats.{Applicative, Monad}
+import com.monovore.decline.{Command, Opts}
+import fs2.io.file.{Files, Path}
+import scribe.Logging
+
+import scala.concurrent.{ExecutionContext, Future}
+import scala.scalajs.js
+
+// Options and commands to work with IPFS
+object DistOpts extends Logging {
+
+  val DistAquaPath = "aqua/dist.aqua"
+  val DeployFuncName = "deploy"
+
+  def srvNameOpt: Opts[String] =
+    Opts
+      .option[String]("service", "What service from the config file to deploy", "s")
+
+  def deployOpt[F[_] : Async](implicit ec: ExecutionContext): Command[F[ExitCode]] =
+    Command(
+      name = "dist",
+      header = "Distribute a service onto a remote peer"
+    ) {
+      Opts.subcommand(deploy)
+    }
+
+  // Uploads a file to IPFS
+  def deploy[F[_] : Async](implicit ec: ExecutionContext): Command[F[ExitCode]] =
+    Command(
+      name = "deploy",
+      header = "Deploy a service onto a remote peer"
+    ) {
+      (
+        GeneralRunOptions.commonOpt,
+        dataFromFileOpt[F],
+        srvNameOpt
+        ).mapN { (common, dataFromFileF, srvName) =>
+        dataFromFileF.flatMap { dff =>
+          val args = VarRaw(srvName, ScalarType.string) :: Nil
+          dff
+            .andThen(data =>
+              checkDataGetServices(args, data).map(getServices =>
+                RunOpts.execRun(
+                  common,
+                  DeployFuncName,
+                  Path(DistAquaPath),
+                  Nil,
+                  args,
+                  getServices,
+                  Nil
+                )
+              )
+            )
+            .fold(
+              errs =>
+                Async[F].pure {
+                  errs.map(logger.error)
+                  cats.effect.ExitCode.Error
+                },
+              identity
+            )
+
+        }
+
+      }
+    }
+}

npm/aqua-run.sh

@@ -1,8 +1,8 @@
 #!/bin/bash
 
-FUNC='identityArgsAndReturn(structField, stringField, numberField)'
-INPUT='test/sample.aqua'
-DATAPATH='test/data.json'
+FUNC='deploy(tsOracle)'
+INPUT='aqua/dist.aqua'
+DATAPATH='test/deploy.json'
 ADDR='/dns4/kras-04.fluence.dev/tcp/19001/wss/p2p/12D3KooWFEwNWcHqi9rtsmDhsYcDbRUCDXH84RC4FW6UfsFWaoHi'
 # IMPORT=
 

npm/aqua/dist.aqua

@@ -0,0 +1,52 @@
+module ServiceDist declares *
+
+import "run-builtins.aqua"
+import "@fluencelabs/aqua-lib/builtin.aqua"
+import "@fluencelabs/aqua-ipfs/ipfs.aqua"
+
+export deploy, remove
+
+data ModuleConf:
+  name: string
+  path: string
+  mounted_binaries: [][]string
+
+data ServiceConf:
+  name: string
+  modules: []ModuleConf
+
+const ON_PEER ?= HOST_PEER_ID
+
+func deploy(serviceConf: ServiceConf) -> string:
+
+  on ON_PEER:
+    multiaddr <- Ipfs.get_external_api_multiaddr()
+
+  mod_hashes: *string
+  for m <- serviceConf.modules:
+      -- TODO check for cache
+      uploadRes <- LocalIpfs.uploadFile(m.path, multiaddr)
+      cid = uploadRes.cid
+      on ON_PEER:
+        hostRes <- Ipfs.get(cid)
+
+        mbs: *[][]string
+        mbs <<- m.mounted_binaries
+
+        conf <- Dist.make_module_config(m.name, nil, nil, nil, nil, nil, mbs, nil)
+        mod <- Dist.add_module_from_vault(hostRes.path, conf)
+
+        mod_hashes <- Op.concat_strings("hash:", mod)
+
+  on ON_PEER:
+
+        blueprint <- Dist.make_blueprint(serviceConf.name, mod_hashes)
+        blueprint_id <- Dist.add_blueprint(blueprint)
+
+        service_id <- Srv.create(blueprint_id)
+
+  <- service_id
+
+func remove(service_id: string):
+  on ON_PEER:
+    Srv.remove(service_id)

npm/aqua/run-builtins/run-builtins.aqua

@@ -9,5 +9,5 @@ data UploadResult:
   cid: string
   size: u64
 
-service IPFS("ipfs"):
+service LocalIpfs("ipfs"):
   uploadFile(path: string, multiaddr: IpfsMultiaddrResult) -> UploadResult

npm/package.json

@@ -23,8 +23,8 @@
   "dependencies": {
     "@fluencelabs/aqua-ipfs": "0.5.2",
     "@fluencelabs/aqua-lib": "0.3.2",
-    "@fluencelabs/fluence": "0.19.0",
     "@fluencelabs/avm": "0.20.2",
+    "@fluencelabs/fluence": "0.19.0",
     "ipfs-http-client": "50.1.2"
   },
   "devDependencies": {

npm/test/deploy.json

@@ -0,0 +1,13 @@
+{
+  "serviceConf": {
+    "name": "ts-oracle",
+    "modules": [
+      {
+        "name": "ts-oracle",
+        "path": "./deploy/ts_oracle.wasm",
+        "mounted_binaries": []
+      }
+    ]
+  }
+}
+