capistrano-data_plane_api 0.1.0

data/lib/capistrano/data_plane_api/deploy/args.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module Capistrano
+  module DataPlaneApi
+    module Deploy
+      # Class which parses all provided command-line arguments
+      # passed to the deployment script and saves them in
+      # an object.
+      class Args
+        # @return [Array<String>]
+        PRINTABLE_ENV_VARS = %w[BRANCH NO_MIGRATIONS].freeze
+
+        # @param options [Array, nil]
+        # @return [self]
+        def self.parse(options = nil) # rubocop:disable Metrics/MethodLength, Style/ClassMethodsDefinitions
+          args = new
+
+          opt_parser = ::OptionParser.new do |parser| # rubocop:disable Metrics/BlockLength
+            parser.banner = <<~BANNER
+              Usage: bin/deploy [options]
+
+              This script can be used to deploy this app to remote servers.
+
+            BANNER
+
+            parser.on(
+              '-c',
+              '--current',
+              'Deploy from the currently checked out branch'
+            ) do |_val|
+              args.branch = `git branch --show-current`.strip
+              ::ENV['BRANCH'] = args.branch
+            end
+
+            parser.on(
+              '-t',
+              '--test',
+              'Show the commands that would be executed but do not carry out the deployment'
+            ) do |val|
+              args.test = val
+            end
+
+            parser.on(
+              '-g GROUP',
+              '--group=GROUP',
+              'Deploy the code to every server in the passed HAProxy backend/group'
+            ) do |val|
+              args.group = val
+            end
+
+            parser.on(
+              '--no-haproxy',
+              'Do not modify the state of any server in HAProxy'
+            ) do |val|
+              args.no_haproxy = val
+              ::ENV['NO_HAPROXY'] = 'true'
+            end
+
+            parser.on(
+              '--force-haproxy',
+              'Ignore the current state of servers in HAProxy'
+            ) do |val|
+              args.force_haproxy = val
+              ::ENV['FORCE_HAPROXY'] = 'true'
+            end
+
+            parser.on(
+              '-o ONLY',
+              '--only=ONLY',
+              'Deploy the code only to the passed servers in the same order'
+            ) do |val|
+              next unless val
+
+              args.only = val.split(',').map(&:strip).uniq
+            end
+
+            parser.on(
+              '-H',
+              '--haproxy-config',
+              'Show the current HAProxy configuration'
+            ) do |val|
+              next unless val
+
+              ::Signal.trap('INT') { exit }
+              ::Capistrano::DataPlaneApi.show_config
+              exit
+            end
+
+            parser.on(
+              '-S',
+              '--haproxy-state',
+              'Show the current HAProxy state'
+            ) do |val|
+              next unless val
+
+              ::Signal.trap('INT') { exit }
+              ::Capistrano::DataPlaneApi.show_state
+              exit
+            end
+
+            parser.on(
+              '-T',
+              '--tasks',
+              'Print a list of all available deployment Rake tasks'
+            ) do |val|
+              next unless val
+
+              puts COLORS.bold.blue('Available Rake Tasks')
+              `cap -T`.each_line do |line|
+                puts line.delete_prefix('cap ')
+              end
+              exit
+            end
+
+            parser.on(
+              '-r RAKE',
+              '--rake=RAKE',
+              'Carry out a particular Rake task on the server'
+            ) do |val|
+              next unless val
+
+              args.rake = val
+            end
+
+            parser.on('-h', '--help', 'Prints this help') do
+              puts parser
+              exit
+            end
+
+            parser.on(
+              '-b BRANCH',
+              '--branch=BRANCH',
+              'Deploy the code from the passed Git branch'
+            ) do |val|
+              args.branch = val
+              ::ENV['BRANCH'] = val
+            end
+
+            parser.on(
+              '--no-migrations',
+              'Do not carry out migrations'
+            ) do |val|
+              args.no_migrations = val
+              ::ENV['NO_MIGRATIONS'] = 'true'
+            end
+          end
+
+          opt_parser.parse!(options || ::ARGV)
+          args.stage = ::ARGV.first&.start_with?('-') ? nil : ::ARGV.first
+          args.prepare_if_one_server
+          args
+        end
+
+        # @return [String, nil] Git branch that the code will be deployed to
+        attr_accessor :branch
+        # @return [Boolean] Runs in test mode if true, only prints commands without executing them
+        attr_accessor :test
+        # @return [String, nil] Name of the HAProxy server group/backend
+        attr_accessor :group
+        # @return [Boolean]
+        attr_accessor :no_haproxy
+        # @return [Boolean]
+        attr_accessor :no_migrations
+        # @return [Boolean]
+        attr_accessor :force_haproxy
+        # @return [Array<String>, nil] Ordered list of servers to which the app will be deployed
+        attr_accessor :only
+        # @return [String, nil] Rake command that will be called remotely (`deploy` by default)
+        attr_accessor :rake
+        # @return [String, nil] Name of the deployment stage/server
+        attr_accessor :stage
+
+        alias test? test
+
+        def initialize
+          @rake = 'deploy'
+        end
+
+        # @return [Boolean]
+        def only?
+          return false if @only.nil?
+
+          @only.any?
+        end
+
+        # @return [void]
+        def prepare_if_one_server
+          return unless one_server?
+
+          server, backend = ::Capistrano::DataPlaneApi.find_server_and_backend(@stage)
+          @only = [server['name']]
+          @group = backend['name']
+        end
+
+        # @param stage [String, Symbol, nil]
+        # @return [String]
+        def deploy_command(stage = nil)
+          used_stage = stage || self.stage
+          "cap #{used_stage} #{rake}"
+        end
+
+        # @param stage [String, Symbol, nil]
+        # @return [String]
+        def humanized_deploy_command(stage = nil)
+          result = ::String.new
+          PRINTABLE_ENV_VARS.each do |env_var_name|
+            next unless (value = ::ENV[env_var_name])
+
+            result << "#{env_var_name}=#{value} "
+          end
+
+          result << deploy_command(stage)
+          result
+        end
+
+        # @param key [Symbol, String]
+        # @return [Object]
+        def [](key)
+          public_send(key)
+        end
+
+        # @param key [Symbol, String]
+        # @param val [Object]
+        # @return [Object]
+        def []=(key, val)
+          public_send("#{key}=", val)
+        end
+
+        private
+
+        # @return [Boolean]
+        def one_server?
+          @stage && @group.nil?
+        end
+      end
+    end
+
+  end
+end

