provisioning 0.0.1.alpha.3 → 0.0.1.alpha.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c4c3ddbf8d9e399ad23cec152889080da86482c6
-  data.tar.gz: 586672476340031fa884f5e9fad0abc008811b79
+  metadata.gz: 933806e5f54e7f91d0c47aa40f1ccebebdc2623c
+  data.tar.gz: a4178fef2186d84051a44985379023c56626d700
 SHA512:
-  metadata.gz: bdc9b54888a68f7e09483aa574eeaa9a8365676cc833ec39ae027cc0d0fcbce477150840d2f4891a3238e2b77c7dcffcf5ac9962a0e012d5e9c840cb02721668
-  data.tar.gz: 51b45ae173f24de850b15564a3f6ff2319d907acc7384ecc863ff6259c919cafcee4c1aad8b6197be8b1476b5c57886024abe1d2090793460044e42486393221
+  metadata.gz: dd72fdf87aa3ae6189da7fd8bb10aa207fd4785a480f54dd64caede766abe0ac342bcccc5bc993e60a28cf0abb2dffbc57bbcc95233b9325467835ee9b2f91f3
+  data.tar.gz: 8caf109b025a5b3339b072f87fb90f41b609f87e3e7572ccc94572c066db23c114e5fd65d976ade15221531177fa7ceed211569f11922d7c24dd51396487d252

data/README.md

@@ -6,7 +6,7 @@ Open PaaS provisioning.
 This gem will install a `provision` command for provisioning an open
 platform-as-a-service (PaaS) from a JSON manifest file.
 
-Currently limited to dokku apps on AWS or DigitalOcean servers.
+Currently limited to dokku or flynn apps on AWS or DigitalOcean servers.
 
 
 Installation
@@ -16,7 +16,7 @@ Installation
 
 Alternatively you can build the gem from its repository:
 
-    $ git clone git://github.com/vinc/provisioning.git
+    $ git clone git://github.com/vinc/provisioning.rb.git
     $ cd provisioning
     $ gem build provisioning.gemspec
     $ gem install provisioning-0.0.1.gem
@@ -25,33 +25,31 @@ Alternatively you can build the gem from its repository:
 Usage
 -----
 
-Run the provisioning script:
+Provision a manifest file:
 
-    $ provision manifest.json
+    $ provision manifest.sample.json
+    Reading provisioning manifest file 'manifest.sample.json'
+    ==> Provisioning digitalocean compute
     Uploading SSH key to DigitalOcean
-
-    Creating server 'dokku.server.net'
-
-    Creating domain 'server.net'
-    Configue 'server.net' with the following DNS servers:
-      - ns1.digitalocean.com
-      - ns2.digitalocean.com
-      - ns3.digitalocean.com
-
-    Creating domain record A 'dokku.server.net' to '192.168.13.37'
-    Creating domain record CNAME 'example.server.net' to 'dokku.server.net.'
-    Configue 'example.com' to point to 'dokku.server.net'
-    Configue 'www.example.com' to point to 'dokku.server.net'
-
-    Installing dokku v0.10.4 on '192.168.13.37'
-    Run `gem install dokku-cli` to get dokku client on your machine
-
-    Creating dokku app 'example' on '192.168.13.37'
-
+    Creating server 'dokku1.sfo1.example.net'
+    ==> Provisioning digitalocean dns
+    Creating zone 'sfo1.example.net'
+    Creating domain record A '@' to '104.131.186.241'
+    Configue 'sfo1.example.net' with the following DNS servers:
+      - ns1.example.net
+      - ns2.example.net
+    Creating domain record CNAME '*' to 'sfo1.example.net.'
+    Configue 'example.com' to point to 'sfo1.example.net'
+    Configue 'www.example.com' to point to 'sfo1.example.net'
+    ==> Provisioning dokku platform
+    Installing dokku v0.10.4 on '104.131.186.241'
+    Creating dokku app 'example' on '104.131.186.241'
+    Run `gem install dokku-cli` to get dokku client on your computer
     Adding dokku to git remotes
