nli_pipeline 0.1.2 → 0.2.0

data/lib/nli_pipeline/git_manager.rb

@@ -0,0 +1,32 @@
+require 'nli_pipeline/system_wrapper/call_wrapper'
+
+module NliPipeline
+  # simple class for managing git commands
+  class GitManager < SystemWrapper::CallWrapper
+    # @return [String] full url to commit
+    def last_commit_url
+      "#{remote}/commits/#{last_commit}"
+    end
+
+    # @param  upstream [String]
+    # @return [String] url for git remote origin
+    def remote(upstream: 'origin')
+      call_system("git ls-remote --get-url #{upstream}", return_output: true)
+    end
+
+    # @return [String] full length hash of last commit
+    def last_commit
+      call_system("git log -1 --pretty=format:'%H'", return_output: true)
+    end
+
+    # @return [String] full messaage for last commit, all as one line
+    def last_commit_message
+      call_system('git log -1 --format=%B --oneline', return_output: true)
+    end
+
+    # @return [String] current branch
+    def branch
+      call_system('git symbolic-ref --short HEAD', return_output: true)
+    end
+  end
+end

data/lib/nli_pipeline/setup_pipeline.rb

@@ -1,125 +1,220 @@
 require 'optparse' # core gem, no install required
+# require 'byebug'
+
+module NliPipeline
+  # TODO: replace $PWD with arg to optionally pass directory
+  # and use Dir.pwd by default
+  # https://stackoverflow.com/questions/1937743/how-to-get-the-current-working-directorys-absolute-path-from-irb
+
+  # Class used to parse arguments from bin/setup_pipeline executable
+  class SetupPipeline
+    attr_reader :commands, :docker_commands, :dir_error, :options, :version
+
+    # Set up class attributes
+    def initialize
+      @version = NliPipeline::VERSION
+
+      @commands = {
+        undo:              proc { |fm| fm.load_from_backup },
+        show_last_created: proc { |fm| puts(fm.last_created_files.to_s) }
+      }
+
+      @docker_commands = {
+        docker_build:          proc { |dm| dm.build },
+        docker_build_commit:   proc { |dm| dm.build_commit? },
+        docker_build_and_save: proc { |dm| dm.build_and_save },
+        docker_deploy_branch:  proc { |dm| dm.deploy_branch },
+        docker_deploy_master:  proc { |dm| dm.deploy_master },
+        docker_exec:           proc { |dm| dm.docker_exec },
+        docker_run:            proc { |dm| dm.run },
+        docker_save:           proc { |dm| dm.save }
+      }
+
+      @dir_error = "
+        The first argument to setup_pipeline must be a valid directory.
+        For example, setting up a pipeline in the current directory:
+
+          setup_pipeline $PWD
+
+        The exceptions to this are:\n
+          setup_pipeline --version
+          setup_pipeline --help
+          setup_pipeline --show-commands
+          setup_pipeline --show-flags
+      "
+    end
+
+    # simple formatter
+    def show_commands
+      puts('FileManager commands')
+      puts(@commands.keys)
+      puts('DockerManager commands')
+      puts(@docker_commands.keys)
+    end
 
-# Class used to parse arguments from bin/setup_pipeline executable
-class SetupPipeline
-  # Commandline Arguments:
-  #   $1 (file path) (required)
-  #   $2 (undo) (not required)
-  #   --version
-  #   --extension=(string: file extension)
-  #   --debug (show system commands when enabled)
-  #
-  # Raises:
-  #   ArgumentError if $1 is missing or is not a valid directory
-
-  # commands available from setup_pipeline (hash of proc)
-  attr_reader :commands   
-  # custom error message for when dir is not provided as arg (string)
-  attr_reader :dir_error
-
-  # Set up class attributes
-  def initialize()
-    @commands = {
-      undo: Proc.new {|fm| fm.load_from_backup()}, 
-      show_last_created: Proc.new {|fm| puts(fm.get_last_created_files().to_s())}, 
-    }
-
-    @dir_error = "
-      The first argument to setup_pipeline must be a valid directory.
-      For example, setting up a pipeline in the current directory: 
-        
+    # print help screen to console
+    # @param opts [OptionParser]
+    def help(opts)
+      how_to_use = "HOW TO USE:\n
         setup_pipeline $PWD
