firespring_dev_commands 1.3.0

data/lib/firespring_dev_commands/docker.rb

@@ -0,0 +1,276 @@
+require 'docker'
+require 'json'
+
+# TODO: Make these configurable?
+# Set docker write timeout to 1 hour
+Excon.defaults[:write_timeout] = 3600
+
+# Set docker read timeout to 1 hour
+Excon.defaults[:read_timeout] = 3600
+
+module Dev
+  # Class contains many useful methods for interfacing with the docker api
+  class Docker
+    # Config object for setting top level docker config options
+    Config = Struct.new(:min_version, :max_version) do
+      def initialize
+        self.min_version = nil
+        self.max_version = nil
+      end
+    end
+
+    class << self
+      # Instantiates a new top level config object if one hasn't already been created
+      # Yields that config object to any given block
+      # Returns the resulting config object
+      def config
+        @config ||= Config.new
+        yield(@config) if block_given?
+        @config
+      end
+
+      # Alias the config method to configure for a slightly clearer access syntax
+      alias_method :configure, :config
+
+      # Returns the version of the docker engine running on the system
+      def version
+        @version ||= JSON.parse(::Docker.connection.get('/version'))['Version']
+      end
+    end
+
+    def initialize
+      check_version
+    end
+
+    # Checks the min and max version against the current docker version if they have been configured
+    def check_version
+      min_version = self.class.config.min_version
+      raise "requires docker version >= #{min_version} (found #{self.class.version})" if min_version && !Dev::Common.new.version_greater_than(min_version, self.class.version)
+
+      max_version = self.class.config.max_version
+      raise "requires docker version < #{max_version} (found #{self.class.version})" if max_version && Dev::Common.new.version_greater_than(max_version, self.class.version)
+    end
+
+    # Prunes/removes all unused containers, networks, volumes, and images
+    def prune
+      prune_containers
+      prune_networks
+      prune_volumes
+      prune_images
+    end
+
+    # Prunes/removes all unused containers
+    def prune_containers
+      _prune('containers')
+    end
+
+    # Prunes/removes all unused networks
+    def prune_networks
+      _prune('networks')
+    end
+
+    # Prunes/removes all unused volumes
+    def prune_volumes
+      _prune('volumes')
+    end
+
+    # Prunes/removes all unused images
+    def prune_images
+      _prune('images')
+    end
+
+    # Private method which actually calls the prune endpoint on the docker api connection
+    private def _prune(type)
+      response = ::Docker.connection.post("/#{type.downcase}/prune", {})
+      format_prune(type, response)
+    rescue ::Docker::Error::ServerError => e
+      # Specifically check for 'prune already running' error and retry if found
+      if /already running/.match?(e.to_s)
+        sleep 2
+        retry
+      end
+      raise
+    end
+
+    # Callback method which formats the output from the prune method to give details on what was cleaned and how much space was reclaimed
+    private def format_prune(type, response)
+      info = JSON.parse(response)
+      type = type.capitalize
+
+      LOG.info "\nDeleted #{type.capitalize}"
+      deleted_items = info["#{type}Deleted"] || []
+      deleted_items.each { |it| LOG.info "  #{it}" }
+      LOG.info "Total reclaimed space: #{filesize(info['SpaceReclaimed'])}"
+    end
+
+    # Print the given filesize using the most appropriate units
+    private def filesize(size)
+      return '0.0 B' if size.to_i.zero?
+
+      units = %w(B KB MB GB TB Pb EB)
+      exp = (Math.log(size) / Math.log(1024)).to_i
+      exp = 6 if exp > 6
+
+      format('%.1f %s', size.to_f / (1024**exp), units[exp])
+    end
+
+    # Remove docker images with the "force" option set to true
+    # This will remove the images even if they are currently in use and cause unintended side effects.
+    def force_remove_images(name_and_tag)
+      images = ::Docker::Image.all(filter: name_and_tag)
+      ::Docker::Image.remove(images[0].id, force: true) unless images.empty?
+    end
+
+    # Calls the docker compose method with the given inputs
+    # @deprecated Please use {Docker::Compose#container_by_name} instead
+    def container_by_name(service_name, prefix = nil, status: [Docker::Status::RUNNING])
+      warn '[DEPRECATION] `Docker#container_by_name` is deprecated.  Please use `Docker::Compose#container_by_name` instead.'
+      Docker::Compose.new.container_by_name(service_name, prefix, status)
+    end
+
+    # Calls the docker compose method with the given inputs
+    # @deprecated Please use {Docker::Compose#mapped_public_port} instead
+    def mapped_public_port(name, private_port)
+      warn '[DEPRECATION] `Docker#mapped_public_port` is deprecated.  Please use `Docker::Compose#mapped_public_port` instead.'
+      Docker::Compose.new.mapped_public_port(name, private_port)
+    end
+
+    # Copies the source path on your local machine to the destination path on the container
+    def copy_to_container(container, source_path, dest_path)
+      LOG.info "Copying #{source_path} to #{dest_path}... "
+
+      container.archive_in(source_path, dest_path, overwrite: true)
+      return unless File.directory?(source_path)
+
+      dest_file = File.basename(source_path)
+      # TODO: Can we find a better solution for this? Seems pretty brittle
+      retcode = container.exec(['bash', '-c', "cd #{dest_path}; tar -xf #{dest_file}; rm -f #{dest_file}"])[-1]
+      raise 'Unable to unpack on container' unless retcode.zero?
+    end
+
+    # Copies the source path on the container to the destination path on your local machine
+    # If required is set to true, the command will fail if the source path does not exist on the container
+    def copy_from_container(container, source_path, dest_path, required: true)
+      LOG.info "Copying #{source_path} to #{dest_path}... "
+
+      tar = StringIO.new
+      begin
+        container.archive_out(source_path) do |chunk|
+          tar.write(chunk)
+        end
+      rescue => e
+        raise e if required
+
+        puts 'Not Found'
+      end
+
+      Dev::Tar.new(tar).unpack(source_path, dest_path)
+    end
+
+    # Display a nicely formatted table of images and their associated information
+    def print_images
+      reposize   = 70
+      tagsize    = 79
+      imagesize  = 15
+      createsize = 20
+      sizesize   = 10
+      total = reposize + tagsize + imagesize + createsize + sizesize
+
+      # If there is additional width available, add it to the repo and tag columns
+      additional = [((Rake.application.terminal_width - total) / 2).floor, 0].max
+      reposize += additional
+      tagsize += additional
+
+      format = "%-#{reposize}s%-#{tagsize}s%-#{imagesize}s%-#{createsize}s%s"
+      puts format(format, :REPOSITORY, :TAG, :'IMAGE ID', :CREATED, :SIZE)
+      ::Docker::Image.all.each do |image|
+        image_info(image).each do |repo, tag, id, created, size|
+          puts format(format, repo, tag, id, created, size)
+        end
+      end
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # Take the given image and grab all of the parts of it which will be used to display the image info
+    private def image_info(image)
+      [].tap do |ary|
+        id = image.info&.dig('id')&.split(':')&.last&.slice(0..11)
+        created = timesince(Time.at(image.info&.dig('Created')))
+        size = filesize(image.info&.dig('Size'))
+
+        repo_urls = image.info&.dig('RepoTags')
+        repo_urls ||= ["#{image.info&.dig('RepoDigests')&.first&.split(':')&.first&.split('@')&.first}:<none>"]
+        repo_urls.each do |repo_url|
+          repo, tag = repo_url.split(':')
+          tag ||= '<none>'
+          ary << [repo, tag, id, created, size]
+        end
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity
+
+    # Display a nicely formatted table of containers and their associated information
+    def print_containers
+      idsize = 15
+      imagesize = 25
+      commandsize = 25
+      createsize = 17
+      statussize = 16
+      portsize = 25
+      namesize = 10
+      total = idsize + imagesize + commandsize + createsize + statussize + portsize + namesize
+
+      # If there is additional width available, add it to the repo and tag columns
+      additional = [((Rake.application.terminal_width - total) / 2).floor, 0].max
+      imagesize += additional
+      portsize += additional
+
+      format = "%-#{idsize}s%-#{imagesize}s%-#{commandsize}s%-#{createsize}s%-#{statussize}s%-#{portsize}s%s"
+      puts format(format, :'CONTAINER ID', :IMAGE, :COMMAND, :CREATED, :STATUS, :PORTS, :NAMES)
+      ::Docker::Container.all.each do |container|
+        id, image, command, created, status, ports, names = container_info(container)
+        puts format(format, id, image, command, created, status, ports, names)
+      end
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # Take the given container and grab all of the parts of it which will be used to display the container info
+    private def container_info(container)
+      id = container.id&.slice(0..11)
+      image = container.info&.dig('Image')
+
+      command = container.info&.dig('Command')&.truncate(20)
+      created = timesince(Time.at(container.info&.dig('Created')))
+      status = container.info&.dig('Status')
+
+      ports = container.info&.dig('Ports')&.map do |port_info|
+        ip = port_info['IP']
+        private_port = port_info['PrivatePort']
+        public_port = port_info['PublicPort']
+        type = port_info['Type']
+        next "#{private_port}/#{type}" unless ip && public_port
+
+        "#{ip}:#{public_port}->#{private_port}/#{type}"
+      end&.join(', ')
+      names = container.info&.dig('Names')&.map { |name| name.split('/').last }&.join(', ')
+
+      [id, image, command, created, status, ports, names]
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity
+
+    # Print the time since the given time in the most appropriate unit
+    private def timesince(time)
+      return '' unless time && time.is_a?(Time)
+
+      time_since = (Time.now - time).to_i
+      return "#{time_since} seconds ago" if time_since <= Dev::Second::PER_MINUTE
+      return "#{(time_since / Dev::Second::PER_MINUTE).ceil} minutes ago" if time_since <= Dev::Second::PER_HOUR
+      return "#{(time_since / Dev::Second::PER_HOUR).ceil} hours ago" if time_since <= Dev::Second::PER_DAY
+      return "#{(time_since / Dev::Second::PER_DAY).ceil} days ago" if time_since <= Dev::Second::PER_WEEK
+      return "#{(time_since / Dev::Second::PER_WEEK).ceil} weeks ago" if time_since <= Dev::Second::PER_MONTH
+      return "#{(time_since / Dev::Second::PER_MONTH).ceil} months ago" if time_since <= Dev::Second::PER_YEAR
+
+      "#{(time_since / Dev::Second::PER_YEAR).ceil} years ago"
+    end
+  end
+end