data/lib/capistrano/data_plane_api/deploy/deployment_stats.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+module Capistrano
+  module DataPlaneApi
+    module Deploy
+      # Represents a collection of deployment stats for particular servers.
+      class DeploymentStats
+        # @return [Capistrano::DataPlaneApi::Configuration::Backend, nil]
+        #   Configuration data of a particular HAProxy backend
+        attr_accessor :backend
+
+        # @return [Time, nil]
+        attr_accessor :start_time
+
+        # @return [Time, nil]
+        attr_accessor :end_time
+
+        # @return [Hash{String => Deploy::ServerStats}]
+        attr_accessor :server_stats
+
+        # @return [Boolean]
+        attr_accessor :success
+
+        def initialize
+          @backend = nil
+          @start_time = nil
+          @end_time = nil
+          @success = true
+          @server_stats = {}
+        end
+
+        # @param key [String]
+        # @return [Deploy::ServerStats]
+        def [](key)
+          @server_stats[key]
+        end
+
+        # @param key [String]
+        # @param val [Deploy::ServerStats]
+        def []=(key, val)
+          @server_stats[key] = val
+        end
+
+        # @param servers [Array<Capistrano::DataPlaneApi::Configuration::Server>, Capistrano::DataPlaneApi::Configuration::Server]
+        # @return [void]
+        def create_stats_for(servers)
+          servers = *servers
+
+          servers.each do |server|
+            @server_stats[server.name] = ServerStats.new(server.name, @backend.name)
+          end
+        end
+
+        # @return [String]
+        def to_s
+          update_states_in_stats
+
+          time_string = COLORS.bold.yellow ::Time.now.to_s
+          if success
+            state = COLORS.bold.green 'Successful'
+            time_sentence = 'took'
+          else
+            state = COLORS.bold.red 'Failed'
+            time_sentence = 'failed after'
+          end
+
+          result = ::String.new
+          result << "\n#{time_string}\n\n"
+          result << "#{state} deployment to #{::Capistrano::DataPlaneApi.humanize_backend_name(@backend)}\n"
+          result << "  #{time_sentence} #{Helper.humanize_time(seconds)}\n"
+
+          @server_stats.each_value do |stats|
+            result << "\n#{stats}"
+          end
+
+          result
+        end
+
+        # @return [Integer, nil] How much time has the deployment taken
+        def seconds
+          @seconds ||= Helper.seconds_since(@start_time, to: @end_time)
+        end
+
+        private
+
+        # @return [void]
+        def update_states_in_stats
+          return if @update_states_in_stats
+
+          @update_states_in_stats = true
+          update_states_in_stats!
+        end
+
+        def update_states_in_stats!
+          server_states = begin
+            ::Capistrano::DataPlaneApi.get_backend_servers_settings(@backend.name).body
+          rescue Error
+            nil
+          end
+
+          return unless server_states
+
+          server_states.each do |server_state|
+            @server_stats[server_state['name']]&.then do |s|
+              s.admin_state = server_state['admin_state']
+              s.operational_state = server_state['operational_state']
+            end
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/capistrano/data_plane_api/deploy/group.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Capistrano
+  module DataPlaneApi
+    module Deploy
+      # Class which deploys the app to all servers
+      # in a particular HAProxy backend/group.
+      class Group
+        class << self
+          # @param args [DeployArgs]
+          # @return [void]
+          def call(args)
+            new(args).call
+          end
+        end
+
+        # @param args [DeployArgs]
+        def initialize(args)
+          @args = args
+          @deployment_stats = DeploymentStats.new
+        end
+
+        # @return [Boolean, nil] Whether the deployment has been successful
+        def call
+          @backend = ::Capistrano::DataPlaneApi.find_backend(@args.group)
+          @servers = servers(@backend)
+          start_deployment
+
+          success = nil
+          @servers.each do |server|
+            server_stats = @deployment_stats[server.name]
+            puts COLORS.bold.blue("Deploying the app to `#{server.stage}` -- `#{@backend.name}:#{server.name}`")
+
+            puts @args.humanized_deploy_command(server.stage)
+            puts
+
+            next if @args.test?
+
+            server_stats.start_time = ::Time.now
+            deploy_command = @args.deploy_command(server.stage)
+            success = system deploy_command
+
+            server_stats.end_time = ::Time.now
+            server_stats.success = success
+
+            next if success
+
+            puts COLORS.bold.red("Command `#{deploy_command}` failed")
+            break
+          end
+
+          return if @args.test?
+
+          finish_deployment(success: success)
+          print_summary
+          success
+        end
+
+        private
+
+        # @return [void]
+        def start_deployment
+          @deployment_stats.tap do |d|
+            d.start_time = ::Time.now
+            d.backend = @backend
+            d.create_stats_for @servers
+          end
+        end
+
+        # @param success [Boolean]
+        def finish_deployment(success: true)
+          @deployment_stats.end_time = ::Time.now
+          @deployment_stats.success = success
+        end
+
+        # @return [void]
+        def print_summary
+          puts @deployment_stats
+        end
+
+        # @param backend [Capistrano::DataPlaneApi::Configuration::Backend]
+        # @return [Array<Capistrano::DataPlaneApi::Configuration::Server>]
+        def servers(backend)
+          return backend.servers unless @args.only?
+
+          chosen_servers = []
+          @args.only.each do |current_server_name|
+            backend.servers.each do |server|
+              next unless server.name == current_server_name || server.stage == current_server_name
+
+              chosen_servers << server
+            end
+          end
+
+          chosen_servers
+        end
+      end
+    end
+  end
+end