+    Uploading SSH key to DigitalOcean
     Run `git push dokku master` to deploy your code
 
-Provisioning manifest json file:
+Sample manifest file (in JSON format)
 
 ```json
 {
@@ -63,8 +61,8 @@ Provisioning manifest json file:
     },
     "platform": {
       "provider": "dokku",
-      "domain": "sfo1.example.net",
-      "version": "v0.10.4"
+      "version": "v0.10.4",
+      "domain": "sfo1.example.net"
     },
     "compute": {
       "provider": "digitalocean",

data/lib/provisioning.rb

@@ -1,10 +1,16 @@
 require "object"
+require "provisioning/core"
 require "provisioning/cli"
+require "provisioning/compute/base"
 require "provisioning/compute/aws"
 require "provisioning/compute/digitalocean"
 require "provisioning/console"
+require "provisioning/dns/base"
+require "provisioning/dns/aws"
 require "provisioning/dns/digitalocean"
+require "provisioning/platform/base"
 require "provisioning/platform/dokku"
+require "provisioning/platform/flynn"
 require "provisioning/public_key"
 require "provisioning/version"
 

data/lib/provisioning/cli.rb

@@ -26,10 +26,11 @@ module Provisioning
       set_instance_variable_from_manifest(%w[compute provider])
       set_instance_variable_from_manifest(%w[dns provider])
 
-      @server_address = nil
-      @server_hostname = [@platform_provider, @platform_domain].join(".")
+      @servers = []
 
-      @ssh_key = PublicKey.new(@env["SSH_PUBLIC_KEY"])
+      key_path = File.join(@env["HOME"], ".ssh/id_rsa.pub")
+      key_body = @env["SSH_PUBLIC_KEY"] || File.open(key_path).read
+      @ssh_key = PublicKey.new(key_body)
     end
 
     def parse_opts(args)
@@ -48,58 +49,84 @@ module Provisioning
       provision_dns
       provision_platform
       add_git_remote
+      # TODO: return false when an error occur
     end
 
     def provision_compute
-      klass = Compute.const_get(@compute_provider.capitalize)
-      compute = klass.new(@manifest["compute"], @opts, @env)
+      compute = provider("compute")
 
       compute.upload_ssh_key(@ssh_key)
 
-      server = compute.find_or_create_server(
-        name: @server_hostname,
-        ssh_key: @ssh_key
-      )
-      server.wait_for { ready? }
-      @server_address = server.public_ip_address
+      n = (@manifest["compute"]["count"] || 1).to_i
+      @servers = n.times.map do |i|
+        compute.find_or_create_server(
+          name: "#{@platform_provider}#{i + 1}.#{@platform_domain}",
+          ssh_key: @ssh_key
+        )
+      end
+
+      @servers.each do |server|
+        server.wait_for { ready? }
+      end
+      sleep 5
     end
 
     def provision_dns
-      klass = DNS.const_get(@dns_provider.capitalize)
-      dns = klass.new(@manifest["dns"], @opts, @env)
+      dns = provider("dns")
 
-      dns.create_domain(@platform_domain, @server_address)
+      cluster = @servers.map(&:public_ip_address)
+
+      if @dns_provider == "digitalocean"
+        dns.create_zone(@platform_domain, cluster.shift)
+      else
+        dns.create_zone(@platform_domain)
+      end
       Console.success("Configue '#{@platform_domain}' with the following DNS servers:")
-      dns.get_domain_name_servers(@platform_domain).each do |hostname|
+      dns.get_name_servers(@platform_domain).each do |hostname|
         Console.success("  - #{hostname}")
       end
 
-      dns.create_domain_record(
-        domain: @platform_domain,
-        type: "A",
-        name: @platform_provider,
-        data: @server_address
-      )
+      if cluster.count > 0
+        dns.create_record(@platform_domain,
+          type: "A",
+          name: [@platform_domain, ""].join("."),
+          value: cluster
+        )
+      end
+
+      @servers.each_with_index do |server, i|
+        dns.create_record(@platform_domain,
+          type: "A",
+          name: "#{@platform_provider}#{i + 1}.#{@platform_domain}",
+          value: server.public_ip_address
+        )
+      end
 
-      dns.create_domain_record(
-        domain: @platform_domain,
+      # Wilcard subdomains
+      dns.create_record(@platform_domain,
         type: "CNAME",
-        name: @app_name,
-        data: @server_hostname + "."
+        name: ["*", @platform_domain, ""].join("."),
+        value: [@platform_domain, ""].join(".")
       )
 
       @manifest["app"]["domains"].each do |app_domain|
-        Console.success("Configue '#{app_domain}' to point to '#{@server_hostname}'")
+        Console.success("Configue '#{app_domain}' to point to '#{@platform_domain}'")
       end
     end
 
     def provision_platform
-      klass = Platform.const_get(@platform_provider.capitalize)
-      platform = klass.new(@manifest["platform"], @opts, @env)
+      platform = provider("platform")
+
+      @servers.each do |server|
+        platform.setup(
+          address: server.public_ip_address,
+          user: @compute_provider == "aws" ? "ubuntu" : "root"
+        )
+      end
 
-      platform.setup(address: @server_address, domain: @platform_domain)
       platform.create_app(@manifest["app"])
 
+      # TODO: add `platform.get_post_install_instructions`
       case @platform_provider
       when "dokku"
         Console.success("Run `gem install dokku-cli` to get dokku client on your computer")
@@ -119,11 +146,14 @@ module Provisioning
         else
           case @platform_provider
           when "dokku"
-            url = "#{@platform_provider}@#{@server_hostname}:#{@app_name}"
+            url = "#{@platform_provider}@#{@platform_domain}:#{@app_name}"
+            git.add_remote(@platform_provider, url)
+          when "flynn"
+            url = "https://git.#{@platform_domain}/#{@app_name}.git"
             git.add_remote(@platform_provider, url)
           end
         end
-        Console.success("Run `git push dokku master` to deploy your code")
+        Console.success("Run `git push #{@platform_provider} master` to deploy your code")
       end
     end
 