data/lib/firespring_dev_commands/dotenv.rb

@@ -0,0 +1,6 @@
+# require 'dotenv'
+
+## Load the override and the env file
+# DOT_ENV_OVERRIDE = '.env.override'.freeze
+# Dotenv.load(DOT_ENV_OVERRIDE)
+# Dotenv.load

data/lib/firespring_dev_commands/env.rb

@@ -0,0 +1,38 @@
+module Dev
+  # Class instance represents a '.env' file and includes methods to read/write the given filename
+  class Env
+    require 'pathname'
+
+    attr_accessor :envfile, :data
+
+    def initialize(filename = '.env')
+      @envfile = Pathname.new(filename)
+      @data = {}
+      return unless File.exist?(@envfile)
+
+      File.readlines(@envfile).each do |line|
+        key, value = line.split('=')
+        @data[key.to_s.strip.to_sym] = value.to_s.strip
+      end
+    end
+
+    # Get the value of the key from the loaded env data
+    def get(key)
+      data[key.to_s.strip.to_sym]
+    end
+
+    # Set the value of the key in the loaded env data
+    def set(key, value)
+      data[key.to_s.strip.to_sym] = value.to_s.strip
+    end
+
+    # Write the current env data back to the original file
+    def write
+      File.open(envfile, 'w') do |file|
+        data.each do |key, value|
+          file.write("#{key}=#{value}\n")
+        end
+      end
+    end
+  end
+end

