firespring_dev_commands 1.3.0

data/lib/firespring_dev_commands/tar.rb

@@ -0,0 +1,149 @@
+require 'fileutils'
+
+module Dev
+  # Class for natively un-tar'ing a file in ruby
+  class Tar
+    attr_accessor :data
+
+    def initialize(data = nil)
+      @data = data
+    end
+
+    # Unpack all data in the given tar into the dest_path
+    def unpack(source_path, dest_path)
+      data.rewind
+      extended_headers = nil
+      ::Gem::Package::TarReader.new(data).each do |entry|
+        # Using https://github.com/kr/tarutil/blob/master/untar.go as a template
+        # Also check out https://go.googlesource.com/go/+/master/src/archive/tar/reader.go?autodive=0%2F%2F%2F
+        case entry.header.typeflag
+        when TypeFlag::TYPE_DIR
+          merge_pax(entry, extended_headers)
+          dest_name = calc_dest_name(source_path, dest_path, entry)
+          create_directory(entry, dest_name)
+
+        when TypeFlag::TYPE_REG, TypeFlag::TYPE_REG_A
+          merge_pax(entry, extended_headers)
+          dest_name = calc_dest_name(source_path, dest_path, entry)
+          create_file(entry, dest_name)
+
+        when TypeFlag::TYPE_LINK
+          raise 'Unimplemented file type: Link'
+
+        when TypeFlag::TYPE_SYMLINK
+          merge_pax(entry, extended_headers)
+          dest_name = calc_dest_name(source_path, dest_path, entry)
+          create_symlink(entry, dest_name)
+
+        when TypeFlag::TYPE_X_HEADER
+          extended_headers = parse_pax(entry.read)
+          next
+
+        when TypeFlag::TYPE_CONT, TypeFlag::TYPE_X_GLOBAL_HEADER
+          raise 'Unimplemented file type Cont/XGlobalHeader'
+
+        when TypeFlag::TYPE_CHAR, TypeFlag::TYPE_BLOCK, TypeFlag::TYPE_FIFO
+          raise 'Unimplemented file type: Char/Block/Fifo'
+
+        else
+          raise 'Unrecognized file type'
+
+        end
+
+        # If we got here we should be done with any extended headers
+        extended_headers = nil
+      end
+    end
+
+    # Extract headers and keep track as we extract the files using the given headers
+    private def parse_pax(content)
+      extended_headers = {}
+      key, value = parse_pax_record(content)
+      extended_headers[key] = value
+      extended_headers
+    end
+
+    # Parse the PAX record and return the results
+    private def parse_pax_record(content)
+      # Check https://golang.org/src/archive/tar/strconv.go
+      _size, keyvalue = content&.split(' ', 2)
+      key, value = keyvalue&.split('=', 2)
+      [key, value]
+    end
+
+    # Calculate what the appropriate destination file name is
+    private def calc_dest_name(source_path, dest_path, entry)
+      if File.directory?(dest_path)
+        dest_path = File.dirname(dest_path) if File.basename(source_path) == File.basename(dest_path)
+
+        return "#{dest_path.chomp('/')}/#{entry.full_name}".strip if File.directory?(dest_path)
+      end
+
+      old_name = File.basename(source_path)
+      entry.full_name.sub(/^#{old_name}/, dest_path).to_s.strip
+    end
+
+    # Create the directory and leading directories
+    private def create_directory(_entry, dest_name)
+      FileUtils.mkdir_p(dest_name)
+    end
+
+    # Write the file contents to the destination
+    private def create_file(entry, dest_name)
+      FileUtils.mkdir_p(File.dirname(dest_name))
+      File.write(dest_name, entry.read)
+    end
+
+    # Create a symlink to the destination
+    private def create_symlink(entry, dest_name)
+      FileUtils.cd(File.dirname(dest_name)) do
+        FileUtils.mkdir_p(File.dirname(entry.header.linkname))
+        FileUtils.symlink(entry.header.linkname, File.basename(dest_name), force: true)
+      end
+    end
+
+    # Merge pax records
+    private def merge_pax(entry, extended_headers)
+      # Reference: https://go.googlesource.com/go/+/master/src/archive/tar/reader.go?autodive=0%2F%2F%2F
+      return unless extended_headers
+
+      extended_headers.each do |k, v|
+        case k
+        when PaxHeader::PAX_PATH
+          entry.header.instance_variable_set(:@name, v)
+
+        when PaxHeader::PAX_LINKPATH
+          entry.header.instance_variable_set(:@linkname, v)
+
+        when PaxHeader::PAX_UNAME
+          entry.header.instance_variable_set(:@uname, v)
+
+        when PaxHeader::PAX_GNAME
+          entry.header.instance_variable_set(:@gname, v)
+
+        when PaxHeader::PAX_UID
+          entry.header.instance_variable_set(:@uid, v)
+
+        when PaxHeader::PAX_GID
+          entry.header.instance_variable_set(:@gid, v)
+
+        when PaxHeader::PAX_ATIME
+          entry.header.instance_variable_set(:@atime, v)
+
+        when PaxHeader::PAX_MTIME
+          entry.header.instance_variable_set(:@mtime, v)
+
+        when PaxHeader::PAX_CTIME
+          entry.header.instance_variable_set(:@ctime, v)
+
+        when PaxHeader::PAX_SIZE
+          entry.header.instance_variable_set(:@size, v)
+
+        else
+          raise "unsupported header #{k}"
+
+        end
+      end
+    end
+  end
+end

data/lib/firespring_dev_commands/templates/aws.rb

@@ -0,0 +1,84 @@
+require_relative './base_interface'
+
+module Dev
+  module Template
+    # Class contains rake templates for managing your AWS settings and logging in
+    class Aws < Dev::Template::BaseInterface
+      # Create the rake task which ensures active credentials are present
+      def create_ensure_credentials_task!
+        # Have to set a local variable to be accessible inside of the instance_eval block
+        exclude = @exclude
+
+        DEV_COMMANDS_TOP_LEVEL.instance_eval do
+          return if exclude.include?(:ensure_aws_credentials)
+
+          task ensure_aws_credentials: %w(init) do
+            raise 'AWS Credentials not found / expired' unless Dev::Aws::Credentials.new.active?
+          end
+        end
+      end
+
+      # Create the rake task for the aws profile method
+      def create_profile_task!
+        # Have to set a local variable to be accessible inside of the instance_eval block
+        exclude = @exclude
+
+        DEV_COMMANDS_TOP_LEVEL.instance_eval do
+          namespace :aws do
+            return if exclude.include?(:profile)
+
+            desc 'Show the current profile/aws account you are configured to use'
+            task profile: %w(init) do
+              Dev::Aws::Profile.new.info
+            end
+          end
+        end
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      # Create the rake task for the aws credentials setup and login method
+      def create_login_task!
+        # Have to set a local variable to be accessible inside of the instance_eval block
+        exclude = @exclude
+
+        DEV_COMMANDS_TOP_LEVEL.instance_eval do
+          namespace :aws do
+            return if exclude.include?(:login)
+
+            namespace :configure do
+              desc 'Configure the default AWS login settings'
+              task default: %w(init default:credentials default:config) do
+                puts
+              end
+
+              namespace :default do
+                desc 'Configure the default AWS login credentials' \
+                     "\n\t(primarily used for rotating access keys)"
+                task credentials: %w(init) do
+                  Dev::Aws::Credentials.new.base_setup!
+                end
+
+                task config: %w(init) do
+                  Dev::Aws::Account.new.base_setup!
+                end
+              end
+
+              Dev::Aws::Account.new.children.each do |account|
+                desc "Configure the #{account.name} account login settings"
+                task account.id => %w(init) do
+                  Dev::Aws::Account.new.setup!(account.id)
+                end
+              end
+            end
+
+            desc 'Select the account you wish to log in to'
+            task login: %w(init) do
+              Dev::Aws::Login.new.login!
+            end
+          end
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+    end
+  end
+end

data/lib/firespring_dev_commands/templates/base_interface.rb

@@ -0,0 +1,54 @@
+require 'rake/dsl_definition'
+
+module Dev
+  # Module containing all available rake template
+  module Template
+    # Base interface template takes a custom arg for the initializer and requires the user to implement the create_tasks! method
+    class BaseInterface
+      include ::Rake::DSL
+
+      def initialize(exclude: [])
+        @exclude = Array(exclude).map(&:to_sym)
+        create_tasks!
+      end
+
+      # This method executes all instance methods which match "create_.*_task!"
+      # This way a user can easily add new methods to the default template simply by defining new create methods
+      # on the class which follow the naming convention
+      def create_tasks!
+        self.class.instance_methods(false).sort.each do |method|
+          next unless /create_.*_task!/.match?(method)
+
+          send(method)
+        end
+      end
+    end
+  end
+end
+
+module Dev
+  module Template
+    # Base interface template customized for applications which require a name to be passed in to the constructor
+    class ApplicationInterface < Dev::Template::BaseInterface
+      include ::Rake::DSL
+
+      def initialize(name, exclude: [])
+        @name = name
+        super(exclude: exclude)
+      end
+    end
+  end
+end
+
+# Create the base init command
+DEV_COMMANDS_TOP_LEVEL.instance_eval do
+  task :init do
+    LOG.debug 'In base init'
+  end
+end
+
+DEV_COMMANDS_TOP_LEVEL.instance_eval do
+  task init_docker: %w(init) do
+    LOG.debug 'In base init docker'
+  end
+end

data/lib/firespring_dev_commands/templates/ci.rb

@@ -0,0 +1,138 @@
+require_relative './base_interface'
+
+module Dev
+  module Template
+    class Aws
+      # Class contains rake templates for managing your ci/cd resources
+      class Ci < Dev::Template::BaseInterface
+        # Base interface template customized for codepipelines which require a pipeline pattern which will match the pipeline name
+        def initialize(cloudformation, exclude: [])
+          @cloudformations = Array(cloudformation).sort_by(&:name)
+          raise 'must specify an arry of cloudformation objects' unless @cloudformations.all?(Dev::Aws::Cloudformation)
+
+          super(exclude: exclude)
+        end
+
+        # Create the rake task for creating the codepipeline
+        def create_create_task!
+          # Have to set a local variable to be accessible inside of the instance_eval block
+          exclude = @exclude
+          cloudformations = @cloudformations
+          return if exclude.include?(:status)
+
+          DEV_COMMANDS_TOP_LEVEL.instance_eval do
+            namespace :ci do
+              desc 'Create the ci cloudformation stack in aws'
+              task create: %w(init ensure_aws_credentials) do
+                LOG.info
+                next if cloudformations.empty?
+
+                # Start create on all stacks without waiting so they are created in parallel
+                cloudformations.each do |cloudformation|
+                  cloudformation.create(should_wait: false)
+                end
+                LOG.info 'Waiting for all stacks to finish create'
+
+                # Wait until all stacks have finished creating
+                cloudformations.each(&:create_wait)
+                LOG.info "Stack create finished at #{Time.now.to_s.light_yellow}"
+                LOG.info
+
+                raise 'Some stacks failed to create' if cloudformations.any?(&:failed?)
+              end
+            end
+          end
+        end
+
+        # Create the rake task for updating the codepipeline
+        def create_update_task!
+          # Have to set a local variable to be accessible inside of the instance_eval block
+          exclude = @exclude
+          cloudformations = @cloudformations
+          return if exclude.include?(:status)
+
+          DEV_COMMANDS_TOP_LEVEL.instance_eval do
+            namespace :ci do
+              desc 'Update the ci cloudformation stack in aws'
+              task update: %w(init ensure_aws_credentials) do
+                LOG.info
+                next if cloudformations.empty?
+
+                # Start update on all stacks without waiting so they are updated in parallel
+                cloudformations.each do |cloudformation|
+                  cloudformation.update(should_wait: false)
+                end
+                LOG.info 'Waiting for all stacks to finish update'
+
+                # Wait until all stacks have finished creating
+                cloudformations.each(&:update_wait)
+                LOG.info "Stack update finished at #{Time.now.to_s.light_yellow}"
+                LOG.info
+
+                raise 'Some stacks failed to update' if cloudformations.any?(&:failed?)
+              end
+            end
+          end
+        end
+
+        # Create the rake task for deleting the codepipeline
+        def create_delete_task!
+          # Have to set a local variable to be accessible inside of the instance_eval block
+          exclude = @exclude
+          cloudformations = @cloudformations
+          return if exclude.include?(:status)
+
+          DEV_COMMANDS_TOP_LEVEL.instance_eval do
+            namespace :ci do
+              desc 'Delete the ci cloudformation stack in aws'
+              task delete: %w(init ensure_aws_credentials) do
+                LOG.info
+                next if cloudformations.empty?
+
+                # Start delete on all stacks without waiting so they are deleted in parallel
+                cloudformations.each do |cloudformation|
+                  cloudformation.delete(should_wait: false)
+                end
+                LOG.info 'Waiting for all stacks to finish delete'
+
+                # Wait until all stacks have finished creating
+                cloudformations.each(&:delete_wait)
+                LOG.info "Stack delete finished at #{Time.now.to_s.light_yellow}"
+                LOG.info
+
+                raise 'Some stacks failed to update' if cloudformations.any?(&:failed?)
+              end
+            end
+          end
+        end
+
+        # Create the rake task for the aws codepipeline status method
+        def create_status_task!
+          # Have to set a local variable to be accessible inside of the instance_eval block
+          exclude = @exclude
+          cloudformations = @cloudformations
+          return if exclude.include?(:status)
+
+          DEV_COMMANDS_TOP_LEVEL.instance_eval do
+            namespace :ci do
+              desc 'Show the current status of the pipelines associated with your branch'
+              task status: %w(init ensure_aws_credentials) do
+                LOG.info
+                next if cloudformations.empty?
+
+                pattern = /#{cloudformations.map(&:name).join('|')}/
+                pipelines = Dev::Aws::CodePipeline.new.pipelines(pattern).sort_by(&:name)
+                LOG.info "No pipelines found matching #{pattern.source.gsub('|', ' OR ')}" if pipelines.empty?
+                pipelines.each do |pipeline|
+                  Dev::Aws::CodePipeline.new.status(pipeline.name)
+                  LOG.info
+                end
+                LOG.info
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/firespring_dev_commands/templates/docker/application.rb

@@ -0,0 +1,177 @@
+require_relative '../base_interface'
+
+module Dev
+  module Template
+    module Docker
+      # Contains all default rake tasks for a docker application
+      class Application < Dev::Template::ApplicationInterface
+        # Create the rake task which runs a docker compose build for the application name
+        def create_build_task!
+          application = @name
+          exclude = @exclude
+
+          DEV_COMMANDS_TOP_LEVEL.instance_eval do
+            namespace application do
+              return if exclude.include?(:build)
+
+              desc "Builds the #{application} container"
+              task build: %w(init_docker) do
+                LOG.debug "In #{application} build"
+                Dev::Docker::Compose.new(services: [application]).build
+              end
+            end
+          end
+        end
+
+        # Create the rake task which runs a docker compose up for the application name
+        def create_up_task!
+          application = @name
+          exclude = @exclude
+
+          DEV_COMMANDS_TOP_LEVEL.instance_eval do
+            namespace application do
+              return if exclude.include?(:up)
+
+              desc "Starts up the #{application} container and it's dependencies"
+              task up: %w(init_docker) do
+                LOG.debug "In #{application} up"
+                Dev::Docker::Compose.new(services: [application]).up
+              end
+            end
+          end
+        end
+
+        # Create the rake task which runs a docker compose up --no-deps for the application name
+        def create_up_no_deps_task!
+          application = @name
+          exclude = @exclude
+
+          DEV_COMMANDS_TOP_LEVEL.instance_eval do
+            namespace application do
+              return if exclude.include?(:up_no_deps)
+
+              desc "Starts up the #{application} container but no dependencies"
+              task up_no_deps: %w(init_docker) do
+                LOG.debug "In #{application} up_no_deps"
+                Dev::Docker::Compose.new(services: [application], options: ['--no-deps']).up
+              end
+            end
+          end
+        end
+
+        # Create the rake task which runs a docker compose exec bash for the application name
+        def create_sh_task!
+          application = @name
+          exclude = @exclude
+
+          DEV_COMMANDS_TOP_LEVEL.instance_eval do
+            namespace application do
+              return if exclude.include?(:sh)
+
+              desc "Open a shell into a running #{application} container"
+              task sh: %W(init_docker #{application}:up) do
+                Dev::Docker::Compose.new(services: [application]).sh
+              end
+            end
+          end
+        end
+
+        # Create the rake task which runs a docker compose logs for the application name
+        def create_logs_task!
+          application = @name
+          exclude = @exclude
+
+          DEV_COMMANDS_TOP_LEVEL.instance_eval do
+            namespace application do
+              return if exclude.include?(:logs)
+
+              desc "Shows logs for the #{application} container"
+              task logs: %w(init_docker) do
+                LOG.debug "In #{application} logs"
+                Dev::Docker::Compose.new(services: [application]).logs
+              end
+            end
+          end
+        end
+
+        # Create the rake task which runs a docker compose down for the application name
+        def create_down_task!
+          application = @name
+          exclude = @exclude
+
+          DEV_COMMANDS_TOP_LEVEL.instance_eval do
+            namespace application do
+              return if exclude.include?(:down)
+
+              desc "Stops the #{application} container"
+              task down: %w(init_docker) do
+                LOG.debug "In #{application} down"
+
+                # docker-copmose down shuts down everything (you can't only specify a single service)
+                # therefore, stop the service manually and prune ununsed resources (just like a down would)
+                Dev::Docker::Compose.new(services: [application]).stop
+                Dev::Docker.new.prune_containers
+                Dev::Docker.new.prune_networks
+                Dev::Docker.new.prune_volumes if ENV['REMOVE_VOLUMES'].to_s.strip == 'true'
+                Dev::Docker.new.prune_images
+              end
+            end
+          end
+        end
+
+        # Create the rake task which stops, cleans, and starts the application
+        def create_reload_task!
+          application = @name
+          exclude = @exclude
+
+          DEV_COMMANDS_TOP_LEVEL.instance_eval do
+            namespace application do
+              return if exclude.include?(:reload)
+
+              desc "Reloads the #{application} container"
+              task reload: %w(init_docker down up) do
+                # Run the down and then the up commands
+              end
+            end
+          end
+        end
+
+        # Create the rake task which runs a docker compose push for the application name
+        def create_push_task!
+          application = @name
+          exclude = @exclude
+
+          DEV_COMMANDS_TOP_LEVEL.instance_eval do
+            namespace application do
+              return if exclude.include?(:push)
+
+              desc "Push the #{application} container to the configured image repository"
+              task push: %w(init_docker) do
+                LOG.debug "In #{application} push"
+                Dev::Docker::Compose.new(services: [application]).push
+              end
+            end
+          end
+        end
+
+        # Create the rake task which runs a docker compose pull for the application name
+        def create_pull_task!
+          application = @name
+          exclude = @exclude
+
+          DEV_COMMANDS_TOP_LEVEL.instance_eval do
+            namespace application do
+              return if exclude.include?(:pull)
+
+              desc "Pull the #{application} container from the configured image repository"
+              task pull: %w(init_docker) do
+                LOG.debug "In #{application} pull"
+                Dev::Docker::Compose.new(services: [application]).pull
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end