glb 0.1.1

data/lib/glb/completer.rb

@@ -0,0 +1,159 @@
+=begin
+Code Explanation:
+
+There are 3 types of things to auto-complete:
+
+  1. command: the command itself
+  2. parameters: command parameters.
+  3. options: command options
+
+Here's an example:
+
+  mycli hello name --from me
+
+  * command: hello
+  * parameters: name
+  * option: --from
+
+When command parameters are done processing, the remaining completion words will be options.  We can tell that the command params are completed based on the method arity.
+
+## Arity
+
+For example, say you had a method for a CLI command with the following form:
+
+  ufo scale service count --cluster development
+
+It's equivalent ruby method:
+
+  scale(service, count) = has an arity of 2
+
+So typing:
+
+  ufo scale service count [TAB] # there are 3 parameters including the "scale" command according to Thor's CLI processing.
+
+So the completion should only show options, something like this:
+
+  --noop --verbose --cluster
+
+## Splat Arguments
+
+When the ruby method has a splat argument, it's arity is negative.  Here are some example methods and their arities.
+
+   ship(service) = 1
+   scale(service, count) = 2
+   ships(*services) = -1
+   foo(example, *rest) = -2
+
+Fortunately, negative and positive arity values are processed the same way. So we take simply take the absolute value of the arity and process it the same.
+
+Here are some test cases, hit TAB after typing the command:
+
+  glb completion
+  glb completion hello
+  glb completion hello name
+  glb completion hello name --
+  glb completion hello name --noop
+
+  glb completion
+  glb completion sub:goodbye
+  glb completion sub:goodbye name
+
+## Subcommands and Thor::Group Registered Commands
+
+Sometimes the commands are not simple thor commands but are subcommands or Thor::Group commands. A good specific example is the ufo tool.
+
+  * regular command: ufo ship
+  * subcommand: ufo docker
+  * Thor::Group command: ufo init
+
+Auto-completion accounts for each of these type of commands.
+=end
+module Glb
+  class Completer
+    def initialize(command_class, *params)
+      @params = params
+      @current_command = @params[0]
+      @command_class = command_class # CLI initiall
+    end
+
+    def run
+      if subcommand?(@current_command)
+        subcommand_class = @command_class.subcommand_classes[@current_command]
+        @params.shift # destructive
+        Completer.new(subcommand_class, *@params).run # recursively use subcommand
+        return
+      end
+
+      # full command has been found!
+      unless found?(@current_command)
+        puts all_commands
+        return
+      end
+
+      # will only get to here if command aws found (above)
+      arity = @command_class.instance_method(@current_command).arity.abs
+      if @params.size > arity or thor_group_command?
+        puts options_completion
+      else
+        puts params_completion
+      end
+    end
+
+    def subcommand?(command)
+      @command_class.subcommands.include?(command)
+    end
+
+    # hacky way to detect that command is a registered Thor::Group command
+    def thor_group_command?
+      command_params(raw=true) == [[:rest, :args]]
+    end
+
+    def found?(command)
+      public_methods = @command_class.public_instance_methods(false)
+      command && public_methods.include?(command.to_sym)
+    end
+
+    # all top-level commands
+    def all_commands
+      commands = @command_class.all_commands.reject do |k,v|
+        v.is_a?(Thor::HiddenCommand)
+      end
+      commands.keys
+    end
+
+    def command_params(raw=false)
+      params = @command_class.instance_method(@current_command).parameters
+      # Example:
+      # >> Sub.instance_method(:goodbye).parameters
+      # => [[:req, :name]]
+      # >>
+      raw ? params : params.map!(&:last)
+    end
+
+    def params_completion
+      offset = @params.size - 1
+      offset_params = command_params[offset..-1]
+      command_params[offset..-1].first
+    end
+
+    def options_completion
+      used = ARGV.select { |a| a.include?('--') } # so we can remove used options
+
+      method_options = @command_class.all_commands[@current_command].options.keys
+      class_options = @command_class.class_options.keys
+
+      all_options = method_options + class_options + ['help']
+
+      all_options.map! { |o| "--#{o.to_s.gsub('_','-')}" }
+      filtered_options = all_options - used
+      filtered_options.uniq
+    end
+
+    # Useful for debugging. Using puts messes up completion.
+    def log(msg)
+      File.open("/tmp/complete.log", "a") do |file|
+        file.puts(msg)
+      end
+    end
+  end
+end