data/lib/capistrano/data_plane_api/deploy/helper.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Capistrano
+  module DataPlaneApi
+    module Deploy
+      # A module which provides some generic helper methods used
+      # in the deployment script.
+      module Helper
+        extend self
+
+        # @param seconds [Integer]
+        # @return [String]
+        def humanize_time(seconds)
+          hours = seconds / 3600
+          rest_seconds = seconds - (hours * 3600)
+          minutes = rest_seconds / 60
+          rest_seconds = seconds - (minutes * 60)
+
+          result = ::String.new
+
+          if rest_seconds.positive?
+            result.prepend "#{rest_seconds}s"
+            styles = %i[bright_green]
+          end
+
+          if minutes.positive?
+            result.prepend "#{minutes}min "
+            styles = %i[bright_yellow]
+          end
+
+          if hours.positive?
+            result.prepend "#{hours}h "
+            styles = %i[bright_red]
+          end
+
+          COLORS.decorate(result.strip, *styles)
+        end
+
+        # Calculate how many seconds have passed
+        # since the given point in time.
+        #
+        # @param time [Time]
+        # @param to [Time]
+        # @return [Integer]
+        def seconds_since(time, to: ::Time.now)
+          (to - time).to_i
+        end
+      end
+    end
+  end
+end

data/lib/capistrano/data_plane_api/deploy/server_stats.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Capistrano
+  module DataPlaneApi
+    module Deploy
+      # Represents the stats of a deployment to a particular server
+      class ServerStats
+        # @return [Boolean, nil] `nil` when the deployment hasn't begun
+        #   `true` when it has finished successfully, `false` when it has failed
+        attr_accessor :success
+
+        # @return [Time, nil]
+        attr_accessor :start_time
+
+        # @return [Time, nil]
+        attr_accessor :end_time
+
+        # @return [String]
+        attr_accessor :server_name
+
+        # @return [String]
+        attr_accessor :backend_name
+
+        # @return [String, nil]
+        attr_accessor :admin_state
+
+        # @return [String, nil]
+        attr_accessor :operational_state
+
+        # @param server_name [String]
+        # @param backend_name [String]
+        def initialize(server_name, backend_name)
+          @server_name = server_name
+          @backend_name = backend_name
+          @success = nil
+          @seconds = nil
+        end
+
+        # @return [String]
+        def to_s
+          time_string =
+            case @success
+            when nil    then 'skipped'
+            when false  then "failed after #{Helper.humanize_time(seconds)}"
+            when true   then "took #{Helper.humanize_time(seconds)}"
+            end
+
+          "  #{state_emoji} #{server_title} #{time_string}#{haproxy_states}"
+        end
+
+        # @return [Integer, nil] How much time has the deployment taken
+        def seconds
+          @seconds ||= Helper.seconds_since(@start_time, to: @end_time)
+        end
+
+        private
+
+        # @return [String, nil]
+        def humanize_admin_state
+          ::Capistrano::DataPlaneApi.humanize_admin_state(@admin_state)
+        end
+
+        # @return [String, nil]
+        def humanize_operational_state
+          ::Capistrano::DataPlaneApi.humanize_operational_state(@operational_state)
+        end
+
+        # @return [String, nil]
+        def haproxy_states
+          <<-HAPROXY
+
+                admin_state: #{humanize_admin_state}
+          operational_state: #{humanize_operational_state}
+          HAPROXY
+        end
+
+        # @return [Hash{String => Symbol}]
+        SERVER_TITLE_COLORS = {
+          nil => :yellow,
+          false => :red,
+          true => :green
+        }.freeze
+        private_constant :SERVER_TITLE_COLORS
+
+        # @return [String]
+        def server_title
+          COLORS.decorate(server_id, :bold, SERVER_TITLE_COLORS[@success])
+        end
+
+        # @return [String]
+        def server_id
+          "#{@backend_name}:#{@server_name}"
+        end
+
+        # @return [Hash{Boolean, nil => Symbol}]
+        STATE_EMOJIS = {
+          nil => '🟡',
+          false => '❌',
+          true => '✅'
+        }.freeze
+        private_constant :STATE_EMOJIS
+
+        # @return [String]
+        def state_emoji
+          STATE_EMOJIS[@success]
+        end
+      end
+    end
+  end
+end

