cl-magic 0.3.0

data/lib/cl/magic/cl-dk

@@ -0,0 +1,402 @@
+#!/usr/bin/env ruby
+require 'yaml'
+require 'json'
+require 'tty-command'
+require 'tempfile'
+
+require 'cl/magic/common/common_options.rb'
+require 'cl/magic/common/logging.rb'
+
+@logger = get_logger()
+
+#
+# Util Methods
+#
+
+def get_base_compose_hash()
+  cmd = "cd #{@working_dir} && docker compose config"
+  return YAML.load(`#{cmd}`)
+end
+
+def get_repo_basename()
+  command = "cd #{@working_dir} && basename $(git remote get-url origin 2> /dev/null) .git"
+  return TTY::Command.new(:printer => :null).run(command).out.gsub('.git', '').strip.chomp
+end
+
+def get_dk_world_project_path()
+  repo_basename = get_repo_basename()
+  return "dk-world/#{repo_basename}" if repo_basename
+  return nil
+end
+
+def get_save_parts_filepath()
+  return File.join(@working_dir, ".cl-dk-parts.yml")
+end
+
+#
+# Print Help Methods
+#
+
+def print_dk_help_line(key, help)
+  if help.nil?
+    @logger.puts("#{key.ljust(15, ' ')} ???no help???")
+  else
+    key = key.ljust(15, ' ')
+    help_parts = help.split(";")
+
+    # first line
+    @logger.puts(key, help_parts.shift)
+
+    # following lines
+    padding = "".ljust(15, ' ')
+    help_parts.each do |p|
+      @logger.puts(padding, p)
+    end
+    puts("") if help.end_with?(";")
+  end
+end
+
+def print_dk_help(dk_parts_hash, dk_make_hash, args)
+  no_args = args.empty?()
+  asked_for_help = args.include?('--help')
+  has_dk_commands = dk_parts_hash.keys.any?
+
+  if no_args or asked_for_help
+    if has_dk_commands
+      puts ""
+      puts "Usage: dk [DK_PARTS] [COMPOSE_OPTIONS] COMPOSE_COMMAND"
+      puts ""
+      puts "Run docker compose while munging yamls in sophisticated ways."
+      puts ""
+      if get_repo_basename
+        puts "PROJ INFO:"
+        puts " - Repo basename:       #{get_repo_basename}"
+        puts " - World filepath:      #{File.join(@working_dir, get_dk_world_project_path())}"
+        puts ""
+      end
+      puts "PROJ PARTS:"
+      dk_parts_hash.keys.each do |key|
+        print_dk_help_line(key, dk_parts_hash[key].fetch('help'))
+      end
+      puts ""
+      puts "YML TOKENS"
+      puts "  - <dk-remove>"
+      puts "  - <dk-replace>"
+      puts "  - <dk-project-path>"
+      puts "  - <dk-world-path>"
+      puts "  - <dk-working-path>"
+      puts ""
+      puts "ADDITIONAL TURNKEY COMMANDS:"
+      puts " - dk make"
+      puts " - dk save-parts"
+      puts ""
+      puts "-------------------------"
+    end
+  end
+end
+
+def print_make_help(dk_parts_hash, dk_make_hash)
+  puts ""
+  puts "Usage: dk [DK_PARTS] make COMMAND"
+  puts ""
+  puts "Make commands designed to make your developer experience more turnkey"
+  puts ""
+  puts "Parts:"
+  dk_parts_hash.keys.each do |key|
+    print_dk_help_line(key, dk_parts_hash[key].fetch('help'))
+  end
+  puts ""
+  puts "Commands:"
+  dk_make_hash.keys.each do |key|
+    print_dk_help_line(key, dk_make_hash[key].fetch('help'))
+  end
+  puts ""
+end
+
+def print_save_parts_help(dk_parts_hash)
+  puts ""
+  puts "Usage: dk [DK_PARTS] save-parts"
+  puts ""
+  puts "Save parts in project and apply every time"
+  puts ""
+  puts "Parts:"
+  dk_parts_hash.keys.each do |key|
+    print_dk_help_line(key, dk_parts_hash[key].fetch('help'))
+  end
+  puts ""
+end
+
+#
+# Yaml Merging
+#
+
+class ::Hash
+  def dk_merge(second)
+    merger = proc { |_, v1, v2|
+      if Hash === v1 && Hash === v2
+        v1.merge(v2, &merger)
+      else
+        if Array === v1 && Array === v2
+          if v2.first=="<dk-replace>"
+            v2[1..-1] # everything but the first item
+          else
+            v1 | v2 # union arrays
+          end
+        else
+          if [:undefined, nil, :nil].include?(v2)
+            v1
+          else
+            v2
+          end
+        end
+      end
+    }
+    merge(second.to_h, &merger)
+  end
+  def dk_reject!(&blk)
+    self.each do |k, v|
+      v.dk_reject!(&blk)  if v.is_a?(Hash)
+      self.delete(k)  if blk.call(k, v)
+    end
+  end
+end
+
+def dk_merge_and_remove(compose_hash, yml_hash)
+  # remove help & merge
+  clean_yml = yml_hash.clone
+  clean_yml.delete('help')
+  return compose_hash.dk_merge(clean_yml).dk_reject! { |k, v| v=='<dk-remove>' }
+end
+
+def merge_world_files(compose_hash, show_help=false)
+  dk_proj_path = get_dk_world_project_path()
+  if dk_proj_path
+    print_dk_help_line("dk-project-path", "#{dk_proj_path}") if show_help
+
+    Dir.glob("#{dk_proj_path}/*.yml").sort.each do |filepath|
+      print_dk_help_line("dk-world", "#{filepath}") if show_help
+
+      # read file and replace
+      contents = File.read(filepath)
+      contents.gsub!('<dk-world-path>', File.join(Dir.pwd, "dk-world"))
+      contents.gsub!('<dk-project-path>', File.join(Dir.pwd, dk_proj_path))
+      contents.gsub!('<dk-working-path>', @working_dir)
+
+      # yml merge
+      yml_hash = YAML.load(contents)
+      compose_hash = dk_merge_and_remove(compose_hash, yml_hash)
+    end
+  end
+  return compose_hash
+end
+
+def get_saved_parts(dk_parts_hash)
+  saved_part_keys = []
+  filepath = get_save_parts_filepath()
+
+  # merge
+  if File.exist?(filepath)
+    saved_parts = YAML.load_file(filepath)
+    saved_parts.each do |potential_part_key|
+      dk_part = dk_parts_hash.fetch(potential_part_key, nil) # yml detail
+      if dk_part
+        saved_part_keys << potential_part_key
+      else
+        @logger.error "invalid saved part: #{potential_part_key}"
+        exit 1
+      end
+    end
+  end
+  return saved_part_keys
+end
+
+def merge_parts_save_and_prep_args(compose_hash, dk_parts_hash, dk_make_hash, saved_part_keys)
+  tempfile = File.new(File.join(@working_dir, ".cl-dk.yml"), 'w')
+  args = ARGV.clone
+
+  # dk help
+  print_dk_help(dk_parts_hash, dk_make_hash, args)
+
+  def print_and_merge_part(part_key, dk_part, compose_hash)
+    # print
+    help_str = dk_part.fetch('help')
+    print_dk_help_line("#{part_key}", "#{help_str ? '- ' + help_str : ''}") if dk_part.keys.any?
+
+    # merge
+    return dk_merge_and_remove(compose_hash, dk_part)
+  end
+
+  # saved parts
+  saved_part_keys.each do |potential_part_key|
+    dk_part = dk_parts_hash.fetch(potential_part_key, nil) # yml detail
+    compose_hash = print_and_merge_part(potential_part_key, dk_part, compose_hash) if dk_part
+  end
+
+  # arg parts
+  selected_part_keys = []
+  while true
+    potential_part_key = args.first
+    dk_part = dk_parts_hash.fetch(potential_part_key, nil) # yml detail
+    if dk_part
+
+      # unless already applied
+      unless saved_part_keys.include?(potential_part_key)
+        compose_hash = print_and_merge_part(potential_part_key, dk_part, compose_hash)
+      end
+      selected_part_keys << potential_part_key
+      args.shift # remove part arg
+    else
+      break
+    end
+  end
+  puts ""                               # tailing line break
+  tempfile.write(compose_hash.to_yaml)  # write it to the tempfile
+
+  # clone args
+  args = args.clone
+
+  # remove existing '-f' flag, if needed
+  file_flag_index = args.index('-f')
+  if file_flag_index==0
+    args.delete_at(file_flag_index)
+    args.delete_at(file_flag_index)
+  end
+  args.unshift('-f', tempfile.path) # add new '-f' flag
+
+  tempfile.close
+  return args, selected_part_keys
+end
+
+#
+# Run: DK
+#
+
+def run_dk(compose_args)
+  cmd = "cd #{@working_dir} && docker compose #{compose_args.join(' ')}"
+  exec(cmd)
+end
+
+#
+# Run: SAVE PARTS
+#
+
+def run_dk_save_parts(compose_args, dk_parts_hash, selected_part_keys)
+  filepath = get_save_parts_filepath()
+  if selected_part_keys.any?
+    tempfile = File.new(filepath, 'w')
+    tempfile.write(selected_part_keys.to_yaml) # write it to the tempfile
+  else
+    if File.exist?(filepath)
+      File.delete(filepath)
+      @logger.info "parts cleared"
+    else
+      print_save_parts_help(dk_parts_hash)
+    end
+  end
+end
+
+#
+# Run: MAKE
+#
+
+def run_dk_make(compose_args, dk_make_hash, dk_parts_hash, selected_part_keys)
+  # print help?
+  no_make_command = (compose_args.count == 3)
+  if no_make_command
+    print_make_help(dk_parts_hash, dk_make_hash)
+  else
+
+    #
+    # supports running multiple commands in a row
+    # ex. dk make down up
+    #
+
+    make_commands = compose_args[3..]
+    make_commands.each_with_index do |key, i|
+
+      if not dk_make_hash.has_key?(key)
+        puts "#{key} - command not found"
+        exit 1
+      else
+
+        all_commands = dk_make_hash[key]["commands"]
+
+        #
+        # all commands run in a subprocess except the last one, so
+        # the last command can run in the forground and be
+        # interactive (ex. dk make down up bash)
+        #
+
+        # construct last command
+        last_cmd = if make_commands.length == i+1
+          all_commands.pop
+        else
+          nil
+        end
+
+        # run background commands
+        all_commands.each do |c|
+          cmd = prep_make_command(c, selected_part_keys)
+          `#{cmd}`  # run in sub-process
+        end
+
+        # run last command in foreground
+        if last_cmd
+          cmd = prep_make_command(last_cmd, selected_part_keys)
+          exec(cmd)
+        end
+      end
+    end
+
+  end
+end
+
+def prep_make_command(c, selected_part_keys)
+  c = interpolate_parts_into_command(c, selected_part_keys)
+
+  # logging
+  @logger.puts ""
+  @logger.wait(c)
+  cmd = "cd #{@working_dir} && #{c}"
+end
+
+def interpolate_parts_into_command(cmd, selected_part_keys)
+  if selected_part_keys.any?
+    parts = selected_part_keys.join(' ')
+    return cmd.gsub("cl dk", "cl dk #{parts}")
+  end
+  return cmd
+end
+
+#
+# Main
+#
+
+@working_dir = ENV['CL_WORKING_DIR'] # passed through cl-magic to here
+
+# get compose settings
+compose_hash = get_base_compose_hash()
+if compose_hash
+
+  # world
+  compose_hash = merge_world_files(compose_hash, show_help=ARGV.include?("--help"))
+
+  # x-dk fragments
+  dk_parts_hash = compose_hash['x-dk-parts'] ? compose_hash.delete('x-dk-parts') : {}
+  dk_make_hash = compose_hash['x-dk-make'] ? compose_hash.delete('x-dk-make') : {}
+
+  # parts
+  saved_part_keys = get_saved_parts(dk_parts_hash)
+  compose_args, selected_part_keys = merge_parts_save_and_prep_args(compose_hash, dk_parts_hash, dk_make_hash, saved_part_keys)
+
+  # sub-command
+  case compose_args[2]
+  when "make"
+    all_part_keys = selected_part_keys + saved_part_keys
+    run_dk_make(compose_args, dk_make_hash, dk_parts_hash, all_part_keys)
+  when "save-parts"
+    run_dk_save_parts(compose_args, dk_parts_hash, selected_part_keys)
+  else
+    run_dk(compose_args)
+  end
+end