data/lib/glb/config.rb

@@ -0,0 +1,147 @@
+require "singleton"
+
+module Glb
+  class Config
+    include Singleton
+    include DslEvaluator
+
+    attr_reader :config
+    def initialize
+      @config = defaults
+    end
+
+    def defaults
+      config = ActiveSupport::OrderedOptions.new
+
+      config.lb = ActiveSupport::OrderedOptions.new
+      # config.lb.region = "us-central1"
+      # config.lb.load_balancing_scheme = "INTERNAL_MANAGED"
+      # config.lb.network = "dev"
+      # config.lb.subnet = "dev-app"
+
+      config.firewall_rule = ActiveSupport::OrderedOptions.new
+      config.firewall_rule.action =  "allow"
+      config.firewall_rule.direction =  "ingress"
+      config.firewall_rule.network = nil # default in set_from_lb_config
+      config.firewall_rule.rules = "tcp:80"
+      config.firewall_rule.source_ranges = "130.211.0.0/22,35.191.0.0/16" # load balancer
+      # config.firewall_rule.target_tags =  @name # @name is not available here
+
+      config.health_check = ActiveSupport::OrderedOptions.new
+      config.health_check.port = 80
+      config.health_check.request_path = "/"
+      config.health_check.region = nil
+
+      config.backend_service = ActiveSupport::OrderedOptions.new
+      config.backend_service.load_balancing_scheme = nil # default in set_from_lb_config
+      config.backend_service.protocol = "HTTP"
+      config.backend_service.port_name = "http"
+      config.backend_service.region = nil
+      # config.backend_service.health_checks = health_check_name # health_check_name is not available here
+
+      config.backend_service.add_backend = ActiveSupport::OrderedOptions.new
+      config.backend_service.add_backend.balancing_mode = "RATE"
+      config.backend_service.add_backend.max_rate_per_endpoint = "1.0"
+      config.backend_service.add_backend.region = nil
+      config.backend_service.health_checks_region = nil
+      # config.backend_service.add_backend.network_endpoint_group_zone = google_zone, # google_zone is not available here
+      # config.backend_service.add_backend.network_endpoint_group = network_endpoint_group # network_endpoint_group is not available here
+
+      config.url_map = ActiveSupport::OrderedOptions.new
+      config.url_map.region = nil
+      # config.url_map.default_service = backend_service_name # backend_service_name is not available here
+
+      config.target_http_proxy = ActiveSupport::OrderedOptions.new
+      config.target_http_proxy.region = nil
+      # config.target_http_proxy.url_map = url_map_name # url_map_name is not available here
+
+      config.target_https_proxy = ActiveSupport::OrderedOptions.new
+      config.target_https_proxy.region = nil
+      config.target_https_proxy.ssl_certificates = nil # must be assigned by user
+      # config.target_https_proxy.url_map = url_map_name # url_map_name is not available here
+
+      config.forwarding_rule = ActiveSupport::OrderedOptions.new
+      config.forwarding_rule.load_balancing_scheme = nil # default in set_from_lb_config
+      config.forwarding_rule.ports = 80
+      config.forwarding_rule.region = nil
+      # config.forwarding_rule.target_http_proxy = target_http_proxy_name # target_http_proxy_name is not available here
+
+      config.forwarding_rule_https = ActiveSupport::OrderedOptions.new
+      config.forwarding_rule_https.load_balancing_scheme = nil # default in set_from_lb_config
+      config.forwarding_rule_https.ports = 443
+      config.forwarding_rule_https.region = nil
+      # config.forwarding_rule_https.target_http_proxy = target_http_proxy_name # target_http_proxy_name is not available here
+
+      config.show = ActiveSupport::OrderedOptions.new
+      config.show.format = nil
+
+      config.naming = ActiveSupport::OrderedOptions.new
+      config.naming.include_type = false
+
+      config
+    end
+
+    def configure
+      yield(@config)
+    end
+
+    # Load configs example:
+    #
+    # .glb/config.rb
+    # .glb/config/env/dev.rb
+    #
+    def load_configs
+      evaluate_file(".glb/config.rb")
+      evaluate_file(".glb/config/env/#{Glb.env}.rb")
+      if Glb.app
+        evaluate_file(".glb/config/app/#{Glb.app}.rb")
+        evaluate_file(".glb/config/app/#{Glb.app}/#{Glb.env}.rb")
+      end
+      set_from_lb_config
+    end
+
+    # Simpiflies the required config values to be set for an internal load balancer
+    # by providing shorthand config.lb options. Example:
+    #
+    #     config.lb.region = "us-central1"
+    #     config.lb.load_balancing_scheme = "INTERNAL_MANAGED"
+    #     config.lb.network = "dev"
+    #     config.lb.subnet = "dev-app"
+    #
+    # Called in initialize so that config values are set before any methods are called.
+    # IE: region_option or args
+    def set_from_lb_config
+      config.firewall_rule.network ||= config.lb.network || "default"
+
+      config.health_check.region ||= config.lb.region
+
+      config.backend_service.load_balancing_scheme ||= config.lb.load_balancing_scheme || "EXTERNAL_MANAGED"
+      config.backend_service.region ||= config.lb.region
+      config.backend_service.health_checks_region ||= config.lb.region
+      config.backend_service.add_backend.region ||= config.lb.region
+
+      config.url_map.region ||= config.lb.region
+
+      config.target_http_proxy.region ||= config.lb.region
+
+      config.target_https_proxy.region ||= config.lb.region
+      config.target_https_proxy.ssl_certificates ||= config.lb.ssl_certificates
+
+      config.forwarding_rule.region ||= config.lb.region
+      config.forwarding_rule.network ||= config.lb.network
+      config.forwarding_rule.subnet ||= config.lb.subnet
+      config.forwarding_rule.load_balancing_scheme ||= config.lb.load_balancing_scheme || "EXTERNAL_MANAGED"
+      config.forwarding_rule.target_http_proxy_region ||= config.lb.region
+
+      config.forwarding_rule_https.region ||= config.lb.region
+      config.forwarding_rule_https.network ||= config.lb.network
+      config.forwarding_rule_https.subnet ||= config.lb.subnet
+      config.forwarding_rule_https.load_balancing_scheme ||= config.lb.load_balancing_scheme || "EXTERNAL_MANAGED"
+      config.forwarding_rule_https.target_https_proxy_region ||= config.lb.region
+
+      # Set to true to create target_https_proxy and additional forwarding_rule which uses https settings
+      config.lb.enabled = false
+    end
+
+  end
+end

