staticpages-plugin-digitalocean 0.3.5

data/lib/kontena/machine/digital_ocean/master_destroyer.rb

@@ -0,0 +1,30 @@
+module Kontena
+  module Machine
+    module DigitalOcean
+      class MasterDestroyer
+        include Kontena::Cli::ShellSpinner
+
+        attr_reader :client, :api_client
+
+        # @param [String] token Digital Ocean token
+        def initialize(token)
+          @client = DropletKit::Client.new(access_token: token)
+        end
+
+        def run!(name)
+          droplet = client.droplets.all.find{|d| d.name == name}
+          if droplet
+            spinner "Terminating DigitalOcean droplet #{name.colorize(:cyan)} " do
+              result = client.droplets.delete(id: droplet.id)
+              if result.is_a?(String)
+                abort "Cannot delete droplet #{name.colorize(:cyan)} in DigitalOcean"
+              end
+            end
+          else
+            abort "Cannot find droplet #{name.colorize(:cyan)} in DigitalOcean"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kontena/machine/digital_ocean/master_provisioner.rb

@@ -0,0 +1,99 @@
+require 'fileutils'
+require 'erb'
+require 'open3'
+
+module Kontena
+  module Machine
+    module DigitalOcean
+      class MasterProvisioner
+        include RandomName
+        include Machine::CertHelper
+        include Kontena::Cli::ShellSpinner
+
+        attr_reader :client, :http_client
+
+        # @param [String] token Digital Ocean token
+        def initialize(token)
+          @client = DropletKit::Client.new(access_token: token)
+        end
+
+        def run!(opts)
+          if opts[:ssl_cert]
+            abort('Invalid ssl cert') unless File.exists?(File.expand_path(opts[:ssl_cert]))
+            ssl_cert = File.read(File.expand_path(opts[:ssl_cert]))
+          else
+            spinner "Generating self-signed SSL certificate" do
+              ssl_cert = generate_self_signed_cert
+            end
+          end
+
+          name = opts[:name]
+          userdata_vars = opts.merge(
+              ssl_cert: ssl_cert,
+              server_name: name
+          )
+
+          droplet = DropletKit::Droplet.new(
+              name: name,
+              region: opts[:region],
+              image: 'coreos-stable',
+              size: opts[:size],
+              private_networking: true,
+              user_data: user_data(userdata_vars),
+              ssh_keys: [opts[:ssh_key_id]],
+              tags: ['master']
+          )
+
+          spinner "Creating DigitalOcean droplet #{droplet.name.colorize(:cyan)} " do
+            droplet = client.droplets.create(droplet)
+            until droplet.status == 'active'
+              droplet = client.droplets.find(id: droplet.id)
+              sleep 1
+            end
+          end
+
+          master_url = "https://#{droplet.public_ip}"
+          Excon.defaults[:ssl_verify_peer] = false
+          @http_client = Excon.new("#{master_url}", {
+            :connect_timeout => 10,
+            :ssl_verify_peer => false
+          })
+
+          spinner "Waiting for #{droplet.name.colorize(:cyan)} to start" do
+            sleep 0.5 until master_running?
+          end
+
+          puts
+          puts "Kontena Master is now running at #{master_url}".colorize(:green)
+          puts
+
+          data = {
+            name: name.sub('kontena-master-', ''),
+            public_ip: droplet.public_ip,
+            code: opts[:initial_admin_code]
+          }
+          if respond_to?(:certificate_public_key) && !opts[:ssl_cert]
+            data[:ssl_certificate] = certificate_public_key(ssl_cert)
+          end
+
+          data
+        end
+
+        def user_data(vars)
+          cloudinit_template = File.join(__dir__ , '/cloudinit_master.yml')
+          erb(File.read(cloudinit_template), vars)
+        end
+
+        def master_running?
+          http_client.get(path: '/').status == 200
+        rescue
+          false
+        end
+
+        def erb(template, vars)
+          ERB.new(template, nil, '%<>-').result(OpenStruct.new(vars).instance_eval { binding })
+        end
+      end
+    end
+  end
+end

data/lib/kontena/machine/digital_ocean/node_destroyer.rb