-      
-      The exceptions to this are:\n 
-        setup_pipeline --version
-        setup_pipeline --help
-        setup_pipeline --show-commands
-        setup_pipeline --show-flags
-    "
-  end
 
-  # simple formatter
-  def show_commands()
-    puts(@commands.keys)
-  end
+        #{opts}
 
-  # print help screen to console
-  def help(opts)
-    how_to_use = "HOW TO USE:\n
-      setup_pipeline $PWD
-      
-      #{opts}
+        FileManager commands:   #{@commands.keys}
 
-      other commands:\n
-      #{@commands.keys}
+        DockerManager commands: #{@docker_commands.keys}
 
-    "
+      "
 
-    errors = "COMMON ERRORS:\n
-      #{@dir_error}
-    "
+      errors = "COMMON ERRORS:\n
+        #{@dir_error}
+      "
 
-    docs = "FOR MORE INFORMATION PLEASE READ THE DOCS:\n
-      on bitbucket:\t\thttps://bitbucket.org/nlireland/nli-pipeline-gem\n
-      or on ruby gems:\t\thttps://rubygems.org/gems/nli_pipeline\n
-    "
+      docs = "FOR MORE INFORMATION PLEASE READ THE DOCS:\n
+        on bitbucket:\t\thttps://bitbucket.org/nlireland/nli-pipeline-gem\n
+        or on ruby gems:\t\thttps://rubygems.org/gems/nli_pipeline\n
+      "
 
-    puts("#{how_to_use}\n#{errors}\n#{docs}")
-  end
+      puts("#{how_to_use}\n#{errors}\n#{docs}")
+    end
 
-  # parse flags (and check if first argument if not valid directory)
-  def parse_flags()
-    options = {}
-    OptionParser.new do |opts|
-      opts.on("--extension=[\w+]") do |v|
-        options[:extension] = v
-      end
-      opts.on("--debug") do |v|
-        options[:debug] = v
-      end
+    # Commandline Flags:
+    #   $1 (file path) (required)
+    #   --version
+    #   --extension=(string: file extension)
+    #   --debug (show all system commands when enabled)
+    def parse_flags
+      options = {}
+      OptionParser.new do |opts|
+        @options = opts
+        # break out of function, don't throw error about passing directory path
+        opts.on('-h', '--help') do |_v|
+          help(opts)
+          return false
+        end
+        opts.on('--show-commands') do |_v|
+          show_commands
+          return false
+        end
+        opts.on('--show-flags') do |_v|
+          puts(self.options)
+          return false
+        end
+        opts.on('-v', '--version') do |_v|
+          puts(self.version)
+          return false
+        end
+        opts.on('-cmds=', '--commands=a,b,c', Array, 'Array of bash commands') do |v|
+          options[:bash_commands] = v
+        end
+        opts.on('--debug') do |v|
+          options[:debug] = v
+        end
+        opts.on("--extension=[[\w\.]+]", String, 'String file extension') do |v|
+          options[:extension] = v
+        end
+        # override git branch (for docker deploy)
+        opts.on("--git-branch=[[\w\.]+]", String, 'String git branch') do |v|
+          options[:git_branch] = v
+        end
+        opts.on('--fail-on-error') do |v|
+          options[:fail_on_error] = v
+        end
+        opts.on("--image=[([\w\-\.\:]+)]", String, 'String docker image') do |v|
+          options[:image_name] = v
+        end
+        opts.on("--mount=[([\w\-\.\:]+)]", String, 'String directory to mount') do |v|
+          options[:mount] = v
+        end
+        opts.on('--ports=a,b,c', Array, 'Array of ports') do |v|
+          options[:ports] = v
+        end
+        opts.on("--proxy=[([\w\-\.\:]+)]", String, 'String proxy') do |v|
+          options[:proxy] = v
+        end
+        opts.on("--upstream-image=[([\w\-\.\:]+)]", String, 'String dockerhub image') do |v|
+          options[:upstream_image_name] = v
+        end
+      end.parse!
+      options
+    end
 