data/lib/glb/core.rb

@@ -0,0 +1,27 @@
+module Glb
+  module Core
+    extend Memoist
+
+    def app
+      ENV['GLB_APP'] unless ENV['GLB_APP'].blank?
+    end
+
+    def env
+      ENV['GLB_ENV'].blank? ? "dev" : ENV['GLB_ENV']
+    end
+
+    def extra
+      ENV['GLB_EXTRA'] unless ENV['GLB_EXTRA'].blank?
+    end
+
+    def configure(&block)
+      Config.instance.configure(&block)
+    end
+
+    def config
+      Config.instance.load_configs
+      Config.instance.config
+    end
+    memoize :config
+  end
+end

data/lib/glb/lb/args.rb

@@ -0,0 +1,66 @@
+class Glb::Lb
+  class Args
+    extend Memoist
+    include Glb::Util::Sh
+
+    # command: "firewall-rule create"
+    def initialize(command, opts)
+      @command, @opts = command, opts
+    end
+
+    # Converts a hash of options to a string of gcloud arguments
+    def transform
+      return "" if invalid_command?
+      options = @opts.dup
+      options.compact!
+      options[:global] = true unless options[:region]
+      allowed = allowed_options(@command)
+      allowed.map! { |o| o.gsub("-", "_") }
+      options = options.select { |k,v| allowed.include?(k.to_s) }
+
+      options.map do |k,v|
+        k = k.to_s.gsub("_", "-")
+        k = "--#{k}"
+        if v == true
+           k # IE: --global
+        elsif v == false
+          ""
+        else
+          "#{k}=#{v}"
+        end
+      end.sort.join(" ").squish
+    end
+
+    def invalid_command?
+      @command == "url-maps update"
+    end
+
+    def allowed_options(command)
+      lines = capture("gcloud help compute #{command}", show_command: false).split("\n")
+      lines = lines.grep(/--/)
+      lines = filter_special_cases(lines)
+      lines.map do |line|
+        md = line.match(/--([\w-]+)/)
+        md[1] if md
+      end.compact.sort.uniq
+    end
+    memoize :allowed_options
+
+    # Note: Tried filtering out lines with bold text, but it didn't work. It introduced too many bugs.
+    #
+    #   "     \e[1m--priority\e[m=\e[4mPRIORITY\e[m",
+    #   "     \e[1m--rules\e[m=[\e[4mPROTOCOL\e[m[:\e[4mPORT\e[m[-\e[4mPORT\e[m]],...]",
+    #   "     \e[1m--source-ranges\e[m=[\e[4mCIDR_RANGE\e[m,...]",
+    #
+    # regexp to match bold text: /^\s+.?\[1m--/ (attempt)
+    #   line.match(/^\s+.?\[1m--/)
+    #
+    def filter_special_cases(lines)
+      case @command
+      when "backend-services update"
+        lines = lines.reject { |line| line.include?("--load-balancing-scheme") }
+      end
+      lines
+    end
+  end
+end