data/lib/cl/magic/cl-envkey

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+require 'optparse'
+require 'optparse/subcommand'
+require 'tty-command'
+require 'tty-prompt'
+
+require 'cl/magic/common/common_options.rb'
+require 'cl/magic/common/logging.rb'
+require 'cl/magic/common/gcloud.rb'
+require 'cl/magic/common/kubectl.rb'
+
+@logger = get_logger()
+@cl_cmd_name = File.basename(__FILE__).split('-').join(' ')
+
+#
+# Features
+#
+
+def do_work(options)
+  envkey_str = `cd #{@working_dir} && envkey-source`
+  envkey_array = envkey_str.split(' ')
+  result = if options[:filter]
+    envkey_array.select {|o|
+      o.gsub("'","").start_with? options[:filter]
+    }
+  else
+    envkey_array
+  end
+  puts result
+end
+
+#
+# Options
+#
+
+options = {}
+global_banner = <<DOC
+
+ A sandbox to try things
+
+ Usage: #{@cl_cmd_name} [options]
+
+DOC
+
+global = OptionParser.new do |g|
+  g.banner = global_banner
+  add_help_and_verbose(g)
+
+  g.on("-f", "--filter string", "filter by string (i.e. starts with)") do |v|
+    options[:filter] = v
+  end
+end
+
+#
+# Run
+#
+
+@working_dir = ENV['CL_WORKING_DIR'] # passed through cl-magic to here
+global.parse(ARGV)
+
+# display full command
+if options[:filter]
+  write_history("""#{@cl_cmd_name} connect \\
+    --filter=#{options[:filter]}
+  """)
+else
+  write_history("""#{@cl_cmd_name}""")
+end
+
+do_work(options)

