firespring_dev_commands 2.1.34 → 2.5.0.pre.alpha.1

data/lib/firespring_dev_commands/bloom_growth.rb

@@ -1,132 +0,0 @@
-require 'net/http'
-
-module Dev
-  # Class for interacting with the Bloom Growth api
-  class BloomGrowth
-    # The config file to try to load credentials from
-    CONFIG_FILE = "#{Dir.home}/.env.bloom".freeze
-
-    # The text of the username variable key
-    BLOOM_USERNAME = 'BLOOM_USERNAME'.freeze
-
-    # The text of the password variable key
-    BLOOM_PASSWORD = 'BLOOM_PASSWORD'.freeze
-
-    # The text of the token variable key
-    BLOOM_TOKEN = 'BLOOM_TOKEN'.freeze
-
-    # The text of the url variable key
-    BLOOM_URL = 'BLOOM_URL'.freeze
-
-    # Config object for setting top level bloom growth config options
-    Config = Struct.new(:username, :password, :url, :http_debug) do
-      def initialize
-        Dotenv.load(CONFIG_FILE) if File.exist?(CONFIG_FILE)
-
-        self.username = ENV.fetch(BLOOM_USERNAME, nil)
-        self.password = ENV.fetch(BLOOM_PASSWORD, nil)
-        self.url = ENV.fetch(BLOOM_URL, 'https://app.bloomgrowth.com')
-        self.http_debug = false
-      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 :username, :password, :url, :token, :client, :default_headers
-
-    # Initialize a new target process client using the given inputs
-    def initialize(username: self.class.config.username, password: self.class.config.password, url: self.class.config.url)
-      raise 'username is required' if username.to_s.strip.empty?
-      raise 'password is required' if password.to_s.strip.empty?
-      raise 'url is required' if url.to_s.strip.empty?
-
-      @username = username
-      @password = password
-      @url = url
-      uri = URI.parse(@url)
-      @client = Net::HTTP.new(uri.host, uri.port)
-      @client.use_ssl = true
-      @client.verify_mode = OpenSSL::SSL::VERIFY_PEER
-      @client.set_debug_output(LOG) if self.class.config.http_debug
-      @default_headers = {
-        'authorization' => "Bearer #{token}",
-        'content-type' => 'application/json',
-        'accept' => 'application/json'
-      }
-    end
-
-    # Method for getting a bearer token for the bloom growth api. There are a couple of possible logic paths
-    #   - If a token has already been defined, use it
-    #   - If a token is found in the ENV, use it
-    #   - Otherwise, use the username and passowrd that has been configured to request a new token from bloom
-    def token
-      @token ||= ENV.fetch(BLOOM_TOKEN, nil)
-
-      unless @token
-        response = post(
-          '/Token',
-          {
-            grant_type: 'password',
-            userName: username,
-            password:
-          },
-          headers: {
-            'content-type' => 'application/json',
-            'accept' => 'application/json'
-          }
-        )
-        # TODO: Should we look at https://github.com/DannyBen/lightly for caching the token?
-        @token = ENV[BLOOM_TOKEN] = response['access_token']
-        LOG.info("Retrieved BloomGrowth token. Expires on #{Time.now + response['expires_in']}")
-      end
-
-      @token
-    end
-
-    # Return all user objects visible to the logged in user
-    def visible_users(&)
-      [].tap do |ary|
-        get('/api/v1/users/mineviewable') do |user_data|
-          ary << User.new(user_data)
-        end
-        ary.each(&)
-      end
-    end
-
-    # Perform a get request to the given path using the given query
-    # Call the given block (if present) with each piece of data
-    # Return all pieces of data
-    def get(path, query_string: nil, headers: default_headers, &)
-      url = path
-      url << "?#{URI.encode_www_form(query_string)}" unless query_string.to_s.strip.empty?
-
-      response = client.request_get(url, headers)
-      raise "Error querying #{url} [#{query_string}]: #{response.inspect}" unless response.response.is_a?(Net::HTTPSuccess)
-
-      JSON.parse(response.body).each(&)
-      nil
-    end
-
-    # Perform a post request to the given path using the gien data
-    # Return the parsed json body
-    def post(path, data, headers: default_headers)
-      data = data.to_json unless data.is_a?(String)
-      response = client.request_post(path, data, headers)
-      raise "Error querying #{url}/#{path}: #{response.inspect}" unless response.response.is_a?(Net::HTTPSuccess)
-
-      JSON.parse(response.body)
-    end
-  end
-end