-      # break out of function, don't throw exception about passing directory path
-      opts.on("-v", "--version") do |v|
-        puts NliPipeline::VERSION
-        return false
-      end
-      opts.on("--show-commands") do |v|
-        show_commands()
-        return false
-      end
-      opts.on("--show-flags") do |v|
-        puts(opts)
-        return false
-      end
-      opts.on("-h", "--help") do |v|
-        help(opts)
-        return false
-      end
-    end.parse!
+    # Commandline Arguments:
+    #   $1 (file path) (required)
+    #   $2 (command to run)
+    #
+    # @raise [ArgumentError] if $1 is missing or is not a valid directory
+    def parse_args
+      raise ArgumentError, "\n#{@dir_error}\n" unless ARGV[0] && Dir.exist?(ARGV[0])
+
+      args = {}
+      args[:path] = ARGV[0]
+      args[:command] = ARGV[1].to_sym unless ARGV[1].nil? || ARGV[1].empty?
+      args
+    end
 
-    if !ARGV[0] || !Dir.exist?(ARGV[0])
-      raise ArgumentError.new("\n\n#{@dir_error}\n\n")
-    else 
-      return [ARGV[0], options]
+    # handle case where invalid flag is passed
+    # show user help screen
+    def flags_or_help_screen
+      begin
+        flags = parse_flags
+      rescue OptionParser::InvalidOption => e
+        puts(e.to_s.red)
+        # inject --help as first arg
+        ARGV.insert(0, '--show-flags')
+        #  call flags again to display help dialogue
+        parse_flags
+        # re-throw error
+        raise e
+      end
+      flags
     end
-  end
 
-  # Method called by bin/setup_pipeline
-  # Parse commands (command line arguments) and pass flags / flags to parse_flags
-  # TODO: move undo arg handling to parse_flags?
-  def main()
-    flags = parse_flags()
-
-    if flags
-      dir, options = flags
-      # pass options hash as keyword arguments
-      fm = FileManager.new(dir, **options)
-      command = ARGV[1].to_sym unless ARGV[1].nil? || ARGV[1].empty?
-      if @commands.keys.include?(command)
-        @commands[command].call(fm)
+    # handle what manager object to create based on flags / command
+    # @param flags   [Hash[Symbol: String]]
+    # @param command [String]
+    def delegate_to_managers(flags, command)
+      if @docker_commands.key?(command)
+        # always fail on error if anything goes wrong with a deploy
+        flags[:fail_on_error] = true if command.to_s.include?('deploy')
+        dm = NliPipeline::DockerManager.new(**flags)
+        @docker_commands[command].call(dm)
+      # if not DockerManager, use FileManager
       else
-        fm.copy_example_files()
+        fm = NliPipeline::FileManager.new(**flags)
+        if @commands.key?(command)
+          @commands[command].call(fm)
+        # is no command is specified, copy example files
+        else
+          fm.copy_example_files
+        end
       end
     end
+
+    # TODO
+    # move undo arg handling to parse_flags?
+    # split out main into handler for FileManager and DockerManager
+
+    # Method called by bin/setup_pipeline
+    # Parse commands (command line arguments) and pass flags / flags to parse_flags
+    def main
+      # byebug
+      flags = flags_or_help_screen
+      # flags will be false if a flag that exits early is passed e.g. false
+      # otherwise flags will be some kind of hash, all of which are truthy, even {}
+      return false unless flags
+
+      # TODO
+      # document this better or
+      # get rid of commands? use separate executables in bin for FileManager vs DockerManager?
+
+      # command is the second argument
+      # e.g. setup_pipeline $PWD COMMAND_GOES_HERE --flags --go --here
+      args = parse_args
+      flags[:path] = args[:path]
+      command = args[:command]
+
+      delegate_to_managers(flags, command)
+    end
   end
 end

