disable rust

Bumps [github.com/spf13/viper](https://github.com/spf13/viper) from 1.6.2 to 1.6.3.
- [Release notes](https://github.com/spf13/viper/releases)
- [Commits](https://github.com/spf13/viper/compare/v1.6.2...v1.6.3)

Signed-off-by: dependabot-preview[bot] <support@dependabot.com>

Co-authored-by: dependabot-preview[bot] <27856297+dependabot-preview[bot]@users.noreply.github.com>

.circleci/config.yml

@@ -1,73 +0,0 @@
-defaults: &defaults
-  machine: true
-  environment:
-    IMPORT_PATH: "github.com/$CIRCLE_PROJECT_USERNAME/$CIRCLE_PROJECT_REPONAME"
-    OUTPUT_DIR: "./build"
-    DIST_DIR: "./dist"
-
-install_golang: &install_golang
-  run:
-    name: install Golang 1.11
-    command: |
-      sudo add-apt-repository ppa:gophers/archive
-      sudo apt-get update
-      sudo apt-get install golang-1.11-go
-      alias go="/usr/lib/go-1.11/bin/go"
-      go version
-
-install_deps: &install_deps
-  run:
-    name: Install deps
-    command: |
-      /usr/lib/go-1.11/bin/go mod vendor
-      /usr/lib/go-1.11/bin/go get -u github.com/gobuffalo/packr/packr
-
-install_httpie: &install_httpie
-  run:
-    name: install httpie
-    command: |
-      sudo apt-get -y update && sudo apt-get -y install httpie
-
-install_jq: &install_jq
-  run:
-    name: install jq
-    command: |
-      sudo apt-get update && sudo apt-get -y install jq
-
-build_binary: &build_binary
-  run:
-    name: build binary
-    command: |
-      /usr/lib/go-1.11/bin/go build -o ${OUTPUT_DIR}/fx fx.go
-
-unit_test: &unit_test
-  run:
-    name: unit test
-    command: |
-      make unit-test
-      bash <(curl -s https://codecov.io/bash) -t ${CODECOV_TOKEN}
-cli_test: &cli_test
-  run:
-    name: cli test
-    command: make cli-test
-
-version: 2
-jobs:
-  test:
-    <<: *defaults
-    steps:
-      - checkout
-      - *install_golang
-      - *install_deps
-      - *unit_test
-      - *build_binary
-      - run:
-          name: Pull images
-          command: make pull
-      - *cli_test
-
-workflows:
-  version: 2
-  workflow:
-    jobs:
-      - test

.github/workflows/ci.yml

@@ -13,27 +13,23 @@ jobs:
       - name: check out
         uses: actions/checkout@master
 
-      - name: setup docker
+      - name: kind create a k8s cluster
         run: |
-          ./scripts/provision.sh
+          kind create cluster
 
-      - name: setup k8s and kind
+      - name: lint
         run: |
-          export GOBIN=$(go env GOPATH)/bin
-          export PATH=$PATH:$GOBIN
-          mkdir -p $GOBIN
-          curl -LO https://storage.googleapis.com/kubernetes-release/release/`curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt`/bin/linux/amd64/kubectl
-          chmod +x kubectl && mv kubectl $GOBIN
-          wget https://github.com/kubernetes-sigs/kind/releases/download/v0.5.0/kind-linux-amd64 && chmod +x kind-linux-amd64 && mv kind-linux-amd64 $GOBIN/kind
-          ./scripts/setup_kind.sh
+          make lint
 
       - name: unit test
         env:
           DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}
           DOCKER_USERNAME: ${{ secrets.DOCKER_USERNAME }}
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
         run: |
-          export KUBECONFIG=/home/runner/.kube/kind-config-fx-test
-          DEBUG=true go test -v ./container_runtimes/... ./deploy/...
+          export KUBECONFIG="$(kind get kubeconfig-path)"
+          make unit-test
+          bash <(curl -s https://codecov.io/bash) -t ${CODECOV_TOKEN}
 
       - name: build fx
         run: |
@@ -47,33 +43,30 @@ jobs:
           make test
           # make docker-publish #TODO in release workflow
 
-      - name: lint
-        run: |
-          export GOBIN=$(go env GOPATH)/bin
-          export PATH=$PATH:$GOBIN
-          go get -u github.com/golangci/golangci-lint/cmd/golangci-lint
-          golangci-lint run
-
-
       - name: test fx cli
+        env:
+          REMOTE_HOST_ADDR: ${{secrets.DOCKER_REMOTE_HOST_ADDR}}
+          REMOTE_HOST_USER: ${{secrets.DOCKER_REMOTE_HOST_USER}}
+          REMOTE_HOST_PASSWORD: ${{secrets.DOCKER_REMOTE_HOST_PASSWORD}}
         run: |
           echo $KUBECONFIG
           unset KUBECONFIG
-          make cli-test
+          make cli-test-ci
 
       - name: test AKS
         env:
           AKS_KUBECONFIG: ${{ secrets.AKS_KUBECONFIG }}
         run: |
-          export KUBECONFIG=${HOME}/.kube/aks
-          echo ${AKS_KUBECONFIG} | base64 -d > $KUBECONFIG
-          if [[ -z "$AKS_KUBECONFIG" ]];then
-            echo "skip deploy test since no valid KUBECONFIG"
-          else
-            DEBUG=true ./build/fx up -n hello -p 12345 examples/functions/JavaScript/func.js
-            ./build/fx down hello
-            rm ${KUBECONFIG}
-          fi
+          echo "skip since aks environment not ready yet"
+          # export KUBECONFIG=${HOME}/.kube/aks
+          # echo ${AKS_KUBECONFIG} | base64 -d > $KUBECONFIG
+          # if [[ -z "$AKS_KUBECONFIG" ]];then
+          #   echo "skip deploy test since no valid KUBECONFIG"
+          # else
+          #   DEBUG=true ./build/fx up -n hello -p 12345 examples/functions/JavaScript/func.js
+          #   ./build/fx down hello
+          #   rm ${KUBECONFIG}
+          # fi
 
   Installation:
     runs-on: ${{ matrix.os }}

.github/workflows/docker.yml

@@ -1,57 +1,70 @@
-on:
-  schedule:
-    - cron: '0 12 * * *'
+on: [push]
+  # schedule:
+  #   - cron: '0 12 * * *'
 name: docker
 jobs:
   Docker:
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        docker_version:
+          - 18.09
+          # - 19.03
+          # - 19.09
+        docker_channel:
+          - stable
+          # - test
     steps:
       - uses: actions/checkout@master
+      - name: setup docker
+        uses: docker-practice/actions-setup-docker@master
+        with:
+          docker_version: ${{ matrix.docker_version }}
+          docker_channel: ${{ matrix.docker_channel }}
 
-      - name: login
-        uses: actions/docker/login@8cdf801b322af5f369e00d85e9cf3a7122f49108
+      - name: login docker hub
         env:
           DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}
           DOCKER_USERNAME: ${{ secrets.DOCKER_USERNAME }}
+        run: |
+          docker login --username $DOCKER_USERNAME --password $DOCKER_PASSWORD
 
-      - name: build-fx-go-image
-        uses: actions/docker/cli@master
-        with:
-          args: build -t metrue/fx-go-base:latest -f api/asserts/dockerfiles/base/go/Dockerfile
-            api/asserts/dockerfiles/base/go
+      - name: build and publish fx d image
+        if: always()
+        run: |
+          docker build -t metrue/fx-d-base:latest -f ./assets/dockerfiles/base/d/Dockerfile ./assets/dockerfiles/base/d
+          docker push metrue/fx-d-base:latest
 
-      - name: push-fx-go-image
-        uses: actions/docker/cli@master
+      - name: build and publish fx go image
+        run: |
+          docker build -t metrue/fx-go-base:latest -f ./assets/dockerfiles/base/go/Dockerfile ./assets/dockerfiles/base/go
+          docker push metrue/fx-go-base:latest
+
+      - name: build and publish fx node image
+        if: always()
+        run: |
+          docker build -t metrue/fx-node-base:latest -f ./assets/dockerfiles/base/node/Dockerfile ./assets/dockerfiles/base/node
+          docker push metrue/fx-node-base:latest
+
+      - name: build and publish fx python image
+        if: always()
+        run: |
+          docker build -t metrue/fx-python-base:latest -f ./assets/dockerfiles/base/python/Dockerfile ./assets/dockerfiles/base/python
+      - name: publish fx python image
         env:
           DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}
           DOCKER_USERNAME: ${{ secrets.DOCKER_USERNAME }}
-        with:
-          args: push metrue/fx-go-base:latest
+        run: |
+          docker push metrue/fx-python-base:latest
 
-      - name: build-fx-rust-image
-        uses: actions/docker/cli@master
-        with:
-          args: build -t metrue/fx-rust-base:latest -f api/asserts/dockerfiles/base/rust/Dockerfile
-            api/asserts/dockerfiles/base/rust
+      - name: build and publish fx perl image
+        if: always()
+        run: |
+          docker build -t metrue/fx-perl-base:latest -f ./assets/dockerfiles/base/perl/Dockerfile ./assets/dockerfiles/base/perl
+          docker push metrue/fx-perl-base:latest
 
-      - name: push-fx-rust-image
-        uses: actions/docker/cli@master
-        env:
-          DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}
-          DOCKER_USERNAME: ${{ secrets.DOCKER_USERNAME }}
-        with:
-          args: push metrue/fx-rust-base:latest
-
-      - name: build-fx-node-image
-        uses: actions/docker/cli@master
-        with:
-          args: build -t metrue/fx-node-base:latest -f api/asserts/dockerfiles/base/node/Dockerfile
-            api/asserts/dockerfiles/base/node
-
-      - name: push-fx-node-image
-        uses: actions/docker/cli@master
-        env:
-          DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}
-          DOCKER_USERNAME: ${{ secrets.DOCKER_USERNAME }}
-        with:
-          args: push metrue/fx-node-base:latest
+      - name: build and publish fx julia image
+        if: always()
+        run: |
+          docker build -t metrue/fx-julia-base:latest -f ./assets/dockerfiles/base/julia/Dockerfile ./assets/dockerfiles/base/julia
+          docker push metrue/fx-julia-base:latest

.github/workflows/release.yml

@@ -18,40 +18,27 @@ jobs:
       - name: check out
         uses: actions/checkout@master
 
-      - name: setup docker
+      - name: kind create a k8s cluster
         run: |
-          ./scripts/provision.sh
+          kind create cluster
 
-      - name: setup k8s and kind
+      - name: lint
         run: |
-          export GOBIN=$(go env GOPATH)/bin
-          export PATH=$PATH:$GOBIN
-          mkdir -p $GOBIN
-          curl -LO https://storage.googleapis.com/kubernetes-release/release/`curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt`/bin/linux/amd64/kubectl
-          chmod +x kubectl && mv kubectl $GOBIN
-          wget https://github.com/kubernetes-sigs/kind/releases/download/v0.5.0/kind-linux-amd64 && chmod +x kind-linux-amd64 && mv kind-linux-amd64 $GOBIN/kind
-          ./scripts/setup_kind.sh
+          docker run --rm -v $(pwd):/app -w /app golangci/golangci-lint \
+          golangci-lint run -v
 
       - name: unit test
         env:
           DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}
           DOCKER_USERNAME: ${{ secrets.DOCKER_USERNAME }}
         run: |
-          export KUBECONFIG=/home/runner/.kube/kind-config-fx-test
-          DEBUG=true go test -v ./container_runtimes/... ./deploy/...
+          export KUBECONFIG="$(kind get kubeconfig-path)"
+          make unit-test
 
       - name: build fx
         run: |
           make build
 
-      - name: lint
-        run: |
-          export GOBIN=$(go env GOPATH)/bin
-          export PATH=$PATH:$GOBIN
-          go get -u github.com/golangci/golangci-lint/cmd/golangci-lint
-          golangci-lint run
-
-
       - name: test fx cli
         run: |
           echo $KUBECONFIG
@@ -64,11 +51,12 @@ jobs:
           DOCKER_USERNAME: ${{ secrets.DOCKER_USERNAME }}
           DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}
         run: |
-          export KUBECONFIG=${HOME}/.kube/aks
-          echo ${AKS_KUBECONFIG} | base64 -d > $KUBECONFIG
-          DEBUG=true ./build/fx up -n hello -p 12345 examples/functions/JavaScript/func.js
-          ./build/fx down hello
-          rm ${KUBECONFIG}
+          echo "skip since aks environment not ready yet"
+          # export KUBECONFIG=${HOME}/.kube/aks
+          # echo ${AKS_KUBECONFIG} | base64 -d > $KUBECONFIG
+          # DEBUG=true ./build/fx up -n hello -p 12345 examples/functions/JavaScript/func.js
+          # ./build/fx down hello
+          # rm ${KUBECONFIG}
   Release:
     runs-on: ${{ matrix.os }}
     needs: [Test]

.golangci.yml

@@ -1,12 +1,14 @@
 run:
-  deadline: 10m
-  timeout: 10m
+  deadline: 20m
+  timeout: 20m
   issues-exit-code: 1
   tests: true
   skip-dirs:
     - examples
     - api/images
     - test/functions
+    - assets/
+    - bundler/go/assets
 linters:
   enable:
     - goimports

.goreleaser.yml

@@ -32,3 +32,5 @@ brews:
     caveats: ""
     homepage: "https://github.com/metrue/fx"
     description: "fx, a simple but powerful Function as a Service build tools"
+    dependencies:
+      - docker

Makefile

@@ -1,14 +1,20 @@
-OUTPUT_DIR=./build
-DIST_DIR=./dist
+OUTPUT_DIR ?=./build
+DIST_DIR ?=./dist
+DOCKER_REMOTE_HOST_ADDR ?= "127.0.0.1"
+DOCKER_REMOTE_HOST_USER ?= $(whoami)
 
 lint:
-	golangci-lint run
+	docker pull golangci/golangci-lint
+	docker run --rm -v $(CURDIR):/app -w /app golangci/golangci-lint golangci-lint run -v
 
 generate:
 	packr
 
+b:
+	go build -ldflags="-s -w" -o ${OUTPUT_DIR}/fx fx.go
+
 build:
-	go build -o ${OUTPUT_DIR}/fx fx.go
+	go build -ldflags="-s -w" -o ${OUTPUT_DIR}/fx fx.go
 
 pull:
 	./scripts/pull.sh
@@ -23,8 +29,11 @@ clean:
 unit-test:
 	./scripts/coverage.sh
 
+cli-test-ci:
+	./scripts/test_cli.sh 'js'
+
 cli-test:
-	./scripts/test_cli.sh
+	./scripts/test_cli.sh 'js rb py go java d pl'
 
 http-test:
 	./scripts/http_test.sh
@@ -32,3 +41,27 @@ http-test:
 zip:
 	zip -r images.zip images/
 .PHONY: test build start list clean generate
+
+start_docker_infra:
+	docker build -t fx-docker-infra -f test/Dockerfile ./test
+	docker run --rm --name fx-docker-infra -p 2222:22 -v /var/run/docker.sock:/var/run/docker.sock -d fx-docker-infra
+
+test_docker_infra:
+	CICD=true SSH_PORT=2222 SSH_KEY_FILE=./test/id_rsa ./build/fx infra create --name docker-local -t docker --host root@127.0.0.1
+
+stop_docker_infra:
+	docker stop fx-docker-infra
+
+start_k3s_infra:
+	multipass launch --name k3s-master --cpus 1 --mem 512M --disk 3G  --cloud-init ./test/k3s/ssh-cloud-init.yaml
+	multipass launch --name k3s-worker1 --cpus 1 --mem 512M --disk 3G  --cloud-init ./test/k3s/ssh-cloud-init.yaml
+	multipass launch --name k3s-worker2 --cpus 1 --mem 512M --disk 3G  --cloud-init ./test/k3s/ssh-cloud-init.yaml
+
+test_k3s_infra:
+	./scripts/test_k3s_infra.sh
+
+stop_k3s_infra:
+	multipass delete k3s-master
+	multipass delete k3s-worker1
+	multipass delete k3s-worker2
+	multipass purge

README.md

@@ -1,10 +1,11 @@
 fx
 ------
+
 Poor man's function as a service.
 <br/>