data/lib/firespring_dev_commands/certificate.rb

@@ -1,59 +0,0 @@
-module Dev
-  # Class contains methods for requesting a certificate from route53.
-  # You must have a hosted zone defined for the desired domain
-  class Certificate
-    attr_accessor :domains, :email
-
-    def initialize(domains, email)
-      @domains = Array(domains)
-      @email = email
-      raise 'No certificate domains specified' if domains.empty?
-    end
-
-    # Request the certificate using the route53 docker image
-    # Certificate is stored in /etc/letsencrypt
-    def request
-      puts
-      puts 'Getting SSL Certs For:'
-      puts domains.join("\n")
-      puts
-      puts 'This process can take up to 10 minutes'
-      puts
-      puts Time.now
-
-      # TODO: Really should use the docker api for this
-      cmd = %w(docker run -it --rm --name certbot)
-      cmd << '-e' << 'AWS_ACCESS_KEY_ID'
-      cmd << '-e' << 'AWS_SECRET_ACCESS_KEY'
-      cmd << '-e' << 'AWS_SESSION_TOKEN'
-      cmd << '-v' << '/etc/letsencrypt:/etc/letsencrypt'
-      cmd << 'certbot/dns-route53:latest'
-      cmd << 'certonly'
-      cmd << '-n'
-      cmd << '--agree-tos'
-      cmd << '--dns-route53'
-      cmd << '-d' << domains.join(',')
-      cmd << '--email' << email
-      cmd << '--server' << 'https://acme-v02.api.letsencrypt.org/directory'
-      puts cmd.join(' ')
-      Dev::Common.new.run_command(cmd)
-    end
-
-    # Saves the latest version of the certificate into the given dest_dir
-    def save(dest_dir)
-      raise "directory #{dest_dir} must be an existing directory" unless File.directory?(dest_dir)
-
-      domain = domains.first.sub(/^\*\./, '') # Need to strip off the '*.' if this is a wildcard cert
-      directories = Dir.glob("/etc/letsencrypt/live/#{domain}*/")
-      no_suffix = directories.delete("/etc/letsencrypt/live/#{domain}/")
-      biggest_suffix = directories.max
-      source_dir = biggest_suffix || no_suffix
-      raise "unable to determine certificate directory for #{domain}" unless source_dir
-
-      FileUtils.cp("#{source_dir}privkey.pem", dest_dir, verbose: true)
-      FileUtils.cp("#{source_dir}cert.pem", dest_dir, verbose: true)
-      FileUtils.cp("#{source_dir}chain.pem", dest_dir, verbose: true)
-      FileUtils.cp("#{source_dir}fullchain.pem", dest_dir, verbose: true)
-    end
-  end
-end

data/lib/firespring_dev_commands/coverage/base.rb

@@ -1,16 +0,0 @@
-module Dev
-  module Coverage
-    # Class which defines the methods which must be implemented to function as a coverage class
-    class Base
-      # Raises not implemented
-      def php_options
-        raise 'not implemented'
-      end
-
-      # Raises not implemented
-      def check(*)
-        raise 'not implemented'
-      end
-    end
-  end
-end

data/lib/firespring_dev_commands/coverage/cobertura.rb