@@ -131,19 +161,16 @@ module Provisioning
       Console.info("Reading provisioning manifest file '#{filename}'")
       begin
         json = JSON.parse(File.open(filename).read)
-      rescue Errno::ENOENT, JSON::ParserError
+      rescue Errno::ENOENT
         Console.error("Could not read provisioning manifest file '#{filename}'")
+      rescue JSON::ParserError
+        Console.error("Could not parse provisioning manifest file '#{filename}'")
       end
       json["manifest"]
     end
 
     private
 
-    def set_instance_variable_from_manifest(keys)
-      name = "@" + keys.join("_")
-      instance_variable_set(name, dig_manifest(keys))
-    end
-
     def dig_manifest(keys)
       path = []
       hash = @manifest
@@ -153,5 +180,22 @@ module Provisioning
       end
       hash
     end
+
+    def set_instance_variable_from_manifest(keys)
+      name = "@" + keys.join("_")
+      instance_variable_set(name, dig_manifest(keys))
+    end
+
+    def provider(type)
+      provider = instance_variable_get("@#{type}_provider")
+
+      Console.info("==> Provisioning #{provider} #{type}")
+
+      klass = Provisioning.
+        const_get(type.capitalize).
+        const_get(provider.capitalize)
+
+      klass.new(@manifest[type], @opts, @env)
+    end
   end
 end

data/lib/provisioning/compute/aws.rb

@@ -4,18 +4,16 @@ require "provisioning"
 
 module Provisioning
   module Compute
-    class Aws
-      KEY_NAME = "provisioning key".freeze
-
+    class Aws < Base
       def initialize(config, opts, env)
         @config = config
         @opts = opts
         Fog.mock! if @opts[:mock]
         @client = Fog::Compute.new(
           provider: "aws",
-          region: @config["region"],
-          aws_access_key_id: env["AWS_ACCESS_KEY_ID"],
-          aws_secret_access_key: env["AWS_SECRET_ACCESS_KEY"]
+          region: fetch("region", config: @config),
+          aws_access_key_id: fetch("AWS_ACCESS_KEY_ID", env: env),
+          aws_secret_access_key: fetch("AWS_SECRET_ACCESS_KEY", env: env)
         )
       end
 