data/lib/glb/lb/backend_service/backend.rb

@@ -0,0 +1,94 @@
+class Glb::Lb::BackendService
+  class Backend < Glb::Lb::Resource
+    # override so resource_name, resource_config, and region_option are correct
+    def resource_type
+      "backend_service"
+    end
+
+    def resource_name
+      backend_service_name
+    end
+
+    def add
+      return unless network_endpoint_group
+      validate_neg_exists!
+
+      google_zones.each do |zone|
+        if backend_added?(zone)
+          puts "Backend already added. network_endpoint_group: #{network_endpoint_group} backend_service: #{resource_name} zone: #{zone}"
+        else
+          sh add_command(zone)
+        end
+      end
+    end
+
+    def add_commands
+      google_zones.map do |zone|
+        add_command(zone)
+      end
+    end
+
+    def add_command(zone)
+      "gcloud compute backend-services add-backend #{resource_name} #{add_args(zone)}"
+    end
+
+    def add_args(zone)
+      defaults = {
+        network_endpoint_group_zone: zone, # us-central1-a
+        network_endpoint_group: network_endpoint_group,
+      }
+      opts = defaults.merge(config.backend_service.add_backend)
+      Glb::Lb::Args.new("backend-services add-backend", opts).transform
+    end
+
+    def backend_added?(zone)
+      @describe_cache ||= capture "gcloud compute backend-services describe #{resource_name} #{region_option} --format json"
+      return false if @describe_cache.blank?
+
+      data = JSON.load(@describe_cache)
+      backends = data["backends"]
+      return false unless backends
+
+      # "backends": [
+      #   {
+      #     "balancingMode": "RATE",
+      #     "capacityScaler": 1,
+      #     "group": "https://www.googleapis.com/compute/v1/projects/PROJECT/zones/ZONE/networkEndpointGroups/NEG",
+      #     "maxRatePerEndpoint": 1
+      #   }
+      backends.any? do |b|
+        # https://www.googleapis.com/compute/v1/projects/PROJECT/zones/ZONE/networkEndpointGroups/NEG
+        parts = b["group"].split("/")
+        parts.last == network_endpoint_group && parts[-3] == zone
+      end
+    end
+
+    private
+    # Validate by checking if the network_endpoint_group exists in any google zone
+    def validate_neg_exists!
+      if google_zones.empty?
+        puts <<~EOL.color(:red)
+          ERROR: Could not find network_endpoint_group: #{network_endpoint_group}
+          in any google zones.
+
+          Please check that the network_endpoint_group exists and try again.
+
+              gcloud compute network-endpoint-groups list --filter='name=#{network_endpoint_group}'
+
+        EOL
+        exit 1
+      end
+    end
+
+    def google_zones
+      out = capture "gcloud compute network-endpoint-groups list --filter='name=#{network_endpoint_group}' --format json", show_command: false
+      groups = JSON.load(out)
+      groups = groups.map { |g| g["zone"].split("/").last }
+    end
+    memoize :google_zones
+
+    def network_endpoint_group
+      Glb.config.backend_service.add_backend.network_endpoint_group
+    end
+  end
+end