data/lib/firespring_dev_commands/eol/product_version.rb

@@ -0,0 +1,86 @@
+require 'date'
+
+module Dev
+  class EndOfLife
+    # Class which tracks a specific product and provides methods for determining the end of life date
+    class ProductVersion
+      attr_accessor :name, :cycle, :eol, :description
+
+      def initialize(name, cycle, description = nil)
+        @name = name
+        @cycle = cycle
+        @eol_date = nil
+        @eol = nil
+        @description = description
+      end
+
+      # Print the status information for the product with additional coloring to show eol status
+      def print_status
+        puts to_s_colorize
+      end
+
+      # Returns whether this product version is currently EOL
+      def eol
+        populate_eol_info unless @eol
+        @eol
+      end
+
+      # Returns the date at which this product is EOL
+      def eol_date
+        populate_eol_info unless @eol_date
+        @eol_date
+      end
+
+      # Populates the eol and eol_date values
+      # If eol is a boolean then the eol_date will be set to nil
+      def populate_eol_info
+        detail = product_detail(name, cycle)
+        eol = detail['eol']
+        if eol.boolean?
+          @eol = eol
+        else
+          @eol_date = Date.parse(eol)
+          @eol = @eol_date < Date.today
+        end
+      end
+
+      # Returns the product details for the product and cycle based off the api response and any manually configured dates
+      def product_detail(product, cycle)
+        detail = {}
+
+        uri = URI.parse("#{END_OF_LIFE_API_URL}/#{product}/#{cycle}.json")
+        response = Net::HTTP.get_response(uri)
+        detail = JSON.parse(response.body) if response.is_a?(Net::HTTPSuccess)
+
+        # If EOL info is a boolean or missing from the current details, overwrite with the manual date (if present)
+        manual_date = Dev::EndOfLife.config.manual_dates["#{product}_#{cycle.tr('.', '_')}".to_sym]
+        detail['eol'] = manual_date if manual_date && (detail['eol'].boolean? || detail['eol'].nil?)
+
+        raise "unable to query eol detail for #{name}, #{cycle}" if detail.empty?
+
+        detail
+      end
+
+      # Returns a string representation of the product and its eol status
+      def to_s
+        message = "  #{name} (#{cycle}) is EOL on #{eol_date || 'n/a'}"
+        message << " (#{(eol_date - Date.today).to_i} days)" if eol_date
+        format '%-60s %s', message, description
+      end
+
+      # Returns the string representation of the product with additional coloring
+      def to_s_colorize
+        return to_s.light_red if eol
+
+        if eol_date
+          return to_s.light_green if eol_date > (Date.today + 240)
+          return to_s.light_yellow if eol_date > (Date.today + 60)
+
+          return to_s.light_magenta
+        end
+
+        to_s.light_white
+      end
+    end
+  end
+end

