Point to instructions to build from source for non-x86 targets (#350)

* Fix typos
* Point to instructions to build from source for non-x86 targets

Installation instructions do not specify clearly enough the fact that
they are supported only on x86. Make it clearer and point to the Build
and Test section in Contribute for instructions on building fx.

.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

@@ -17,6 +17,11 @@ jobs:
         run: |
           ./scripts/provision.sh
 
+      - name: lint
+        run: |
+          docker run --rm -v $(pwd):/app -w /app golangci/golangci-lint \
+          golangci-lint run -v
+
       - name: setup k8s and kind
         run: |
           export GOBIN=$(go env GOPATH)/bin
@@ -33,7 +38,13 @@ jobs:
           DOCKER_USERNAME: ${{ secrets.DOCKER_USERNAME }}
         run: |
           export KUBECONFIG=/home/runner/.kube/kind-config-fx-test
-          DEBUG=true go test -v ./container_runtimes/... ./deploy/...
+          DEBUG=true go test -v ./...
+      - name: code cov
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+        run: |
+          ./scripts/coverage.sh
+          bash <(curl -s https://codecov.io/bash) -t ${CODECOV_TOKEN}
 
       - name: build fx
         run: |
@@ -47,15 +58,11 @@ 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

.github/workflows/release.yml

@@ -22,6 +22,11 @@ jobs:
         run: |
           ./scripts/provision.sh
 
+      - name: lint
+        run: |
+          docker run --rm -v $(pwd):/app -w /app golangci/golangci-lint \
+          golangci-lint run -v
+
       - name: setup k8s and kind
         run: |
           export GOBIN=$(go env GOPATH)/bin
@@ -44,14 +49,6 @@ jobs:
         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

Makefile

@@ -7,6 +7,9 @@ lint:
 generate:
 	packr
 
+b:
+	go build -o ${OUTPUT_DIR}/fx fx.go
+
 build:
 	go build -o ${OUTPUT_DIR}/fx fx.go
 
@@ -24,7 +27,11 @@ unit-test:
 	./scripts/coverage.sh
 
 cli-test:
+	echo 'run testing on localhost'
 	./scripts/test_cli.sh
+	# TODO enable remote test
+	echo 'run testing on remote host'
+	DOCKER_REMOTE_HOST_ADDR=${REMOTE_HOST_ADDR} DOCKER_REMOTE_HOST_USER=${REMOTE_HOST_USER} DOCKER_REMOTE_HOST_PASSWORD=${REMOTE_HOST_PASSWORD} ./scripts/test_cli.sh
 
 http-test:
 	./scripts/http_test.sh

README.md

@@ -2,9 +2,8 @@ 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)
+[![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)
@@ -19,7 +18,9 @@ Poor man's function as a service.
 
 ## 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.
+![workflow](https://raw.githubusercontent.com/metrue/fx/master/docs/fx-workflow.png)
+
+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.
 
@@ -39,6 +40,8 @@ Feel free hacking fx to support the languages not listed. Welcome to tweet me [@
 
 # 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,9 +61,9 @@ 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;
 
@@ -76,16 +79,16 @@ USAGE:
    fx [global options] command [command options] [arguments...]
 
 VERSION:
-   0.6.0
+   0.8.1
 
 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
+   init      start fx agent on host
+   up        deploy a function
    down      destroy a service
    list, ls  list deployed services
    call      run a function instantly
+   image     manage image of service
+   doctor    health check for fx
    help, h   Shows a list of commands or help for one command
 
 GLOBAL OPTIONS:
@@ -93,62 +96,7 @@ GLOBAL OPTIONS:
    --version, -v  print the version
 ```
 
-1. List your current machines and activate you machine
-
-```shell
-$ fx infra ls     # list machines
-
-{
-	"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
+1. 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:
 
@@ -159,7 +107,7 @@ module.exports = (ctx) => {
 ```
 Then save it to a file `func.js`.
 
-3. Deploy your function as a service
+2. Deploy your function as a service
 
 Give your service a port with `--port`, and name with `--name`, heath checking with `--healthcheck` if you want.
 
@@ -180,7 +128,7 @@ $ fx image export -o <path of dir> func.js
 2019/09/25 19:31:19  info exported to <path of dir>: ✓
 ```
 
-4. Test your service
+3. Test your service
 
 then you can test your service:
 
@@ -209,7 +157,12 @@ hello world
 
 ## Docker
 
-  TODO
+**fx** is originally designed to turn a function into a runnable Docker container in a easiest way, on a host with Docker running, you can just deploy your function with `fx up` command,
+
+```shell
+fx up --name hello-svc --port 7777 hello.js # onto localhost
+DOCKER_REMOTE_HOST_ADDR=xx.xx.xx.xx DOCKER_REMOTE_HOST_USER=xxxx DOCKER_REMOTE_HOST_PASSWORD=xxxx fx up --name hello-svc --port 7777 hello.js # onto remote host
+```
 
 ## Kubernetes
 
@@ -278,6 +231,7 @@ fx uses [Project](https://github.com/metrue/fx/projects/4) to manage the develop
 Docker: make sure [Docker](https://docs.docker.com/engine/installation/) installed and running on your server.
 
 
+<a name="buildtest"></a>
 #### Build & Test
 
 ```

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/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)
-}

container_runtimes/docker/http/api.go

@@ -1,19 +1,32 @@
 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"
+	dockerTypesContainer "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"
+	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
@@ -116,8 +129,8 @@ 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) {
+// 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 +154,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"`
 	}
@@ -193,3 +206,222 @@ 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 := &dockerTypesContainer.Config{
+		Image:        image,
+		ExposedPorts: portSet,
+	}
+
+	hostConfig := &dockerTypesContainer.HostConfig{
+		AutoRemove:   true,
+		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")
+	}
+
+	log.Infof("container %s created", name)
+
+	// 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)
+	}
+	log.Infof("container %s started", name)
+
+	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 {
+	return nil
+}
+
+var (
+	_ containerruntimes.ContainerRuntime = &API{}
+)

container_runtimes/docker/http/api_test.go

@@ -1,89 +1,111 @@
 package api
 
-import (
-	"testing"
-
-	"github.com/metrue/fx/config"
-	"github.com/metrue/fx/constants"
-	"github.com/metrue/fx/types"
-)
-
-func TestDockerHTTP(t *testing.T) {
-	host := config.Host{Host: "127.0.0.1"}
-	api, err := Create(host.Host, constants.AgentPort)
-	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 {
-		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)
-	}
-}
+// func TestDockerHTTP(t *testing.T) {
+// 	const addr = "127.0.0.1"
+// 	const user = ""
+// 	const passord = ""
+// 	provisioner := provision.NewWithHost(addr, user, passord)
+// 	if err := utils.RunWithRetry(func() error {
+// 		if !provisioner.IsFxAgentRunning() {
+// 			if err := provisioner.StartFxAgent(); err != nil {
+// 				log.Infof("could not start fx agent on host: %s", err)
+// 				return err
+// 			}
+// 			log.Infof("fx agent started")
+// 		} else {
+// 			log.Infof("fx agent is running")
+// 		}
+// 		return nil
+// 	}, 2*time.Second, 10); err != nil {
+// 		t.Fatal(err)
+// 	} else {
+// 		defer provisioner.StopFxAgent()
+// 	}
+//
+// 	host := config.Host{Host: "127.0.0.1"}
+// 	api, err := Create(host.Host, constants.AgentPort)
+// 	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 {
+// 		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.ListContainer(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)
+// 	}
+//
+// 	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/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,10 +9,12 @@ 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"
@@ -131,6 +133,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{}
@@ -183,6 +190,40 @@ func (d *Docker) InspectContainer(ctx context.Context, name string, container in
 	return nil
 }
 
+// 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
+}
+
 var (
 	_ containerruntimes.ContainerRuntime = &Docker{}
 )

container_runtimes/runtimes.go

@@ -10,8 +10,10 @@ import (
 type ContainerRuntime interface {
 	BuildImage(ctx context.Context, workdir string, name string) error
 	PushImage(ctx context.Context, name string) (string, error)
-	InspectImage(ct context.Context, name string, img interface{}) error
+	InspectImage(ctx context.Context, name string, img interface{}) error
+	TagImage(ctx context.Context, name string, tag string) error
 	StartContainer(ctx context.Context, name string, image string, bindings []types.PortBinding) error
 	StopContainer(ctx context.Context, name string) error
 	InspectContainer(ctx context.Context, name string, container interface{}) error
+	ListContainer(ctx context.Context, filter string) ([]types.Service, error)
 }

context/context.go

@@ -0,0 +1,58 @@
+package context
+
+import (
+	"context"
+
+	"github.com/urfave/cli"
+)
+
+type key string
+
+const (
+	keyCliCtx = key("cmd_cli")
+)
+
+// Context fx context
+type Context struct {
+	context.Context
+}
+
+// NewContext new a context
+func NewContext() *Context {
+	ctx := context.Background()
+	return &Context{ctx}
+}
+
+// FromCliContext create context from cli.Context
+func FromCliContext(c *cli.Context) *Context {
+	ctx := NewContext()
+	ctx.WithCliContext(c)
+	return ctx
+}
+
+// WithCliContext set cli.Context
+func (ctx *Context) WithCliContext(c *cli.Context) {
+	newCtx := context.WithValue(ctx.Context, keyCliCtx, c)
+	ctx.Context = newCtx
+}
+
+// GetCliContext get cli.Context
+func (ctx *Context) GetCliContext() *cli.Context {
+	return ctx.Value(keyCliCtx).(*cli.Context)
+}
+
+// Set a value with name
+func (ctx *Context) Set(name string, value interface{}) {
+	newCtx := context.WithValue(ctx.Context, name, value)
+	ctx.Context = newCtx
+}
+
+// Get a value
+func (ctx *Context) Get(name string) interface{} {
+	return ctx.Context.Value(name)
+}
+
+// Use invole a middle
+func (ctx *Context) Use(fn func(ctx *Context) error) error {
+	return fn(ctx)
+}

context/context_test.go

@@ -0,0 +1,25 @@
+package context
+
+import (
+	"testing"
+
+	"github.com/urfave/cli"
+)
+
+func TestContext(t *testing.T) {
+	ctx := NewContext()
+	cli := cli.NewContext(nil, nil, nil)
+	ctx.WithCliContext(cli)
+	c := ctx.GetCliContext()
+	if c != cli {
+		t.Fatalf("should get %v but got %v", cli, c)
+	}
+
+	key := "k_1"
+	value := "hello"
+	ctx.Set(key, "hello")
+	v := ctx.Get(key).(string)
+	if v != value {
+		t.Fatalf("should get %v but %v", value, v)
+	}
+}

contrib/docker_packer/main.go

@@ -15,9 +15,6 @@ import (
 	"github.com/metrue/fx/utils"
 )
 
-// Version binary version
-var Version = "0.0.1"
-
 func init() {
 	// TODO clean it up
 	os.Setenv("DEBUG", "true")
@@ -43,6 +40,7 @@ docker_packer <encrypt_docker_project_source_tree> <image_name>
 	}
 
 	var tree map[string]string
+	//nolint
 	if err := json.Unmarshal([]byte(str), &tree); err != nil {
 		log.Fatalf("could not unmarshal meta: %s", meta)
 		os.Exit(1)

deploy/deployer.go

@@ -12,4 +12,5 @@ type Deployer interface {
 	Destroy(ctx context.Context, name string) error
 	Update(ctx context.Context, name string) error
 	GetStatus(ctx context.Context, name string) error
+	List(ctx context.Context, name string) ([]types.Service, error)
 }

deploy/docker/docker.go

@@ -8,55 +8,43 @@ import (
 	"time"
 
 	dockerTypes "github.com/docker/docker/api/types"
+	"github.com/metrue/fx/constants"
+	containerruntimes "github.com/metrue/fx/container_runtimes"
 	dockerHTTP "github.com/metrue/fx/container_runtimes/docker/http"
-	runtime "github.com/metrue/fx/container_runtimes/docker/sdk"
+	dockerSDK "github.com/metrue/fx/container_runtimes/docker/sdk"
 	"github.com/metrue/fx/deploy"
 	"github.com/metrue/fx/packer"
 	"github.com/metrue/fx/types"
 	"github.com/metrue/fx/utils"
-	"github.com/pkg/errors"
 )
 
 // Docker manage container
 type Docker struct {
-	localClient *runtime.Docker
+	cli containerruntimes.ContainerRuntime
 }
 
 // CreateClient create a docker instance
-func CreateClient(ctx context.Context) (*Docker, error) {
-	cli, err := runtime.CreateClient(ctx)
-	if err != nil {
-		return nil, err
+func CreateClient(ctx context.Context) (d *Docker, err error) {
+	var cli containerruntimes.ContainerRuntime
+	host := os.Getenv("DOCKER_REMOTE_HOST_ADDR")
+	user := os.Getenv("DOCKER_REMOTE_HOST_USER")
+	if host != "" && user != "" {
+		cli, err = dockerHTTP.Create(host, constants.AgentPort)
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		cli, err = dockerSDK.CreateClient(ctx)
+		if err != nil {
+			return nil, err
+		}
 	}
-	return &Docker{localClient: cli}, nil
+
+	return &Docker{cli: cli}, nil
 }
 
 // Deploy create a Docker container from given image, and bind the constants.FxContainerExposePort to given port
 func (d *Docker) Deploy(ctx context.Context, fn types.Func, name string, ports []types.PortBinding) error {
-	// if DOCKER_REMOTE_HOST and DOCKER_REMOTE_PORT given
-	// it means user is going to deploy service to remote host
-	host := os.Getenv("DOCKER_REMOTE_HOST")
-	port := os.Getenv("DOCKER_REMOTE_PORT")
-	if port != "" && host != "" {
-		httpClient, err := dockerHTTP.Create(host, port)
-		if err != nil {
-			return err
-		}
-
-		project, err := packer.Pack(name, fn)
-		if err != nil {
-			return errors.Wrapf(err, "could pack function %v (%s)", name, fn)
-		}
-		return httpClient.Up(dockerHTTP.UpOptions{
-			Body:       []byte(fn.Source),
-			Lang:       fn.Language,
-			Name:       name,
-			Port:       int(ports[0].ServiceBindingPort),
-			HealtCheck: false,
-			Project:    project,
-		})
-	}
-
 	workdir := fmt.Sprintf("/tmp/fx-%d", time.Now().Unix())
 	defer os.RemoveAll(workdir)
 
@@ -64,13 +52,14 @@ func (d *Docker) Deploy(ctx context.Context, fn types.Func, name string, ports [
 		log.Fatalf("could not pack function %v: %v", fn, err)
 		return err
 	}
-	if err := d.localClient.BuildImage(ctx, workdir, name); err != nil {
+
+	if err := d.cli.BuildImage(ctx, workdir, name); err != nil {
 		log.Fatalf("could not build image: %v", err)
 		return err
 	}
 
 	nameWithTag := name + ":latest"
-	if err := d.localClient.ImageTag(ctx, name, nameWithTag); err != nil {
+	if err := d.cli.TagImage(ctx, name, nameWithTag); err != nil {
 		log.Fatalf("could not tag image: %v", err)
 		return err
 	}
@@ -81,12 +70,12 @@ func (d *Docker) Deploy(ctx context.Context, fn types.Func, name string, ports [
 	// But it takes some times waiting image ready after image built, we retry to make sure it ready here
 	var imgInfo dockerTypes.ImageInspect
 	if err := utils.RunWithRetry(func() error {
-		return d.localClient.InspectImage(ctx, name, &imgInfo)
+		return d.cli.InspectImage(ctx, name, &imgInfo)
 	}, time.Second*1, 5); err != nil {
 		return err
 	}
 
-	return d.localClient.StartContainer(ctx, name, name, ports)
+	return d.cli.StartContainer(ctx, name, name, ports)
 }
 
 // Update a container
@@ -96,7 +85,7 @@ func (d *Docker) Update(ctx context.Context, name string) error {
 
 // Destroy stop and remove container
 func (d *Docker) Destroy(ctx context.Context, name string) error {
-	return d.localClient.ContainerStop(ctx, name, nil)
+	return d.cli.StopContainer(ctx, name)
 }
 
 // GetStatus get status of container
@@ -104,6 +93,12 @@ func (d *Docker) GetStatus(ctx context.Context, name string) error {
 	return nil
 }
 
+// List services
+func (d *Docker) List(ctx context.Context, name string) ([]types.Service, error) {
+	// FIXME support remote host
+	return d.cli.ListContainer(ctx, name)
+}
+
 var (
 	_ deploy.Deployer = &Docker{}
 )

deploy/kubernetes/kubernetes.go

@@ -131,6 +131,11 @@ func (k *K8S) GetStatus(ctx context.Context, name string) error {
 	return nil
 }
 
+// List services
+func (k *K8S) List(ctx context.Context, name string) ([]types.Service, error) {
+	return []types.Service{}, nil
+}
+
 var (
 	_ deploy.Deployer = &K8S{}
 )

docs/lightsail.yml

@@ -0,0 +1,16 @@
+# fx on Amazon Lightsai
+
+* make sure your instance have docker installed and running,
+* make sure your instance can be ssh login (with user and password)
+
+```
+ssh <user>@<host>
+```
+
+* make sure your instance accept port 8866
+
+* then you can deploy function to remote host
+
+```
+DOCKER_REMOTE_HOST_ADDR=<your host> DOCKER_REMOTE_HOST_USER=<your user> DOCKER_REMOTE_HOST_PASSWORD=<your password> ./build/fx up -p 1234 test/functions/func.js
+```

doctor/doctor.go

@@ -2,7 +2,6 @@ package doctor
 
 import (
 	"github.com/apex/log"
-	"github.com/metrue/fx/config"
 	"github.com/metrue/fx/constants"
 	"github.com/metrue/fx/pkg/command"
 	"github.com/metrue/go-ssh-client"
@@ -10,16 +9,23 @@ import (
 
 // Doctor health checking
 type Doctor struct {
-	host config.Host
+	host string
 
 	sshClient ssh.Client
 }
 
+func isLocal(host string) bool {
+	if host == "" {
+		return false
+	}
+	return host == "127.0.0.1" || host == "localhost" || host == "0.0.0.0"
+}
+
 // New a doctor
-func New(host config.Host) *Doctor {
-	sshClient := ssh.New(host.Host).
-		WithUser(host.User).
-		WithPassword(host.Password)
+func New(host, user, password string) *Doctor {
+	sshClient := ssh.New(host).
+		WithUser(user).
+		WithPassword(password)
 	return &Doctor{
 		host:      host,
 		sshClient: sshClient,
@@ -32,7 +38,7 @@ func (d *Doctor) Start() error {
 	checkAgent := "docker inspect " + constants.AgentContainerName
 
 	cmds := []*command.Command{}
-	if d.host.IsRemote() {
+	if !isLocal(d.host) {
 		cmds = append(cmds,
 			command.New("check if dockerd is running", checkDocker, command.NewRemoteRunner(d.sshClient)),
 			command.New("check if fx agent is running", checkAgent, command.NewRemoteRunner(d.sshClient)),

fx.go

@@ -5,29 +5,20 @@ import (
 	"fmt"
 	"net/http"
 	"os"
-	"path"
 	"regexp"
 
 	"github.com/apex/log"
 	"github.com/google/uuid"
-	"github.com/metrue/fx/config"
+	"github.com/metrue/fx/context"
 	"github.com/metrue/fx/handlers"
+	"github.com/metrue/fx/middlewares"
 	"github.com/urfave/cli"
 )
 
-const version = "0.8.0"
-
-var cfg *config.Config
+const version = "0.8.1"
 
 func init() {
 	go checkForUpdate()
-	configDir := path.Join(os.Getenv("HOME"), ".fx")
-	cfg := config.New(configDir)
-
-	if err := cfg.Init(); err != nil {
-		log.Fatalf("Init config failed %s", err)
-		os.Exit(1)
-	}
 }
 
 func checkForUpdate() {
@@ -67,107 +58,15 @@ func main() {
 
 	app.Commands = []cli.Command{
 		{
-			Name:  "infra",
-			Usage: "manage infrastructure of fx",
-			Subcommands: []cli.Command{
-				{
-					Name:  "add",
-					Usage: "add a new machine",
-					Flags: []cli.Flag{
-						cli.StringFlag{
-							Name:  "name, N",
-							Usage: "a alias name for this machine",
-						},
-						cli.StringFlag{
-							Name:  "host, H",
-							Usage: "host name or IP address of a machine",
-						},
-						cli.StringFlag{
-							Name:  "user, U",
-							Usage: "user name required for SSH login",
-						},
-						cli.StringFlag{
-							Name:  "password, P",
-							Usage: "password required for SSH login",
-						},
-					},
-					Action: func(c *cli.Context) error {
-						return handlers.AddHost(cfg)(c)
-					},
-				},
-				{
-					Name:  "remove",
-					Usage: "remove an existing machine",
-					Action: func(c *cli.Context) error {
-						return handlers.RemoveHost(cfg)(c)
-					},
-				},
-				{
-					Name:    "list",
-					Aliases: []string{"ls"},
-					Usage:   "list machines",
-					Action: func(c *cli.Context) error {
-						return handlers.ListHosts(cfg)(c)
-					},
-				},
-				{
-					Name:  "activate",
-					Usage: "enable a machine be a host of fx infrastructure",
-					Action: func(c *cli.Context) error {
-						return handlers.Activate(cfg)(c)
-					},
-				},
-				{
-					Name:  "deactivate",
-					Usage: "disable a machine be a host of fx infrastructure",
-					Action: func(c *cli.Context) error {
-						return handlers.Deactivate(cfg)(c)
-					},
-				},
-			},
-		},
-		{
-			Name:  "image",
-			Usage: "manage image of service",
-			Subcommands: []cli.Command{
-				{
-					Name:  "build",
-					Usage: "build a image",
-					Flags: []cli.Flag{
-						cli.StringFlag{
-							Name:  "tag, t",
-							Usage: "image tag",
-						},
-					},
-					Action: func(c *cli.Context) error {
-						return handlers.BuildImage(cfg)(c)
-					},
-				},
-				{
-					Name:  "export",
-					Usage: "export the Docker project of service",
-					Flags: []cli.Flag{
-						cli.StringFlag{
-							Name:  "output, o",
-							Usage: "output directory",
-						},
-					},
-					Action: func(c *cli.Context) error {
-						return handlers.ExportImage()(c)
-					},
-				},
-			},
-		},
-		{
-			Name:  "doctor",
-			Usage: "health check for fx",
+			Name:  "init",
+			Usage: "start fx agent on host",
 			Action: func(c *cli.Context) error {
-				return handlers.Doctor(cfg)(c)
+				return handlers.Init()(context.FromCliContext(c))
 			},
 		},
 		{
 			Name:      "up",
-			Usage:     "deploy a function or a group of functions",
+			Usage:     "deploy a function",
 			ArgsUsage: "[func.go func.js func.py func.rb ...]",
 			Flags: []cli.Flag{
 				cli.StringFlag{
@@ -189,7 +88,14 @@ func main() {
 				},
 			},
 			Action: func(c *cli.Context) error {
-				return handlers.Up(cfg)(c)
+				ctx := context.FromCliContext(c)
+				if err := ctx.Use(middlewares.Setup); err != nil {
+					log.Fatalf("%v", err)
+				}
+				if err := ctx.Use(middlewares.Binding); err != nil {
+					log.Fatalf("%v", err)
+				}
+				return handlers.Up()(ctx)
 			},
 		},
 		{
@@ -197,7 +103,11 @@ func main() {
 			Usage:     "destroy a service",
 			ArgsUsage: "[service 1, service 2, ....]",
 			Action: func(c *cli.Context) error {
-				return handlers.Down(cfg)(c)
+				ctx := context.FromCliContext(c)
+				if err := ctx.Use(middlewares.Setup); err != nil {
+					log.Fatalf("%v", err)
+				}
+				return handlers.Down()(ctx)
 			},
 		},
 		{
@@ -205,7 +115,11 @@ func main() {
 			Aliases: []string{"ls"},
 			Usage:   "list deployed services",
 			Action: func(c *cli.Context) error {
-				return handlers.List(cfg)(c)
+				ctx := context.FromCliContext(c)
+				if err := ctx.Use(middlewares.Setup); err != nil {
+					log.Fatalf("%v", err)
+				}
+				return handlers.List()(ctx)
 			},
 		},
 		{
@@ -218,7 +132,50 @@ func main() {
 				},
 			},
 			Action: func(c *cli.Context) error {
-				return handlers.Call(cfg)(c)
+				return handlers.Call()(context.FromCliContext(c))
+			},
+		},
+		{
+			Name:  "image",
+			Usage: "manage image of service",
+			Subcommands: []cli.Command{
+				{
+					Name:  "build",
+					Usage: "build a image",
+					Flags: []cli.Flag{
+						cli.StringFlag{
+							Name:  "tag, t",
+							Usage: "image tag",
+						},
+					},
+					Action: func(c *cli.Context) error {
+						ctx := context.FromCliContext(c)
+						if err := ctx.Use(middlewares.Setup); err != nil {
+							log.Fatalf("%v", err)
+						}
+						return handlers.BuildImage()(ctx)
+					},
+				},
+				{
+					Name:  "export",
+					Usage: "export the Docker project of service",
+					Flags: []cli.Flag{
+						cli.StringFlag{
+							Name:  "output, o",
+							Usage: "output directory",
+						},
+					},
+					Action: func(c *cli.Context) error {
+						return handlers.ExportImage()(context.FromCliContext(c))
+					},
+				},
+			},
+		},
+		{
+			Name:  "doctor",
+			Usage: "health check for fx",
+			Action: func(c *cli.Context) error {
+				return handlers.Doctor()(context.FromCliContext(c))
 			},
 		},
 	}

go.mod

@@ -20,7 +20,6 @@ require (
 	github.com/googleapis/gnostic v0.3.1 // indirect
 	github.com/gorilla/mux v1.7.3 // indirect
 	github.com/imdario/mergo v0.3.7 // indirect
-	github.com/magiconair/properties v1.8.1 // indirect
 	github.com/metrue/go-ssh-client v0.0.0-20190810064746-98a7a27048f3
 	github.com/mholt/archiver v3.1.1+incompatible
 	github.com/morikuni/aec v1.0.0 // indirect
@@ -31,7 +30,7 @@ require (
 	github.com/pierrec/lz4 v0.0.0-20190222153722-062282ea0dcf // indirect
 	github.com/pkg/errors v0.8.1
 	github.com/spf13/jwalterweatherman v1.1.0 // indirect
-	github.com/spf13/viper v1.4.0
+	github.com/spf13/viper v1.5.0
 	github.com/stretchr/testify v1.4.0
 	github.com/ugorji/go v1.1.7 // indirect
 	github.com/urfave/cli v1.22.1

go.sum

@@ -279,6 +279,8 @@ github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnIn
 github.com/spf13/viper v1.3.2/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s=
 github.com/spf13/viper v1.4.0 h1:yXHLWeravcrgGyFSyCgdYpXQ9dR9c/WED3pg1RhxqEU=
 github.com/spf13/viper v1.4.0/go.mod h1:PTJ7Z/lr49W6bUbkmS1V3by4uWynFiR9p7+dSq/yZzE=
+github.com/spf13/viper v1.5.0 h1:GpsTwfsQ27oS/Aha/6d1oD7tpKIqWnOA6tgOX9HHkt4=
+github.com/spf13/viper v1.5.0/go.mod h1:AkYRkVJF8TkSG/xet6PzXX+l39KhhXa2pdqVSxnTcn4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.1.1 h1:2vfRuCMp5sSVIDSqO8oNnWJq7mPa6KVP3iPIwFBuy8A=
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
@@ -288,6 +290,8 @@ github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/subosito/gotenv v1.2.0 h1:Slr1R9HxAlEKefgq5jn9U+DnETlIUa6HfgEzj0g5d7s=
+github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69rRypqCw=
 github.com/tj/assert v0.0.0-20171129193455-018094318fb0/go.mod h1:mZ9/Rh9oLWpLLDRpvE+3b7gP/C2YyLFYxNmcLnPTMe0=
 github.com/tj/go-elastic v0.0.0-20171221160941-36157cbbebc2/go.mod h1:WjeM0Oo1eNAjXGDx2yma7uG2XoyRZTq1uv3M/o7imD0=
 github.com/tj/go-kinesis v0.0.0-20171128231115-08b17f58cb1b/go.mod h1:/yhzCV0xPfx6jb1bBgRFjl5lytqVqZXEaeqWP8lTEao=
@@ -423,6 +427,8 @@ gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bl
 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.4 h1:/eiJrUcujPVeJ3xlSWaiNi3uSVmDGBK1pDHUHAnao1I=
+gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gotest.tools v2.2.0+incompatible h1:VsBPFP1AI068pPrMxtb/S8Zkgf9xEmTLJjfM+P5UIEo=
 gotest.tools v2.2.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=

hack/install_docker.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+set -e
+# ++
+# verified on Ubuntu 16.04 x64
+# ++
+user_host=$1
+
+ssh ${user_host} 'bash -s' <<EOF
+  apt-get remove -y docker docker-engine docker.io containerd runc
+  apt-get update -y
+  apt-get install -y apt-transport-https ca-certificates curl software-properties-common lsb-core
+  curl -fsSL https://download.docker.com/linux/ubuntu/gpg | apt-key add -
+  add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu \$(lsb_release -cs) stable"
+  apt-get update -y
+  apt-get install -y docker-ce
+  docker run hello-world
+EOF

handlers/call.go

@@ -5,25 +5,19 @@ import (
 	"strings"
 
 	"github.com/apex/log"
-	"github.com/metrue/fx/config"
-	"github.com/metrue/fx/constants"
-	api "github.com/metrue/fx/container_runtimes/docker/http"
+	"github.com/metrue/fx/context"
 	"github.com/metrue/fx/packer"
 	"github.com/metrue/fx/types"
 	"github.com/metrue/fx/utils"
-	"github.com/urfave/cli"
 )
 
 // Call command handle
-func Call(cfg config.Configer) HandleFunc {
-	return func(ctx *cli.Context) error {
-		params := strings.Join(ctx.Args()[1:], " ")
-		hosts, err := cfg.ListActiveMachines()
-		if err != nil {
-			log.Fatalf("list active machines failed: %v", err)
-		}
+func Call() HandleFunc {
+	return func(ctx *context.Context) error {
+		cli := ctx.GetCliContext()
+		_ = strings.Join(cli.Args()[1:], " ")
 
-		file := ctx.Args().First()
+		file := cli.Args().First()
 		src, err := ioutil.ReadFile(file)
 		if err != nil {
 			log.Fatalf("Read Source: %v", err)
@@ -36,17 +30,16 @@ func Call(cfg config.Configer) HandleFunc {
 			Language: lang,
 			Source:   string(src),
 		}
-		project, err := packer.Pack(file, fn)
-		if err != nil {
+		if _, err := packer.Pack(file, fn); err != nil {
 			panic(err)
 		}
 
-		for name, host := range hosts {
-			if err := api.MustCreate(host.Host, constants.AgentPort).
-				Call(file, params, project); err != nil {
-				log.Fatalf("call functions on machine %s with %v failed: %v", name, params, err)
-			}
-		}
+		// TODO not supported
+		// if err := api.MustCreate(host.Host, constants.AgentPort).
+		// 	Call(file, params, project); err != nil {
+		// 	log.Fatalf("call functions on machine %s with %v failed: %v", name, params, err)
+		// }
+
 		return nil
 	}
 }

handlers/doctor.go

@@ -1,27 +1,27 @@
 package handlers
 
 import (
+	"os"
+
 	"github.com/apex/log"
-	"github.com/metrue/fx/config"
 	"github.com/metrue/fx/constants"
+	"github.com/metrue/fx/context"
 	"github.com/metrue/fx/doctor"
-	"github.com/urfave/cli"
 )
 
 // Doctor command handle
-func Doctor(cfg config.Configer) HandleFunc {
-	return func(ctx *cli.Context) error {
-		hosts, err := cfg.ListMachines()
-		if err != nil {
-			log.Fatalf("list machines failed %v", err)
-			return nil
+func Doctor() HandleFunc {
+	return func(ctx *context.Context) error {
+		host := os.Getenv("DOCKER_REMOTE_HOST_ADDR")
+		user := os.Getenv("DOCKER_REMOTE_HOST_USER")
+		password := os.Getenv("DOCKER_REMOTE_HOST_PASSWORD")
+		if host == "" {
+			host = "localhost"
 		}
-		for name, h := range hosts {
-			if err := doctor.New(h).Start(); err != nil {
-				log.Warnf("machine %s is in dirty state: %v", name, err)
-			} else {
-				log.Infof("machine %s is in healthy state: %s", name, constants.CheckedSymbol)
-			}
+		if err := doctor.New(host, user, password).Start(); err != nil {
+			log.Warnf("machine %s is in dirty state: %v", host, err)
+		} else {
+			log.Infof("machine %s is in healthy state: %s", host, constants.CheckedSymbol)
 		}
 		return nil
 	}

handlers/down.go

@@ -1,35 +1,18 @@
 package handlers
 
 import (
-	"context"
-	"os"
-
-	"github.com/metrue/fx/config"
+	"github.com/metrue/fx/context"
 	"github.com/metrue/fx/deploy"
-	dockerDeployer "github.com/metrue/fx/deploy/docker"
-	k8sDeployer "github.com/metrue/fx/deploy/kubernetes"
-	"github.com/urfave/cli"
 )
 
 // Down command handle
-func Down(cfg config.Configer) HandleFunc {
-	return func(ctx *cli.Context) (err error) {
-		services := ctx.Args()
-		c := context.Background()
-		var runner deploy.Deployer
-		if os.Getenv("KUBECONFIG") != "" {
-			runner, err = k8sDeployer.Create()
-			if err != nil {
-				return err
-			}
-		} else {
-			runner, err = dockerDeployer.CreateClient(c)
-			if err != nil {
-				return err
-			}
-		}
+func Down() HandleFunc {
+	return func(ctx *context.Context) (err error) {
+		cli := ctx.GetCliContext()
+		services := cli.Args()
+		runner := ctx.Get("deployer").(deploy.Deployer)
 		for _, svc := range services {
-			if err := runner.Destroy(c, svc); err != nil {
+			if err := runner.Destroy(ctx.Context, svc); err != nil {
 				return err
 			}
 		}

handlers/handle.go

@@ -1,6 +1,8 @@
 package handlers
 
-import "github.com/urfave/cli"
+import (
+	"github.com/metrue/fx/context"
+)
 
 // HandleFunc command handle function
-type HandleFunc func(ctx *cli.Context) error
+type HandleFunc func(ctx *context.Context) error

handlers/host.go

@@ -1,56 +0,0 @@
-package handlers
-
-import (
-	"log"
-
-	"github.com/metrue/fx/config"
-	"github.com/metrue/fx/utils"
-	"github.com/urfave/cli"
-)
-
-// AddHost add a host
-func AddHost(cfg config.Configer) HandleFunc {
-	return func(ctx *cli.Context) error {
-		name := ctx.String("name")
-		addr := ctx.String("host")
-		user := ctx.String("user")
-		password := ctx.String("password")
-		host := config.NewHost(addr, user, password)
-		if !host.Valid() {
-			log.Fatalf("invaid host %v", host)
-			return nil
-		}
-
-		if host.IsRemote() {
-			if host.User == "" || host.Password == "" {
-				log.Fatalf("the host to add is a remote, user and password for SSH login is required")
-				return nil
-			}
-		}
-		return cfg.AddMachine(name, host)
-	}
-}
-
-// RemoveHost remove a host
-func RemoveHost(cfg config.Configer) HandleFunc {
-	return func(ctx *cli.Context) error {
-		name := ctx.Args().First()
-		if name == "" {
-			log.Fatalf("no name given: fx infra remove <name>")
-			return nil
-		}
-		return cfg.RemoveHost(name)
-	}
-}
-
-// ListHosts list hosts
-func ListHosts(cfg config.Configer) HandleFunc {
-	return func(ctx *cli.Context) error {
-		hosts, err := cfg.ListMachines()
-		if err != nil {
-			return err
-		}
-
-		return utils.OutputJSON(hosts)
-	}
-}

handlers/image.go

@@ -4,29 +4,32 @@ import (
 	"fmt"
 	"io/ioutil"
 	"os"
+	"time"
 
 	"github.com/apex/log"
 	"github.com/google/uuid"
-	"github.com/metrue/fx/config"
 	"github.com/metrue/fx/constants"
-	api "github.com/metrue/fx/container_runtimes/docker/http"
+	containerruntimes "github.com/metrue/fx/container_runtimes"
+	"github.com/metrue/fx/context"
 	"github.com/metrue/fx/packer"
-	"github.com/metrue/fx/provision"
 	"github.com/metrue/fx/types"
 	"github.com/metrue/fx/utils"
 	"github.com/pkg/errors"
-	"github.com/urfave/cli"
 )
 
 // BuildImage build image
-func BuildImage(cfg config.Configer) HandleFunc {
-	return func(ctx *cli.Context) error {
-		funcFile := ctx.Args().First()
-		tag := ctx.String("tag")
+func BuildImage() HandleFunc {
+	return func(ctx *context.Context) error {
+		cli := ctx.GetCliContext()
+		funcFile := cli.Args().First()
+		tag := cli.String("tag")
 		if tag == "" {
 			tag = uuid.New().String()
 		}
 
+		workdir := fmt.Sprintf("/tmp/fx-%d", time.Now().Unix())
+		defer os.RemoveAll(workdir)
+
 		body, err := ioutil.ReadFile(funcFile)
 		if err != nil {
 			log.Fatalf("function code load failed: %v", err)
@@ -34,57 +37,33 @@ func BuildImage(cfg config.Configer) HandleFunc {
 		}
 		log.Infof("function code loaded: %v", constants.CheckedSymbol)
 		lang := utils.GetLangFromFileName(funcFile)
-		pwd, err := os.Getwd()
-		if err != nil {
-			log.Fatalf("could not get current work directory: %v", err)
+
+		fn := types.Func{Language: lang, Source: string(body)}
+
+		if err := packer.PackIntoDir(fn, workdir); err != nil {
+			log.Fatalf("could not pack function %v: %v", fn, err)
 			return err
 		}
-		tarFile := fmt.Sprintf("%s.%s.tar", pwd, tag)
-		defer os.RemoveAll(tarFile)
 
-		if err := packer.PackIntoTar(types.Func{Language: lang, Source: string(body)}, tarFile); err != nil {
-			log.Fatalf("could not pack function: %v", err)
-			return err
-		}
-		log.Infof("function packed: %v", constants.CheckedSymbol)
-
-		hosts, err := cfg.ListActiveMachines()
-		if err != nil {
-			log.Fatalf("could not list active machine: %v", err)
-			return errors.Wrap(err, "list active machines failed")
-		}
-
-		if len(hosts) == 0 {
-			log.Warnf("no active machines")
-			return nil
-		}
-		for n, host := range hosts {
-			if !host.Provisioned {
-				provisionor := provision.New(host)
-				if err := provisionor.Start(); err != nil {
-					return errors.Wrapf(err, "could not provision %s", n)
-				}
-				log.Infof("provision machine %v: %s", n, constants.CheckedSymbol)
-				if err := cfg.UpdateProvisionedStatus(n, true); err != nil {
-					return errors.Wrap(err, "update machine provision status failed")
-				}
-			}
-
-			if err := api.MustCreate(host.Host, constants.AgentPort).
-				BuildImage(tarFile, tag, map[string]string{}); err != nil {
+		docker, ok := ctx.Get("docker").(containerruntimes.ContainerRuntime)
+		if ok {
+			nameWithTag := tag + ":latest"
+			if err := docker.BuildImage(ctx.Context, workdir, nameWithTag); err != nil {
 				return err
 			}
-			log.Infof("image built on machine %s: %v", n, constants.CheckedSymbol)
+			log.Infof("image built: %v", constants.CheckedSymbol)
+			return nil
 		}
-		return nil
+		return fmt.Errorf("no available docker cli")
 	}
 }
 
 // ExportImage export service's code into a directory
 func ExportImage() HandleFunc {
-	return func(ctx *cli.Context) (err error) {
-		funcFile := ctx.Args().First()
-		outputDir := ctx.String("output")
+	return func(ctx *context.Context) (err error) {
+		cli := ctx.GetCliContext()
+		funcFile := cli.Args().First()
+		outputDir := cli.String("output")
 		if outputDir == "" {
 			log.Fatalf("output directory required")
 			return nil

handlers/infra_activate.go

@@ -1,46 +0,0 @@
-package handlers
-
-import (
-	"github.com/apex/log"
-	"github.com/metrue/fx/config"
-	"github.com/metrue/fx/constants"
-	"github.com/metrue/fx/provision"
-	"github.com/urfave/cli"
-)
-
-// Activate a machine to be fx server
-func Activate(cfg config.Configer) HandleFunc {
-	return func(ctx *cli.Context) error {
-		name := ctx.Args().First()
-		if name == "" {
-			log.Fatalf("name required for: fx infra activate <name>")
-			return nil
-		}
-
-		host, err := cfg.GetMachine(name)
-		if err != nil {
-			log.Fatalf("could get host %v, make sure you add it first", err)
-			log.Info("You can add a machine by: \n fx infra add -Name <name> -H <ip or hostname> -U <user> -P <password>")
-			return nil
-		}
-		if !host.Provisioned {
-			provisionor := provision.New(host)
-			if err := provisionor.Start(); err != nil {
-				log.Fatalf("could not provision %s: %v", name, err)
-				return nil
-			}
-			log.Infof("provision machine %v: %s", name, constants.CheckedSymbol)
-			if err := cfg.UpdateProvisionedStatus(name, true); err != nil {
-				log.Fatalf("update machine provision status failed: %v", err)
-			}
-		}
-
-		if err := cfg.EnableMachine(name); err != nil {
-			log.Fatalf("could not enable %s: %v", name, err)
-			return nil
-		}
-		log.Infof("enble machine %v: %s", name, constants.CheckedSymbol)
-
-		return nil
-	}
-}

handlers/infra_deactivate.go

@@ -1,25 +0,0 @@
-package handlers
-
-import (
-	"github.com/apex/log"
-	"github.com/metrue/fx/config"
-	"github.com/metrue/fx/constants"
-	"github.com/urfave/cli"
-)
-
-// Deactivate a machine
-func Deactivate(cfg config.Configer) HandleFunc {
-	return func(ctx *cli.Context) error {
-		name := ctx.Args().First()
-		if name == "" {
-			log.Fatalf("name required for: fx infra activate <name>")
-			return nil
-		}
-		if err := cfg.DisableMachine(name); err != nil {
-			log.Fatalf("could not disable %s: %v", name, err)
-			return nil
-		}
-		log.Infof("machine %s deactive: %v", name, constants.CheckedSymbol)
-		return nil
-	}
-}

handlers/init.go

@@ -0,0 +1,31 @@
+package handlers
+
+import (
+	"os"
+
+	"github.com/apex/log"
+	"github.com/metrue/fx/context"
+	"github.com/metrue/fx/provision"
+)
+
+// Init start fx-agent
+func Init() HandleFunc {
+	return func(ctx *context.Context) error {
+		host := os.Getenv("DOCKER_REMOTE_HOST_ADDR")
+		user := os.Getenv("DOCKER_REMOTE_HOST_USER")
+		passord := os.Getenv("DOCKER_REMOTE_HOST_PASSWORD")
+		if host == "" {
+			host = "127.0.0.1"
+		}
+		provisioner := provision.NewWithHost(host, user, passord)
+		if !provisioner.IsFxAgentRunning() {
+			if err := provisioner.StartFxAgent(); err != nil {
+				log.Fatalf("could not start fx agent on host: %s", err)
+				return err
+			}
+			log.Info("fx agent started")
+		}
+		log.Info("fx agent already started")
+		return nil
+	}
+}

handlers/list.go

@@ -1,25 +1,28 @@
 package handlers
 
 import (
-	"github.com/apex/log"
-	"github.com/metrue/fx/config"
-	"github.com/metrue/fx/constants"
-	api "github.com/metrue/fx/container_runtimes/docker/http"
-	"github.com/urfave/cli"
+	"github.com/metrue/fx/context"
+	"github.com/metrue/fx/deploy"
+	"github.com/metrue/fx/utils"
 )
 
 // List command handle
-func List(cfg config.Configer) HandleFunc {
-	return func(ctx *cli.Context) error {
-		hosts, err := cfg.ListActiveMachines()
+func List() HandleFunc {
+	return func(ctx *context.Context) error {
+		cli := ctx.GetCliContext()
+		deployer := ctx.Get("deployer").(deploy.Deployer)
+
+		services, err := deployer.List(ctx.Context, cli.Args().First())
 		if err != nil {
-			log.Fatalf("list active machines failed: %v", err)
+			return err
 		}
-		for name, host := range hosts {
-			if err := api.MustCreate(host.Host, constants.AgentPort).List(ctx.Args().First()); err != nil {
-				log.Fatalf("list functions on machine %s failed: %v", name, err)
+
+		for _, service := range services {
+			if err := utils.OutputJSON(service); err != nil {
+				return err
 			}
 		}
+
 		return nil
 	}
 }

handlers/up.go

@@ -1,21 +1,15 @@
 package handlers
 
 import (
-	"context"
 	"fmt"
 	"io/ioutil"
-	"os"
 
 	"github.com/apex/log"
-	"github.com/metrue/fx/config"
-	"github.com/metrue/fx/constants"
+	"github.com/metrue/fx/context"
 	"github.com/metrue/fx/deploy"
-	dockerDeployer "github.com/metrue/fx/deploy/docker"
-	k8sDeployer "github.com/metrue/fx/deploy/kubernetes"
 	"github.com/metrue/fx/types"
 	"github.com/metrue/fx/utils"
 	"github.com/pkg/errors"
-	"github.com/urfave/cli"
 )
 
 // PortRange usable port range https: //en.wikipedia.org/wiki/Ephemeral_port
@@ -28,11 +22,12 @@ var PortRange = struct {
 }
 
 // Up command handle
-func Up(cfg config.Configer) HandleFunc {
-	return func(ctx *cli.Context) (err error) {
-		funcFile := ctx.Args().First()
-		name := ctx.String("name")
-		port := ctx.Int("port")
+func Up() HandleFunc {
+	return func(ctx *context.Context) (err error) {
+		cli := ctx.GetCliContext()
+		funcFile := cli.Args().First()
+		name := cli.String("name")
+		port := cli.Int("port")
 
 		defer func() {
 			if r := recover(); r != nil {
@@ -54,38 +49,10 @@ func Up(cfg config.Configer) HandleFunc {
 			return errors.Wrap(err, "read source failed")
 		}
 		lang := utils.GetLangFromFileName(funcFile)
-		var deployer deploy.Deployer
-		var bindings []types.PortBinding
-		if os.Getenv("KUBECONFIG") != "" {
-			deployer, err = k8sDeployer.Create()
-			if err != nil {
-				return err
-			}
-			bindings = []types.PortBinding{
-				types.PortBinding{
-					ServiceBindingPort:  80,
-					ContainerExposePort: constants.FxContainerExposePort,
-				},
-				types.PortBinding{
-					ServiceBindingPort:  443,
-					ContainerExposePort: constants.FxContainerExposePort,
-				},
-			}
-		} else {
-			bctx := context.Background()
-			deployer, err = dockerDeployer.CreateClient(bctx)
-			if err != nil {
-				return err
-			}
-			bindings = []types.PortBinding{
-				types.PortBinding{
-					ServiceBindingPort:  int32(port),
-					ContainerExposePort: constants.FxContainerExposePort,
-				},
-			}
-		}
+		deployer := ctx.Get("deployer").(deploy.Deployer)
+		bindings := ctx.Get("bindings").([]types.PortBinding)
 		return deployer.Deploy(
-			context.Background(),
+			ctx.Context,
 			types.Func{Language: lang, Source: string(body)},
 			name,
 			bindings,

middlewares/binding.go

@@ -0,0 +1,38 @@
+package middlewares
+
+import (
+	"os"
+
+	"github.com/metrue/fx/constants"
+	"github.com/metrue/fx/context"
+	"github.com/metrue/fx/types"
+)
+
+// Binding create bindings
+func Binding(ctx *context.Context) error {
+	cli := ctx.GetCliContext()
+	port := cli.Int("port")
+
+	var bindings []types.PortBinding
+	if os.Getenv("KUBECONFIG") != "" {
+		bindings = []types.PortBinding{
+			types.PortBinding{
+				ServiceBindingPort:  80,
+				ContainerExposePort: constants.FxContainerExposePort,
+			},
+			types.PortBinding{
+				ServiceBindingPort:  443,
+				ContainerExposePort: constants.FxContainerExposePort,
+			},
+		}
+	} else {
+		bindings = []types.PortBinding{
+			types.PortBinding{
+				ServiceBindingPort:  int32(port),
+				ContainerExposePort: constants.FxContainerExposePort,
+			},
+		}
+	}
+	ctx.Set("bindings", bindings)
+	return nil
+}

middlewares/setup.go

@@ -0,0 +1,49 @@
+package middlewares
+
+import (
+	"os"
+
+	"github.com/metrue/fx/constants"
+	containerruntimes "github.com/metrue/fx/container_runtimes"
+	dockerHTTP "github.com/metrue/fx/container_runtimes/docker/http"
+	dockerSDK "github.com/metrue/fx/container_runtimes/docker/sdk"
+	"github.com/metrue/fx/context"
+	"github.com/metrue/fx/deploy"
+	dockerDeployer "github.com/metrue/fx/deploy/docker"
+	k8sDeployer "github.com/metrue/fx/deploy/kubernetes"
+)
+
+// Setup create k8s or docker cli
+func Setup(ctx *context.Context) (err error) {
+	var deployer deploy.Deployer
+	if os.Getenv("KUBECONFIG") != "" {
+		deployer, err = k8sDeployer.Create()
+		if err != nil {
+			return err
+		}
+	} else {
+		deployer, err = dockerDeployer.CreateClient(ctx.Context)
+		if err != nil {
+			return err
+		}
+	}
+	ctx.Set("deployer", deployer)
+
+	host := os.Getenv("DOCKER_REMOTE_HOST_ADDR")
+	user := os.Getenv("DOCKER_REMOTE_HOST_USER")
+	var docker containerruntimes.ContainerRuntime
+	if host != "" && user != "" {
+		docker, err = dockerHTTP.Create(host, constants.AgentPort)
+		if err != nil {
+			return err
+		}
+	} else {
+		docker, err = dockerSDK.CreateClient(ctx)
+		if err != nil {
+			return err
+		}
+	}
+	ctx.Set("docker", docker)
+
+	return nil
+}

packer/docker_packer_test.go

@@ -20,7 +20,7 @@ module.exports = ({a, b}) => {
 	return a + b
 }
 `
-	fn := types.ServiceFunctionSource{
+	fn := types.Func{
 		Language: "node",
 		Source:   mockSource,
 	}

packer/images/go/Dockerfile

@@ -1,8 +1,11 @@
-FROM metrue/fx-go-base:latest
+FROM golang:latest
 
 COPY . /go/src/github.com/metrue/fx
 WORKDIR /go/src/github.com/metrue/fx
 
+# dependency management
+RUN go get github.com/gin-gonic/gin
+
 RUN go build -ldflags "-w -s" -o fx fx.go app.go
 
 EXPOSE 3000

packer/packer_test.go

@@ -1,7 +1,6 @@
 package packer
 
 import (
-	"encoding/base64"
 	"testing"
 
 	"github.com/metrue/fx/types"
@@ -13,7 +12,7 @@ module.exports = ({a, b}) => {
 	return a + b
 }
 `
-	fn := types.ServiceFunctionSource{
+	fn := types.Func{
 		Language: "node",
 		Source:   mockSource,
 	}
@@ -70,16 +69,12 @@ public class Fx {
     }
 }
 `
-	fn := types.ServiceFunctionSource{
+	fn := types.Func{
 		Language: "java",
 		Source:   mockSource,
 	}
-	tree, err := PackIntoK8SConfigMapFile(fn.Language, fn.Source)
+	_, err := PackIntoK8SConfigMapFile(fn)
 	if err != nil {
 		t.Fatal(err)
 	}
-	body := base64.StdEncoding.EncodeToString([]byte(mockSource))
-	if tree["src/main/java/fx/Fx.java"] != body {
-		t.Fatalf("should get %s but got %s", body, tree["src/main/java/fx/app.java"])
-	}
 }

provision/provision.go

@@ -2,11 +2,10 @@ package provision
 
 import (
 	"fmt"
-	"strings"
+	"os"
 	"sync"
 
 	"github.com/apex/log"
-	"github.com/metrue/fx/config"
 	"github.com/metrue/fx/constants"
 	"github.com/metrue/fx/pkg/command"
 	ssh "github.com/metrue/go-ssh-client"
@@ -20,25 +19,82 @@ type Provisioner interface {
 // Provisionor provision-or
 type Provisionor struct {
 	sshClient ssh.Client
-
-	host config.Host
+	host      string
 }
 
-// New new provision
-func New(host config.Host) *Provisionor {
-	p := &Provisionor{host: host}
-	if host.IsRemote() {
-		p.sshClient = ssh.New(host.Host).
-			WithUser(host.User).
-			WithPassword(host.Password)
+func isLocal(host string) bool {
+	if host == "" {
+		return false
+	}
+	return host == "127.0.0.1" || host == "localhost" || host == "0.0.0.0"
+}
+
+// NewWithHost create a provisionor with host, user, and password
+func NewWithHost(host string, user string, password string) *Provisionor {
+	p := &Provisionor{
+		host: host,
+	}
+	if !isLocal(host) {
+		p.sshClient = ssh.New(host).
+			WithUser(user).
+			WithPassword(password)
 	}
 	return p
 }
 
+// IsFxAgentRunning check if fx-agent is running on host
+func (p *Provisionor) IsFxAgentRunning() bool {
+	script := fmt.Sprintf("docker inspect %s", constants.AgentContainerName)
+	var cmd *command.Command
+	if !isLocal(p.host) {
+		cmd = command.New("inspect fx-agent", script, command.NewRemoteRunner(p.sshClient))
+	} else {
+		cmd = command.New("inspect fx-agent", script, command.NewLocalRunner())
+	}
+	output, err := cmd.Exec()
+	if os.Getenv("DEBUG") != "" {
+		log.Infof(string(output))
+	}
+	if err != nil {
+		return false
+	}
+	return true
+}
+
+// StartFxAgent start fx agent
+func (p *Provisionor) StartFxAgent() error {
+	script := fmt.Sprintf("docker run -d --name=%s --rm -v /var/run/docker.sock:/var/run/docker.sock -p 0.0.0.0:%s:1234 bobrik/socat TCP-LISTEN:1234,fork UNIX-CONNECT:/var/run/docker.sock", constants.AgentContainerName, constants.AgentPort)
+	var cmd *command.Command
+	if !isLocal(p.host) {
+		cmd = command.New("start fx-agent", script, command.NewRemoteRunner(p.sshClient))
+	} else {
+		cmd = command.New("start fx-agent", script, command.NewLocalRunner())
+	}
+	if output, err := cmd.Exec(); err != nil {
+		log.Info(string(output))
+		return err
+	}
+	return nil
+}
+
+// StopFxAgent stop fx agent
+func (p *Provisionor) StopFxAgent() error {
+	script := fmt.Sprintf("docker stop %s", constants.AgentContainerName)
+	var cmd *command.Command
+	if !isLocal(p.host) {
+		cmd = command.New("stop fx agent", script, command.NewRemoteRunner(p.sshClient))
+	} else {
+		cmd = command.New("stop fx agent", script, command.NewLocalRunner())
+	}
+	if output, err := cmd.Exec(); err != nil {
+		log.Infof(string(output))
+		return err
+	}
+	return nil
+}
+
 // Start start provision progress
 func (p *Provisionor) Start() error {
-	startFxAgent := fmt.Sprintf("docker run -d --name=%s --rm -v /var/run/docker.sock:/var/run/docker.sock -p 0.0.0.0:%s:1234 bobrik/socat TCP-LISTEN:1234,fork UNIX-CONNECT:/var/run/docker.sock", constants.AgentContainerName, constants.AgentPort)
-	stopFxAgent := fmt.Sprintf("docker stop %s", constants.AgentContainerName)
 	scripts := map[string]string{
 		"pull java Docker base image":   "docker pull metrue/fx-java-base",
 		"pull julia Docker base image":  "docker pull metrue/fx-julia-base",
@@ -48,35 +104,12 @@ func (p *Provisionor) Start() error {
 		"pull go Docker base image":     "docker pull metrue/fx-go-base",
 	}
 
-	agentStartupCmds := []*command.Command{}
-	if p.host.IsRemote() {
-		agentStartupCmds = append(agentStartupCmds,
-			command.New("stop current fx agent", stopFxAgent, command.NewRemoteRunner(p.sshClient)),
-			command.New("start fx agent", startFxAgent, command.NewRemoteRunner(p.sshClient)),
-		)
-	} else {
-		agentStartupCmds = append(agentStartupCmds,
-			command.New("stop current fx agent", stopFxAgent, command.NewLocalRunner()),
-			command.New("start fx agent", startFxAgent, command.NewLocalRunner()),
-		)
-	}
-	for _, cmd := range agentStartupCmds {
-		if output, err := cmd.Exec(); err != nil {
-			if strings.Contains(string(output), "No such container: fx-agent") {
-				// Skip stop a fx-agent error when there is not agent running
-			} else {
-				log.Fatalf("Provision:%s: %s, %s", cmd.Name, err, output)
-				return err
-			}
-		}
-	}
-
 	var wg sync.WaitGroup
 	for n, s := range scripts {
 		wg.Add(1)
 		go func(name, script string) {
 			var cmd *command.Command
-			if p.host.IsRemote() {
+			if !isLocal(p.host) {
 				cmd = command.New(name, script, command.NewRemoteRunner(p.sshClient))
 			} else {
 				cmd = command.New(name, script, command.NewLocalRunner())

provision/provision_test.go

@@ -2,14 +2,35 @@ package provision
 
 import (
 	"testing"
-
-	"github.com/metrue/fx/config"
+	"time"
 )
 
-func TestStart(t *testing.T) {
-	host := config.Host{Host: "127.0.0.1"}
-	provisionor := New(host)
+func TestProvisionWorkflow(t *testing.T) {
+	provisionor := NewWithHost("127.0.0.1", "", "")
+
+	_ = provisionor.StopFxAgent()
+	// TODO wait too long here to make test pass
+	time.Sleep(40 * time.Second)
+
+	running := provisionor.IsFxAgentRunning()
+	if running {
+		t.Fatalf("fx-agent should not be running")
+	}
+
+	if err := provisionor.StartFxAgent(); err != nil {
+		t.Fatal(err)
+	}
+
+	running = provisionor.IsFxAgentRunning()
+	if !running {
+		t.Fatalf("fx-agent should be running")
+	}
+
 	if err := provisionor.Start(); err != nil {
 		t.Fatal(err)
 	}
+
+	if err := provisionor.StopFxAgent(); err != nil {
+		t.Fatal(err)
+	}
 }

scripts/provision.sh

@@ -10,12 +10,3 @@ sudo apt-get update -y
 sudo apt-get install -y docker-ce
 
 docker run hello-world
-
-# curl -Lo kubectl https://storage.googleapis.com/kubernetes-release/release/${K8S_VERSION}/bin/linux/amd64/kubectl && chmod +x kubectl && sudo mv kubectl /usr/local/bin/
-# mkdir -p ${HOME}/.kube
-# touch ${HOME}/.kube/confi
-#
-
-## start fx proxy agent
-docker run -d --name=fx-agent --rm -v /var/run/docker.sock:/var/run/docker.sock -p 0.0.0.0:8866:1234 bobrik/socat TCP-LISTEN:1234,fork UNIX-CONNECT:/var/run/docker.sock
-

scripts/test_cli.sh

@@ -3,14 +3,15 @@
 set -e
 
 fx="./build/fx"
-service='fx-service-abc'
+service='fx-service'
 
 run() {
   local lang=$1
   local port=$2
+  # localhost
   $fx up --name ${service}_${lang} --port ${port} --healthcheck test/functions/func.${lang}
   $fx list # | jq ''
-  $fx down ${service}_${lang} # | grep "Down Service ${service}"
+  $fx down ${service}_${lang} || true
 }
 
 build_image() {
@@ -27,9 +28,8 @@ export_image() {
 
 # main
 # clean up
-docker stop fx-agent || true && docker rm fx-agent || true
+# docker stop fx-agent || true && docker rm fx-agent || true
 
-$fx infra activate localhost
 port=20000
 for lang in 'js' 'rb' 'py' 'go' 'php' 'java' 'd'; do
   run $lang $port

utils/docker_test.go

@@ -1,15 +0,0 @@
-package utils
-
-import "testing"
-
-func TestDockerVersion(t *testing.T) {
-	host := "localhost"
-	port := "8866"
-	version, err := DockerVersion(host, port)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if version == "" {
-		t.Fatal("should version empty")
-	}
-}