data/lib/nli_pipeline/system_wrapper/call_wrapper.rb

@@ -0,0 +1,100 @@
+require 'open3'
+require 'nli_pipeline/system_wrapper/call_wrapper_error'
+require 'nli_pipeline/abstract_util/init_attrs'
+
+module NliPipeline
+  # methods / classes that interact with the os
+  module SystemWrapper
+    # wrapper for system calls
+    # handles output / debugging
+    class CallWrapper
+      include NliPipeline::AbstractUtil
+
+      attr_accessor :last_return_code
+
+      # static methods required by NliPipeline::AbstractUtil::init_attrs
+      # @see NliPipeline::AbstractUtil#init_with_attrs
+      # @see NliPipeline::AbstractUtil#get_allowed_args
+      # @return [Hash]
+      def self.supported_args
+        { debug: false, fail_on_error: false }
+      end
+
+      # no required args in this case, but method is required
+      # @see NliPipeline::AbstractUtil#init_with_attrs
+      # @see NliPipeline::AbstractUtil::ClassMethods#required_args?
+      # @return [Array]
+      def self.required_args
+        []
+      end
+
+      # @see NliPipeline::AbstractUtil#init_with_attrs handles everything
+      def initialize(**kwargs)
+        init_with_attrs(**kwargs)
+      end
+
+      # @param command              [String]  command to run
+      # @param custom_error_message [String]  custom error to display on error
+      # @param return_output        [Boolean] if false return code, if true return stdout
+      # @return [String | Boolean]
+      def call_system(command, custom_error_message: false, return_output: false)
+        result = return_output ? `#{command}`.chomp : system(command)
+        return_code = $CHILD_STATUS
+        if @debug
+          puts("\t#{command}")
+          puts("\treturned: #{result} #{return_code}")
+        end
+        # can't return both output and code in return_output case
+        # so assign instance var
+        @last_return_code = return_code
+        # only catches cases where command finished but with non-zero exit code
+        # e.g. "echo 'hi" will throw an exception regardless of @fail_on_error
+        # "echo 'hi' grep | 'y'" will throw a CallWrapperError only if @fail_on_error is true
+        if @fail_on_error && !result
+          puts(custom_error_message.red) if custom_error_message
+          raise CallWrapperError.new(call: command, code: return_code)
+        end
+        result
+      end
+
+      # # on hold until we figure out how to test Open3.popen3 better
+      # # expect object to receive_message_chain ?
+      # def call_system(command, custom_error_message: false, return_output: false)
+      #   # result = system(command)
+      #   Open3.popen3(command) do |stdin, stdout, stderr, wait_thr|
+      #     # return comes back as pid #{int} exit #{int}
+      #     return_code = wait_thr.value.to_s.split(' ')[-1].to_i
+      #     if @debug
+      #       puts("\t#{command}")
+      #       puts("\treturned: #{result} #{return_code}")
+      #     end
+      #     # only catches cases where command finished but with non-zero exit code
+      #     # e.g. "echo 'hi" will throw an exception regardless of @fail_on_error
+      #     # "echo 'hi' grep | 'y'" will throw a CallWrapperError only if @fail_on_error is true
+      #     if @fail_on_error && return_code != 0
+      #       puts(custom_error_message.red) if custom_error_message
+      #       raise CallWrapperError.new(call: command, code: return_code)
+      #     end
+      #     return stdout.gets if return_output
+      #     # return true if command exits with 0, otherwise return false
+      #     return_code == 0
+      #   end
+      # end
+
+      private
+
+      # pretty print intended for use with @see #call_system
+      # @param custom_message [String]
+      def pretty_print(custom_message: false)
+        # assign return value of block to ret
+        ret = yield
+        out_str = ret.to_s
+
+        message_args = { custom_message: custom_message, out_str: out_str }
+        out_str = format('%<custom_message>-20s: %<out_str>s', message_args) if custom_message
+        puts(ret ? out_str.green : out_str.red)
+        ret
+      end
+    end
+  end
+end