@@ -38,9 +36,10 @@ module Provisioning
           end
         end
 
+        # TODO: set instance name instead of tagging it
         @client.servers.create(
-          image_id: @config["image_id"],
-          flavor_id: @config["flavor_id"],
+          image_id: fetch("image_id", config: @config),
+          flavor_id: fetch("flavor_id", config: @config),
           tags: { name: name },
           key_name: KEY_NAME
         )

data/lib/provisioning/compute/base.rb

@@ -0,0 +1,23 @@
+require "provisioning"
+
+module Provisioning
+  module Compute
+    class Base
+      include Provisioning::Core
+
+      KEY_NAME = "provisioning key".freeze
+
+      def initialize(config, opts, env)
+        raise NotImplementedError
+      end
+
+      def upload_ssh_key(ssh_key)
+        raise NotImplementedError
+      end
+
+      def find_or_create_server(name:, ssh_key:)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/provisioning/compute/digitalocean.rb

@@ -4,16 +4,14 @@ require "provisioning"
 
 module Provisioning
   module Compute
-    class Digitalocean
-      KEY_NAME = "provisioning key".freeze
-
+    class Digitalocean < Base
       def initialize(config, opts, env)
         @config = config
         @opts = opts
         Fog.mock! if @opts[:mock]
         @client = Fog::Compute.new(
           provider: :digitalocean,
-          digitalocean_token: env["DIGITALOCEAN_TOKEN"]
+          digitalocean_token: fetch("DIGITALOCEAN_TOKEN", env: env)
         )
       end
 
@@ -41,9 +39,9 @@ module Provisioning
 
         @client.servers.create(
           name: name,
-          region: @config["region"],
-          image: @config["image"],
-          size: @config["size"],
+          region: fetch("region", config: @config),
+          image: fetch("image", config: @config),
+          size: fetch("size", config: @config),
           ssh_keys: [ssh_key.fingerprint]
         )
       end

data/lib/provisioning/core.rb

@@ -0,0 +1,15 @@
+require "provisioning"
+
+module Provisioning
+  module Core
+    def fetch(key, default = nil, env: nil, config: nil)
+      if env
+        env[key] || default || Console.error("Could not find '#{key}' in environment")
+      elsif config
+        config[key] || default || Console.error("Could not find '#{key}' in manifest")
+      else
+        # TODO: env or config required
+      end
+    end
+  end
+end

data/lib/provisioning/dns/aws.rb

@@ -0,0 +1,54 @@
+require "fog/aws"
+
+require "provisioning"
+
+module Provisioning
+  module Dns
+    class Aws < Base
+      def initialize(config, opts, env)
+        @config = config
+        @opts = opts
+        Fog.mock! if @opts[:mock]
+        @client = Fog::DNS.new(
+          provider: "aws",
+          aws_access_key_id: fetch("AWS_ACCESS_KEY_ID", env: env),
+          aws_secret_access_key: fetch("AWS_SECRET_ACCESS_KEY", env: env)
+        )
+      end
+
+      def create_zone(domain)
+        Console.info("Creating zone '#{domain}'")
+
+        zone = get_zone(domain)
+        if zone
+          Console.warning("Domain already exists, skipping")
+        else
+          zone = @client.zones.create(domain: domain)
+        end
+      end
+
+      def create_record(domain, type:, name:, value:)
+        value = value.is_a?(Array) ? value : [value]
+        value_to_s = value.join(", ")
+        Console.info("Creating domain record #{type} '#{name}' to '#{value_to_s}'")
+
+        zone = get_zone(domain)
+        if zone.records.get(name, type).try(:value) == value
+          Console.warning("Record already exists, skipping")
+        else
+          zone.records.create(type: type, name: name, value: value)
+        end
+      end
+
+      def get_name_servers(domain)
+        get_zone(domain).reload.nameservers || []
+      end
+
+      private
+
+      def get_zone(domain)
+        @client.zones.all.find { |z| z.domain == domain + "." }
+      end
+    end
+  end
+end