@@ -0,0 +1,39 @@
+module Kontena
+  module Machine
+    module DigitalOcean
+      class NodeDestroyer
+        include RandomName
+        include Kontena::Cli::ShellSpinner
+
+        attr_reader :client, :api_client
+
+        # @param [Kontena::Client] api_client Kontena api client
+        # @param [String] token Digital Ocean token
+        def initialize(api_client, token)
+          @api_client = api_client
+          @client = DropletKit::Client.new(access_token: token)
+        end
+
+        def run!(grid, name)
+          droplet = client.droplets.all.find{|d| d.name == name}
+          if droplet
+            spinner "Terminating DigitalOcean droplet #{name.colorize(:cyan)} " do
+              result = client.droplets.delete(id: droplet.id)
+              if result.is_a?(String)
+                abort "Cannot delete droplet #{name.colorize(:cyan)} in DigitalOcean"
+              end
+            end
+          else
+            abort "Cannot find droplet #{name.colorize(:cyan)} in DigitalOcean"
+          end
+          node = api_client.get("grids/#{grid['id']}/nodes")['nodes'].find{|n| n['name'] == name}
+          if node
+            spinner "Removing node #{name.colorize(:cyan)} from grid #{grid['name'].colorize(:cyan)} " do
+              api_client.delete("nodes/#{grid['id']}/#{name}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kontena/machine/digital_ocean/node_provisioner.rb

@@ -0,0 +1,90 @@
+require 'fileutils'
+require 'erb'
+require 'open3'
+
+module Kontena
+  module Machine
+    module DigitalOcean
+      class NodeProvisioner
+        include RandomName
+        include Kontena::Cli::ShellSpinner
+
+        attr_reader :client, :api_client
+
+        # @param [Kontena::Client] api_client Kontena api client
+        # @param [String] token Digital Ocean token
+        def initialize(api_client, token)
+          @api_client = api_client
+          @client = DropletKit::Client.new(access_token: token)
+        end
+
+        def run!(opts)
+          userdata_vars = {
+            version: opts[:version],
+            master_uri: opts[:master_uri],
+            grid_token: opts[:grid_token],
+          }
+          image = "coreos-#{opts[:channel]}"
+          droplets = []
+          opts[:count].to_i.times do
+            droplet = DropletKit::Droplet.new(
+              name: opts[:name] || generate_name,
+              region: opts[:region],
+              image: image,
+              size: opts[:size],
+              private_networking: true,
+              user_data: user_data(userdata_vars),
+              ssh_keys: [opts[:ssh_key_id]],
+              tags: [opts[:grid]]
+            )
+            created = client.droplets.create(droplet)
+            spinner "Creating DigitalOcean droplet #{droplet.name.colorize(:cyan)} " do
+              sleep 1 until client.droplets.find(id: created.id).status == 'active'
+            end
+            droplets << droplet
+          end
+          droplets.each do |droplet|
+            node = nil
+            spinner "Waiting for node #{droplet.name.colorize(:cyan)} join to grid #{opts[:grid].colorize(:cyan)} " do
+              sleep 1 until node = droplet_exists_in_grid?(opts[:grid], droplet)
+            end
+            set_labels(
+              node,
+              [
+                "region=#{opts[:region]}",
+                "az=#{opts[:region]}",
+                "provider=digitalocean"
+              ]
+            )
+          end
+        end
+
+        def user_data(vars)
+          cloudinit_template = File.join(__dir__ , '/cloudinit.yml')
+          erb(File.read(cloudinit_template), vars)
+        end
+
+        def generate_name
+          "#{super}-#{rand(1..99)}"
+        end
+
+        def ssh_key(public_key)
+          ssh_key = client.ssh_keys.all.find{|key| key.public_key == public_key}
+        end
+
+        def droplet_exists_in_grid?(grid, droplet)
+          api_client.get("grids/#{grid}/nodes")['nodes'].find{|n| n['name'] == droplet.name}
+        end
+
+        def erb(template, vars)
+          ERB.new(template).result(OpenStruct.new(vars).instance_eval { binding })
+        end
+
+        def set_labels(node, labels)
+          data = {labels: labels}
+          api_client.put("nodes/#{node['id']}", data, {}, {'Kontena-Grid-Token' => node['grid']['token']})
+        end
+      end
+    end
+  end
+end

data/lib/kontena/machine/digital_ocean/ssh_key_manager.rb

@@ -0,0 +1,31 @@
+module Kontena
+  module Machine
+    module DigitalOcean
+      class SshKeyManager
+
+        attr_reader :client
+
+        # @param [String] token Digital Ocean API token
+        def initialize(token)
+          @client = DropletKit::Client.new(access_token: token)
+        end
+
+        def find_by_public_key(public_key)
+          list.find { |key| key.public_key == public_key }
+        end
+
+        def list
+          client.ssh_keys.all.to_a
+        end
+
+        def create(public_key)
+          client.ssh_keys.create(DropletKit::SSHKey.new(public_key: public_key, name: public_key.split(/\s+/).last))
+        end
+
+        def find_or_create_by_public_key(public_key)
+          find_by_public_key(public_key) || create(public_key)
+        end
+      end
+    end
+  end
+end

data/lib/kontena/machine/digital_ocean.rb

@@ -0,0 +1,8 @@
+require 'droplet_kit'
+require 'kontena/machine/random_name'
+require 'kontena/machine/cert_helper'
+require_relative 'digital_ocean/node_provisioner'
+require_relative 'digital_ocean/node_destroyer'
+require_relative 'digital_ocean/master_provisioner'
+require_relative 'digital_ocean/master_destroyer'
+require_relative 'digital_ocean/ssh_key_manager'

data/lib/kontena/plugin/digital_ocean/master/create_command.rb

@@ -0,0 +1,53 @@
+require 'kontena/plugin/digital_ocean/prompts'
+
+module Kontena::Plugin::DigitalOcean::Master
+  class CreateCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Plugin::DigitalOcean::Prompts
+
+    option "--name", "[NAME]", "Set master name"
+    option "--token", "TOKEN", "DigitalOcean API token", environment_variable: "DO_TOKEN"
+    option "--region", "REGION", "Region"
+    option "--size", "SIZE", "Droplet size"
+    option "--ssh-key", "SSH_KEY", "Path to ssh public key"
+    option "--ssl-cert", "SSL CERT", "SSL certificate file"
+    option "--vault-secret", "VAULT_SECRET", "Secret key for Vault (optional)"
+    option "--vault-iv", "VAULT_IV", "Initialization vector for Vault (optional)"
+    option "--mongodb-uri", "URI", "External MongoDB uri (optional)"
+    option "--version", "VERSION", "Define installed Kontena version", default: 'latest'
+
+    def execute
+      suppress_warnings # until DO merges resource_kit pr #32
+      do_token = ask_do_token
+
+      require 'securerandom'
+      require 'kontena/machine/digital_ocean'
+
+      do_token = ask_do_token
+      do_region = ask_droplet_region(do_token)
+      do_size = ask_droplet_size(do_token, do_region)
+      do_ssh_key_id = ask_ssh_key(do_token)
+
+      provisioner = provisioner(do_token)
+      provisioner.run!(
+        name: name,
+        ssh_key_id: do_ssh_key_id,
+        ssl_cert: ssl_cert,
+        size: do_size,
+        region: do_region,
+        version: version,
+        vault_secret: vault_secret || SecureRandom.hex(24),
+        vault_iv: vault_iv || SecureRandom.hex(24),
+        initial_admin_code: SecureRandom.hex(16),
+        mongodb_uri: mongodb_uri
+      )
+    ensure
+      resume_warnings
+    end
+
+    # @param [String] token
+    def provisioner(token)
+      Kontena::Machine::DigitalOcean::MasterProvisioner.new(token)
+    end
+  end
+end

data/lib/kontena/plugin/digital_ocean/master/terminate_command.rb

@@ -0,0 +1,29 @@
+require 'kontena/plugin/digital_ocean/prompts'
+
+module Kontena::Plugin::DigitalOcean::Master
+  class TerminateCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::GridOptions
+    include Kontena::Plugin::DigitalOcean::Prompts
+
+    parameter "NAME", "Master name"
+    option "--token", "TOKEN", "DigitalOcean API token", environment_variable: "DO_TOKEN"
+    option "--force", :flag, "Force remove", default: false, attribute_name: :forced
+
+    def execute
+      suppress_warnings # until DO merges resource_kit pr #32
+      require 'kontena/machine/digital_ocean'
+      do_token = ask_do_token
+      confirm_command(name) unless forced?
+      destroyer = destroyer(do_token)
+      destroyer.run!(name)
+    ensure
+      resume_warnings
+    end
+
+    # @param [String] token
+    def destroyer(token)
+      Kontena::Machine::DigitalOcean::MasterDestroyer.new(token)
+    end
+  end
+end

data/lib/kontena/plugin/digital_ocean/master_command.rb

@@ -0,0 +1,4 @@
+class Kontena::Plugin::DigitalOcean::MasterCommand < Kontena::Command
+  subcommand "create", "Create a new master to DigitalOcean", load_subcommand('kontena/plugin/digital_ocean/master/create_command')
+  subcommand "terminate", "Terminate DigitalOcean master", load_subcommand('kontena/plugin/digital_ocean/master/terminate_command')
+end

data/lib/kontena/plugin/digital_ocean/node_command.rb

@@ -0,0 +1,5 @@
+class Kontena::Plugin::DigitalOcean::NodeCommand < Kontena::Command
+  subcommand "create", "Create a new node to DigitalOcean", load_subcommand('kontena/plugin/digital_ocean/nodes/create_command')
+  subcommand "restart", "Restart DigitalOcean node", load_subcommand('kontena/plugin/digital_ocean/nodes/restart_command')
+  subcommand "terminate", "Terminate DigitalOcean node", load_subcommand('kontena/plugin/digital_ocean/nodes/terminate_command')
+end

data/lib/kontena/plugin/digital_ocean/nodes/create_command.rb

@@ -0,0 +1,68 @@
+require 'kontena/plugin/digital_ocean/prompts'
+
+module Kontena::Plugin::DigitalOcean::Nodes
+  class CreateCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::GridOptions
+    include Kontena::Plugin::DigitalOcean::Prompts
+
+    parameter "[NAME]", "Node name"
+    option "--token", "TOKEN", "DigitalOcean API token", environment_variable: 'DO_TOKEN'
+    option "--region", "REGION", "Region"
+    option "--ssh-key", "SSH_KEY", "Path to ssh public key"
+    option "--size", "SIZE", "Droplet size"
+    option "--count", "COUNT", "How many droplets to create"
+    option "--version", "VERSION", "Define installed Kontena version", default: 'latest'
+    option "--channel", "CHANNEL", "Define CoreOS image channel"
+
+    def execute
+      suppress_warnings # until DO merges resource_kit pr #32
+      require 'kontena/machine/digital_ocean'
+      require_api_url
+      require_current_grid
+
+      do_token = ask_do_token
+      do_region = ask_droplet_region(do_token)
+      coreos_channel = self.channel || ask_channel
+      do_size = ask_droplet_size(do_token, do_region)
+      do_count = ask_droplet_count
+      do_ssh_key_id = ask_ssh_key(do_token)
+
+      grid = fetch_grid
+      provisioner = provisioner(client(require_token), do_token)
+      provisioner.run!(
+        master_uri: api_url,
+        grid_token: grid['token'],
+        grid: current_grid,
+        ssh_key_id: do_ssh_key_id,
+        name: name,
+        size: do_size,
+        count: do_count,
+        region: do_region,
+        version: version,
+        channel: coreos_channel
+      )
+    ensure
+      resume_warnings
+    end
+
+    def ask_droplet_count
+      if self.count.nil?
+        prompt.ask('How many droplets?:', default: 1)
+      else
+        self.count
+      end
+    end
+
+    # @param [Kontena::Client] client
+    # @param [String] token
+    def provisioner(client, token)
+      Kontena::Machine::DigitalOcean::NodeProvisioner.new(client, token)
+    end
+
+    # @return [Hash]
+    def fetch_grid
+      client(require_token).get("grids/#{current_grid}")
+    end
+  end
+end