data/lib/firespring_dev_commands/eol.rb

@@ -0,0 +1,58 @@
+module Dev
+  # Class that contains methods for checking product versions of all tracked projects
+  class EndOfLife
+    # The URL of the end of life project api
+    END_OF_LIFE_API_URL = 'https://endoflife.date/api'.freeze
+
+    # Config object for setting top level git config options
+    Config = Struct.new(:product_versions, :manual_dates) do
+      def initialize
+        self.product_versions = []
+        self.manual_dates = {}
+      end
+    end
+
+    class << self
+      # Instantiates a new top level config object if one hasn't already been created
+      # Yields that config object to any given block
+      # Returns the resulting config object
+      def config
+        @config ||= Config.new
+        yield(@config) if block_given?
+        @config
+      end
+
+      # Alias the config method to configure for a slightly clearer access syntax
+      alias_method :configure, :config
+    end
+
+    attr_accessor :url, :products, :product_versions
+
+    def initialize(product_versions: self.class.config.product_versions)
+      @product_versions = Array(product_versions)
+      raise 'product version must be of type Dev::EndOfLife::ProductVersions' unless @product_versions.all?(Dev::EndOfLife::ProductVersion)
+    end
+
+    # Returns all products supported by the EOL api
+    def products
+      unless @products
+        uri = URI.parse("#{END_OF_LIFE_API_URL}/all.json")
+        response = Net::HTTP.get_response(uri)
+        raise 'unable to query products' unless response.is_a?(Net::HTTPSuccess)
+
+        @products = JSON.parse(response.body)
+      end
+
+      @products
+    end
+
+    # Prints all of the product version statuses
+    # Raises an error if any products are EOL
+    def check
+      puts
+      product_versions.sort_by(&:name).each(&:print_status)
+      puts
+      raise 'found EOL versions' if product_versions.any?(&:eol)
+    end
+  end
+end

data/lib/firespring_dev_commands/git/info.rb

@@ -0,0 +1,13 @@
+module Dev
+  class Git
+    # Class which contains information about the git repository
+    class Info
+      attr_accessor :name, :path
+
+      def initialize(name, path)
+        @name = name
+        @path = path
+      end
+    end
+  end
+end