data/lib/provisioning/dns/base.rb

@@ -0,0 +1,25 @@
+require "provisioning"
+
+module Provisioning
+  module Dns
+    class Base
+      include Provisioning::Core
+
+      def initialize(config, opts, env)
+        raise NotImplementedError
+      end
+
+      def create_zone(domain)
+        raise NotImplementedError
+      end
+
+      def create_record(domain, type:, name:, data:)
+        raise NotImplementedError
+      end
+
+      def get_name_servers(domain)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/provisioning/dns/digitalocean.rb

@@ -3,24 +3,25 @@ require "droplet_kit"
 require "provisioning"
 
 module Provisioning
-  module DNS
-    class Digitalocean
+  module Dns
+    class Digitalocean < Base
       def initialize(config, opts, env)
         @config = config
         @opts = opts
         @client = DropletKit::Client.new(
-          access_token: env["DIGITALOCEAN_TOKEN"]
+          access_token: fetch("DIGITALOCEAN_TOKEN", env: env)
         ) unless @opts[:mock]
       end
 
-      def create_domain(name, address)
-        Console.info("Creating domain '#{name}'")
+      def create_zone(name, address)
+        Console.info("Creating zone '#{name}'")
 
         disable_verbose
         return if @opts[:mock]
         if @client.domains.all.map(&:name).include?(name)
           Console.warning("Domain already exists, skipping")
         else
+          Console.info("Creating domain record A '@' to '#{address}'")
           domain = DropletKit::Domain.new(name: name, ip_address: address)
           @client.domains.create(domain)
         end
@@ -28,22 +29,30 @@ module Provisioning
         restore_verbose
       end
 
-      def create_domain_record(domain:, type:, name:, data:)
-        Console.info("Creating domain record #{type} '#{name}.#{domain}' to '#{data}'")
+      def create_record(domain, type:, name:, value:)
+        name = name.gsub("#{domain}.", "@").gsub(".@", "")
+        value = value.is_a?(Array) ? value : [value]
+        value_to_s = value.join(", ")
+        Console.info("Creating domain record #{type} '#{name}' to '#{value_to_s}'")
 
         disable_verbose
         return if @opts[:mock]
-        if @client.domain_records.all(for_domain: domain).map(&:name).include?(name)
-          Console.warning("Record already exists, skipping")
-        else
-          record = DropletKit::DomainRecord.new(type: type, name: name, data: data)
-          @client.domain_records.create(record, for_domain: domain)
+
+        records = @client.domain_records.all(for_domain: domain)
+        value.each do |data|
+          data = data.gsub("#{domain}.", "@")
+          if records.any? { |r| r.name == name && r.data == data }
+            Console.warning("Record already exists, skipping")
+          else
+            record = DropletKit::DomainRecord.new(type: type, name: name, data: data)
+            @client.domain_records.create(record, for_domain: domain)
+          end
         end
       ensure
         restore_verbose
       end
 
-      def get_domain_name_servers(domain)
+      def get_name_servers(domain)
         disable_verbose
         return %w[ns1.example.net ns2.example.net] if @opts[:mock]
         @client.domain_records.all(for_domain: domain).

data/lib/provisioning/platform/base.rb

@@ -0,0 +1,31 @@
+require "provisioning"
+
+module Provisioning
+  module Platform
+    class Base
+      include Provisioning::Core
+
+      def initialize(config, opts, env)
+        @opts = opts
+        @config = config
+        @servers = []
+      end
+
+      def setup(address:, user: "root")
+        @servers << [address, user]
+        raise NotImplementedError
+      end
+
+      def create_app(config)
+        raise NotImplementedError
+      end
+
+      protected
+
+      def ssh_exec(ssh, cmd, user: "root")
+        cmd = "sudo bash -c '#{cmd}'" if user != "root"
+        ssh.exec!(cmd)
+      end
+    end
+  end
+end

