@corellium/corellium-cli 1.0.2 → 1.0.4

package/src/table.js

@@ -6,8 +6,13 @@ async function displayTable (format, data, filteredFields, columnWidths) {
     const displayJson = JSON.stringify(data, null, 2)
     log.plain(displayJson)
   } else {
-    let rows = data.map(i => {
-      return filteredFields.map(key => `${i[key]}`)
+    let rows = data.map(d => {
+      return filteredFields.map(field => {
+        // Not perfect, but this is to avoid the [object Object] scenario for json fields in DB
+        return typeof d[field] === 'object' && d[field] !== null
+          ? JSON.stringify(d[field])
+          : d[field]
+      })
     })
 
     if (format === 'csv') {

package/src/upload.js

@@ -1,7 +1,69 @@
-const images = require('@corellium/corellium-api/src/images')
+const fs = require('fs')
+const path = require('path')
+const util = require('util')
+const Resumable = require('./resumable')
 const { basename } = require('path')
 const { getErrorMessage } = require('./error')
 
+class File {
+  constructor ({ filePath, type, size }) {
+    this.path = filePath
+    this.name = path.basename(filePath)
+    this.type = type
+    this.size = size
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  slice (start, end, _contentType) {
+    return fs.createReadStream(this.path, { start, end })
+  }
+}
+
+async function uploadFile (token, url, filePath, progress) {
+  return new Promise((resolve, reject) => {
+    const r = new Resumable({
+      target: url,
+      headers: {
+        authorization: token,
+        'x-corellium-image-encoding': 'plain'
+      },
+      uploadMethod: 'PUT',
+      chunkSize: 5 * 1024 * 1024,
+      prioritizeFirstAndLastChunk: true,
+      method: 'octet'
+    })
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    r.on('fileAdded', (_file) => {
+      r.upload()
+    })
+
+    r.on('progress', () => {
+      if (progress) progress(r.progress())
+    })
+
+    r.on('fileError', (_file, message) => {
+      reject(message)
+    })
+
+    r.on('fileSuccess', (_file, message) => {
+      resolve(JSON.parse(message))
+    })
+
+    return util
+      .promisify(fs.stat)(filePath)
+      .then((stat) => {
+        const file = new File({
+          filePath: filePath,
+          type: 'application/octet-stream',
+          size: stat.size
+        })
+
+        r.addFile(file)
+      })
+  })
+}
+
 async function uploadWithProgress (url, token, file, multi) {
   const fileName = basename(file)
 
@@ -13,7 +75,7 @@ async function uploadWithProgress (url, token, file, multi) {
   })
 
   try {
-    const res = await images.uploadFile(
+    const res = await uploadFile(
       token,
       url,
       file,

package/test/test.js

@@ -0,0 +1,89 @@
+const { exec } = require('child_process')
+const { promisify } = require('util')
+const path = require('path')
+const execp = promisify(exec)
+const assert = require('node:assert').strict
+
+test()
+  .catch(e => console.error(e))
+
+async function test () {
+  await testProjects()
+  await testInstances()
+}
+
+async function testInstances () {
+  const projectId = (await ej('project create --cores 20 --instances 10 --ram 5000 CoolNewProject'))[0].id
+
+  const { state, id: instanceId } = (await ej(`instance create ranchu 12.0.0 ${projectId}`))[0]
+  assert.equal(state, 'creating')
+
+  const instances = await ej('instance list')
+  assert.ok(instances.map(p => p.id).includes(instanceId))
+  // TODO: instance stop
+  // TODO: instance start
+  await e(`instance delete ${instanceId}`)
+
+  await pollUntilNoThrow(instanceId)
+
+  // Cleanup
+  await e(`project delete ${projectId}`)
+}
+
+async function testProjects () {
+  const { id: projectId } = (await ej('project create --cores 10 --instances 2 --ram 2000 CoolNewProject'))[0]
+
+  // The list has the newly created project in it
+  let projects = await ej('project list')
+  assert.ok(projects.map(p => p.id).includes(projectId))
+
+  await e(`project delete ${projectId}`)
+
+  // The list has no longer has the project
+  projects = await ej('project list')
+  assert.equal(-1, projects.map(p => p.id).indexOf(projectId))
+}
+
+async function sleep (ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+async function pollUntilNoThrow (instanceId, tries = 1) {
+  if (tries > 10) {
+    return
+  }
+  console.log(`try ${tries} looking for ${instanceId}`)
+
+  try {
+    const instances = await ej('instance list')
+    assert.equal(-1, instances.map(i => i.id).indexOf(instanceId))
+  } catch (err) {
+    if (err.code === 'ERR_ASSERTION') {
+      const ms = 1 + Math.random() * (2 ** tries * 10)
+      await sleep(ms)
+      await pollUntilNoThrow(instanceId, tries + 1)
+    } else {
+      throw err
+    }
+  }
+}
+
+// short for "execJSON"
+// Used to exec things we want the return value of
+async function ej (s) {
+  const { stdout, stderr } = await execp(`node index.js ${s} --format json`, { cwd: path.join(__dirname, '../') })
+  if (stderr) {
+    console.log(stderr)
+  }
+  return JSON.parse(stdout)
+}
+
+// short for "exec"
+// Used mainly for deletes, which have no --format flag and return no parseable data (204, generally)
+async function e (s) {
+  const { stdout, stderr } = await execp(`node index.js ${s}`, { cwd: path.join(__dirname, '../') })
+  if (stderr) {
+    console.log(stderr)
+  }
+  return stdout
+}