data/lib/glb/lb/backend_service.rb

@@ -0,0 +1,19 @@
+class Glb::Lb
+  class BackendService < Resource
+    def default_options
+      {
+        health_checks: health_check_name,
+      }
+    end
+
+    def up
+      super
+      backend.add
+    end
+
+    def backend
+      Backend.new(@options)
+    end
+    memoize :backend
+  end
+end

data/lib/glb/lb/firewall_rule.rb

@@ -0,0 +1,9 @@
+class Glb::Lb
+  class FirewallRule < Resource
+    def default_options
+      {
+        target_tags: Glb.config.firewall_rule.target_tags || @name,
+      }
+    end
+  end
+end

data/lib/glb/lb/forwarding_rule.rb

@@ -0,0 +1,16 @@
+class Glb::Lb
+  class ForwardingRule < Resource
+    def default_options
+      {
+        target_http_proxy: target_http_proxy_name,
+      }
+    end
+
+    def show_ip
+      out = capture "gcloud compute forwarding-rules describe #{resource_name} #{region_option} --format json", show_command: false
+      ip = JSON.parse(out)["IPAddress"]
+      name = self.class.name.split('::').last.underscore.humanize
+      puts "#{name} ip: #{ip}"
+    end
+  end
+end

data/lib/glb/lb/forwarding_rule_https.rb

@@ -0,0 +1,24 @@
+class Glb::Lb
+  class ForwardingRuleHttps < ForwardingRule
+    # override so resource_name is correct
+    def resource_type
+      "forwarding_rule"
+    end
+
+    # override so resource_name is correct
+    def resource_name
+      forwarding_rule_https_name
+    end
+
+    # override so resource_config and region_option are correct
+    def resource_config
+      config.forwarding_rule_https
+    end
+
+    def default_options
+      {
+        target_https_proxy: target_https_proxy_name,
+      }
+    end
+  end
+end

data/lib/glb/lb/health_check.rb

@@ -0,0 +1,13 @@
+class Glb::Lb
+  class HealthCheck < Resource
+    # Override to add http to the command
+    def up_command
+      "gcloud compute health-checks #{action} http #{resource_name} #{args}" if valid?
+    end
+
+    # Override to add http to the command
+    def args
+      Args.new("health-checks #{action} http", config.health_check).transform
+    end
+  end
+end

data/lib/glb/lb/names.rb

@@ -0,0 +1,50 @@
+class Glb::Lb
+  module Names
+    def firewall_rule_name
+      build_name("#{network}-#{@name}", 'firewall-rule') # IE: dev-demo-dev
+    end
+
+    # firewall_rule_name network method to be defined in the class
+    # defined here to make easier to follow
+    def network
+      Glb.config.firewall_rule.network
+    end
+
+    def health_check_name
+      build_name(@name, 'health-check') # IE: demo-health-check-dev
+    end
+
+    def backend_service_name
+      build_name(@name, 'backend-service') # IE: demo-backend-service-dev
+    end
+
+    def url_map_name
+      build_name(@name, 'url-map') # IE: demo-url-map-dev
+    end
+
+    def target_http_proxy_name
+      build_name(@name, 'target-http-proxy') # IE: demo-target-http-proxy-dev
+    end
+
+    def forwarding_rule_name
+      build_name(@name, 'forwarding-rule')
+    end
+
+    # Note: target_https_proxy name can be the same as target_http_proxy name
+    # Google considers them different types of resources.
+    def target_https_proxy_name
+      build_name(@name, 'target-https-proxy') # IE: demo-target-https-proxy-dev
+    end
+
+    # Note: forwarding rules for https must be differently named from the http one
+    # Google considers them the type of resources.
+    def forwarding_rule_https_name
+      build_name(@name, 'forwarding-rule', 'https') # IE: demo-forwarding-rule-https-dev
+    end
+
+    def build_name(name, type, infix=nil)
+      type = nil unless config.naming.include_type
+      [name, type, infix, Glb.env, Glb.extra].compact.join('-') # IE: demo-health-check-dev
+    end
+  end
+end