@@ -1,86 +0,0 @@
-module Dev
-  # Module containing different classes for interfacing with coverage files
-  module Coverage
-    # Class for checking code coverage using cobertura
-    class Cobertura < Base
-      attr_reader :local_filename, :container_filename, :filename, :threshold, :exclude
-
-      def initialize(filename: File.join('coverage', 'cobertura.xml'), threshold: nil, container_path: nil, local_path: nil, exclude: nil)
-        super()
-
-        @filename = filename
-        @local_filename = File.join(local_path || '.', @filename)
-        @container_filename = File.join(container_path || '.', @filename)
-        @threshold = threshold
-        @exclude = (exclude || []).map do |it|
-          next it if it.is_a?(Regex)
-
-          Regex.new(it)
-        end
-      end
-
-      # Remove any previous versions of the local file that will be output
-      # return the phpunit options needed to regenerate the cobertura xml file
-      def php_options
-        # Remove any previous coverage info
-        FileUtils.rm_f(local_filename, verbose: true)
-
-        # Return the needed php commands to generate the cobertura report
-        %W(--coverage-cobertura #{container_filename})
-      end
-
-      # Parse the cobertura file and check the lines missed against the desired threshold
-      def check(application: nil)
-        # If an application has been specified and the file does not exist locally, attempt to copy it back from the docker container
-        if application && !File.exist?(local_filename)
-          container = Dev::Docker::Compose.new.container_by_name(application)
-          Dev::Docker.new.copy_from_container(container, container_filename, local_filename, required: true)
-        end
-
-        report = Ox.load(File.read(local_filename))
-        total_missed = report.coverage.locate('packages/package').sum { |package| parse_package_missed(package) }
-        puts "Lines missing coverage was #{total_missed}"
-        puts "Configured threshold was #{threshold}" if threshold
-        raise 'Code coverage not met' if threshold && total_missed > threshold
-      end
-
-      # Go through the package and add up all of the lines that were missed
-      # Ignore if the file was in the exlude list
-      private def parse_package_missed(package)
-        filename =  package.attributes[:name]
-        return if exclude.any? { |it| it.match(filename) }
-
-        missed = 0
-        lines_processed = Set.new
-        package.locate('classes/class/lines/line').each do |line|
-          # Don't count lines multiple times
-          line_number = line.attributes[:number]
-          next if lines_processed.include?(line_number)
-
-          lines_processed << line_number
-          missed += 1 unless line.attributes[:hits].to_i.positive?
-        end
-        total = lines_processed.length
-
-        sanity_check_coverage_against_cobertura_values(package, missed, total)
-        missed
-      end
-
-      # Calculate the coverage percent based off the numbers we got and compare to the
-      # value cobertura reported. This is meant as a sanity check that we are reading the data correctly
-      # TODO: This should be removed after the above logic has been vetted
-      private def sanity_check_coverage_against_cobertura_values(package, missed, total)
-        line_rate = package.attributes[:'line-rate']
-        cobertura_reported_coverage = line_rate.to_f
-        cobertura_reported_precision = line_rate.split('.').last.length
-
-        file_coverage = 0.0
-        file_coverage = ((total - missed).to_f / total).round(cobertura_reported_precision) if total.positive?
-        return if file_coverage == cobertura_reported_coverage
-
-        filename = package.attributes[:name]
-        puts "WARNINNG: #{filename} coverage (#{file_coverage}) differed from what cobertura reported (#{cobertura_reported_coverage})"
-      end
-    end
-  end
-end

data/lib/firespring_dev_commands/coverage/none.rb

@@ -1,21 +0,0 @@
-module Dev
-  # Module with a variety of coverage methods for different languages
-  module Coverage
-    # Class which provides methods to effectvely skip coverage
-    class None < Base
-      def initialize(*)
-        super()
-      end
-
-      # Returns the php options for generating code coverage file
-      def php_options
-        []
-      end
-
-      # Checks the code coverage against the defined threshold
-      def check(*)
-        puts 'Coverage not configured'
-      end
-    end
-  end
-end

data/lib/firespring_dev_commands/docker/desktop.rb

@@ -1,59 +0,0 @@
-module Dev
-  class Docker
-    # Class for configuring docker desktop
-    # This is mostly around configuring the docker URL correctly
-    class Desktop
-      # A snippet of a docker compose file which forwards a socket to a local port so that we can read it in the docker library
-      WIN_TCP_COMPOSE_CONTENT = "
----
-version: '3.8'
-services:
-  windows_tcp:
-    image: alpine/socat
-    network_mode: bridge
-    ports:
-      - 127.0.0.1:23750:2375
-    volumes:
-      - /var/run/docker.sock:/var/run/docker.sock
-    command: tcp-listen:2375,reuseaddr,fork unix-connect:/var/run/docker.sock
-    restart: always".freeze
-
-      # Set up the local ports/sockets correctly based off of the os type
-      def configure
-        if Dev::Os.new.windows?
-          # Start up a small proxy container if running Docker Desktop on windows
-          # This is needed because the docker api library cannot connect to the windows socket
-          unless Dev::Port.new('127.0.0.1', 23_750).open?
-            LOG.info('Starting local proxy port for docker')
-
-            # Write the compose data to a tmp file
-            tmp_compose_file = Tempfile.new('windows_tcp')
-            tmp_compose_file.write(WIN_TCP_COMPOSE_CONTENT)
-            tmp_compose_file.close
-
-            # Start up the container
-            Dev::Docker::Compose.new(
-              compose_files: tmp_compose_file.path,
-              options: ['--detach'],
-              project_name: 'proxy'
-            ).up
-
-            # Wait 1 second before we continue
-            sleep 1
-          end
-
-          # Configure the docker url to use 23750 on windows
-          ::Docker.url = 'tcp://127.0.0.1:23750'
-
-        else
-          # If a user based socket has been defined, default to that
-          ::Docker.url = if File.exist?("/#{Dir.home}/.docker/run/docker.sock")
-                           "unix://#{Dir.home}/.docker/run/docker.sock"
-                         elsif File.exist?("/#{Dir.home}/.docker/desktop/docker.sock")
-                           "unix://#{Dir.home}/.docker/desktop/docker.sock"
-                         end
-        end
-      end
-    end
-  end
-end

data/lib/firespring_dev_commands/jira/parent.rb

@@ -1,19 +0,0 @@
-module Dev
-  class Jira
-    # Contains information on the Jira parent issue
-    class Parent
-      attr_accessor :data, :id, :title
-
-      def initialize(data)
-        @data = data.parent
-        @id = data.parent['key']
-        @title = data.parent['fields']['summary']
-      end
-
-      # Converts the jira parent object to a string representation
-      def to_s
-        "[#{id}] #{title}"
-      end
-    end
-  end
-end

data/lib/firespring_dev_commands/os.rb

@@ -1,35 +0,0 @@
-module Dev
-  # Class containing methods for determining operating system information
-  class Os
-    attr_accessor :os
-
-    def initialize
-      @os = ::RbConfig::CONFIG['host_os']
-    end
-
-    # Returns true if the host_os contains windowsy text
-    def windows?
-      os.match?(/(mingw|mswin|windows)/i)
-    end
-
-    # Returns true if the host_os contains darwinsy text
-    def darwin?
-      os.match?(/(darwin|mac os)/i)
-    end
-
-    # Returns true if the host_os contains macsy text
-    def mac?
-      darwin?
-    end
-
-    # Returns true if the host_os contains nixy text
-    def nix?
-      os.match?(/(linux|bsd|aix|solaris)/i)
-    end
-
-    # Returns true if the host_os contains cygwiny text
-    def cygwin?
-      os.match?(/(cygwin)/i)
-    end
-  end
-end

data/lib/firespring_dev_commands/port.rb

@@ -1,24 +0,0 @@
-module Dev
-  # Class containing methods for actions to be taken on ports
-  class Port
-    attr_accessor :ip_address, :port
-
-    def initialize(ip_address, port)
-      @ip_address = ip_address
-      @port = port
-    end
-
-    # Returns true if the port is open
-    # Returns false otherwise
-    def open?(timeout = 1)
-      Timeout.timeout(timeout) do
-        TCPSocket.new(ip_address, port).close
-        return true
-      end
-
-      false
-    rescue Timeout::Error, Errno::ECONNREFUSED, Errno::EHOSTUNREACH
-      false
-    end
-  end
-end

data/lib/firespring_dev_commands/target_process/time.rb

@@ -1,32 +0,0 @@
-module Dev
-  class TargetProcess
-    # The class to query time information from Target Process
-    class Time
-      # The resource type for the api endpoint
-      RESOURCE_TYPE = 'Time'.freeze
-
-      # The api path for time requests
-      PATH = '/Time'.freeze
-
-      attr_accessor :data, :id, :type, :description, :hours, :date, :story, :user
-
-      def initialize(data)
-        @data = data
-        @id = data['Id']
-        @type = data['ResourceType']
-        @description = data['Description']
-        @hours = data['Spent']
-        @date = parse_time(data['Date'])
-        @story = UserStory.new(data['Assignable']) if data['Assignable']
-        @user = User.new(data['User']) if data['User']
-      end
-
-      # Parse the dot net time representation into something that ruby can use
-      def parse_time(string)
-        return nil unless string && !string.empty?
-
-        ::Time.at(string.slice(6, 10).to_i)
-      end
-    end
-  end
-end

data/lib/firespring_dev_commands/templates/aws/services/route53.rb

@@ -1,106 +0,0 @@
-require_relative '../../base_interface'
-
-module Dev
-  module Template
-    class Aws
-      module Services
-        # Class contains rake templates for managing your AWS settings and logging in
-        class Route53 < 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 hosted zone method
-          def create_dns_logging_activate_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?(:dns_logging)
-
-                namespace :hosted_zone do
-                  namespace :dns_logging do
-                    desc 'Activates query logging for all hosted zones by default.' \
-                         'This command should be run from the account the hosted zone(s) reside.' \
-                         "\n\t(Required) Specify LOG_GROUP_ARN='arn:aws:logs:REGION:ACCOUNT_ID:' to specify the ARN of the target log group." \
-                         "\n\toptionally specify DOMAINS='foo.com,foobar.com' to specify the hosted zones to activate." \
-                         "\n\t\tComma delimited list."
-                    task activate: %w(ensure_aws_credentials) do
-                      route53 = Dev::Aws::Route53.new(ENV['DOMAINS'].to_s.strip.split(','))
-                      # Use user defined log group.
-                      log_group = ENV.fetch('LOG_GROUP_ARN', nil)
-                      raise 'The Hosted Zone Log Group ARN, LOG_GROUP_ARN, is required' unless log_group
-
-                      route53.activate_query_logging(log_group)
-                    end
-                  end
-                end
-              end
-            end
-          end
-
-          # Create the rake task for the hosted zone method
-          def create_dns_logging_deactivate_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?(:dns_logging)
-
-                namespace :hosted_zone do
-                  namespace :dns_logging do
-                    desc 'Deactivates query logging for all hosted zones by default. ' \
-                         'This command should be run from the account the hosted zone(s) reside.' \
-                         "\n\toptionally specify DOMAINS='foo.com,foobar.com' to specify the hosted zones to activate." \
-                         "\n\t\tComma delimited list."
-                    task deactivate: %w(ensure_aws_credentials) do
-                      route53 = Dev::Aws::Route53.new(ENV['DOMAINS'].to_s.strip.split(','))
-                      route53.deactivate_query_logging
-                    end
-                  end
-                end
-              end
-            end
-          end
-
-          # Create the rake task for the hosted zone method
-          def create_list_query_config_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?(:dns_logging)
-
-                namespace :hosted_zone do
-                  namespace :dns_logging do
-                    desc 'Lists the current config for domain(s). ' \
-                         'This command should be run from the account the hosted zone(s) reside.' \
-                         "\n\toptionally specify DOMAINS='foo.com,foobar.com' to specify the hosted zones to activate." \
-                         "\n\t\tComma delimited list."
-                    task list_query_configs: %w(ensure_aws_credentials) do
-                      route53 = Dev::Aws::Route53.new(ENV['DOMAINS'].to_s.strip.split(','))
-                      route53.list_query_configs
-                    end
-                  end
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/firespring_dev_commands/templates/certificate.rb

@@ -1,41 +0,0 @@
-require_relative 'base_interface'
-
-module Dev
-  module Template
-    # Class contains rake templates for managing configured certificates
-    class Certificate < Dev::Template::BaseInterface
-      attr_reader :domains, :email, :paths
-
-      def initialize(domains, email:, paths:, exclude: [])
-        @domains = domains
-        @email = email
-        @paths = Array(paths)
-
-        super(exclude:)
-      end
-
-      # Create the rake task for the generate method
-      def create_generate_task!
-        # Have to set a local variable to be accessible inside of the instance_eval block
-        domains = @domains
-        email = @email
-        paths = @paths
-        exclude = @exclude
-
-        DEV_COMMANDS_TOP_LEVEL.instance_eval do
-          return if exclude.include?(:generate)
-
-          namespace :certificate do
-            desc 'Requests a new certificate for the configured domain using the route53 validation and deposits it in the configured paths'
-            task generate: %w(init_docker ensure_aws_credentials) do
-              Dev::Docker.new.pull_image('certbot/dns-route53', 'latest')
-              c = Dev::Certificate.new(domains, email)
-              c.request
-              paths.each { |path| c.save(path) }
-            end
-          end
-        end
-      end
-    end
-  end
-end