chore: move mac build to circle

tasks/ci.ts

@@ -4,6 +4,20 @@ import * as assert from 'assert'
 const { env } = process
 
 export function triggerMacBuild(release: NexeTarget, branch: string) {
+  assert.ok(env.CIRCLE_TOKEN)
+  const circle = `https://circleci.com/api/v1.1/project/github/nexe/nexe/tree/${
+    branch}?circle-token=${env.CIRCLE_TOKEN}`
+  return got(circle, {
+    json: true,
+    body: {
+      build_parameters: {
+        NEXE_VERSION: release.toString()
+      }
+    }
+  })
+}
+
+export function triggerDockerBuild (release: NexeTarget, branch: string) {
   assert.ok(env.TRAVIS_TOKEN)
   const travis = `https://api.travis-ci.org/repo/nexe%2Fnexe/requests`
   return got(travis, {
@@ -29,19 +43,6 @@ export function triggerMacBuild(release: NexeTarget, branch: string) {
   })
 }
 
-export function triggerDockerBuild (release: NexeTarget, branch: string) {
-  assert.ok(env.CIRCLE_TOKEN)
-  const circle = `https://circleci.com/api/v1.1/project/github/nexe/nexe/tree/${branch}?circle-token=${env.CIRCLE_TOKEN}`
-  return got(circle, {
-    json: true,
-    body: {
-      build_parameters: {
-        NEXE_VERSION: release.toString()
-      }
-    }
-  })
-}
-
 export function triggerWindowsBuild (release: NexeTarget) {
   const hasVersion = 'NEXE_VERSION' in env
   env.NEXE_VERSION = hasVersion 

tasks/docker.ts

@@ -2,73 +2,53 @@ import { NexeTarget } from '../lib/target'
 import { writeFileAsync, readFileAsync } from '../lib/util'
 import { spawn } from 'child_process'
 import got = require('got')
-import { createWriteStream, WriteStream } from 'fs'
+import execa = require('execa')
+import { appendFileSync } from 'fs'
 
 function alpine (target: NexeTarget, nexeVersion: string) {  
   return `
-FROM i386/alpine:3.4
+FROM ${target.arch === 'x64' ? '' : 'i386/'}alpine:3.4
 RUN apk add --no-cache curl make gcc g++ binutils-gold python linux-headers paxctl libgcc libstdc++ git vim tar gzip wget
 ENV NODE_VERSION=${target.version}
 ENV NEXE_VERSION=beta
 WORKDIR /
 
 RUN curl -sSL https://nodejs.org/dist/v\${NODE_VERSION}/node-v\${NODE_VERSION}.tar.gz | tar -xz && \
-  cd /node-v\${NODE_VERSION} && \
+  mkdir /nexe_temp && mv /node-v\${NODE_VERSION} /nexe_temp/\${NODE_VERSION} && \
+  cd /nexe_temp/\${NODE_VERSION} && \
   ./configure --prefix=/usr --fully-static && \
-  make -j$(getconf _NPROCESSORS_ONLN) && \
-  make install && \
+  make && make install && \
   paxctl -cm /usr/bin/node
 
-RUN mkdir /nexe_temp && mv node-v\${NODE_VERSION} /nexe_temp/\${NODE_VERSION} && \
+RUN rm /nexe_temp/\${NODE_VERSION}/out/Release/node && \
   npm install -g nexe@\${NEXE_VERSION} && \
   nexe --build --empty --temp /nexe_temp -c="--fully-static" -o out
 `.trim()
 }
 
-export async function runAsync (command: string, output: WriteStream) {
-  const commands = command.split(/\r?\n/)
-    .filter(x => x.trim())
-    .map(x => x.trim().split(' '))
-  const sequence = Promise.resolve()
-  for (const command of commands) {
-    await new Promise((resolve, reject) => {
-      const cp = spawn(command.shift() as string, command)
-      cp.stderr.pipe(output)
-      cp.stdout.pipe(output)
-      const close = function (this: any, e: Error) {
-        this.kill()
-        e ? reject(e) : resolve()
-      }
-      cp.on('error', (e) => {
-        output.write(e.stack)
-      })
-      .on('close', close)
-      .on('exit', close)
-    })
-  }
-}
-
 export async function runAlpineBuild (target: NexeTarget, nexeVersion: string) {
   await writeFileAsync('Dockerfile', alpine(target, nexeVersion))
   const outFilename = 'nexe-alpine-build-log.txt'
-  const output = createWriteStream(outFilename)
+  await writeFileAsync(outFilename, '')
+  let output: any = []
+
   try {
-    await runAsync(`
-    docker build -t nexe-alpine .
-    docker run -d --name nexe nexe-alpine sh
-    docker cp nexe:/out out
-    docker rm nexe
-  `, output)
+    output.push(await execa.shell(`docker build -t nexe-alpine .`))    
+    output.push(await execa.shell(`docker run -d --name nexe nexe-alpine sh`))    
+    output.push(await execa.shell(`docker cp nexe:/out out`))    
+    output.push(await execa.shell(`docker rm nexe`))
   } catch(e) {
-    console.log(e)
+    console.log('Error running docker', e)
   } finally {
-    output.on('error', (e) => console.log(e))
-    output.close()
+    output.forEach((x: any) => {
+      appendFileSync(outFilename, x.stderr)
+      appendFileSync(outFilename, x.stdout)
+    })
     await got(`https://transfer.sh/${Math.random().toString(36).substring(2)}.txt`, {
       body: await readFileAsync(outFilename),
       method: 'PUT'
     })
-    .then(x => console.log(x.body))
+    .then(x => console.log('Posted docker log: ', x.body))
     .catch(e => console.log('Error posting log', e))
   }
 }