data/lib/capistrano/data_plane_api/deploy.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative '../data_plane_api'
+
+module Capistrano
+  module DataPlaneApi
+    # Contains code used in the deployment script.
+    module Deploy
+      class << self
+        # @return [void]
+        def call
+          args = Args.parse
+          puts COLORS.bold.blue('Running the deployment script')
+
+          result = Group.call(args)
+          abort if result == false
+        end
+      end
+    end
+  end
+end
+
+require_relative 'deploy/args'
+require_relative 'deploy/helper'
+require_relative 'deploy/deployment_stats'
+require_relative 'deploy/server_stats'
+require_relative 'deploy/group'

data/lib/capistrano/data_plane_api/diggable.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Capistrano
+  module DataPlaneApi
+    # Include in a class to grant it the `#dig` method.
+    # It's implemented so that it calls public methods.
+    module Diggable
+      # Extracts the nested value specified by the sequence of key objects by calling `dig` at each step,
+      # returning `nil` if any intermediate step is `nil`.
+      #
+      # This implementation of `dig` uses `public_send` under the hood.
+      #
+      # @raise [TypeError] value has no #dig method
+      # @return [Object]
+      def dig(*args)
+        return unless args.size.positive?
+
+        return unless respond_to?(key = args.shift)
+
+        value = public_send(key)
+        return if value.nil?
+        return value if args.size.zero?
+        raise ::TypeError, "#{value.class} does not have #dig method" unless value.respond_to?(:dig)
+
+        value.dig(*args)
+      rescue ::ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/capistrano/data_plane_api/equatable.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Capistrano
+  module DataPlaneApi
+    # Include in a class to make its instances capable
+    # of comparing themselves with other objects of the same class
+    # by calling `==` on their instance variables.
+    module Equatable
+      # @param other [Object]
+      # @return [Boolean]
+      def eql?(other)
+        return true if equal?(other)
+        return false unless other.is_a?(self.class) || is_a?(other.class)
+
+        # @type [Set<Symbol>]
+        self_ivars = instance_variables.to_set
+        # @type [Set<Symbol>]
+        other_ivars = other.instance_variables.to_set
+
+        return false unless self_ivars == other_ivars
+
+        self_ivars.each do |ivar|
+          return false if instance_variable_get(ivar) != other.instance_variable_get(ivar)
+        end
+
+        true
+      end
+
+      alias == eql?
+    end
+  end
+end