data/lib/provisioning/platform/dokku.rb

@@ -4,58 +4,60 @@ require "provisioning"
 
 module Provisioning
   module Platform
-    class Dokku
-      def initialize(config, opts, env)
-        @opts = opts
-        @config = config
-        @servers = []
-      end
-
-      def setup(address:, domain:)
-        @servers << address
-        version = @config["version"]
+    class Dokku < Base
+      def setup(address:, user: "root")
+        @servers << [address, user]
+        version = fetch("version", config: @config)
         Console.info("Installing dokku #{version} on '#{address}'")
         return if @opts[:mock]
-        Net::SSH.start(address, "root") do |ssh|
-          if ssh.exec!("which dokku").present?
+        Net::SSH.start(address, user) do |ssh|
+          if ssh_exec(ssh, "which dokku", user: user).present?
             Console.warning("Dokku already installed, skipping")
           else
+            # TODO: configure hostname
+            domain = fetch("domain", config: @config)
             [
               "wget https://raw.githubusercontent.com/dokku/dokku/#{version}/bootstrap.sh",
               "DOKKU_TAG=#{version} bash bootstrap.sh",
               "service dokku-installer stop",
               "systemctl disable dokku-installer",
               "cat .ssh/authorized_keys | sshcommand acl-add dokku admin",
-              "echo -n #{domain} > /home/dokku/VHOST",
-              "echo -n #{domain} > /home/dokku/HOSTNAME"
-            ].each { |command| Console.debug(ssh.exec!(command)) }
+              "echo #{domain} > /home/dokku/VHOST",
+              "echo #{domain} > /home/dokku/HOSTNAME"
+            ].each { |cmd| Console.debug(ssh_exec(ssh, cmd, user: user)) }
           end
         end
       end
 
       def create_app(config)
-        name = config["name"]
-        @servers.each do |address|
+        name = fetch("name", config: config)
+        @servers.each do |address, user|
           Console.info("Creating dokku app '#{name}' on '#{address}'")
-          return if @opts[:mock]
-          Net::SSH.start(address, "root") do |ssh|
-            existing_apps = ssh.exec!("dokku apps").to_s.lines.map(&:chomp)
+          next if @opts[:mock]
+          Net::SSH.start(address, user) do |ssh|
+            existing_apps = ssh_exec(ssh, "dokku apps", user: user).to_s.lines.map(&:chomp)
             if existing_apps.include?(name)
               Console.warning("App already exists, skipping")
             else
-              Console.debug(ssh.exec!("dokku apps:create #{name}"))
+              Console.debug(ssh_exec(ssh, "dokku apps:create #{name}", user: user))
 
-              config["services"].each do |service|
-                #TODO check if service exists
+              fetch("services", [], config: config).each do |service|
+                if @servers.count > 1
+                  Console.warning("Service '#{service}' for dokku wont work in a cluster configuration")
+                end
+                # TODO: check if service exists
                 [
                   "dokku plugin:install https://github.com/dokku/dokku-#{service}.git #{service}",
                   "dokku #{service}:create #{name}-#{service}",
                   "dokku #{service}:link #{name}-#{service} #{name}"
-                ].each { |command| Console.debug(ssh.exec!(command)) }
+                ].each { |cmd| Console.debug(ssh_exec(ssh, cmd, user: user)) }
               end
 
-              domains = config["domains"].join(" ")
-              Console.debug(ssh.exec!("dokku domains:add #{name} #{domains}"))
+              fetch("domains", [], config: config).each do |domain|
+                # This will replace default subdomain 'foo.example.com' in /dokku/foo/VHOST
+                # because the app has not been deployed once yet.
+                Console.debug(ssh_exec(ssh, "dokku domains:add #{name} #{domain}", user: user))
+              end
             end
           end
         end

data/lib/provisioning/platform/flynn.rb

