pmgmt 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3e30d7e78a8a61ae27c505f47f1821c2ee991ac91264abfed389651626823e9a
+  data.tar.gz: 151734accba09a0511a88d78380894de6c4af6fad2ad0613c701441eb89963de
+SHA512:
+  metadata.gz: 764187c3dcb66e45fd17b6e111d8230f06e4fa622f75690f9cf3a43639f75777392b1d8a37cbb59d6b13e854da3e2411e5c3e3e2fe5d6c1c5ad28fe20c1cbfb2
+  data.tar.gz: 97a9f031cd58f3ba87e97104cef2be3945a27c13815a55be444507cf9184f7285a3e6c011ee3e44d62fd0a7d5d586f31cd0ff817ed03373509f00ef9043f4fea

data/lib/dockerhelper.rb

@@ -0,0 +1,47 @@
+module PmgmtLib
+  class DockerHelper
+    attr :c
+
+    def initialize(common)
+      @c = common
+    end
+
+    def in_docker?()
+      File.exist?("/.dockerenv")
+    end
+
+    def requires_docker()
+      status = c.run %W{which docker}
+      unless status.success?
+        c.error "docker not installed."
+        STDERR.puts "Installation instructions:"
+        STDERR.puts "\n  https://www.docker.com/community-edition\n\n"
+        exit 1
+      end
+      status = c.run %W{docker info}
+      unless status.success?
+        c.error "`docker info` command failed."
+        STDERR.puts "This is usually a permissions problem. Try allowing your user to run docker\n"
+        STDERR.puts "without sudo:"
+        STDERR.puts "\n$ sudo usermod -aG docker #{ENV["USER"]}\n\n"
+        c.error "Note: You will need to log-in to a new shell before this change will take effect.\n"
+        exit 1
+      end
+    end
+
+    def image_exists?(name)
+      requires_docker
+      fmt = "{{.Repository}}:{{.Tag}}"
+      c.capture_stdout(%W{docker images --format #{fmt}}).include?(name)
+    end
+
+    def ensure_image(name)
+      requires_docker
+      if not image_exists?(name)
+        c.error "Missing docker image \"#{name}\". Pulling..."
+        c.run_inline(%W{docker pull #{name}})
+        c.status "Image \"#{name}\" pulled."
+      end
+    end
+  end
+end

data/lib/pmgmt.rb

@@ -0,0 +1,218 @@
+require "open3"
+require "ostruct"
+require "yaml"
+
+require_relative "dockerhelper"
+require_relative "syncfiles"
+
+class Pmgmt
+  @@commands = []
+
+  def self.load_scripts(scripts_dir)
+    if !File.directory?(scripts_dir)
+      self.new.error "Cannot load scripts. Not a directory: #{scripts_dir}"
+      exit 1
+    end
+    Dir.foreach(scripts_dir) do |item|
+      if item =~ /[.]rb$/
+        require "#{scripts_dir}/#{item}"
+      end
+    end
+  end
+
+  def self.register_command(command)
+    invocation = command[:invocation]
+    fn = command[:fn]
+    if fn.nil?
+      self.new.error "No :fn key defined for command #{invocation}"
+      exit 1
+    end
+    if fn.is_a?(Symbol)
+      unless Object.private_method_defined?(fn)
+        self.new.error "Function #{fn.to_s} is not defined for #{invocation}."
+        exit 1
+      end
+    else
+      # TODO(dmohs): Deprecation warning.
+      unless fn.is_a?(Proc)
+        self.new.error ":fn key for #{invocation} does not define a Proc or Symbol"
+        exit 1
+      end
+    end
+
+    @@commands.push(command)
+  end
+
+  def self.commands()
+    @@commands
+  end
+
+  def self.handle_or_die(args)
+    if args.length == 0 or args[0] == "--help"
+      self.new.print_usage
+      exit 0
+    end
+
+    if args[0] == "--cmplt" # Shell completion argument name inspired by vault
+      # Form of args: --cmplt <index-of-current-argument> ./project.rb arg arg arg
+      index = args[1].to_i
+      word = args[2 + index]
+      puts @@commands.select{ |x| x[:invocation].start_with?(word) }
+          .map{ |x| x[:invocation]}.join("\n")
+      exit 0
+    end
+
+    command = args.first
+    handler = @@commands.select{ |x| x[:invocation] == command }.first
+    if handler.nil?
+      error "#{command} command not found."
+      exit 1
+    end
+
+    fn = handler[:fn]
+    if fn.is_a?(Symbol)
+      method(fn).call(*args)
+    else
+      handler[:fn].call(*args.drop(1))
+    end
+  end
+
+  attr :docker
+  attr :sf
+
+  def initialize()
+    @docker = PmgmtLib::DockerHelper.new(self)
+    @sf = PmgmtLib::SyncFiles.new(self)
+  end
+
+  def print_usage()
+    STDERR.puts "\nUsage: #{$PROGRAM_NAME} <command> <options>\n\n"
+    if !@@commands.empty?
+      STDERR.puts "COMMANDS\n\n"
+      @@commands.each do |command|
+        STDERR.puts bold_term_text(command[:invocation])
+        STDERR.puts command[:description] || "[No description provided.]"
+        STDERR.puts
+      end
+    else
+      STDERR.puts " >> No commands defined.\n\n"
+    end
+  end
+
+  def load_env()
+    if not File.exists?("project.yaml")
+      error "Missing project.yaml"
+      exit 1
+    end
+    OpenStruct.new YAML.load(File.read("project.yaml"))
+  end
+
+  def red_term_text(text)
+    "\033[0;31m#{text}\033[0m"
+  end
+
+  def blue_term_text(text)
+    "\033[0;36m#{text}\033[0m"
+  end
+
+  def yellow_term_text(text)
+    "\033[0;33m#{text}\033[0m"
+  end
+
+  def bold_term_text(text)
+    "\033[1m#{text}\033[0m"
+  end
+
+  def status(text)
+    STDERR.puts blue_term_text(text)
+  end
+
+  def warning(text)
+    STDERR.puts yellow_term_text(text)
+  end
+
+  def error(text)
+    STDERR.puts red_term_text(text)
+  end
+
+  def put_command(cmd, redact=nil)
+    if cmd.is_a?(String)
+      command_string = "+ #{cmd}"
+    else
+      command_string = "+ #{cmd.join(" ")}"
+    end
+    command_to_echo = command_string.clone
+    if redact
+      command_to_echo.sub! redact, "*" * redact.length
+    end
+    STDERR.puts command_to_echo
+  end
+
+  # Pass err=nil to suppress stderr.
+  def capture_stdout(cmd, err = STDERR)
+    if err.nil?
+      err = "/dev/null"
+    end
+    output, _ = Open3.capture2(*cmd, :err => err)
+    output
+  end
+
+  def run_inline(cmd, redact=nil)
+    put_command(cmd, redact)
+
+    # `system`, by design (?!), hides stderr when the command fails.
+    if ENV["PROJECTRB_USE_SYSTEM"] == "true"
+      if not system(*cmd)
+        exit $?.exitstatus
+      end
+    else
+      pid = spawn(*cmd)
+      Process.wait pid
+      if $?.exited?
+        if !$?.success?
+          exit $?.exitstatus
+        end
+      else
+        error "Command exited abnormally."
+        exit 1
+      end
+    end
+  end
+
+  def run_inline_swallowing_interrupt(cmd)
+    begin
+      run_inline cmd
+    rescue Interrupt
+    end
+  end
+
+  def run_or_fail(cmd, redact=nil)
+    put_command(cmd, redact)
+    Open3.popen3(*cmd) do |i, o, e, t|
+      i.close
+      if not t.value.success?
+        STDERR.write red_term_text(e.read)
+        exit t.value.exitstatus
+      end
+    end
+  end
+
+  def run(cmd)
+    Open3.popen3(*cmd) do |i, o, e, t|
+      i.close
+      t.value
+    end
+  end
+
+  def pipe(*cmds)
+    s = cmds.map { |x| x.join(" ") }
+    s = s.join(" | ")
+    STDERR.puts "+ #{s}"
+    Open3.pipeline(*cmds).each do |status|
+      unless status.success?
+        error "Piped command failed"
+        exit 1
+      end
+    end
+  end
+end

data/lib/syncfiles.rb

@@ -0,0 +1,205 @@
+require "open3"
+
+module PmgmtLib
+  class SyncFiles
+    attr :c
+
+    def initialize(common)
+      @c = common
+    end
+
+    def is_fswatch_installed()
+      status = c.run %W{which fswatch}
+      return status.success?
+    end
+
+    def src_vol_name()
+      env = c.load_env
+      "#{env.namespace}-src"
+    end
+
+    def output_vol_name()
+      env = c.load_env
+      "#{env.namespace}-out"
+    end
+
+    def get_src_volume_mount()
+      if is_fswatch_installed
+        %W{-v #{src_vol_name}:/w}
+      else
+        %W{-v #{ENV["PWD"]}:/w}
+      end
+    end
+
+    def get_volume_mounts()
+      env = c.load_env
+      if env.static_file_dest
+        get_src_volume_mount + %W{-v #{output_vol_name}:/w/#{env.static_file_dest}}
+      else
+        get_src_volume_mount
+      end
+    end
+
+    def log_file_name()
+      ".rsync.log"
+    end
+
+    def log_message(s)
+      File.open(log_file_name, "a") do |file|
+        file.write s
+      end
+    end
+
+    def get_dest_path(src, dst)
+      if dst.nil?
+        dst = src
+      end
+      dst = dst.split(/\//).reverse.drop(1).reverse.join("/")
+      if not dst.empty?
+        dst = "/w/#{dst}"
+      else
+        dst = "/w"
+      end
+    end
+
+    def start_rsync_container()
+      env = c.load_env
+      c.docker.requires_docker
+      c.docker.ensure_image("tjamet/rsync")
+      cmd = %W{
+        docker run -d
+          --name #{env.namespace}-rsync
+          -v #{src_vol_name}:/w
+      }
+      if env.static_file_dest
+        cmd += %W{-v #{output_vol_name}:/w/#{env.static_file_dest}}
+      end
+      c.run_inline cmd + %W{-e DAEMON=docker tjamet/rsync}
+    end
+
+    def stop_rsync_container()
+      env = c.load_env
+      c.run_inline %W{docker rm -f #{env.namespace}-rsync}
+    end
+
+    def rsync_path(src, dst, log)
+      env = c.load_env
+      dst = get_dest_path(src, dst)
+      rsync_remote_shell = "docker exec -i"
+      cmd = %W{
+        rsync --blocking-io -azlv --delete -e #{rsync_remote_shell}
+          #{src}
+          #{env.namespace}-rsync:#{dst}
+      }
+      if log
+        Open3.popen3(*cmd) do |i, o, e, t|
+          i.close
+          if not t.value.success?
+            c.error e.read
+            exit t.value.exitstatus
+          end
+          log_message o.read
+        end
+      else
+        c.run_inline cmd
+      end
+    end
+
+    def link_static_file(src, dst)
+      cmd = %W{docker run --rm -w /w} + get_volume_mounts + %W{alpine ln -snf /w/#{src} /w/#{dst}}
+      c.run_inline cmd
+    end
+
+    def link_static_files()
+      env = c.load_env
+      threads = []
+      foreach_static_file do |path, entry|
+        threads << Thread.new do
+          link_static_file "#{path}/#{entry}", "#{env.static_file_dest}/#{entry}"
+        end
+      end
+      threads.each do |t|
+        t.join
+      end
+    end
+
+    def foreach_static_file()
+      env = c.load_env
+      Dir.foreach(env.static_file_src) do |entry|
+        unless [".", ".."].include?(entry)
+          yield env.static_file_src, entry
+        end
+      end
+    end
+
+    def watch_path(src, dst)
+      Open3.popen3(*%W{fswatch -o #{src}}) do |stdin, stdout, stderr, thread|
+        Thread.current["pid"] = thread.pid
+        stdin.close
+        stdout.each_line do |_|
+          rsync_path src, dst, true
+        end
+      end
+    end
+
+    def perform_initial_sync()
+      env = c.load_env
+      env.source_file_paths.each do |src_path|
+        # Copying using tar ensures the destination directories will be created.
+        c.pipe(
+          %W{env COPYFILE_DISABLE=1 tar -c #{src_path}},
+          %W{docker cp - #{env.namespace}-rsync:/w}
+        )
+        rsync_path src_path, nil, false
+      end
+      if env.static_file_src
+        c.pipe(
+          %W{env COPYFILE_DISABLE=1 tar -c #{env.static_file_src}},
+          %W{docker cp - #{env.namespace}-rsync:/w}
+        )
+        rsync_path env.static_file_src, nil, false
+      end
+    end
+
+    def start_watching_sync()
+      env = c.load_env
+      File.open(log_file_name, "w") {} # Create and truncate if exists.
+      paths_to_watch = env.source_file_paths
+      if env.static_file_src
+        paths_to_watch += [env.static_file_src]
+      end
+      paths_to_watch.each do |src_path|
+        thread = Thread.new { watch_path src_path, nil }
+        at_exit {
+          Process.kill("HUP", thread["pid"])
+          thread.join
+        }
+      end
+    end
+
+    def maybe_start_file_syncing()
+      system_name, _ = Open3.capture2("uname")
+      system_name.chomp!
+      env = c.load_env
+      if env.static_file_src
+        c.status "Linking static files..."
+        link_static_files
+      end
+      fswatch_installed = is_fswatch_installed
+      if system_name == "Darwin" and not fswatch_installed
+        c.error "fswatch is not installed."
+        STDERR.puts "File syncing will be extremely slow due to a performance problem in docker.\n" \
+          "Installing fswatch is highly recommended. Try:\n\n$ brew install fswatch\n\n"
+      end
+      if fswatch_installed
+        c.status "Starting rsync container..."
+        at_exit { stop_rsync_container }
+        start_rsync_container
+        c.status "Performing initial file sync..."
+        perform_initial_sync
+        start_watching_sync
+        c.status "Watching source files. See log at #{log_file_name}."
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,46 @@
+--- !ruby/object:Gem::Specification
+name: pmgmt
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- David Mohs
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-07-10 00:00:00.000000000 Z
+dependencies: []
+description: A library to make Ruby your preferred scripting language for dev scripts.
+email: davidmohs@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/dockerhelper.rb
+- lib/pmgmt.rb
+- lib/syncfiles.rb
+homepage: http://rubygems.org/gems/pmgmt
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Project management scripting library.
+test_files: []