data/lib/cl/magic/cl-gc-sql

@@ -0,0 +1,135 @@
+#!/usr/bin/env ruby
+require 'optparse'
+require 'optparse/subcommand'
+require 'tty-command'
+require 'tty-prompt'
+
+require 'cl/magic/common/common_options.rb'
+require 'cl/magic/common/logging.rb'
+require 'cl/magic/common/gcloud.rb'
+
+@logger = get_logger()
+@cl_cmd_name = File.basename(__FILE__).split('-').join(' ')
+
+#
+# Features
+#
+
+def set_project_instance_and_user(options)
+  project = pick_gcloud_project(options[:project])
+  instance = pick_single_result(get_sql_instances, 'Pick sql instance', options[:instance])
+  user = pick_single_result(get_sql_users(instance), 'Pick sql user', options[:user])
+  return project, instance, user
+end
+
+def set_password(options)
+  project, instance, user = set_project_instance_and_user(options)
+
+  # display full command
+  write_history("""#{@cl_cmd_name} set-password \\
+  --project=#{project.first} \\
+  --instance=#{instance.first} \\
+  --user=#{user.first}
+""")
+
+  # run
+  @logger.puts ""
+  cmd = "gcloud sql users set-password #{user.first} --instance=#{instance.first} --prompt-for-password"
+  @logger.wait cmd
+  exec(cmd)
+end
+
+def connect(options)
+  project, instance, user = set_project_instance_and_user(options)
+  database = pick_single_result(get_sql_databases(instance), "Which database?")
+
+  # display full command
+  write_history("""#{@cl_cmd_name} connect \\
+  --project=#{project.first} \\
+  --instance=#{instance.first} \\
+  --user=#{user.first} \\
+  --database=#{database.first}
+""")
+
+  # run
+  @logger.puts ""
+  cmd = "gcloud sql connect #{instance.first} --user=#{user.first} --database=#{database.first}"
+  @logger.wait cmd
+  exec(cmd)
+end
+
+#
+# Options
+#
+
+options = {}
+global_banner = <<DOC
+
+ A tool for everything google cloud sql
+
+ Usage: #{@cl_cmd_name} [options]
+
+DOC
+
+set_password_banner = <<DOC
+
+ Set the password for a sql user
+
+ Usage: #{@cl_cmd_name} set-password [options]
+
+DOC
+
+connect_banner = <<DOC
+
+ Connect to a sql database
+
+ Usage: #{@cl_cmd_name} connect [options]
+
+DOC
+
+def add_project_instance_and_user_options(s, options)
+  s.on("-p", "--project PROJECT", "google cloud project") do |v|
+    options[:project] = v
+  end
+  s.on("-i", "--instance INSTANCE", "google cloud sql instance") do |v|
+    options[:instance] = v
+  end
+  s.on("-u", "--user USER", "google cloud sql user") do |v|
+    options[:user] = v
+  end
+end
+
+global = OptionParser.new do |g|
+  g.banner = global_banner
+  add_help_and_verbose(g)
+
+  g.subcommand 'set-password' do |s|
+    s.banner = set_password_banner
+    options[:action] = :set_password
+    add_project_instance_and_user_options(s, options)
+  end
+
+  g.subcommand 'connect' do |s|
+    s.banner = connect_banner
+    options[:action] = :connect
+    add_project_instance_and_user_options(s, options)
+    s.on("-d", "--database DATABASE", "google cloud sql database name") do |v|
+      options[:user] = v
+    end
+  end
+end
+
+#
+# Run
+#
+
+global.parse(ARGV)
+
+case options[:action]
+when :set_password
+  set_password(options)
+when :connect
+  connect(options)
+else
+  puts global.parse! %w[--help]
+end