@@ -0,0 +1,74 @@
+require "net/ssh"
+
+require "provisioning"
+
+module Provisioning
+  module Platform
+    class Flynn < Base
+      def setup(address:, user: "root")
+        Console.info("Installing flynn on '#{address}'")
+        @servers << [address, user]
+        return if @opts[:mock]
+        Net::SSH.start(address, user) do |ssh|
+          if ssh_exec(ssh, "which flynn", user: user).present?
+            Console.warning("Flynn already installed, skipping")
+          else
+            # Install flynn
+            ssh_exec(ssh, "bash < <(curl -fsSL https://dl.flynn.io/install-flynn)", user: user)
+
+            # Init cluster
+            if @servers.count == 1
+              @token = ssh_exec(ssh, "flynn-host init --init-discovery", user: user)
+            else
+              ssh_exec(ssh, "flynn-host init --discovery #{@token}", user: user)
+            end
+
+            # Start flynn
+            ssh_exec(ssh, "systemctl start flynn-host", user: user)
+          end
+        end
+      end
+
+      def create_app(config)
+        name = fetch("name", config: config)
+        (address, user) = @servers.first
+
+        Console.info("Creating flynn app '#{name}' on '#{address}'")
+        return if @opts[:mock]
+        Net::SSH.start(address, user) do |ssh|
+          out = ssh_exec(ssh, "flynn apps | awk '{ print $2 }'", user: user)
+          existing_apps = out.lines.map(&:chomp)
+          if existing_apps.include?(name)
+            Console.warning("App already exists, skipping")
+          else
+            cmds = []
+
+            # Bootstrap flynn
+            platform_domain = fetch("domain", config: @config)
+            bootstrap = "CLUSTER_DOMAIN=#{platform_domain} flynn-host bootstrap"
+            bootstrap += " --min-hosts 3 --discovery #{@token}" if @token && @servers.count >= 3
+            cmds << bootstrap
+
+            # Configure flynn command
+            out = ssh_exec(ssh, "flynn-host cli-add-command", user: user)
+            cmds << out.lines.map(&:chomp).find do |line|
+              line.start_with?("flynn cluster add")
+            end
+
+            cmds << "flynn create #{name}"
+
+            fetch("services", [], config: config).each do |service|
+              cmds << "flynn -a #{name} resource add #{service}"
+            end
+
+            fetch("domains", [], config: config).each do |domain|
+              cmds << "flynn -a #{name} route add http #{domain}"
+            end
+
+            cmds.each { |cmd| Console.debug(ssh_exec(ssh, cmd, user: user)) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/provisioning/version.rb

@@ -1,3 +1,3 @@
 module Provisioning
-  VERSION = "0.0.1.alpha.3".freeze
+  VERSION = "0.0.1.alpha.4".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: provisioning
 version: !ruby/object:Gem::Version
-  version: 0.0.1.alpha.3
+  version: 0.0.1.alpha.4
 platform: ruby
 authors:
 - Vincent Ollivier
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-28 00:00:00.000000000 Z
+date: 2017-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: droplet_kit
@@ -150,6 +150,26 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.1.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.6.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.6.0
 description: Open PaaS provisioning on cloud providers from JSON manifest file
 email: v@vinc.cc
 executables:
@@ -164,10 +184,16 @@ files:
 - lib/provisioning.rb
 - lib/provisioning/cli.rb
 - lib/provisioning/compute/aws.rb
+- lib/provisioning/compute/base.rb
 - lib/provisioning/compute/digitalocean.rb
 - lib/provisioning/console.rb
+- lib/provisioning/core.rb
+- lib/provisioning/dns/aws.rb
+- lib/provisioning/dns/base.rb
 - lib/provisioning/dns/digitalocean.rb
+- lib/provisioning/platform/base.rb
 - lib/provisioning/platform/dokku.rb
+- lib/provisioning/platform/flynn.rb
 - lib/provisioning/public_key.rb
 - lib/provisioning/version.rb
 homepage: https://github.com/vinc/provisioning.rb
@@ -190,7 +216,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Open PaaS provisioning