-![ci](https://github.com/metrue/fx/workflows/ci/badge.svg)
-![build](https://circleci.com/gh/metrue/fx.svg?style=svg&circle-token=bd62abac47802f8504faa4cf8db43e4f117e7cd7)
-[![codecov](https://codecov.io/gh/metrue/fx/branch/master/graph/badge.svg)](https://codecov.io/gh/metrue/fx)
+![CI](https://github.com/metrue/fx/workflows/ci/badge.svg)
+![GitHub contributors](https://img.shields.io/github/contributors/metrue/fx)
+[![CodeCov](https://codecov.io/gh/metrue/fx/branch/master/graph/badge.svg)](https://codecov.io/gh/metrue/fx)
 [![Go Report Card](https://goreportcard.com/badge/github.com/metrue/fx?style=flat-square)](https://goreportcard.com/report/github.com/metrue/fx)
 [![Go Doc](https://img.shields.io/badge/godoc-reference-blue.svg?style=flat-square)](http://godoc.org/github.com/metrue/fx)
 ![](https://img.shields.io/github/license/metrue/fx.svg)
@@ -14,12 +15,10 @@ Poor man's function as a service.
 - [Introduction](#introduction)
 - [Installation](#installation)
 - [Usage](#usage)
-- [Contribute](#contribute)
-
 
 ## Introduction
 
-fx is a tool to help you do Function as a Service on your own server. fx can make your stateless function a service in seconds. The most exciting thing is that you can write your functions with most programming languages.
+fx is a tool to help you do Function as a Service on your own server, fx can make your stateless function a service in seconds, both Docker host and Kubernetes cluster supported. The most exciting thing is that you can write your functions with most programming languages.
 
 Feel free hacking fx to support the languages not listed. Welcome to tweet me [@_metrue](https://twitter.com/_metrue) on Twitter, [@metrue](https://www.weibo.com/u/2165714507) on Weibo.
 
@@ -35,10 +34,13 @@ Feel free hacking fx to support the languages not listed. Welcome to tweet me [@
 | PHP           | Supported     | [@chlins](https://github.com/chlins)| [/examples/PHP](https://github.com/metrue/fx/tree/master/examples/functions/PHP) |
 | Julia         | Supported     | [@matbesancon](https://github.com/matbesancon)| [/examples/Julia](https://github.com/metrue/fx/tree/master/examples/functions/Julia) |
 | D             | Supported     | [@andre2007](https://github.com/andre2007)| [/examples/D](https://github.com/metrue/fx/tree/master/examples/functions/D) |
+| Perl          | Supported     | fx            | [/examples/Perl](https://github.com/metrue/fx/tree/master/examples/functions/Perl) |
 | R             | Working on [need your help](https://github.com/metrue/fx/issues/31)   | ||
 
 # Installation
 
+Binaries are available for Windows, MacOS and Linux/Unix on x86. For other architectures and platforms, follow instructions to [build fx from source](#buildtest).
+
 * MacOS
 
 ```
@@ -58,16 +60,14 @@ curl -o- https://raw.githubusercontent.com/metrue/fx/master/scripts/install.sh |
 curl -o- https://raw.githubusercontent.com/metrue/fx/master/scripts/install.sh | sudo bash
 ```
 
-fx will be installed into /usr/local/bin, sometimes you may need `source ~/.zshrc` or `source ~/.bashrc` to make fx available in `$PAHT`.
+fx will be installed into /usr/local/bin, sometimes you may need `source ~/.zshrc` or `source ~/.bashrc` to make fx available in `$PATH`.
 
-* Window
+* Windows
 
 You can go the release page to [download](https://github.com/metrue/fx/releases) fx manually;
 
 ## Usage
 
-Make sure [Docker](https://docs.docker.com/engine/installation/) installed and running on your server first. then type `fx -h` on your terminal to check out basic help.
-
 ```
 NAME:
    fx - makes function as a service
@@ -75,17 +75,11 @@ NAME:
 USAGE:
    fx [global options] command [command options] [arguments...]
 
-VERSION:
-   0.6.0
-
 COMMANDS:
-   infra     manage infrastructure of fx
-   image     manage image of service
-   doctor    health check for fx
-   up        deploy a function or a group of functions
+   up        deploy a function
    down      destroy a service
    list, ls  list deployed services
-   call      run a function instantly
+   image     manage image of service
    help, h   Shows a list of commands or help for one command
 
 GLOBAL OPTIONS:
@@ -93,99 +87,54 @@ GLOBAL OPTIONS:
    --version, -v  print the version
 ```
 
-1. List your current machines and activate you machine
+### Deploy function
+
+#### Local Docker environment
+
+By default, function will be deployed on localhost， make sure [Docker](https://docs.docker.com/engine/installation/) installed and running on your server first. then type `fx -h` on your terminal to check out basic help.
+
+```
+$ fx up --name hello ./examples/functions/JavaScript/func.js
+
++------------------------------------------------------------------+-----------+---------------+
+|                                ID                                |   NAME    |   ENDPOINT    |
++------------------------------------------------------------------+-----------+---------------+
+| 5b24d36608ee392c937a61a530805f74551ddec304aea3aca2ffa0fabcf98cf3 | /hello    | 0.0.0.0:58328 |
++------------------------------------------------------------------+-----------+---------------+
+```
+
+#### Remote host
+
+Use `--host` to specify the target host for your function, or you can just set it to `FX_HOST` environment variable.
 
 ```shell
-$ fx infra ls     # list machines
+$ fx up --host roo@<your host> --name hello ./examples/functions/JavaScript/func.js
 
-{
-	"localhost": {
-		"Host": "localhost",
-		"User": "",
-		"Password": "",
-		"Enabled": true,
-		"Provisioned": false
-	}
-}
-
-$ fx infra activate localhost    # activate 'localhost'
-
-2019/08/10 13:21:20  info Provision:pull python Docker base iamge: ✓
-2019/08/10 13:21:21  info Provision:pull d Docker base image: ✓
-2019/08/10 13:21:23  info Provision:pull java Docker base image: ✓
-2019/08/10 13:21:28  info Provision:pull julia Docker base image: ✓
-2019/08/10 13:21:31  info Provision:pull node Docker base image: ✓
-2019/08/10 13:22:09  info Provision:pull go Docker base image: ✓
-2019/08/10 13:22:09  info provision machine localhost: ✓
-2019/08/10 13:22:09  info enble machine localhost: ✓
-```
-It may take seconds since `fx` needs to download some basic resources
-
-*Note* you can add a remote host as fx machine also,
-```
-$ fx infra add --name my_aws_vm --host 13.121.202.227 --user root --password yourpassword
-
-$ fx infra list
-{
-	"my_aws_vm": {
-		"Host": "13.121.202.227",
-		"User": "root",
-		"Password": "yourpassword",
-		"Enabled": false,
-		"Provisioned": false
-	},
-	"localhost": {
-		"Host": "localhost",
-		"User": "",
-		"Password": "",
-		"Enabled": true,
-		"Provisioned": true
-	}
-}
-
-$ fx infra activate my_aws_vm
-
-```
-then your function will be deployed onto remote host also.
-
-2. Write a function
-
-You can check out [examples](https://github.com/metrue/fx/tree/master/examples/functions) for reference. Let's write a function as an example,  it calculates the sum of two numbers then returns:
-
-```js
-module.exports = (ctx) => {
-    ctx.body = 'hello world'
-}
-```
-Then save it to a file `func.js`.
-
-3. Deploy your function as a service
-
-Give your service a port with `--port`, and name with `--name`, heath checking with `--healthcheck` if you want.
-
-```shell
-$ fx up -name fx_service_name -p 10001 --healthcheck func.js
-
-2019/08/10 13:26:37  info Pack Service: ✓
-2019/08/10 13:26:39  info Build Service: ✓
-2019/08/10 13:26:39  info Run Service: ✓
-2019/08/10 13:26:39  info Service (fx_service_name) is running on: 0.0.0.0:10001
-2019/08/10 13:26:39  info up function fx_service_name(func.js) to machine localhost: ✓
++------------------------------------------------------------------+-----------+---------------+
+|                                ID                                |   NAME    |   ENDPOINT    |
++------------------------------------------------------------------+-----------+---------------+
+| 5b24d36608ee392c937a61a530805f74551ddec304aea3aca2ffa0fabcf98cf3 | /hello    | 0.0.0.0:58345 |
++------------------------------------------------------------------+-----------+---------------+
 ```
 
-if you want see what the source code of your service looks like, you can export it into a dirctory,
+#### Kubernetes
 
-```shell
-$ fx image export -o <path of dir> func.js
-2019/09/25 19:31:19  info exported to <path of dir>: ✓
+```
+$ FX_KUBECONF=~/.kube/config fx up examples/functions/JavaScript/func.js --name hello
+
++-------------------------------+------+----------------+
+| ID                     | NAME        |    ENDPOINT    |
++----+--------------------------+-----------------------+
+|  5b24d36608ee392c937a  | hello-fx    | 10.0.242.75:80 |
++------------------------+-------------+----------------+
 ```
 
-4. Test your service
+### Test service
 
 then you can test your service:
 
 ```shell
-$ curl -v 0.0.0.0:10001
+$ curl -v 0.0.0.0:58328
 
 
 GET / HTTP/1.1
@@ -207,34 +156,7 @@ hello world
 
 ```
 
-## Docker
-
-  TODO
-
-## Kubernetes
-
-**fx** supports deploy function to be a service onto Kubernetes cluster infrasture, and we encourage you to do that other than on bare Docker environment, there are lots of advantage to run your function on Kubernetes like self-healing, load balancing, easy horizontal scaling, etc. It's pretty simple to deploy your function onto Kubernetes with **fx**, you just set KUBECONFIG in your enviroment.
-
-```shell
-KUBECONFIG=<Your KUBECONFIG> fx deploy -n fx-service-abc_js -p 12349 examples/functions/JavaScript/func.js   # function will be deploy to your Kubernetes cluster and expose a IP address of your loadbalencer
-```
-
-or
-
-```shell
-$ export KUBECONFIG=<Your KUBECONFIG>
-$ fx deploy -n fx-service-abc_js -p 12349 examples/functions/JavaScript/func.js   # function will be deploy to your Kubernetes cluster and expose a IP address of your loadbalencer
-```
-
-* Local Kubernetes Cluster
-
-Docker for Mac and Docker for Windows already support Kubernetes with single node cluster, we can use it directly, and the default `KUBECONFIG` is `~/.kube/config`.
-
-```shell
-$ export KUBECONFIG=~/.kube/config  # then fx will take the config to deloy function
-```
-
-if you have multiple Kubernetes clusters configured, you have to set context correctly. FYI [configure-access-multiple-clusters](https://kubernetes.io/docs/tasks/access-application-cluster/configure-access-multiple-clusters/)
+## Use Public Cloud Kubernetes Service as infrastructure to run your functions
 
 * Azure Kubernetes Service (AKS)
 
@@ -258,7 +180,7 @@ aks-nodepool1-31718369-0   Ready    agent   6m44s   v1.12.8
 Since AKS's config will be merged into `~/.kube/config` and set to be current context after you run `az aks get-credentials` command, so you can just set KUBECONFIG to default config also,
 
 ```shell
-$ export KUBECONFIG=~/.kube/config  # then fx will take the config to deloy function
+$ export FX_KUBECONF=~/.kube/config  # then fx will take the config to deloy function
 ```
 
 But we would suggest you run `kubectl config current-context` to check if the current context is what you want.
@@ -266,31 +188,31 @@ But we would suggest you run `kubectl config current-context` to check if the cu
 * Amazon Elastic Kubernetes Service (EKS)
   TODO
 
-* Google Kubernetes Engine (GKET)
-  TODO
+* Google Kubernetes Engine (GKE)
 
-## Contribute
+First you should create a Kubernetes cluster in your GKE, then make sure your KUBECONFIG is ready in `~/.kube/config`, if not, you can run following commands,
 
-fx uses [Project](https://github.com/metrue/fx/projects/4) to manage the development.
-
-#### Prerequisites
-
-Docker: make sure [Docker](https://docs.docker.com/engine/installation/) installed and running on your server.
-
-
-#### Build & Test
-
-```
-$ git clone https://github.com/metrue/fx
-$ cd fx
-$ make build
+``` shell
+$ gcloud auth login
+$ gcloud container clusters get-credentials <your cluster> --zone <zone> --project <project>
 ```
 
-Then you can build and test:
+Then make sure you current context is GKE cluster, you can check it with command,
 
+``` shell
+$ kubectl config current-context
 ```
-$ make build
-$ ./build/fx -h
+
+Then you can deploy your function onto GKE cluster with,
+
+```shell
+$ FX_KUBECONF=~/.kube/config fx up examples/functions/JavaScript/func.js --name hellojs
+```
+
+* Setup your own Kubernetes cluster
+
+```shell
+fx infra create --type k3s --name fx-cluster-1 --master root@123.11.2.3 --agents 'root@1.1.1.1,root@2.2.2.2'
 ```
 
 

assets/dockerfiles/base/go/Dockerfile

@@ -0,0 +1,4 @@
+FROM golang:latest
+
+# dependency management
+RUN go get github.com/gin-gonic/gin

assets/dockerfiles/base/node/package-lock.json

@@ -0,0 +1,26 @@
+{
+  "name": "fx-node-base",
+  "version": "1.0.0",
+  "lockfileVersion": 1,
+  "requires": true,
+  "dependencies": {
+    "@koa/cors": {
+      "version": "2.2.3",
+      "resolved": "https://registry.npmjs.org/@koa/cors/-/cors-2.2.3.tgz",
+      "integrity": "sha512-tCVVXa39ETsit5kGBtEWWimjLn1sDaeu8+0phgb8kT3GmBDZOykkI3ZO8nMjV2p3MGkJI4K5P+bxR8Ztq0bwsA==",
+      "requires": {
+        "vary": "^1.1.2"
+      }
+    },
+    "node-fetch": {
+      "version": "2.6.0",
+      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.0.tgz",
+      "integrity": "sha512-8dG4H5ujfvFiqDmVu9fQ5bOHUC15JMjMY/Zumv26oOvvVJjM67KF8koCWIabKQ1GJIa9r2mMZscBq/TbdOcmNA=="
+    },
+    "vary": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
+      "integrity": "sha1-IpnwLG3tMNSllhsLn3RSShj2NPw="
+    }
+  }
+}

assets/dockerfiles/base/node/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "aok",
+  "name": "fx-node-base",
   "version": "1.0.0",
   "description": "",
   "main": "index.js",
@@ -10,12 +10,11 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
+    "@koa/cors": "^2.2.3",
     "get-port": "^3.2.0",
     "is-generator-function": "^1.0.6",
     "koa": "^2.3.0",
-    "koa-bodyparser": "^4.2.0"
-  },
-  "devDependencies": {
-    "get-port-cli": "^1.1.0"
+    "koa-bodyparser": "^4.2.0",
+    "node-fetch": "^2.6.0"
   }
 }

assets/dockerfiles/base/perl/Dockerfile

@@ -0,0 +1,10 @@
+FROM alpine:3.4
+MAINTAINER Mojolicious
+
+ADD . .
+COPY cpanfile /
+ENV EV_EXTRA_DEFS -DEV_NO_ATFORK
+
+RUN apk update && \
+  apk add perl perl-io-socket-ssl perl-dbd-pg perl-dev g++ make wget curl && \
+  curl -L https://cpanmin.us | perl - App::cpanminus && cpanm --installdeps . -M https://cpan.metacpan.org

assets/dockerfiles/base/perl/cpanfile

@@ -0,0 +1,3 @@
+requires "EV";
+requires "JSON";
+requires "Mojolicious::Lite";

assets/dockerfiles/base/ruby/Dockerfile

@@ -0,0 +1,3 @@
+FROM ruby:latest
+
+RUN gem install sinatra

bundle/bundle.go

@@ -0,0 +1,44 @@
+package bundle
+
+import (
+	"fmt"
+
+	"github.com/metrue/fx/bundler"
+	"github.com/metrue/fx/bundler/d"
+	golang "github.com/metrue/fx/bundler/go"
+	"github.com/metrue/fx/bundler/java"
+	"github.com/metrue/fx/bundler/julia"
+	"github.com/metrue/fx/bundler/node"
+	"github.com/metrue/fx/bundler/perl"
+	"github.com/metrue/fx/bundler/python"
+	"github.com/metrue/fx/bundler/ruby"
+	"github.com/metrue/fx/bundler/rust"
+)
+
+// Bundle function to project
+func Bundle(workdir string, language string, fn string, deps ...string) error {
+	var bundler bundler.Bundler
+	switch language {
+	case "d":
+		bundler = d.New()
+	case "node":
+		bundler = node.New()
+	case "go":
+		bundler = golang.New()
+	case "java":
+		bundler = java.New()
+	case "julia":
+		bundler = julia.New()
+	case "perl":
+		bundler = perl.New()
+	case "python":
+		bundler = python.New()
+	case "ruby":
+		bundler = ruby.New()
+	case "rust":
+		bundler = rust.New()
+	default:
+		return fmt.Errorf("%s not suppported yet", language)
+	}
+	return bundler.Bundle(workdir, fn, deps...)
+}

bundle/bundler_test.go

@@ -0,0 +1,117 @@
+package bundle
+
+import (
+	"io/ioutil"
+	"os"
+	"testing"
+)
+
+func createFn(content string, t *testing.T) string {
+	fd, err := ioutil.TempFile("", "fx_func_*.js")
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = ioutil.WriteFile(fd.Name(), []byte(content), 0666)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	return fd.Name()
+}
+
+func TestBundle(t *testing.T) {
+	workdir, err := ioutil.TempDir("", "fx-test")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(workdir)
+
+	cases := []struct {
+		workdir  string
+		language string
+		fn       string
+		deps     []string
+	}{
+		{
+			workdir:  workdir,
+			language: "d",
+			fn: `
+module.exports = (ctx) => {
+  ctx.body = 'hello fx'
+}
+			`,
+		},
+		{
+			workdir:  workdir,
+			language: "go",
+			fn: `
+module.exports = (ctx) => {
+  ctx.body = 'hello fx'
+}
+			`,
+		},
+		{
+			workdir:  workdir,
+			language: "java",
+			fn: `
+module.exports = (ctx) => {
+  ctx.body = 'hello fx'
+}
+			`,
+		},
+		{
+			workdir:  workdir,
+			language: "julia",
+			fn: `
+module.exports = (ctx) => {
+  ctx.body = 'hello fx'
+}
+			`,
+		},
+		{
+			workdir:  workdir,
+			language: "perl",
+			fn: `
+module.exports = (ctx) => {
+  ctx.body = 'hello fx'
+}
+			`,
+		},
+		{
+			workdir:  workdir,
+			language: "python",
+			fn: `
+module.exports = (ctx) => {
+  ctx.body = 'hello fx'
+}
+			`,
+		},
+		{
+			workdir:  workdir,
+			language: "ruby",
+			fn: `
+module.exports = (ctx) => {
+  ctx.body = 'hello fx'
+}
+			`,
+		},
+		{
+			workdir:  workdir,
+			language: "rust",
+			fn: `
+module.exports = (ctx) => {
+  ctx.body = 'hello fx'
+}
+			`,
+		},
+	}
+
+	for _, c := range cases {
+		fn := createFn(c.fn, t)
+		defer os.Remove(fn)
+
+		if err := Bundle(c.workdir, c.language, fn, c.deps...); err != nil {
+			t.Fatal(err)
+		}
+	}
+}

bundler/README.md

@@ -0,0 +1,63 @@
+The only thing `fx` does is to make a single function to be an HTTP service, `fx` takes two steps to finish the process,
+* Wraps the function into a web server project and make it be the handler function of the HTTP request.
+* Builds the bundled web server to be Docker image, then run it as a Docker container and expose the service port.
+
+`bundler` is the component responsible for step 1: wrap a single function (and its dependencies) into a web server.  Take a Node web service as an example, the project looks like this,
+```
+helloworld
+├── Dockerfile
+├── app.js
+└── fx.js
+```
+
+And the codes is pretty simple,
+
+**app.js**
+```javascript
+const Koa = require('koa');
+const bodyParser = require('koa-bodyparser');
+const cors = require('@koa/cors');
+const fx = require('./fx');
+
+const app = new Koa();
+app.use(cors({
+  origin: '*',
+}));
+app.use(bodyParser());
+app.use(fx);
+
+app.listen(3000);
+```
+
+**fx.js**
+```javascript
+module.exports = (ctx) => {
+  ctx.body = 'hello world'
+}
+```
+
+**Dockerfile**
+```dockerfile
+FROM metrue/fx-node-base
+
+COPY . .
+EXPOSE 3000
+CMD ["node", "app.js"]
+```
+
+You can see that it's a web service built with `Koa`,  the request handler function defined in `fx.js` to response plain text `hello world`,  so to make a general JavaScript/Node function to be a web service, we only have to put it into `fx.js` above, then build and run it with Docker and that's it.
+
+To support different programming languages, `fx` needs to implement different `bundlers`, the reasons are,
+* The way to set up a web service is different in different languages
+* The way to manage dependency is different in different languages.
+
+So there will be (are) different `bundlers` in `fx`.
+```
+go-bundler: based on Gin
+ruby-bundler: based on Sinatra
+node-bundler: based on Koa
+python-bundler: based on flask
+...
+```
+
+

bundler/bundler.go

@@ -0,0 +1,88 @@
+package bundler
+
+import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/gobuffalo/packd"
+	"github.com/gobuffalo/packr/v2"
+	"github.com/metrue/fx/constants"
+	"github.com/metrue/fx/utils"
+)
+
+// Bundler defines interface
+type Bundler interface {
+	Scaffold(output string) error
+	Bundle(output string, fn string, deps ...string) error
+}
+
+// IsHandler check if it's handle file
+func IsHandler(name string, lang string) bool {
+	basename := filepath.Base(name)
+	nameWithoutExt := strings.TrimSuffix(basename, filepath.Ext(basename))
+	if constants.ExtLangMapping[filepath.Ext(basename)] != lang {
+		return false
+	}
+
+	return (nameWithoutExt == "fx" ||
+		// Fx is for Java
+		nameWithoutExt == "Fx" ||
+		// mod.rs is for Rust)
+		nameWithoutExt == "mod")
+}
+
+// Restore directory from packr box
+func Restore(box *packr.Box, output string) error {
+	if err := box.Walk(func(name string, fd packd.File) error {
+		content, err := box.Find(name)
+		if err != nil {
+			return err
+		}
+
+		dest := filepath.Join(output, name)
+		if err := utils.EnsureFile(dest); err != nil {
+			return err
+		}
+
+		if err := ioutil.WriteFile(dest, content, 0644); err != nil {
+			return err
+		}
+
+		return nil
+	}); err != nil {
+		return err
+	}
+	return nil
+}
+
+// Bundle bundle a function
+func Bundle(box *packr.Box, output string, language string, fn string, deps ...string) error {
+	if err := Restore(box, output); err != nil {
+		return err
+	}
+
+	if err := utils.Merge(output, deps...); err != nil {
+		return err
+	}
+
+	// Replace the default handler source file with given function source file
+	if err := filepath.Walk(output, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		if IsHandler(path, language) {
+			if err := utils.CopyFile(fn, path); err != nil {
+				return err
+			}
+		}
+
+		return nil
+	}); err != nil {
+		return err
+	}
+
+	return nil
+}

bundler/bundler_test.go

@@ -0,0 +1,51 @@
+package bundler
+
+import (
+	"io/ioutil"
+	"log"
+	"os"
+	"testing"
+
+	"github.com/gobuffalo/packr/v2"
+)
+
+func TestBundler(t *testing.T) {
+	t.Run("Restore", func(t *testing.T) {
+		box := packr.New("", "./node/assets")
+		outputDir, err := ioutil.TempDir("", "fx_koa")
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer os.RemoveAll(outputDir)
+		if err := Restore(box, outputDir); err != nil {
+			t.Fatal(err)
+		}
+	})
+
+	t.Run("Bundle", func(t *testing.T) {
+		fd, err := ioutil.TempFile("", "fx_func_*.js")
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer os.Remove(fd.Name())
+
+		content := `
+module.exports = (ctx) => {
+  ctx.body = 'hello fx'
+}`
+		if err = ioutil.WriteFile(fd.Name(), []byte(content), 0666); err != nil {
+			t.Fatal(err)
+		}
+
+		outputDir, err := ioutil.TempDir("", "fx_koa")
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer os.RemoveAll(outputDir)
+
+		box := packr.New("", "./node/assets")
+		if err := Bundle(box, outputDir, "node", fd.Name()); err != nil {
+			t.Fatal(err)
+		}
+	})
+}

bundler/d/d-packr.go

@@ -0,0 +1,8 @@
+// +build !skippackr
+// Code generated by github.com/gobuffalo/packr/v2. DO NOT EDIT.
+
+// You can use the "packr clean" command to clean up this,
+// and any other packr generated files.
+package d
+
+import _ "github.com/metrue/fx/packrd"

bundler/d/d.go

@@ -0,0 +1,32 @@
+package d
+
+import (
+	"github.com/gobuffalo/packr/v2"
+	"github.com/metrue/fx/bundler"
+)
+
+// D defines d bundler
+type D struct {
+	assets *packr.Box
+}
+
+// New a koa bundler
+func New() *D {
+	return &D{
+		assets: packr.New("d", "./assets"),
+	}
+}
+
+// Scaffold a koa app
+func (d *D) Scaffold(output string) error {
+	return bundler.Restore(d.assets, output)
+}
+
+// Bundle a function into a koa project
+func (d *D) Bundle(output string, fn string, deps ...string) error {
+	return bundler.Bundle(d.assets, output, "d", fn, deps...)
+}
+
+var (
+	_ bundler.Bundler = &D{}
+)

bundler/go/assets/Dockerfile

@@ -1,4 +1,4 @@
-FROM metrue/fx-go-base:latest
+FROM metrue/fx-go-base
 
 COPY . /go/src/github.com/metrue/fx
 WORKDIR /go/src/github.com/metrue/fx

bundler/go/go.go

@@ -0,0 +1,32 @@
+package golang
+
+import (
+	"github.com/gobuffalo/packr/v2"
+	"github.com/metrue/fx/bundler"
+)
+
+// Gin defines javascript bundler
+type Gin struct {
+	assets *packr.Box
+}
+
+// New a koa bundler
+func New() *Gin {
+	return &Gin{
+		assets: packr.New("go", "./assets"),
+	}
+}
+
+// Scaffold a koa app
+func (g *Gin) Scaffold(output string) error {
+	return bundler.Restore(g.assets, output)
+}
+
+// Bundle a function into a koa project
+func (g *Gin) Bundle(output string, fn string, deps ...string) error {
+	return bundler.Bundle(g.assets, output, "go", fn, deps...)
+}
+
+var (
+	_ bundler.Bundler = &Gin{}
+)

bundler/go/go_test.go

@@ -0,0 +1,143 @@
+package golang
+
+import (
+	"io/ioutil"
+	"log"
+	"os"
+	"reflect"
+	"testing"
+
+	"github.com/metrue/fx/utils"
+)
+
+func TestKoaBundler(t *testing.T) {
+	t.Run("Scaffold", func(t *testing.T) {
+		outputDir, err := ioutil.TempDir("", "fx_koa")
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer os.RemoveAll(outputDir)
+
+		koa := New()
+		if err := koa.Scaffold(outputDir); err != nil {
+			t.Fatal(err)
+		}
+
+		diff, _, _, err := utils.Diff(outputDir, "./assets")
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if diff {
+			t.Fatalf("%s is not equal with %s", outputDir, "./assets")
+		}
+	})
+
+	t.Run("BundleSingleFunc", func(t *testing.T) {
+		fd, err := ioutil.TempFile("", "fx_func_*.js")
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer os.Remove(fd.Name())
+
+		content := `
+module.exports = (ctx) => {
+  ctx.body = 'hello fx'
+}`
+		err = ioutil.WriteFile(fd.Name(), []byte(content), 0666)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		outputDir, err := ioutil.TempDir("", "fx_koa")
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer os.RemoveAll(outputDir)
+
+		koa := New()
+		if err := koa.Bundle(outputDir, fd.Name()); err != nil {
+			t.Fatal(err)
+		}
+
+		diff, pre, cur, err := utils.Diff("./assets", outputDir)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if !diff {
+			t.Fatalf("handle functino should be changed")
+		}
+
+		if !reflect.DeepEqual(cur, []byte(content)) {
+			t.Fatalf("it should be %s but got %s", content, cur)
+		}
+
+		preHandleFunc, err := ioutil.ReadFile("./assets/fx.go")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !reflect.DeepEqual(pre, preHandleFunc) {
+			{
+			}
+			t.Fatalf("it should get %s but got %s", preHandleFunc, pre)
+		}
+	})
+
+	t.Run("BundleFuncAndDeps", func(t *testing.T) {
+		fd, err := ioutil.TempFile("", "fx_func_*.js")
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer os.Remove(fd.Name())
+
+		content, err := ioutil.ReadFile("./assets/fx.go")
+		if err != nil {
+			t.Fatal(err)
+		}
+		err = ioutil.WriteFile(fd.Name(), content, 0666)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addFunc := `
+module.exports = (a, b) => a+b
+  `
+		addFd, err := ioutil.TempFile("", "fx_add_func_*.js")
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		err = ioutil.WriteFile(addFd.Name(), []byte(addFunc), 0644)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		outputDir, err := ioutil.TempDir("", "fx_koa")
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer os.RemoveAll(outputDir)
+
+		koa := New()
+		if err := koa.Bundle(outputDir, fd.Name(), addFd.Name()); err != nil {
+			t.Fatal(err)
+		}
+
+		diff, pre, cur, err := utils.Diff("./assets", outputDir)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if !diff {
+			t.Fatalf("handle functino should be changed")
+		}
+
+		if !reflect.DeepEqual(cur, []byte(addFunc)) {
+			t.Fatalf("it should be %s but got %s", content, cur)
+		}
+		if pre != nil {
+			t.Fatal(pre)
+		}
+	})
+}

bundler/go/golang-packr.go

@@ -0,0 +1,8 @@
+// +build !skippackr
+// Code generated by github.com/gobuffalo/packr/v2. DO NOT EDIT.
+
+// You can use the "packr clean" command to clean up this,
+// and any other packr generated files.
+package golang
+
+import _ "github.com/metrue/fx/packrd"

bundler/java/java-packr.go

@@ -0,0 +1,8 @@
+// +build !skippackr
+// Code generated by github.com/gobuffalo/packr/v2. DO NOT EDIT.
+
+// You can use the "packr clean" command to clean up this,
+// and any other packr generated files.
+package java
+
+import _ "github.com/metrue/fx/packrd"

bundler/java/java.go

@@ -0,0 +1,32 @@
+package java
+
+import (
+	"github.com/gobuffalo/packr/v2"
+	"github.com/metrue/fx/bundler"
+)
+
+// Java defines javascript bundler
+type Java struct {
+	assets *packr.Box
+}
+
+// New a koa bundler
+func New() *Java {
+	return &Java{
+		assets: packr.New("java", "./assets"),
+	}
+}
+
+// Scaffold a koa app
+func (k *Java) Scaffold(output string) error {
+	return bundler.Restore(k.assets, output)
+}
+
+// Bundle a function into a koa project
+func (k *Java) Bundle(output string, fn string, deps ...string) error {
+	return bundler.Bundle(k.assets, output, "java", fn, deps...)
+}
+
+var (
+	_ bundler.Bundler = &Java{}
+)

bundler/java/java_test.go

@@ -0,0 +1,155 @@
+package java
+
+import (
+	"io/ioutil"
+	"log"
+	"os"
+	"reflect"
+	"testing"
+
+	"github.com/metrue/fx/utils"
+)
+
+func TestJavaBundler(t *testing.T) {
+	t.Run("Scaffold", func(t *testing.T) {
+		outputDir, err := ioutil.TempDir("", "fx_java")
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer os.RemoveAll(outputDir)
+
+		java := New()
+		if err := java.Scaffold(outputDir); err != nil {
+			t.Fatal(err)
+		}
+
+		diff, _, _, err := utils.Diff(outputDir, "./assets")
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if diff {
+			t.Fatalf("%s is not equal with %s", outputDir, "./assets")
+		}
+	})
+
+	t.Run("BundleSingleFunc", func(t *testing.T) {
+		fd, err := ioutil.TempFile("", "fx_func_*.java")
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer os.Remove(fd.Name())
+
+		content := `package fx;
+
+import io.javalin.Javalin;
+import org.json.JSONObject;
+
+public class app {
+    public static void main(String[] args) {
+        Javalin app = Javalin.start(3000);
+        Fx handler = new Fx();
+        app.post("/", ctx -> {
+            JSONObject obj = new JSONObject(ctx.body());
+            ctx.result(""+handler.handle(obj));
+        });
+    }
+}
+		`
+		err = ioutil.WriteFile(fd.Name(), []byte(content), 0666)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		outputDir, err := ioutil.TempDir("", "fx_java")
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer os.RemoveAll(outputDir)
+
+		java := New()
+		if err := java.Bundle(outputDir, fd.Name()); err != nil {
+			t.Fatal(err)
+		}
+
+		diff, pre, cur, err := utils.Diff("./assets", outputDir)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if !diff {
+			t.Fatalf("handle functino should be changed")
+		}
+
+		if !reflect.DeepEqual(cur, []byte(content)) {
+			t.Fatalf("it should be %s but got %s", content, cur)
+		}
+
+		preHandleFunc, err := ioutil.ReadFile("./assets/src/main/java/fx/Fx.java")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !reflect.DeepEqual(pre, preHandleFunc) {
+			{
+			}
+			t.Fatalf("it should get %s but got %s", preHandleFunc, pre)
+		}
+	})
+
+	t.Run("BundleFuncAndDeps", func(t *testing.T) {
+		fd, err := ioutil.TempFile("", "fx_func_*.js")
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer os.Remove(fd.Name())
+
+		content, err := ioutil.ReadFile("./assets/src/main/java/fx/Fx.java")
+		if err != nil {
+			t.Fatal(err)
+		}
+		err = ioutil.WriteFile(fd.Name(), content, 0666)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addFunc := `
+module.exports = (a, b) => a+b
+  `
+		addFd, err := ioutil.TempFile("", "fx_add_func_*.js")
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		err = ioutil.WriteFile(addFd.Name(), []byte(addFunc), 0644)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		outputDir, err := ioutil.TempDir("", "fx_java")
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer os.RemoveAll(outputDir)
+
+		java := New()
+		if err := java.Bundle(outputDir, fd.Name(), addFd.Name()); err != nil {
+			t.Fatal(err)
+		}
+
+		diff, pre, cur, err := utils.Diff("./assets", outputDir)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if !diff {
+			t.Fatalf("handle functino should be changed")
+		}
+
+		if !reflect.DeepEqual(cur, []byte(addFunc)) {
+			t.Fatalf("it should be %s but got %s", content, cur)
+		}
+		if pre != nil {
+			t.Fatal(pre)
+		}
+	})
+}

bundler/julia/assets/fx.jl

@@ -1,4 +1,3 @@
-
 struct Input
     a::Number
     b::Number

bundler/julia/julia-packr.go

@@ -0,0 +1,8 @@
+// +build !skippackr
+// Code generated by github.com/gobuffalo/packr/v2. DO NOT EDIT.
+
+// You can use the "packr clean" command to clean up this,
+// and any other packr generated files.
+package julia
+
+import _ "github.com/metrue/fx/packrd"

bundler/julia/julia.go

@@ -0,0 +1,32 @@
+package julia
+
+import (
+	"github.com/gobuffalo/packr/v2"
+	"github.com/metrue/fx/bundler"
+)
+
+// Julia defines javascript bundler
+type Julia struct {
+	assets *packr.Box
+}
+
+// New a koa bundler
+func New() *Julia {
+	return &Julia{
+		assets: packr.New("julia", "./assets"),
+	}
+}
+
+// Scaffold a koa app
+func (k *Julia) Scaffold(output string) error {
+	return bundler.Restore(k.assets, output)
+}
+
+// Bundle a function into a koa project
+func (k *Julia) Bundle(output string, fn string, deps ...string) error {
+	return bundler.Bundle(k.assets, output, "julia", fn, deps...)
+}
+
+var (
+	_ bundler.Bundler = &Julia{}
+)

bundler/julia/julia_test.go

@@ -0,0 +1,148 @@
+package julia
+
+import (
+	"io/ioutil"
+	"log"
+	"os"
+	"reflect"
+	"testing"
+
+	"github.com/metrue/fx/utils"
+)
+
+func TestJuliaBundler(t *testing.T) {
+	t.Run("Scaffold", func(t *testing.T) {
+		outputDir, err := ioutil.TempDir("", "fx_julia")
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer os.RemoveAll(outputDir)
+
+		julia := New()
+		if err := julia.Scaffold(outputDir); err != nil {
+			t.Fatal(err)
+		}
+
+		diff, _, _, err := utils.Diff(outputDir, "./assets")
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if diff {
+			t.Fatalf("%s is not equal with %s", outputDir, "./assets")
+		}
+	})
+
+	t.Run("BundleSingleFunc", func(t *testing.T) {
+		fd, err := ioutil.TempFile("", "fx_func_*.julia")
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer os.Remove(fd.Name())
+
+		content := `struct Input
+    a::Number
+    b::Number
+end
+
+fx = function(input::Input)
+    return input.a + input.b
+end
+		`
+		err = ioutil.WriteFile(fd.Name(), []byte(content), 0666)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		outputDir, err := ioutil.TempDir("", "fx_julia")
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer os.RemoveAll(outputDir)
+
+		julia := New()
+		if err := julia.Bundle(outputDir, fd.Name()); err != nil {
+			t.Fatal(err)
+		}
+
+		diff, pre, cur, err := utils.Diff("./assets", outputDir)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if !diff {
+			t.Fatalf("handle function should be changed")
+		}
+
+		if !reflect.DeepEqual(cur, []byte(content)) {
+			t.Fatalf("it should be %s but got %s", content, cur)
+		}
+
+		preHandleFunc, err := ioutil.ReadFile("./assets/fx.jl")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !reflect.DeepEqual(pre, preHandleFunc) {
+			{
+			}
+			t.Fatalf("it should get %s but got %s", preHandleFunc, pre)
+		}
+	})
+
+	t.Run("BundleFuncAndDeps", func(t *testing.T) {
+		fd, err := ioutil.TempFile("", "fx_func_*.js")
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer os.Remove(fd.Name())
+
+		content, err := ioutil.ReadFile("./assets/fx.jl")
+		if err != nil {
+			t.Fatal(err)
+		}
+		err = ioutil.WriteFile(fd.Name(), content, 0666)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addFunc := `
+module.exports = (a, b) => a+b
+  `
+		addFd, err := ioutil.TempFile("", "fx_add_func_*.js")
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		err = ioutil.WriteFile(addFd.Name(), []byte(addFunc), 0644)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		outputDir, err := ioutil.TempDir("", "fx_julia")
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer os.RemoveAll(outputDir)
+
+		julia := New()
+		if err := julia.Bundle(outputDir, fd.Name(), addFd.Name()); err != nil {
+			t.Fatal(err)
+		}
+
+		diff, pre, cur, err := utils.Diff("./assets", outputDir)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if !diff {
+			t.Fatalf("handle functino should be changed")
+		}
+
+		if !reflect.DeepEqual(cur, []byte(addFunc)) {
+			t.Fatalf("it should be %s but got %s", content, cur)
+		}
+		if pre != nil {
+			t.Fatal(pre)
+		}
+	})
+}

bundler/node/assets/app.js

@@ -0,0 +1,13 @@
+const Koa = require('koa');
+const bodyParser = require('koa-bodyparser');
+const cors = require('@koa/cors');
+const fx = require('./fx');
+
+const app = new Koa();
+app.use(cors({
+  origin: '*',
+}));
+app.use(bodyParser());
+app.use(fx);
+
+app.listen(3000);

bundler/node/node-packr.go

@@ -0,0 +1,8 @@
+// +build !skippackr
+// Code generated by github.com/gobuffalo/packr/v2. DO NOT EDIT.
+
+// You can use the "packr clean" command to clean up this,
+// and any other packr generated files.
+package node
+
+import _ "github.com/metrue/fx/packrd"

bundler/node/node.go

@@ -0,0 +1,34 @@
+package node
+
+import (
+	"github.com/gobuffalo/packr/v2"
+	"github.com/metrue/fx/bundler"
+)
+
+const language = "node"
+
+// Node defines node bundler
+type Node struct {
+	assets *packr.Box
+}
+
+// New a koa bundler
+func New() *Node {
+	return &Node{
+		assets: packr.New("node", "./assets"),
+	}
+}
+
+// Scaffold a koa app
+func (k *Node) Scaffold(output string) error {
+	return bundler.Restore(k.assets, output)
+}
+
+// Bundle a function into a koa project
+func (k *Node) Bundle(output string, fn string, deps ...string) error {
+	return bundler.Bundle(k.assets, output, language, fn, deps...)
+}
+
+var (
+	_ bundler.Bundler = &Node{}
+)

bundler/node/node_test.go

@@ -0,0 +1,143 @@
+package node
+
+import (
+	"io/ioutil"
+	"log"
+	"os"
+	"reflect"
+	"testing"
+
+	"github.com/metrue/fx/utils"
+)
+
+func TestNodeBundler(t *testing.T) {
+	t.Run("Scaffold", func(t *testing.T) {
+		outputDir, err := ioutil.TempDir("", "fx_koa")
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer os.RemoveAll(outputDir)
+
+		koa := New()
+		if err := koa.Scaffold(outputDir); err != nil {
+			t.Fatal(err)
+		}
+
+		diff, _, _, err := utils.Diff(outputDir, "./assets")
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if diff {
+			t.Fatalf("%s is not equal with %s", outputDir, "./assets")
+		}
+	})
+
+	t.Run("BundleSingleFunc", func(t *testing.T) {
+		fd, err := ioutil.TempFile("", "fx_func_*.js")
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer os.Remove(fd.Name())
+
+		content := `
+module.exports = (ctx) => {
+  ctx.body = 'hello fx'
+}`
+		err = ioutil.WriteFile(fd.Name(), []byte(content), 0666)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		outputDir, err := ioutil.TempDir("", "fx_koa")
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer os.RemoveAll(outputDir)
+
+		koa := New()
+		if err := koa.Bundle(outputDir, fd.Name()); err != nil {
+			t.Fatal(err)
+		}
+
+		diff, pre, cur, err := utils.Diff("./assets", outputDir)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if !diff {
+			t.Fatalf("handle functino should be changed")
+		}
+
+		if !reflect.DeepEqual(cur, []byte(content)) {
+			t.Fatalf("it should be %s but got %s", content, cur)
+		}
+
+		preHandleFunc, err := ioutil.ReadFile("./assets/fx.js")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !reflect.DeepEqual(pre, preHandleFunc) {
+			{
+			}
+			t.Fatalf("it should get %s but got %s", preHandleFunc, pre)
+		}
+	})
+
+	t.Run("BundleFuncAndDeps", func(t *testing.T) {
+		fd, err := ioutil.TempFile("", "fx_func_*.js")
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer os.Remove(fd.Name())
+
+		content, err := ioutil.ReadFile("./assets/fx.js")
+		if err != nil {
+			t.Fatal(err)
+		}
+		err = ioutil.WriteFile(fd.Name(), content, 0666)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addFunc := `
+module.exports = (a, b) => a+b
+  `
+		addFd, err := ioutil.TempFile("", "fx_add_func_*.js")
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		err = ioutil.WriteFile(addFd.Name(), []byte(addFunc), 0644)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		outputDir, err := ioutil.TempDir("", "fx_koa")
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer os.RemoveAll(outputDir)
+
+		koa := New()
+		if err := koa.Bundle(outputDir, fd.Name(), addFd.Name()); err != nil {
+			t.Fatal(err)
+		}
+
+		diff, pre, cur, err := utils.Diff("./assets", outputDir)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if !diff {
+			t.Fatalf("handle functino should be changed")
+		}
+
+		if !reflect.DeepEqual(cur, []byte(addFunc)) {
+			t.Fatalf("it should be %s but got %s", content, cur)
+		}
+		if pre != nil {
+			t.Fatal(pre)
+		}
+	})
+}

bundler/perl/assets/Dockerfile

@@ -0,0 +1,6 @@
+FROM metrue/fx-perl-base
+
+ADD . .
+
+EXPOSE 3000
+CMD ["perl", "app.pl", "daemon"]

bundler/perl/assets/app.pl

@@ -0,0 +1,17 @@
+use Mojolicious::Lite;
+
+require "./fx.pl";
+
+get '/' => sub {
+  my $ctx = shift;
+  my $res = fx($ctx);
+  $ctx->render(json => $res);
+};
+
+post '/' => sub {
+  my $ctx = shift;
+  my $res = fx($ctx);
+  $ctx->render(json => $res);
+};
+
+app->start;

bundler/perl/assets/fx.pl

@@ -0,0 +1,6 @@
+sub fx {
+  my $ctx = shift;
+  return 'hello fx'
+}
+
+1;

bundler/perl/perl-packr.go

@@ -0,0 +1,8 @@
+// +build !skippackr
+// Code generated by github.com/gobuffalo/packr/v2. DO NOT EDIT.
+
+// You can use the "packr clean" command to clean up this,
+// and any other packr generated files.
+package perl
+
+import _ "github.com/metrue/fx/packrd"

bundler/perl/perl.go

@@ -0,0 +1,32 @@
+package perl
+
+import (
+	"github.com/gobuffalo/packr/v2"
+	"github.com/metrue/fx/bundler"
+)
+
+// Julia defines javascript bundler
+type Julia struct {
+	assets *packr.Box
+}
+
+// New a koa bundler
+func New() *Julia {
+	return &Julia{
+		assets: packr.New("perl", "./assets"),
+	}
+}
+
+// Scaffold a koa app
+func (k *Julia) Scaffold(output string) error {
+	return bundler.Restore(k.assets, output)
+}
+
+// Bundle a function into a koa project
+func (k *Julia) Bundle(output string, fn string, deps ...string) error {
+	return bundler.Bundle(k.assets, output, "perl", fn, deps...)
+}
+
+var (
+	_ bundler.Bundler = &Julia{}
+)

bundler/perl/perl_test.go

@@ -0,0 +1,148 @@
+package perl
+
+import (
+	"io/ioutil"
+	"log"
+	"os"
+	"reflect"
+	"testing"
+
+	"github.com/metrue/fx/utils"
+)
+
+func TestJuliaBundler(t *testing.T) {
+	t.Run("Scaffold", func(t *testing.T) {
+		outputDir, err := ioutil.TempDir("", "fx_julia")
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer os.RemoveAll(outputDir)
+
+		julia := New()
+		if err := julia.Scaffold(outputDir); err != nil {
+			t.Fatal(err)
+		}
+
+		diff, _, _, err := utils.Diff(outputDir, "./assets")
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if diff {
+			t.Fatalf("%s is not equal with %s", outputDir, "./assets")
+		}
+	})
+
+	t.Run("BundleSingleFunc", func(t *testing.T) {
+		fd, err := ioutil.TempFile("", "fx_func_*.julia")
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer os.Remove(fd.Name())
+
+		content := `struct Input
+    a::Number
+    b::Number
+end
+
+fx = function(input::Input)
+    return input.a + input.b
+end
+		`
+		err = ioutil.WriteFile(fd.Name(), []byte(content), 0666)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		outputDir, err := ioutil.TempDir("", "fx_julia")
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer os.RemoveAll(outputDir)
+
+		julia := New()
+		if err := julia.Bundle(outputDir, fd.Name()); err != nil {
+			t.Fatal(err)
+		}
+
+		diff, pre, cur, err := utils.Diff("./assets", outputDir)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if !diff {
+			t.Fatalf("handle function should be changed")
+		}
+
+		if !reflect.DeepEqual(cur, []byte(content)) {
+			t.Fatalf("it should be %s but got %s", content, cur)
+		}
+
+		preHandleFunc, err := ioutil.ReadFile("./assets/fx.pl")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !reflect.DeepEqual(pre, preHandleFunc) {
+			{
+			}
+			t.Fatalf("it should get %s but got %s", preHandleFunc, pre)
+		}
+	})
+
+	t.Run("BundleFuncAndDeps", func(t *testing.T) {
+		fd, err := ioutil.TempFile("", "fx_func_*.js")
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer os.Remove(fd.Name())
+
+		content, err := ioutil.ReadFile("./assets/fx.pl")
+		if err != nil {
+			t.Fatal(err)
+		}
+		err = ioutil.WriteFile(fd.Name(), content, 0666)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addFunc := `
+module.exports = (a, b) => a+b
+  `
+		addFd, err := ioutil.TempFile("", "fx_add_func_*.js")
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		err = ioutil.WriteFile(addFd.Name(), []byte(addFunc), 0644)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		outputDir, err := ioutil.TempDir("", "fx_julia")
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer os.RemoveAll(outputDir)
+
+		julia := New()
+		if err := julia.Bundle(outputDir, fd.Name(), addFd.Name()); err != nil {
+			t.Fatal(err)
+		}
+
+		diff, pre, cur, err := utils.Diff("./assets", outputDir)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if !diff {
+			t.Fatalf("handle functino should be changed")
+		}
+
+		if !reflect.DeepEqual(cur, []byte(addFunc)) {
+			t.Fatalf("it should be %s but got %s", content, cur)
+		}
+		if pre != nil {
+			t.Fatal(pre)
+		}
+	})
+}

bundler/python/python-packr.go

@@ -0,0 +1,8 @@
+// +build !skippackr
+// Code generated by github.com/gobuffalo/packr/v2. DO NOT EDIT.
+
+// You can use the "packr clean" command to clean up this,
+// and any other packr generated files.
+package python
+
+import _ "github.com/metrue/fx/packrd"

bundler/python/python.go

@@ -0,0 +1,32 @@
+package python
+
+import (
+	"github.com/gobuffalo/packr/v2"
+	"github.com/metrue/fx/bundler"
+)
+
+// Julia defines javascript bundler
+type Julia struct {
+	assets *packr.Box
+}
+
+// New a koa bundler
+func New() *Julia {
+	return &Julia{
+		assets: packr.New("python", "./assets"),
+	}
+}
+
+// Scaffold a koa app
+func (k *Julia) Scaffold(output string) error {
+	return bundler.Restore(k.assets, output)
+}
+
+// Bundle a function into a koa project
+func (k *Julia) Bundle(output string, fn string, deps ...string) error {
+	return bundler.Bundle(k.assets, output, "python", fn, deps...)
+}
+
+var (
+	_ bundler.Bundler = &Julia{}
+)

bundler/python/python_test.go

@@ -0,0 +1,148 @@
+package python
+
+import (
+	"io/ioutil"
+	"log"
+	"os"
+	"reflect"
+	"testing"
+
+	"github.com/metrue/fx/utils"
+)
+
+func TestJuliaBundler(t *testing.T) {
+	t.Run("Scaffold", func(t *testing.T) {
+		outputDir, err := ioutil.TempDir("", "fx_julia")
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer os.RemoveAll(outputDir)
+
+		julia := New()
+		if err := julia.Scaffold(outputDir); err != nil {
+			t.Fatal(err)
+		}
+
+		diff, _, _, err := utils.Diff(outputDir, "./assets")
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if diff {
+			t.Fatalf("%s is not equal with %s", outputDir, "./assets")
+		}
+	})
+
+	t.Run("BundleSingleFunc", func(t *testing.T) {
+		fd, err := ioutil.TempFile("", "fx_func_*.julia")
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer os.Remove(fd.Name())
+
+		content := `struct Input
+    a::Number
+    b::Number
+end
+
+fx = function(input::Input)
+    return input.a + input.b
+end
+		`
+		err = ioutil.WriteFile(fd.Name(), []byte(content), 0666)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		outputDir, err := ioutil.TempDir("", "fx_julia")
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer os.RemoveAll(outputDir)
+
+		julia := New()
+		if err := julia.Bundle(outputDir, fd.Name()); err != nil {
+			t.Fatal(err)
+		}
+
+		diff, pre, cur, err := utils.Diff("./assets", outputDir)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if !diff {
+			t.Fatalf("handle function should be changed")
+		}
+
+		if !reflect.DeepEqual(cur, []byte(content)) {
+			t.Fatalf("it should be %s but got %s", content, cur)
+		}
+
+		preHandleFunc, err := ioutil.ReadFile("./assets/fx.py")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !reflect.DeepEqual(pre, preHandleFunc) {
+			{
+			}
+			t.Fatalf("it should get %s but got %s", preHandleFunc, pre)
+		}
+	})
+
+	t.Run("BundleFuncAndDeps", func(t *testing.T) {
+		fd, err := ioutil.TempFile("", "fx_func_*.js")
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer os.Remove(fd.Name())
+
+		content, err := ioutil.ReadFile("./assets/fx.py")
+		if err != nil {
+			t.Fatal(err)
+		}
+		err = ioutil.WriteFile(fd.Name(), content, 0666)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addFunc := `
+module.exports = (a, b) => a+b
+  `
+		addFd, err := ioutil.TempFile("", "fx_add_func_*.js")
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		err = ioutil.WriteFile(addFd.Name(), []byte(addFunc), 0644)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		outputDir, err := ioutil.TempDir("", "fx_julia")
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer os.RemoveAll(outputDir)
+
+		julia := New()
+		if err := julia.Bundle(outputDir, fd.Name(), addFd.Name()); err != nil {
+			t.Fatal(err)
+		}
+
+		diff, pre, cur, err := utils.Diff("./assets", outputDir)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if !diff {
+			t.Fatalf("handle functino should be changed")
+		}
+
+		if !reflect.DeepEqual(cur, []byte(addFunc)) {
+			t.Fatalf("it should be %s but got %s", content, cur)
+		}
+		if pre != nil {
+			t.Fatal(pre)
+		}
+	})
+}

bundler/ruby/assets/Dockerfile

@@ -1,6 +1,4 @@
-FROM ruby:latest
-
-RUN gem install sinatra
+FROM metrue/fx-ruby-base
 
 COPY . .
 EXPOSE 3000

bundler/ruby/ruby-packr.go

@@ -0,0 +1,8 @@
+// +build !skippackr
+// Code generated by github.com/gobuffalo/packr/v2. DO NOT EDIT.
+
+// You can use the "packr clean" command to clean up this,
+// and any other packr generated files.
+package ruby
+
+import _ "github.com/metrue/fx/packrd"

bundler/ruby/ruby.go

@@ -0,0 +1,32 @@
+package ruby
+
+import (
+	"github.com/gobuffalo/packr/v2"
+	"github.com/metrue/fx/bundler"
+)
+
+// Julia defines javascript bundler
+type Julia struct {
+	assets *packr.Box
+}
+
+// New a koa bundler
+func New() *Julia {
+	return &Julia{
+		assets: packr.New("ruby", "./assets"),
+	}
+}
+
+// Scaffold a koa app
+func (k *Julia) Scaffold(output string) error {
+	return bundler.Restore(k.assets, output)
+}
+
+// Bundle a function into a koa project
+func (k *Julia) Bundle(output string, fn string, deps ...string) error {
+	return bundler.Bundle(k.assets, output, "ruby", fn, deps...)
+}
+
+var (
+	_ bundler.Bundler = &Julia{}
+)

bundler/ruby/ruby_test.go

@@ -0,0 +1,148 @@
+package ruby
+
+import (
+	"io/ioutil"
+	"log"
+	"os"
+	"reflect"
+	"testing"
+
+	"github.com/metrue/fx/utils"
+)
+
+func TestJuliaBundler(t *testing.T) {
+	t.Run("Scaffold", func(t *testing.T) {
+		outputDir, err := ioutil.TempDir("", "fx_julia")
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer os.RemoveAll(outputDir)
+
+		julia := New()
+		if err := julia.Scaffold(outputDir); err != nil {
+			t.Fatal(err)
+		}
+
+		diff, _, _, err := utils.Diff(outputDir, "./assets")
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if diff {
+			t.Fatalf("%s is not equal with %s", outputDir, "./assets")
+		}
+	})
+
+	t.Run("BundleSingleFunc", func(t *testing.T) {
+		fd, err := ioutil.TempFile("", "fx_func_*.julia")
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer os.Remove(fd.Name())
+
+		content := `struct Input
+    a::Number
+    b::Number
+end
+
+fx = function(input::Input)
+    return input.a + input.b
+end
+		`
+		err = ioutil.WriteFile(fd.Name(), []byte(content), 0666)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		outputDir, err := ioutil.TempDir("", "fx_julia")
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer os.RemoveAll(outputDir)
+
+		julia := New()
+		if err := julia.Bundle(outputDir, fd.Name()); err != nil {
+			t.Fatal(err)
+		}
+
+		diff, pre, cur, err := utils.Diff("./assets", outputDir)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if !diff {
+			t.Fatalf("handle function should be changed")
+		}
+
+		if !reflect.DeepEqual(cur, []byte(content)) {
+			t.Fatalf("it should be %s but got %s", content, cur)
+		}
+
+		preHandleFunc, err := ioutil.ReadFile("./assets/fx.rb")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !reflect.DeepEqual(pre, preHandleFunc) {
+			{
+			}
+			t.Fatalf("it should get %s but got %s", preHandleFunc, pre)
+		}
+	})
+
+	t.Run("BundleFuncAndDeps", func(t *testing.T) {
+		fd, err := ioutil.TempFile("", "fx_func_*.js")
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer os.Remove(fd.Name())
+
+		content, err := ioutil.ReadFile("./assets/fx.rb")
+		if err != nil {
+			t.Fatal(err)
+		}
+		err = ioutil.WriteFile(fd.Name(), content, 0666)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addFunc := `
+module.exports = (a, b) => a+b
+  `
+		addFd, err := ioutil.TempFile("", "fx_add_func_*.js")
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		err = ioutil.WriteFile(addFd.Name(), []byte(addFunc), 0644)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		outputDir, err := ioutil.TempDir("", "fx_julia")
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer os.RemoveAll(outputDir)
+
+		julia := New()
+		if err := julia.Bundle(outputDir, fd.Name(), addFd.Name()); err != nil {
+			t.Fatal(err)
+		}
+
+		diff, pre, cur, err := utils.Diff("./assets", outputDir)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if !diff {
+			t.Fatalf("handle functino should be changed")
+		}
+
+		if !reflect.DeepEqual(cur, []byte(addFunc)) {
+			t.Fatalf("it should be %s but got %s", content, cur)
+		}
+		if pre != nil {
+			t.Fatal(pre)
+		}
+	})
+}

bundler/rust/rust-packr.go

@@ -0,0 +1,8 @@
+// +build !skippackr
+// Code generated by github.com/gobuffalo/packr/v2. DO NOT EDIT.
+
+// You can use the "packr clean" command to clean up this,
+// and any other packr generated files.
+package rust
+
+import _ "github.com/metrue/fx/packrd"

bundler/rust/rust.go

@@ -0,0 +1,32 @@
+package rust
+
+import (
+	"github.com/gobuffalo/packr/v2"
+	"github.com/metrue/fx/bundler"
+)
+
+// Julia defines javascript bundler
+type Julia struct {
+	assets *packr.Box
+}
+
+// New a koa bundler
+func New() *Julia {
+	return &Julia{
+		assets: packr.New("rust", "./assets"),
+	}
+}
+
+// Scaffold a koa app
+func (k *Julia) Scaffold(output string) error {
+	return bundler.Restore(k.assets, output)
+}
+
+// Bundle a function into a koa project
+func (k *Julia) Bundle(output string, fn string, deps ...string) error {
+	return bundler.Bundle(k.assets, output, "rust", fn, deps...)
+}
+
+var (
+	_ bundler.Bundler = &Julia{}
+)

bundler/rust/rust_test.go

@@ -0,0 +1,148 @@
+package rust
+
+import (
+	"io/ioutil"
+	"log"
+	"os"
+	"reflect"
+	"testing"
+
+	"github.com/metrue/fx/utils"
+)
+
+func TestJuliaBundler(t *testing.T) {
+	t.Run("Scaffold", func(t *testing.T) {
+		outputDir, err := ioutil.TempDir("", "fx_julia")
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer os.RemoveAll(outputDir)
+
+		julia := New()
+		if err := julia.Scaffold(outputDir); err != nil {
+			t.Fatal(err)
+		}
+
+		diff, _, _, err := utils.Diff(outputDir, "./assets")
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if diff {
+			t.Fatalf("%s is not equal with %s", outputDir, "./assets")
+		}
+	})
+
+	t.Run("BundleSingleFunc", func(t *testing.T) {
+		fd, err := ioutil.TempFile("", "fx_func_*.julia")
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer os.Remove(fd.Name())
+
+		content := `struct Input
+    a::Number
+    b::Number
+end
+
+fx = function(input::Input)
+    return input.a + input.b
+end
+		`
+		err = ioutil.WriteFile(fd.Name(), []byte(content), 0666)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		outputDir, err := ioutil.TempDir("", "fx_julia")
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer os.RemoveAll(outputDir)
+
+		julia := New()
+		if err := julia.Bundle(outputDir, fd.Name()); err != nil {
+			t.Fatal(err)
+		}
+
+		diff, pre, cur, err := utils.Diff("./assets", outputDir)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if !diff {
+			t.Fatalf("handle function should be changed")
+		}
+
+		if !reflect.DeepEqual(cur, []byte(content)) {
+			t.Fatalf("it should be %s but got %s", content, cur)
+		}
+
+		preHandleFunc, err := ioutil.ReadFile("./assets/src/fns/mod.rs")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !reflect.DeepEqual(pre, preHandleFunc) {
+			{
+			}
+			t.Fatalf("it should get %s but got %s", preHandleFunc, pre)
+		}
+	})
+
+	t.Run("BundleFuncAndDeps", func(t *testing.T) {
+		fd, err := ioutil.TempFile("", "fx_func_*.js")
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer os.Remove(fd.Name())
+
+		content, err := ioutil.ReadFile("./assets/src/fns/mod.rs")
+		if err != nil {
+			t.Fatal(err)
+		}
+		err = ioutil.WriteFile(fd.Name(), content, 0666)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addFunc := `
+module.exports = (a, b) => a+b
+  `
+		addFd, err := ioutil.TempFile("", "fx_add_func_*.js")
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		err = ioutil.WriteFile(addFd.Name(), []byte(addFunc), 0644)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		outputDir, err := ioutil.TempDir("", "fx_julia")
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer os.RemoveAll(outputDir)
+
+		julia := New()
+		if err := julia.Bundle(outputDir, fd.Name(), addFd.Name()); err != nil {
+			t.Fatal(err)
+		}
+
+		diff, pre, cur, err := utils.Diff("./assets", outputDir)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if !diff {
+			t.Fatalf("handle functino should be changed")
+		}
+
+		if !reflect.DeepEqual(cur, []byte(addFunc)) {
+			t.Fatalf("it should be %s but got %s", content, cur)
+		}
+		if pre != nil {
+			t.Fatal(pre)
+		}
+	})
+}

config/config.go

@@ -1,213 +0,0 @@
-package config
-
-import (
-	"fmt"
-	"os"
-	"path"
-
-	"github.com/spf13/viper"
-)
-
-// Configer interface
-type Configer interface {
-	GetMachine(name string) (Host, error)
-	AddMachine(name string, host Host) error
-	RemoveHost(name string) error
-	ListActiveMachines() (map[string]Host, error)
-	ListMachines() (map[string]Host, error)
-	EnableMachine(name string) error
-	DisableMachine(name string) error
-	UpdateProvisionedStatus(name string, ok bool) error
-}
-
-// Config config of fx
-type Config struct {
-	dir string
-}
-
-// New create a config
-func New(dir string) *Config {
-	return &Config{dir: dir}
-}
-
-// Init config
-func (c *Config) Init() error {
-	if err := os.MkdirAll(c.dir, os.ModePerm); err != nil {
-		return err
-	}
-
-	ext := "yaml"
-	name := "config"
-	viper.SetConfigType(ext)
-	viper.SetConfigName(name)
-	viper.AddConfigPath(c.dir)
-
-	// detect if file exists
-	configFilePath := path.Join(c.dir, name+"."+ext)
-	if _, err := os.Stat(configFilePath); os.IsNotExist(err) {
-		fd, err := os.Create(configFilePath)
-		if err != nil {
-			return err
-		}
-		fd.Close()
-
-		localhost := Host{
-			Host:        "localhost",
-			Password:    "",
-			User:        "",
-			Enabled:     true,
-			Provisioned: false,
-		}
-		viper.Set("hosts", map[string]Host{"localhost": localhost})
-		return viper.WriteConfig()
-	}
-
-	if err := viper.ReadInConfig(); err != nil {
-		return fmt.Errorf("fatal error config file: %s", err)
-	}
-	return nil
-}
-
-// GetMachine get host by name
-func (c *Config) GetMachine(name string) (Host, error) {
-	var hosts map[string]Host
-	if err := viper.UnmarshalKey("hosts", &hosts); err != nil {
-		return Host{}, err
-	}
-	host, ok := hosts[name]
-	if !ok {
-		return Host{}, fmt.Errorf("no such host %v", name)
-	}
-	return host, nil
-}
-
-// ListActiveMachines list enabled machines
-func (c *Config) ListActiveMachines() (map[string]Host, error) {
-	hosts, err := c.ListMachines()
-	if err != nil {
-		return map[string]Host{}, err
-	}
-	lst := map[string]Host{}
-	for name, h := range hosts {
-		if h.Enabled {
-			lst[name] = h
-		}
-	}
-	return lst, nil
-}
-
-// AddMachine add host
-func (c *Config) AddMachine(name string, host Host) error {
-	if !viper.IsSet("hosts") {
-		viper.Set("hosts", map[string]Host{})
-	}
-
-	hosts, err := c.ListMachines()
-	if err != nil {
-		return err
-	}
-	hosts[name] = host
-	viper.Set("hosts", hosts)
-	return viper.WriteConfig()
-}
-
-// RemoveHost remote a host
-func (c *Config) RemoveHost(name string) error {
-	hosts, err := c.ListMachines()
-	if err != nil {
-		return err
-	}
-
-	if len(hosts) == 1 {
-		return fmt.Errorf("only one host left now, at least one host required by fx")
-	}
-
-	if _, ok := hosts[name]; ok {
-		delete(hosts, name)
-
-		viper.Set("hosts", hosts)
-		return viper.WriteConfig()
-	}
-	return fmt.Errorf("no such host %s", name)
-}
-
-// ListMachines list hosts
-func (c *Config) ListMachines() (map[string]Host, error) {
-	var hosts map[string]Host
-	if err := viper.UnmarshalKey("hosts", &hosts); err != nil {
-		return nil, err
-	}
-	return hosts, nil
-}
-
-// EnableMachine enable a machine, after machine enabled, function will be deployed onto it when ever `fx up` invoked
-func (c *Config) EnableMachine(name string) error {
-	host, err := c.GetMachine(name)
-	if err != nil {
-		return err
-	}
-	host.Enabled = true
-
-	if !viper.IsSet("hosts") {
-		viper.Set("hosts", map[string]Host{})
-	}
-
-	hosts, err := c.ListMachines()
-	if err != nil {
-		return err
-	}
-	hosts[name] = host
-	viper.Set("hosts", hosts)
-	return viper.WriteConfig()
-}
-
-// DisableMachine disable a machine, after machine disabled, function will not be deployed onto it
-func (c *Config) DisableMachine(name string) error {
-	host, err := c.GetMachine(name)
-	if err != nil {
-		return err
-	}
-	host.Enabled = false
-
-	if !viper.IsSet("hosts") {
-		viper.Set("hosts", map[string]Host{})
-	}
-
-	hosts, err := c.ListMachines()
-	if err != nil {
-		return err
-	}
-	hosts[name] = host
-	viper.Set("hosts", hosts)
-	return viper.WriteConfig()
-}
-
-// UpdateProvisionedStatus update provisioned status
-func (c *Config) UpdateProvisionedStatus(name string, ok bool) error {
-	host, err := c.GetMachine(name)
-	if err != nil {
-		return err
-	}
-	host.Provisioned = ok
-
-	if !viper.IsSet("hosts") {
-		viper.Set("hosts", map[string]Host{})
-	}
-
-	hosts, err := c.ListMachines()
-	if err != nil {
-		return err
-	}
-	hosts[name] = host
-	viper.Set("hosts", hosts)
-	return viper.WriteConfig()
-}
-
-// IsMachineProvisioned check if machine provisioned
-func (c *Config) IsMachineProvisioned(name string) bool {
-	host, err := c.GetMachine(name)
-	if err != nil {
-		return false
-	}
-	return host.Provisioned
-}

config/config_test.go

@@ -1,98 +0,0 @@
-package config
-
-import (
-	"os"
-	"reflect"
-	"testing"
-)
-
-func TestConfig(t *testing.T) {
-	configPath := "/tmp/.fx"
-	defer func() {
-		if err := os.RemoveAll(configPath); err != nil {
-			t.Fatal(err)
-		}
-	}()
-
-	c := New(configPath)
-	if err := c.Init(); err != nil {
-		t.Fatal(err)
-	}
-
-	hosts, err := c.ListMachines()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if len(hosts) != 1 {
-		t.Fatalf("should have localhost as default machine")
-	}
-
-	host := hosts["localhost"]
-	if !reflect.DeepEqual(host, Host{Host: "localhost", Enabled: true}) {
-		t.Fatalf("should get %v but got %v", Host{Host: "localhost"}, host)
-	}
-
-	name := "remote-a"
-	h := Host{
-		Host:     "192.168.1.1",
-		User:     "user-a",
-		Password: "password-a",
-		Enabled:  false,
-	}
-	if err := c.AddMachine(name, h); err != nil {
-		t.Fatal(err)
-	}
-
-	hosts, err = c.ListMachines()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(hosts) != 2 {
-		t.Fatalf("should have %d machines now, but got %d", 2, len(hosts))
-	}
-
-	lst, err := c.ListActiveMachines()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if len(lst) != 1 {
-		t.Fatalf("should only have %d machine enabled, but got %d", 1, len(lst))
-	}
-
-	if err := c.EnableMachine(name); err != nil {
-		t.Fatal(err)
-	}
-
-	lst, err = c.ListActiveMachines()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if len(lst) != 2 {
-		t.Fatalf("should only have %d machine enabled, but got %d", 2, len(lst))
-	}
-
-	h.Enabled = true
-	if !reflect.DeepEqual(lst[name], h) {
-		t.Fatalf("should get %v but got %v", h, lst[name])
-	}
-
-	if lst[name].Provisioned != false {
-		t.Fatalf("should get %v but got %v", false, lst[name].Provisioned)
-	}
-
-	if err := c.UpdateProvisionedStatus(name, true); err != nil {
-		t.Fatal(err)
-	}
-
-	updatedHost, err := c.GetMachine(name)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if updatedHost.Provisioned != true {
-		t.Fatalf("should get %v but got %v", true, updatedHost.Provisioned)
-	}
-}

config/env.go

@@ -0,0 +1,14 @@
+package config
+
+import (
+	"os"
+)
+
+// DisableContainerAutoremove to tell if to run container with --rm
+var DisableContainerAutoremove = false
+
+func init() {
+	if os.Getenv("DISABLE_CONTAINER_AUTOREMOVE") == "true" {
+		DisableContainerAutoremove = true
+	}
+}

config/env_test.go

@@ -0,0 +1,17 @@
+package config
+
+import (
+	"os"
+	"testing"
+)
+
+var _ = func() (_ struct{}) {
+	os.Setenv("DISABLE_CONTAINER_AUTOREMOVE", "true")
+	return
+}()
+
+func TestEnvLoad(t *testing.T) {
+	if !DisableContainerAutoremove {
+		t.Fatalf("should be true after set")
+	}
+}

config/host.go

@@ -1,40 +0,0 @@
-package config
-
-// Host host entity
-type Host struct {
-	Host        string
-	User        string
-	Password    string
-	Enabled     bool
-	Provisioned bool
-}
-
-// NewHost new a host
-func NewHost(addr, user, password string) Host {
-	return Host{
-		Host:        addr,
-		User:        user,
-		Password:    password,
-		Enabled:     false,
-		Provisioned: false,
-	}
-}
-
-// Valid if host is valid
-func (h Host) Valid() bool {
-	// TODO stronger check
-	return h.Host != ""
-}
-
-// IsLocal if host is localhost
-func (h Host) IsLocal() bool {
-	if !h.Valid() {
-		return false
-	}
-	return h.Host == "127.0.0.1" || h.Host == "localhost"
-}
-
-// IsRemote is host is remote
-func (h Host) IsRemote() bool {
-	return !h.IsLocal()
-}

config/mocks/config.go

@@ -1,149 +0,0 @@
-// Code generated by MockGen. DO NOT EDIT.
-// Source: ./config.go
-
-// Package mock_config is a generated GoMock package.
-package mock_config
-
-import (
-	gomock "github.com/golang/mock/gomock"
-	config "github.com/metrue/fx/config"
-	reflect "reflect"
-)
-
-// MockConfiger is a mock of Configer interface
-type MockConfiger struct {
-	ctrl     *gomock.Controller
-	recorder *MockConfigerMockRecorder
-}
-
-// MockConfigerMockRecorder is the mock recorder for MockConfiger
-type MockConfigerMockRecorder struct {
-	mock *MockConfiger
-}
-
-// NewMockConfiger creates a new mock instance
-func NewMockConfiger(ctrl *gomock.Controller) *MockConfiger {
-	mock := &MockConfiger{ctrl: ctrl}
-	mock.recorder = &MockConfigerMockRecorder{mock}
-	return mock
-}
-
-// EXPECT returns an object that allows the caller to indicate expected use
-func (m *MockConfiger) EXPECT() *MockConfigerMockRecorder {
-	return m.recorder
-}
-
-// GetMachine mocks base method
-func (m *MockConfiger) GetMachine(name string) (config.Host, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetMachine", name)
-	ret0, _ := ret[0].(config.Host)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetMachine indicates an expected call of GetMachine
-func (mr *MockConfigerMockRecorder) GetMachine(name interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMachine", reflect.TypeOf((*MockConfiger)(nil).GetMachine), name)
-}
-
-// AddMachine mocks base method
-func (m *MockConfiger) AddMachine(name string, host config.Host) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AddMachine", name, host)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// AddMachine indicates an expected call of AddMachine
-func (mr *MockConfigerMockRecorder) AddMachine(name, host interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddMachine", reflect.TypeOf((*MockConfiger)(nil).AddMachine), name, host)
-}
-
-// RemoveHost mocks base method
-func (m *MockConfiger) RemoveHost(name string) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RemoveHost", name)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// RemoveHost indicates an expected call of RemoveHost
-func (mr *MockConfigerMockRecorder) RemoveHost(name interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveHost", reflect.TypeOf((*MockConfiger)(nil).RemoveHost), name)
-}
-
-// ListActiveMachines mocks base method
-func (m *MockConfiger) ListActiveMachines() (map[string]config.Host, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListActiveMachines")
-	ret0, _ := ret[0].(map[string]config.Host)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListActiveMachines indicates an expected call of ListActiveMachines
-func (mr *MockConfigerMockRecorder) ListActiveMachines() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListActiveMachines", reflect.TypeOf((*MockConfiger)(nil).ListActiveMachines))
-}
-
-// ListMachines mocks base method
-func (m *MockConfiger) ListMachines() (map[string]config.Host, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListMachines")
-	ret0, _ := ret[0].(map[string]config.Host)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListMachines indicates an expected call of ListMachines
-func (mr *MockConfigerMockRecorder) ListMachines() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMachines", reflect.TypeOf((*MockConfiger)(nil).ListMachines))
-}
-
-// EnableMachine mocks base method
-func (m *MockConfiger) EnableMachine(name string) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableMachine", name)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// EnableMachine indicates an expected call of EnableMachine
-func (mr *MockConfigerMockRecorder) EnableMachine(name interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableMachine", reflect.TypeOf((*MockConfiger)(nil).EnableMachine), name)
-}
-
-// DisableMachine mocks base method
-func (m *MockConfiger) DisableMachine(name string) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableMachine", name)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DisableMachine indicates an expected call of DisableMachine
-func (mr *MockConfigerMockRecorder) DisableMachine(name interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableMachine", reflect.TypeOf((*MockConfiger)(nil).DisableMachine), name)
-}
-
-// UpdateProvisionedStatus mocks base method
-func (m *MockConfiger) UpdateProvisionedStatus(name string, ok bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UpdateProvisionedStatus", name, ok)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// UpdateProvisionedStatus indicates an expected call of UpdateProvisionedStatus
-func (mr *MockConfigerMockRecorder) UpdateProvisionedStatus(name, ok interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProvisionedStatus", reflect.TypeOf((*MockConfiger)(nil).UpdateProvisionedStatus), name, ok)
-}

constants/languages.go

@@ -0,0 +1,15 @@
+package constants
+
+// ExtLangMapping file extension mapping with programming language
+var ExtLangMapping = map[string]string{
+	".js":   "node",
+	".go":   "go",
+	".rb":   "ruby",
+	".py":   "python",
+	".php":  "php",
+	".jl":   "julia",
+	".java": "java",
+	".d":    "d",
+	".rs":   "rust",
+	".pl":   "perl",
+}

container_runtimes/docker/http/api.go

@@ -1,50 +1,87 @@
 package api
 
 import (
+	"bufio"
 	"bytes"
+	"context"
 	"encoding/json"
 	"fmt"
 	"io/ioutil"
 	"net/http"
+	"net/url"
+	"os"
+	"path/filepath"
 	"strconv"
 	"strings"
 	"time"
 
+	"github.com/apex/log"
 	dockerTypes "github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/container"
+	"github.com/docker/docker/api/types/network"
+	"github.com/docker/go-connections/nat"
 	"github.com/google/go-querystring/query"
+	"github.com/google/uuid"
+	fxConfig "github.com/metrue/fx/config"
+	containerruntimes "github.com/metrue/fx/container_runtimes"
 	"github.com/metrue/fx/types"
 	"github.com/metrue/fx/utils"
+	"github.com/pkg/errors"
 )
 
 // API interact with dockerd http api
 type API struct {
+	host     string
+	port     string
 	endpoint string
 	version  string
 }
 
+// New a API
+func New(host string, port string) *API {
+	return &API{
+		host: host,
+		port: port,
+	}
+}
+
+// Initialize an API
+func (api *API) Initialize() error {
+	addr := api.host + ":" + api.port
+	v, err := version(addr)
+	if err != nil {
+		return err
+	}
+	endpoint := fmt.Sprintf("http://%s:%s/v%s", api.host, api.port, v)
+	api.endpoint = endpoint
+	return nil
+}
+
 // Create a API
 func Create(host string, port string) (*API, error) {
-	version, err := utils.DockerVersion(host, port)
+	addr := host + ":" + port
+	v, err := version(addr)
 	if err != nil {
 		return nil, err
 	}
-	endpoint := fmt.Sprintf("http://%s:%s/v%s", host, port, version)
+	endpoint := fmt.Sprintf("http://%s:%s/v%s", host, port, v)
 	return &API{
 		endpoint: endpoint,
-		version:  version,
+		version:  v,
 	}, nil
 }
 
 // MustCreate a api object, panic if not
 func MustCreate(host string, port string) *API {
-	version, err := utils.DockerVersion(host, port)
+	addr := host + ":" + port
+	v, err := version(addr)
 	if err != nil {
 		panic(err)
 	}
-	endpoint := fmt.Sprintf("http://%s:%s/v%s", host, port, version)
+	endpoint := fmt.Sprintf("http://%s:%s/v%s", host, port, v)
 	return &API{
 		endpoint: endpoint,
-		version:  version,
+		version:  v,
 	}
 }
 
@@ -116,8 +153,48 @@ func (api *API) post(path string, body []byte, expectStatus int, v interface{})
 	return nil
 }
 
-// List list service
-func (api *API) list(name string) ([]types.Service, error) {
+// Version get version of docker engine
+func (api *API) Version(ctx context.Context) (string, error) {
+	addr := api.host + ":" + api.port
+	return version(addr)
+}
+
+func version(endpoint string) (string, error) {
+	path := endpoint + "/version"
+	if !strings.HasPrefix(path, "http") {
+		path = "http://" + path
+	}
+
+	req, err := http.NewRequest("GET", path, nil)
+	if err != nil {
+		return "", err
+	}
+	client := &http.Client{Timeout: 20 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", err
+	}
+
+	if resp.StatusCode != 200 {
+		return "", fmt.Errorf("request %s failed: %d - %s", path, resp.StatusCode, resp.Status)
+	}
+
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return "", err
+	}
+
+	var res dockerTypes.Version
+	err = json.Unmarshal(body, &res)
+	if err != nil {
+		return "", err
+	}
+	return res.APIVersion, nil
+}
+
+// ListContainer list service
+func (api *API) ListContainer(ctx context.Context, name string) ([]types.Service, error) {
 	if name != "" {
 		info, err := api.inspect(name)
 		if err != nil {
@@ -141,7 +218,7 @@ func (api *API) list(name string) ([]types.Service, error) {
 	}
 
 	type filterItem struct {
-		Status []string `json:"url,omitempty"`
+		Status []string `json:"status,omitempty"`
 		Label  []string `json:"label,omitempty"`
 		Name   []string `json:"name,omitempty"`
 	}
@@ -173,17 +250,27 @@ func (api *API) list(name string) ([]types.Service, error) {
 
 	svs := make(map[string]types.Service)
 	for _, container := range containers {
+		name := "UNKNOWN"
+		if len(container.Names) > 0 {
+			name = container.Names[0]
+		}
+
+		port := -1
+		ip := "UNKNOWN"
+		if len(container.Ports) > 0 {
+			ip = container.Ports[0].IP
+			port = int(container.Ports[0].PublicPort)
+		}
+
 		// container name have extra forward slash
 		// https://github.com/moby/moby/issues/6705
-		if strings.HasPrefix(container.Names[0], fmt.Sprintf("/%s", name)) {
-			svs[container.Image] = types.Service{
-				Name:  container.Names[0],
-				Image: container.Image,
-				ID:    container.ID,
-				Host:  container.Ports[0].IP,
-				Port:  int(container.Ports[0].PublicPort),
-				State: container.State,
-			}
+		svs[container.Image] = types.Service{
+			Name:  name,
+			Image: container.Image,
+			ID:    container.ID,
+			Host:  ip,
+			Port:  port,
+			State: container.State,
 		}
 	}
 	services := []types.Service{}
@@ -193,3 +280,223 @@ func (api *API) list(name string) ([]types.Service, error) {
 
 	return services, nil
 }
+
+// BuildImage build image
+func (api *API) BuildImage(ctx context.Context, workdir string, name string) error {
+	tarDir, err := ioutil.TempDir("/tmp", "fx-tar")
+	if err != nil {
+		return err
+	}
+	defer os.RemoveAll(tarDir)
+
+	imageID := uuid.New().String()
+	tarFilePath := filepath.Join(tarDir, fmt.Sprintf("%s.tar", imageID))
+
+	if err := utils.TarDir(workdir, tarFilePath); err != nil {
+		return err
+	}
+
+	dockerBuildContext, err := os.Open(tarFilePath)
+	if err != nil {
+		return err
+	}
+	defer dockerBuildContext.Close()
+
+	type buildQuery struct {
+		Labels     string `url:"labels,omitempty"`
+		Tags       string `url:"t,omitempty"`
+		Dockerfile string `url:"dockerfile,omitempty"`
+	}
+
+	// Apply default labels
+	labelsJSON, _ := json.Marshal(map[string]string{
+		"belong-to": "fx",
+	})
+	q := buildQuery{
+		Labels:     string(labelsJSON),
+		Dockerfile: "Dockerfile",
+	}
+
+	qs, err := query.Values(q)
+	if err != nil {
+		return err
+	}
+	qs.Add("t", name)
+	qs.Add("t", imageID)
+
+	path := "/build"
+	url := fmt.Sprintf("%s%s?%s", api.endpoint, path, qs.Encode())
+	req, err := http.NewRequest("POST", url, dockerBuildContext)
+	if err != nil {
+		return err
+	}
+
+	req.Header.Set("Content-Type", "application/x-tar")
+	client := &http.Client{Timeout: 600 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return err
+	}
+
+	defer resp.Body.Close()
+	scanner := bufio.NewScanner(resp.Body)
+
+	for scanner.Scan() {
+		if os.Getenv("DEBUG") != "" {
+			log.Infof(scanner.Text())
+		}
+	}
+	if err := scanner.Err(); err != nil {
+		return err
+	}
+	return nil
+}
+
+// PushImage push a image
+func (api *API) PushImage(ctx context.Context, name string) (string, error) {
+	return "", nil
+}
+
+// InspectImage inspect image
+func (api *API) InspectImage(ctx context.Context, name string, image interface{}) error {
+	return nil
+}
+
+// TagImage tag image
+func (api *API) TagImage(ctx context.Context, name string, tag string) error {
+	query := url.Values{}
+	query.Set("repo", name)
+	query.Set("tag", tag)
+	path := fmt.Sprintf("/images/%s/tag?%s", name, query.Encode())
+
+	url := fmt.Sprintf("%s%s", api.endpoint, path)
+	req, err := http.NewRequest("POST", url, nil)
+	if err != nil {
+		return err
+	}
+
+	client := &http.Client{Timeout: 10 * time.Second}
+	if _, err = client.Do(req); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// StartContainer start container
+func (api *API) StartContainer(ctx context.Context, name string, image string, bindings []types.PortBinding) error {
+	networks, err := api.GetNetwork(fxNetworkName)
+	if err != nil {
+		return errors.Wrapf(err, "get network failed: %s", err)
+	}
+
+	if len(networks) == 0 {
+		if err := api.CreateNetwork(fxNetworkName); err != nil {
+			return errors.Wrapf(err, "error create network: %s", err)
+		}
+	}
+	networks, _ = api.GetNetwork(fxNetworkName)
+
+	endpoint := &network.EndpointSettings{
+		NetworkID: networks[0].ID,
+	}
+	networkConfig := &network.NetworkingConfig{
+		EndpointsConfig: map[string]*network.EndpointSettings{
+			"fx-net": endpoint,
+		},
+	}
+
+	portSet := nat.PortSet{}
+	portMap := nat.PortMap{}
+	for _, binding := range bindings {
+		bindings := []nat.PortBinding{
+			nat.PortBinding{
+				HostIP:   types.DefaultHost,
+				HostPort: fmt.Sprintf("%d", binding.ServiceBindingPort),
+			},
+		}
+		port := nat.Port(fmt.Sprintf("%d/tcp", binding.ContainerExposePort))
+		portSet[port] = struct{}{}
+		portMap[port] = bindings
+	}
+	config := &container.Config{
+		Image:        image,
+		ExposedPorts: portSet,
+	}
+
+	hostConfig := &container.HostConfig{
+		AutoRemove:   !fxConfig.DisableContainerAutoremove,
+		PortBindings: portMap,
+	}
+
+	req := ContainerCreateRequestPayload{
+		Config:           config,
+		HostConfig:       hostConfig,
+		NetworkingConfig: networkConfig,
+	}
+
+	body, err := json.Marshal(req)
+	if err != nil {
+		return errors.Wrap(err, "error mashal container create req")
+	}
+
+	// create container
+	path := fmt.Sprintf("/containers/create?name=%s", name)
+	var createRes container.ContainerCreateCreatedBody
+	if err := api.post(path, body, 201, &createRes); err != nil {
+		return errors.Wrap(err, "create container request failed")
+	}
+
+	if createRes.ID == "" {
+		return fmt.Errorf("container id is missing")
+	}
+
+	// start container
+	path = fmt.Sprintf("/containers/%s/start", createRes.ID)
+	url := fmt.Sprintf("%s%s", api.endpoint, path)
+	request, err := http.NewRequest("POST", url, nil)
+	if err != nil {
+		return errors.Wrap(err, "error new container create request")
+	}
+	client := &http.Client{Timeout: 20 * time.Second}
+	resp, err := client.Do(request)
+	if err != nil {
+		return errors.Wrap(err, "error do start container request")
+	}
+
+	defer resp.Body.Close()
+	b, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+
+	if len(b) != 0 {
+		msg := fmt.Sprintf("start container met issue: %s", string(b))
+		return errors.New(msg)
+	}
+
+	if _, err = api.inspect(createRes.ID); err != nil {
+		msg := fmt.Sprintf("inspect container %s error", name)
+		return errors.Wrap(err, msg)
+	}
+
+	return nil
+}
+
+// StopContainer stop a container
+func (api *API) StopContainer(ctx context.Context, name string) error {
+	return api.Stop(name)
+}
+
+// InspectContainer inspect container
+func (api *API) InspectContainer(ctx context.Context, name string, container interface{}) error {
+	path := fmt.Sprintf("/containers/%s/json", name)
+	if err := api.get(path, "", &container); err != nil {
+		return err
+	}
+	return nil
+}
+
+var (
+	_ containerruntimes.ContainerRuntime = &API{}
+)

container_runtimes/docker/http/api_test.go

@@ -1,89 +1,31 @@
 package api
 
 import (
+	"context"
+	"os"
 	"testing"
 
-	"github.com/metrue/fx/config"
-	"github.com/metrue/fx/constants"
-	"github.com/metrue/fx/types"
+	"github.com/docker/docker/api/types"
 )
 
 func TestDockerHTTP(t *testing.T) {
-	host := config.Host{Host: "127.0.0.1"}
-	api, err := Create(host.Host, constants.AgentPort)
+	host := os.Getenv("DOCKER_ENGINE_HOST")
+	port := os.Getenv("DOCKER_ENGINE_PORT")
+	if host == "" ||
+		port == "" {
+		t.Skip("DOCKER_ENGINE_HOST and DOCKER_ENGINE_PORT required")
+	}
+
+	api, err := Create(host, port)
 	if err != nil {
 		t.Fatal(err)
 	}
-
-	serviceName := "a-test-service"
-	project := types.Project{
-		Name:     serviceName,
-		Language: "node",
-		Files: []types.ProjectSourceFile{
-			types.ProjectSourceFile{
-				Path: "Dockerfile",
-				Body: `
-FROM metrue/fx-node-base
-
-COPY . .
-EXPOSE 3000
-CMD ["node", "app.js"]`,
-				IsHandler: false,
-			},
-			types.ProjectSourceFile{
-				Path: "app.js",
-				Body: `
-const Koa = require('koa');
-const bodyParser = require('koa-bodyparser');
-const func = require('./fx');
-
-const app = new Koa();
-app.use(bodyParser());
-app.use(ctx => {
-  const msg = func(ctx.request.body);
-  ctx.body = msg;
-});
-
-app.listen(3000);`,
-				IsHandler: false,
-			},
-			types.ProjectSourceFile{
-				Path: "fx.js",
-				Body: `
-module.exports = (input) => {
-    return input.a + input.b
-}
-					`,
-				IsHandler: true,
-			},
-		},
-	}
-
-	service, err := api.Build(project)
-	if err != nil {
+	name := "fx-agent"
+	var container types.ContainerJSON
+	if err := api.InspectContainer(context.Background(), name, &container); err != nil {
 		t.Fatal(err)
 	}
-
-	if err != nil {
-		t.Fatal(err)
-	}
-	if service.Name != serviceName {
-		t.Fatalf("should get %s but got %s", serviceName, service.Name)
-	}
-
-	if err := api.Run(9999, &service); err != nil {
-		t.Fatal(err)
-	}
-
-	services, err := api.list(serviceName)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(services) != 1 {
-		t.Fatal("service number should be 1")
-	}
-
-	if err := api.Stop(serviceName); err != nil {
-		t.Fatal(err)
+	if container.Name != "/"+name {
+		t.Fatalf("should get %s but got %s", name, container.Name)
 	}
 }

container_runtimes/docker/http/call.go

@@ -1,60 +1,51 @@
 package api
 
 import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"strings"
-	"time"
-
-	"github.com/apex/log"
 	"github.com/metrue/fx/types"
-	"github.com/metrue/fx/utils"
 )
 
 // Call function directly with given params
 func (api *API) Call(file string, param string, project types.Project) error {
-	service, err := api.Build(project)
-	if err != nil {
-		log.Fatalf("Build Service: %v", err)
-		return err
-	}
-	log.Info("Build Service: \u2713")
-
-	if err := api.Run(9999, &service); err != nil {
-		log.Fatalf("Run Service: %v", err)
-		return err
-	}
-	log.Info("Run Service: \u2713")
-
-	params := utils.PairsToParams(strings.Fields(param))
-	body, err := json.Marshal(params)
-	if err != nil {
-		return err
-	}
-
-	// Wait 2 seconds for service startup
-	time.Sleep(time.Second * 2)
-
-	url := fmt.Sprintf("http://%s:%d", service.Host, service.Port)
-	r, err := http.NewRequest("POST", url, bytes.NewReader(body))
-	if err != nil {
-		return err
-	}
-	r.Header.Set("Content-Type", "application/json")
-	client := &http.Client{Timeout: 20 * time.Second}
-	resp, err := client.Do(r)
-	if err != nil {
-		log.Fatalf("Call Service: %v", err)
-		return err
-	}
-	buf, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		log.Fatalf("Call Service: %v", err)
-		return err
-	}
-	log.Info("Call Service: \u2713")
-	return utils.OutputJSON(string(buf))
+	return nil
+	// service, err := api.Build(project)
+	// if err != nil {
+	// 	log.Fatalf("Build Service: %v", err)
+	// 	return err
+	// }
+	// log.Info("Build Service: \u2713")
+	//
+	// if err := api.Run(9999, &service); err != nil {
+	// 	log.Fatalf("Run Service: %v", err)
+	// 	return err
+	// }
+	// log.Info("Run Service: \u2713")
+	//
+	// params := utils.PairsToParams(strings.Fields(param))
+	// body, err := json.Marshal(params)
+	// if err != nil {
+	// 	return err
+	// }
+	//
+	// // Wait 2 seconds for service startup
+	// time.Sleep(time.Second * 2)
+	//
+	// url := fmt.Sprintf("http://%s:%d", service.Host, service.Port)
+	// r, err := http.NewRequest("POST", url, bytes.NewReader(body))
+	// if err != nil {
+	// 	return err
+	// }
+	// r.Header.Set("Content-Type", "application/json")
+	// client := &http.Client{Timeout: 20 * time.Second}
+	// resp, err := client.Do(r)
+	// if err != nil {
+	// 	log.Fatalf("Call Service: %v", err)
+	// 	return err
+	// }
+	// buf, err := ioutil.ReadAll(resp.Body)
+	// if err != nil {
+	// 	log.Fatalf("Call Service: %v", err)
+	// 	return err
+	// }
+	// log.Info("Call Service: \u2713")
+	// return utils.OutputJSON(string(buf))
 }

container_runtimes/docker/http/list.go

@@ -1,22 +0,0 @@
-package api
-
-import (
-	"github.com/apex/log"
-	"github.com/metrue/fx/utils"
-)
-
-// List services
-func (api *API) List(name string) error {
-	services, err := api.list(name)
-	if err != nil {
-		log.Fatalf("List Services: %v", err)
-		return err
-	}
-
-	for _, service := range services {
-		if err := utils.OutputJSON(service); err != nil {
-			return err
-		}
-	}
-	return nil
-}

container_runtimes/docker/http/network_test.go

@@ -1,35 +0,0 @@
-package api
-
-import (
-	"testing"
-
-	"github.com/golang/mock/gomock"
-	"github.com/metrue/fx/config"
-	"github.com/metrue/fx/constants"
-	gock "gopkg.in/h2non/gock.v1"
-)
-
-func TestNetwork(t *testing.T) {
-	defer gock.Off()
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-
-	host := config.Host{Host: "127.0.0.1"}
-	api, err := Create(host.Host, constants.AgentPort)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	const network = "fx-net"
-	if err := api.CreateNetwork(network); err != nil {
-		t.Fatal(err)
-	}
-
-	nws, err := api.GetNetwork(network)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if nws[0].Name != network {
-		t.Fatalf("should get %s but got %s", network, nws[0].Name)
-	}
-}

container_runtimes/docker/http/service_build.go

@@ -1,119 +1,59 @@
 package api
 
-import (
-	"bufio"
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"os"
-	"path/filepath"
-	"time"
-
-	"github.com/apex/log"
-	"github.com/google/go-querystring/query"
-	"github.com/google/uuid"
-	"github.com/metrue/fx/types"
-	"github.com/metrue/fx/utils"
-)
-
-func makeTar(project types.Project, tarFilePath string) error {
-	dir, err := ioutil.TempDir("/tmp", "fx-build-dir")
-	if err != nil {
-		return err
-	}
-
-	defer os.RemoveAll(dir)
-
-	for _, file := range project.Files {
-		tmpfn := filepath.Join(dir, file.Path)
-		if err := utils.EnsureFile(tmpfn); err != nil {
-			return err
-		}
-		if err := ioutil.WriteFile(tmpfn, []byte(file.Body), 0666); err != nil {
-			return err
-		}
-	}
-
-	return utils.TarDir(dir, tarFilePath)
-}
-
-// Build build a project
-func (api *API) Build(project types.Project) (types.Service, error) {
-	tarDir, err := ioutil.TempDir("/tmp", "fx-tar")
-	if err != nil {
-		return types.Service{}, err
-	}
-	defer os.RemoveAll(tarDir)
-
-	imageID := uuid.New().String()
-	tarFilePath := filepath.Join(tarDir, fmt.Sprintf("%s.tar", imageID))
-	if err := makeTar(project, tarFilePath); err != nil {
-		return types.Service{}, err
-	}
-	labels := map[string]string{
-		"belong-to": "fx",
-	}
-	if err := api.BuildImage(tarFilePath, imageID, labels); err != nil {
-		return types.Service{}, err
-	}
-
-	return types.Service{
-		Name:  project.Name,
-		Image: imageID,
-	}, nil
-}
-
-// BuildImage build docker image
-func (api *API) BuildImage(tarFile string, tag string, labels map[string]string) error {
-	dockerBuildContext, err := os.Open(tarFile)
-	if err != nil {
-		return err
-	}
-	defer dockerBuildContext.Close()
-
-	type buildQuery struct {
-		Labels     string `url:"labels,omitempty"`
-		Tags       string `url:"t,omitempty"`
-		Dockerfile string `url:"dockerfile,omitempty"`
-	}
-
-	// Apply default labels
-	labelsJSON, _ := json.Marshal(labels)
-	q := buildQuery{
-		Tags:       tag,
-		Labels:     string(labelsJSON),
-		Dockerfile: "Dockerfile",
-	}
-	qs, err := query.Values(q)
-	if err != nil {
-		return err
-	}
-
-	path := "/build"
-	url := fmt.Sprintf("%s%s?%s", api.endpoint, path, qs.Encode())
-	req, err := http.NewRequest("POST", url, dockerBuildContext)
-	if err != nil {
-		return err
-	}
-
-	req.Header.Set("Content-Type", "application/x-tar")
-	client := &http.Client{Timeout: 600 * time.Second}
-	resp, err := client.Do(req)
-	if err != nil {
-		return err
-	}
-
-	defer resp.Body.Close()
-	scanner := bufio.NewScanner(resp.Body)
-
-	for scanner.Scan() {
-		if os.Getenv("DEBUG") != "" {
-			log.Infof(scanner.Text())
-		}
-	}
-	if err := scanner.Err(); err != nil {
-		return err
-	}
-	return nil
-}
+// import (
+// 	"fmt"
+// 	"io/ioutil"
+// 	"os"
+// 	"path/filepath"
+//
+// 	"github.com/google/uuid"
+// 	"github.com/metrue/fx/types"
+// 	"github.com/metrue/fx/utils"
+// )
+//
+// func makeTar(project types.Project, tarFilePath string) error {
+// 	dir, err := ioutil.TempDir("/tmp", "fx-build-dir")
+// 	if err != nil {
+// 		return err
+// 	}
+//
+// 	defer os.RemoveAll(dir)
+//
+// 	for _, file := range project.Files {
+// 		tmpfn := filepath.Join(dir, file.Path)
+// 		if err := utils.EnsureFile(tmpfn); err != nil {
+// 			return err
+// 		}
+// 		if err := ioutil.WriteFile(tmpfn, []byte(file.Body), 0666); err != nil {
+// 			return err
+// 		}
+// 	}
+//
+// 	return utils.TarDir(dir, tarFilePath)
+// }
+//
+// // Build build a project
+// func (api *API) Build(project types.Project) (types.Service, error) {
+// 	tarDir, err := ioutil.TempDir("/tmp", "fx-tar")
+// 	if err != nil {
+// 		return types.Service{}, err
+// 	}
+// 	defer os.RemoveAll(tarDir)
+//
+// 	imageID := uuid.New().String()
+// 	tarFilePath := filepath.Join(tarDir, fmt.Sprintf("%s.tar", imageID))
+// 	if err := makeTar(project, tarFilePath); err != nil {
+// 		return types.Service{}, err
+// 	}
+// 	labels := map[string]string{
+// 		"belong-to": "fx",
+// 	}
+// 	if err := api.BuildImage(tarFilePath, imageID, labels); err != nil {
+// 		return types.Service{}, err
+// 	}
+//
+// 	return types.Service{
+// 		Name:  project.Name,
+// 		Image: imageID,
+// 	}, nil
+// }

container_runtimes/docker/http/service_build_test.go

@@ -1,166 +1,82 @@
 package api
 
-import (
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/metrue/fx/config"
-	"github.com/metrue/fx/constants"
-	"github.com/metrue/fx/types"
-	gock "gopkg.in/h2non/gock.v1"
-)
-
-func TestMakeTar(t *testing.T) {
-	serviceName := "mock-service-abc"
-	project := types.Project{
-		Name:     serviceName,
-		Language: "node",
-		Files: []types.ProjectSourceFile{
-			types.ProjectSourceFile{
-				Path: "Dockerfile",
-				Body: `
-FROM metrue/fx-node-base
-
-COPY . .
-EXPOSE 3000
-CMD ["node", "app.js"]`,
-				IsHandler: false,
-			},
-			types.ProjectSourceFile{
-				Path: "app.js",
-				Body: `
-const Koa = require('koa');
-const bodyParser = require('koa-bodyparser');
-const func = require('./fx');
-
-const app = new Koa();
-app.use(bodyParser());
-app.use(ctx => {
-  const msg = func(ctx.request.body);
-  ctx.body = msg;
-});
-
-app.listen(3000);`,
-				IsHandler: false,
-			},
-			types.ProjectSourceFile{
-				Path: "fx.js",
-				Body: `
-module.exports = (input) => {
-    return input.a + input.b
-}
-					`,
-				IsHandler: true,
-			},
-		},
-	}
-	tarDir, err := ioutil.TempDir("/tmp", "fx-tar")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tarDir)
-
-	tarFilePath := filepath.Join(tarDir, fmt.Sprintf("%s.tar", serviceName))
-	if err := makeTar(project, tarFilePath); err != nil {
-		t.Fatal(err)
-	}
-
-	file, err := os.Open(tarFilePath)
-	if err != nil {
-		t.Fatal(err)
-	}
-	stat, err := file.Stat()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if stat.Name() != serviceName+".tar" {
-		t.Fatalf("should get %s but got %s", serviceName+".tar", stat.Name())
-	}
-	if stat.Size() <= 0 {
-		t.Fatalf("tarfile invalid: size %d", stat.Size())
-	}
-}
-
-func TestBuild(t *testing.T) {
-	defer gock.Off()
-
-	host := config.Host{Host: "127.0.0.1"}
-	api, err := Create(host.Host, constants.AgentPort)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	url := "http://" + host.Host + ":" + constants.AgentPort
-	gock.New(url).
-		Post("/v" + api.version + "/build").
-		AddMatcher(func(req *http.Request, ereq *gock.Request) (bool, error) {
-			if strings.Contains(req.URL.String(), "/v"+api.version+"/build") {
-				return true, nil
-			}
-			return false, nil
-		}).
-		Reply(200).
-		JSON(map[string]string{
-			"stream": "Step 1/5...",
-		})
-
-	serviceName := "mock-service-abc"
-	project := types.Project{
-		Name:     serviceName,
-		Language: "node",
-		Files: []types.ProjectSourceFile{
-			types.ProjectSourceFile{
-				Path: "Dockerfile",
-				Body: `
-FROM metrue/fx-node-base
-
-COPY . .
-EXPOSE 3000
-CMD ["node", "app.js"]`,
-				IsHandler: false,
-			},
-			types.ProjectSourceFile{
-				Path: "app.js",
-				Body: `
-const Koa = require('koa');
-const bodyParser = require('koa-bodyparser');
-const func = require('./fx');
-
-const app = new Koa();
-app.use(bodyParser());
-app.use(ctx => {
-  const msg = func(ctx.request.body);
-  ctx.body = msg;
-});
-
-app.listen(3000);`,
-				IsHandler: false,
-			},
-			types.ProjectSourceFile{
-				Path: "fx.js",
-				Body: `
-module.exports = (input) => {
-    return input.a + input.b
-}
-					`,
-				IsHandler: true,
-			},
-		},
-	}
-
-	service, err := api.Build(project)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if service.Name != serviceName {
-		t.Fatalf("should get %s but got %s", serviceName, service.Name)
-	}
-	if service.Image == "" {
-		t.Fatal("service image should not be empty")
-	}
-}
+// import (
+// 	"fmt"
+// 	"io/ioutil"
+// 	"os"
+// 	"path/filepath"
+// 	"testing"
+//
+// 	"github.com/metrue/fx/types"
+// )
+//
+// func TestMakeTar(t *testing.T) {
+// 	serviceName := "mock-service-abc"
+// 	project := types.Project{
+// 		Name:     serviceName,
+// 		Language: "node",
+// 		Files: []types.ProjectSourceFile{
+// 			types.ProjectSourceFile{
+// 				Path: "Dockerfile",
+// 				Body: `
+// FROM metrue/fx-node-base
+//
+// COPY . .
+// EXPOSE 3000
+// CMD ["node", "app.js"]`,
+// 				IsHandler: false,
+// 			},
+// 			types.ProjectSourceFile{
+// 				Path: "app.js",
+// 				Body: `
+// const Koa = require('koa');
+// const bodyParser = require('koa-bodyparser');
+// const func = require('./fx');
+//
+// const app = new Koa();
+// app.use(bodyParser());
+// app.use(ctx => {
+//   const msg = func(ctx.request.body);
+//   ctx.body = msg;
+// });
+//
+// app.listen(3000);`,
+// 				IsHandler: false,
+// 			},
+// 			types.ProjectSourceFile{
+// 				Path: "fx.js",
+// 				Body: `
+// module.exports = (input) => {
+//     return input.a + input.b
+// }
+// 					`,
+// 				IsHandler: true,
+// 			},
+// 		},
+// 	}
+// 	tarDir, err := ioutil.TempDir("/tmp", "fx-tar")
+// 	if err != nil {
+// 		t.Fatal(err)
+// 	}
+// 	defer os.RemoveAll(tarDir)
+//
+// 	tarFilePath := filepath.Join(tarDir, fmt.Sprintf("%s.tar", serviceName))
+// 	if err := makeTar(project, tarFilePath); err != nil {
+// 		t.Fatal(err)
+// 	}
+//
+// 	file, err := os.Open(tarFilePath)
+// 	if err != nil {
+// 		t.Fatal(err)
+// 	}
+// 	stat, err := file.Stat()
+// 	if err != nil {
+// 		t.Fatal(err)
+// 	}
+// 	if stat.Name() != serviceName+".tar" {
+// 		t.Fatalf("should get %s but got %s", serviceName+".tar", stat.Name())
+// 	}
+// 	if stat.Size() <= 0 {
+// 		t.Fatalf("tarfile invalid: size %d", stat.Size())
+// 	}
+// }

container_runtimes/docker/http/service_run_test.go

@@ -1,55 +0,0 @@
-package api
-
-import (
-	"net/http"
-	"testing"
-
-	"github.com/golang/mock/gomock"
-	"github.com/metrue/fx/config"
-	"github.com/metrue/fx/constants"
-	"github.com/metrue/fx/types"
-
-	gock "gopkg.in/h2non/gock.v1"
-)
-
-func TestServiceRun(t *testing.T) {
-	defer gock.Off()
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-
-	host := config.Host{Host: "127.0.0.1"}
-	api, err := Create(host.Host, constants.AgentPort)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	service := types.Service{
-		Name:  "a-mock-service",
-		Image: "a-mock-image-id",
-	}
-
-	mockContainerID := "mock-container-id"
-	url := "http://" + host.Host + ":" + constants.AgentPort
-	gock.New(url).
-		Post("/v0.2.1/containers").
-		AddMatcher(func(req *http.Request, ereq *gock.Request) (m bool, e error) {
-			// TODO multiple matching not supported by gock
-			if req.URL.String() == url+"/v0.2.1/containers/"+mockContainerID+"/start" {
-				return true, nil
-			} else if req.URL.String() == url+"/v0.2.1/containers/create?name="+service.Name {
-				return true, nil
-			}
-
-			return false, nil
-		}).
-		Reply(201).
-		JSON(map[string]interface{}{
-			"Id":       mockContainerID,
-			"Warnings": []string{},
-		})
-
-	// FIXME
-	if err := api.Run(9999, &service); err == nil {
-		t.Fatal(err)
-	}
-}

container_runtimes/docker/http/stop_test.go

@@ -1,39 +0,0 @@
-package api
-
-import (
-	"net/http"
-	"strings"
-	"testing"
-
-	"github.com/golang/mock/gomock"
-	"github.com/metrue/fx/config"
-	"github.com/metrue/fx/constants"
-	gock "gopkg.in/h2non/gock.v1"
-)
-
-func TestStop(t *testing.T) {
-	defer gock.Off()
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-
-	host := config.Host{Host: "127.0.0.1"}
-	api, err := Create(host.Host, constants.AgentPort)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	mockServiceName := "mock-service-name"
-	url := "http://" + host.Host + ":" + constants.AgentPort
-	gock.New(url).
-		Post("/v" + api.version + "/containers/" + mockServiceName + "/stop").
-		AddMatcher(func(req *http.Request, ereq *gock.Request) (m bool, e error) {
-			if strings.Contains(req.URL.String(), "/v"+api.version+"/containers/"+mockServiceName+"/stop") {
-				return true, nil
-			}
-			return false, nil
-		}).
-		Reply(204)
-	if err := api.Stop(mockServiceName); err != nil {
-		t.Fatal(err)
-	}
-}

container_runtimes/docker/http/up.go

@@ -1,81 +1,71 @@
 package api
 
-import (
-	"context"
-	"time"
-
-	"github.com/apex/log"
-	"github.com/docker/docker/api/types/container"
-	"github.com/metrue/fx/constants"
-	"github.com/metrue/fx/types"
-)
-
-// UpOptions options for up
-type UpOptions struct {
-	Body       []byte
-	Lang       string
-	Name       string
-	Port       int
-	HealtCheck bool
-	Project    types.Project
-}
-
-// Up up a source code of function to be a service
-func (api *API) Up(opt UpOptions) error {
-	service, err := api.Build(opt.Project)
-	if err != nil {
-		log.Fatalf("Build Service %s: %v", opt.Name, err)
-		return err
-	}
-	log.Infof("Build Service %s: %s", opt.Name, constants.CheckedSymbol)
-
-	if err := api.Run(opt.Port, &service); err != nil {
-		log.Fatalf("Run Service: %v", err)
-		return err
-	}
-	log.Infof("Run Service: %s", constants.CheckedSymbol)
-	log.Infof("Service (%s) is running on: %s:%d", service.Name, service.Host, service.Port)
-
-	if opt.HealtCheck {
-		go func() {
-			resultC, errC := api.ContainerWait(
-				context.Background(),
-				service.ID,
-				container.WaitConditionNextExit,
-				20*time.Second,
-			)
-			for {
-				select {
-				case res := <-resultC:
-					var msg string
-					if res.Error != nil {
-						msg = res.Error.Message
-					}
-					log.Warnf("container exited: Code(%d) %s %s", res.StatusCode, msg, constants.UncheckedSymbol)
-				case err := <-errC:
-					log.Fatalf("wait container status exit: %s, %v", constants.UncheckedSymbol, err)
-				}
-			}
-		}()
-
-		trys := 0
-		for {
-			if trys > 2 {
-				break
-			}
-			info, err := api.inspect(service.ID)
-			if err != nil {
-				log.Fatalf("healt checking failed: %v", err)
-			}
-			if info.State.Running {
-				log.Info("service is running")
-			} else {
-				log.Warnf("service is %s", info.State.Status)
-			}
-			time.Sleep(1 * time.Second)
-			trys++
-		}
-	}
-
-	return nil
-}
+// // UpOptions options for up
+// type UpOptions struct {
+// 	Body       []byte
+// 	Lang       string
+// 	Name       string
+// 	Port       int
+// 	HealtCheck bool
+// 	Project    types.Project
+// }
+//
+// // Up up a source code of function to be a service
+// func (api *API) Up(opt UpOptions) error {
+// 	service, err := api.Build(opt.Project)
+// 	if err != nil {
+// 		log.Fatalf("Build Service %s: %v", opt.Name, err)
+// 		return err
+// 	}
+// 	log.Infof("Build Service %s: %s", opt.Name, constants.CheckedSymbol)
+//
+// 	if err := api.Run(opt.Port, &service); err != nil {
+// 		log.Fatalf("Run Service: %v", err)
+// 		return err
+// 	}
+// 	log.Infof("Run Service: %s", constants.CheckedSymbol)
+// 	log.Infof("Service (%s) is running on: %s:%d", service.Name, service.Host, service.Port)
+//
+// 	if opt.HealtCheck {
+// 		go func() {
+// 			resultC, errC := api.ContainerWait(
+// 				context.Background(),
+// 				service.ID,
+// 				container.WaitConditionNextExit,
+// 				20*time.Second,
+// 			)
+// 			for {
+// 				select {
+// 				case res := <-resultC:
+// 					var msg string
+// 					if res.Error != nil {
+// 						msg = res.Error.Message
+// 					}
+// 					log.Warnf("container exited: Code(%d) %s %s", res.StatusCode, msg, constants.UncheckedSymbol)
+// 				case err := <-errC:
+// 					log.Fatalf("wait container status exit: %s, %v", constants.UncheckedSymbol, err)
+// 				}
+// 			}
+// 		}()
+//
+// 		trys := 0
+// 		for {
+// 			if trys > 2 {
+// 				break
+// 			}
+// 			info, err := api.inspect(service.ID)
+// 			if err != nil {
+// 				log.Fatalf("healt checking failed: %v", err)
+// 			}
+// 			if info.State.Running {
+// 				log.Info("service is running")
+// 			} else {
+// 				log.Warnf("service is %s", info.State.Status)
+// 			}
+// 			time.Sleep(1 * time.Second)
+// 			trys++
+// 		}
+// 	}
+//
+// 	return nil
+// }

container_runtimes/docker/sdk/docker.go

@@ -9,13 +9,16 @@ import (
 	"io/ioutil"
 	"os"
 	"path/filepath"
+	"strings"
 
 	"github.com/apex/log"
 	dockerTypes "github.com/docker/docker/api/types"
 	dockerTypesContainer "github.com/docker/docker/api/types/container"
+	dockerFilters "github.com/docker/docker/api/types/filters"
 	"github.com/docker/docker/client"
 	"github.com/docker/go-connections/nat"
 	"github.com/google/uuid"
+	fxConfig "github.com/metrue/fx/config"
 	containerruntimes "github.com/metrue/fx/container_runtimes"
 	"github.com/metrue/fx/types"
 	"github.com/metrue/fx/utils"
@@ -74,7 +77,9 @@ func (d *Docker) BuildImage(ctx context.Context, workdir string, name string) er
 	if err != nil {
 		return err
 	}
-	log.Info(string(body))
+	if os.Getenv("DEBUG") != "" {
+		log.Info(string(body))
+	}
 
 	return nil
 }
@@ -131,6 +136,11 @@ func (d *Docker) InspectImage(ctx context.Context, name string, img interface{})
 	return json.NewDecoder(rdr).Decode(&img)
 }
 
+// TagImage tag image
+func (d *Docker) TagImage(ctx context.Context, name string, tag string) error {
+	return d.ImageTag(ctx, name, tag)
+}
+
 // StartContainer create and start a container from given image
 func (d *Docker) StartContainer(ctx context.Context, name string, image string, ports []types.PortBinding) error {
 	portSet := nat.PortSet{}
@@ -152,7 +162,7 @@ func (d *Docker) StartContainer(ctx context.Context, name string, image string,
 	}
 
 	hostConfig := &dockerTypesContainer.HostConfig{
-		AutoRemove:   true,
+		AutoRemove:   !fxConfig.DisableContainerAutoremove,
 		PortBindings: portMap,
 	}
 	resp, err := d.ContainerCreate(ctx, config, hostConfig, nil, name)
@@ -180,7 +190,59 @@ func (d *Docker) StopContainer(ctx context.Context, name string) error {
 
 // InspectContainer inspect a container
 func (d *Docker) InspectContainer(ctx context.Context, name string, container interface{}) error {
-	return nil
+	res, err := d.ContainerInspect(ctx, name)
+	if err != nil {
+		return err
+	}
+
+	body, err := json.Marshal(res)
+	if err != nil {
+		return err
+	}
+	return json.Unmarshal(body, &container)
+}
+
+// ListContainer list containers
+func (d *Docker) ListContainer(ctx context.Context, name string) ([]types.Service, error) {
+	args := dockerFilters.NewArgs(
+		dockerFilters.Arg("label", "belong-to=fx"),
+	)
+	containers, err := d.ContainerList(ctx, dockerTypes.ContainerListOptions{
+		Filters: args,
+	})
+	if err != nil {
+		return []types.Service{}, err
+	}
+
+	svs := make(map[string]types.Service)
+	for _, container := range containers {
+		// container name have extra forward slash
+		// https://github.com/moby/moby/issues/6705
+		if strings.HasPrefix(container.Names[0], fmt.Sprintf("/%s", name)) {
+			svs[container.Image] = types.Service{
+				Name:  container.Names[0],
+				Image: container.Image,
+				ID:    container.ID,
+				Host:  container.Ports[0].IP,
+				Port:  int(container.Ports[0].PublicPort),
+				State: container.State,
+			}
+		}
+	}
+	services := []types.Service{}
+	for _, s := range svs {
+		services = append(services, s)
+	}
+	return services, nil
+}
+
+// Version get version of docker engine
+func (d *Docker) Version(ctx context.Context) (string, error) {
+	ping, err := d.Ping(ctx)
+	if err != nil {
+		return "", err
+	}
+	return ping.APIVersion, nil
 }
 
 var (

container_runtimes/docker/sdk/docker_test.go

@@ -8,6 +8,7 @@ import (
 	"time"
 
 	dockerTypes "github.com/docker/docker/api/types"
+	"github.com/metrue/fx/types"
 )
 
 func TestDocker(t *testing.T) {
@@ -42,6 +43,23 @@ func TestDocker(t *testing.T) {
 		t.Fatalf("should have built image with tag %s", name)
 	}
 
+	if err := cli.StartContainer(ctx, name, name, []types.PortBinding{
+		types.PortBinding{
+			ServiceBindingPort:  9000,
+			ContainerExposePort: 3000,
+		},
+	}); err != nil {
+		t.Fatal(err)
+	}
+
+	var container dockerTypes.ContainerJSON
+	if err := cli.InspectContainer(ctx, name, &container); err != nil {
+		t.Fatal(err)
+	}
+	if container.Name != "/"+name {
+		t.Fatalf("should get %s but got %s", "/"+name, container.Name)
+	}
+
 	username := os.Getenv("DOCKER_USERNAME")
 	password := os.Getenv("DOCKER_PASSWORD")
 	if username == "" || password == "" {

container_runtimes/mocks/runtime.go

@@ -0,0 +1,164 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: runtimes.go
+
+// Package mock_containerruntimes is a generated GoMock package.
+package mock_containerruntimes
+
+import (
+	context "context"
+	gomock "github.com/golang/mock/gomock"
+	types "github.com/metrue/fx/types"
+	reflect "reflect"
+)
+
+// MockContainerRuntime is a mock of ContainerRuntime interface
+type MockContainerRuntime struct {
+	ctrl     *gomock.Controller
+	recorder *MockContainerRuntimeMockRecorder
+}
+
+// MockContainerRuntimeMockRecorder is the mock recorder for MockContainerRuntime
+type MockContainerRuntimeMockRecorder struct {
+	mock *MockContainerRuntime
+}
+
+// NewMockContainerRuntime creates a new mock instance
+func NewMockContainerRuntime(ctrl *gomock.Controller) *MockContainerRuntime {
+	mock := &MockContainerRuntime{ctrl: ctrl}
+	mock.recorder = &MockContainerRuntimeMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockContainerRuntime) EXPECT() *MockContainerRuntimeMockRecorder {
+	return m.recorder
+}
+
+// BuildImage mocks base method
+func (m *MockContainerRuntime) BuildImage(ctx context.Context, workdir, name string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "BuildImage", ctx, workdir, name)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// BuildImage indicates an expected call of BuildImage
+func (mr *MockContainerRuntimeMockRecorder) BuildImage(ctx, workdir, name interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildImage", reflect.TypeOf((*MockContainerRuntime)(nil).BuildImage), ctx, workdir, name)
+}
+
+// PushImage mocks base method
+func (m *MockContainerRuntime) PushImage(ctx context.Context, name string) (string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PushImage", ctx, name)
+	ret0, _ := ret[0].(string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PushImage indicates an expected call of PushImage
+func (mr *MockContainerRuntimeMockRecorder) PushImage(ctx, name interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PushImage", reflect.TypeOf((*MockContainerRuntime)(nil).PushImage), ctx, name)
+}
+
+// InspectImage mocks base method
+func (m *MockContainerRuntime) InspectImage(ctx context.Context, name string, img interface{}) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "InspectImage", ctx, name, img)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// InspectImage indicates an expected call of InspectImage
+func (mr *MockContainerRuntimeMockRecorder) InspectImage(ctx, name, img interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InspectImage", reflect.TypeOf((*MockContainerRuntime)(nil).InspectImage), ctx, name, img)
+}
+
+// TagImage mocks base method
+func (m *MockContainerRuntime) TagImage(ctx context.Context, name, tag string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TagImage", ctx, name, tag)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// TagImage indicates an expected call of TagImage
+func (mr *MockContainerRuntimeMockRecorder) TagImage(ctx, name, tag interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagImage", reflect.TypeOf((*MockContainerRuntime)(nil).TagImage), ctx, name, tag)
+}
+
+// StartContainer mocks base method
+func (m *MockContainerRuntime) StartContainer(ctx context.Context, name, image string, bindings []types.PortBinding) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "StartContainer", ctx, name, image, bindings)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// StartContainer indicates an expected call of StartContainer
+func (mr *MockContainerRuntimeMockRecorder) StartContainer(ctx, name, image, bindings interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartContainer", reflect.TypeOf((*MockContainerRuntime)(nil).StartContainer), ctx, name, image, bindings)
+}
+
+// StopContainer mocks base method
+func (m *MockContainerRuntime) StopContainer(ctx context.Context, name string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "StopContainer", ctx, name)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// StopContainer indicates an expected call of StopContainer
+func (mr *MockContainerRuntimeMockRecorder) StopContainer(ctx, name interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopContainer", reflect.TypeOf((*MockContainerRuntime)(nil).StopContainer), ctx, name)
+}
+
+// InspectContainer mocks base method
+func (m *MockContainerRuntime) InspectContainer(ctx context.Context, name string, container interface{}) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "InspectContainer", ctx, name, container)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// InspectContainer indicates an expected call of InspectContainer
+func (mr *MockContainerRuntimeMockRecorder) InspectContainer(ctx, name, container interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InspectContainer", reflect.TypeOf((*MockContainerRuntime)(nil).InspectContainer), ctx, name, container)
+}
+
+// ListContainer mocks base method
+func (m *MockContainerRuntime) ListContainer(ctx context.Context, filter string) ([]types.Service, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListContainer", ctx, filter)
+	ret0, _ := ret[0].([]types.Service)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListContainer indicates an expected call of ListContainer
+func (mr *MockContainerRuntimeMockRecorder) ListContainer(ctx, filter interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContainer", reflect.TypeOf((*MockContainerRuntime)(nil).ListContainer), ctx, filter)
+}
+
+// Version mocks base method
+func (m *MockContainerRuntime) Version(ctx context.Context) (string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Version", ctx)
+	ret0, _ := ret[0].(string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Version indicates an expected call of Version
+func (mr *MockContainerRuntimeMockRecorder) Version(ctx interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*MockContainerRuntime)(nil).Version), ctx)
+}