armrest 0.1.0

data/lib/armrest/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:
+
+  armrest completion
+  armrest completion hello
+  armrest completion hello name
+  armrest completion hello name --
+  armrest completion hello name --noop
+
+  armrest completion
+  armrest completion sub:goodbye
+  armrest 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 Armrest
+  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/armrest/logger.rb

@@ -0,0 +1,6 @@
+require 'logger'
+
+module Armrest
+  class Logger < ::Logger
+  end
+end

data/lib/armrest/logging.rb

@@ -0,0 +1,22 @@
+module Armrest
+  module Logging
+    @@logger = nil
+    def logger
+      @@logger ||= default_logger
+    end
+
+    def logger=(v)
+      @@logger = v
+    end
+
+    # Note the Armrest logger on debug is pretty verbose so think it may be better
+    # to not assign the Armrest::Logging.logger = Terraspace.logger
+    def default_logger
+      logger = Armrest::Logger.new($stderr)
+      logger.level = ENV['ARMREST_LOG_LEVEL'] ? ENV['ARMREST_LOG_LEVEL'] : :info
+      logger
+    end
+
+    extend self
+  end
+end

data/lib/armrest/services/base.rb

@@ -0,0 +1,16 @@
+module Armrest::Services
+  class Base
+    include Armrest::Api::Mods
+    extend Memoist
+
+    def initialize(options={})
+      @options = options
+    end
+
+  private
+    def api
+      Armrest::Api::Main.new
+    end
+    memoize :api
+  end
+end

data/lib/armrest/services/blob_container.rb

@@ -0,0 +1,29 @@
+module Armrest::Services
+  class BlobContainer < Base
+    def initialize(options={})
+      super
+      @storage_account = options[:storage_account]
+    end
+
+    # https://docs.microsoft.com/en-us/rest/api/storagerp/blob-containers/get
+    # GET https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/blobServices/default/containers/{containerName}?api-version=2021-04-01
+    def get(attrs={})
+      name = attrs[:name]
+      path = "subscriptions/#{subscription_id}/resourceGroups/#{group}/providers/Microsoft.Storage/storageAccounts/#{@storage_account}/blobServices/default/containers/#{name}"
+      api.get(path)
+    end
+
+    def exist?(attrs={})
+      resp = get(attrs)
+      resp.code =~ /^20/
+    end
+
+    # https://docs.microsoft.com/en-us/rest/api/storagerp/blob-containers/create
+    # PUT https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/blobServices/default/containers/{containerName}?api-version=2021-04-01
+    def create(attrs={})
+      name = attrs.delete(:name)
+      path = "subscriptions/#{subscription_id}/resourceGroups/#{group}/providers/Microsoft.Storage/storageAccounts/#{@storage_account}/blobServices/default/containers/#{name}"
+      api.put(path)
+    end
+  end
+end

data/lib/armrest/services/blob_service.rb

@@ -0,0 +1,25 @@
+module Armrest::Services
+  class BlobService < Base
+    def initialize(options={})
+      super
+      @storage_account = options[:storage_account]
+    end
+
+    # https://docs.microsoft.com/en-us/rest/api/storagerp/blob-services/get-service-properties
+    # GET https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/blobServices/default?api-version=2021-04-01
+    def get_properties
+      path = "subscriptions/#{subscription_id}/resourceGroups/#{group}/providers/Microsoft.Storage/storageAccounts/#{@storage_account}/blobServices/default"
+      resp = api.get(path)
+      load_json(resp)
+    end
+
+    # https://docs.microsoft.com/en-us/rest/api/storagerp/blob-services/set-service-properties
+    # PUT https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/blobServices/default?api-version=2021-04-01
+    def set_properties(props)
+      props = props.to_h.deep_symbolize_keys
+      data = { properties: props }
+      path = "subscriptions/#{subscription_id}/resourceGroups/#{group}/providers/Microsoft.Storage/storageAccounts/#{@storage_account}/blobServices/default"
+      api.put(path, data)
+    end
+  end
+end

data/lib/armrest/services/key_vault/base.rb

@@ -0,0 +1,54 @@
+module Armrest::Services::KeyVault
+  class Base < Armrest::Services::Base
+    class Error < StandardError; end
+    class VaultNotFoundError < Error; end
+    class VaultNotConfiguredError < Error; end
+
+    extend Memoist
+    cattr_accessor :vault
+
+  private
+    def api
+      check_vault_configured!
+      vault_subdomain = @vault.downcase
+      endpoint = "https://#{vault_subdomain}.vault.azure.net"
+      logger.debug "Azure vault endpoint #{endpoint}"
+      Armrest::Api::Main.new(
+        api_version: "7.1",
+        endpoint: endpoint,
+        resource: "https://vault.azure.net",
+      )
+    end
+    memoize :api
+
+    def check_vault_configured!
+      return if @vault
+      logger.error "ERROR: Vault has not been configured.".color(:red)
+      logger.error <<~EOL
+        Please configure the Azure KeyVault you want to use.  Examples:
+
+        1. env var
+
+            ARMREST_VAULT=demo-vault
+
+        2. class var
+
+            Armrest::KeyVault::Secret.vault = "demo-vault"
+      EOL
+      raise VaultNotConfiguredError.new
+    end
+
+    # Secret error handling: 1. network 2. json parse 3. missing secret
+    #
+    # Azure API responses with decent error message when
+    #   403 Forbidden - KeyVault Access Policy needs to be set up
+    #   404 Not Found - Secret name is incorrect
+    #
+    def standard_error_message(resp)
+      data = JSON.load(resp.body)
+      data['error']['message']
+    rescue JSON::ParserError
+      resp.body
+    end
+  end
+end

data/lib/armrest/services/key_vault/secret.rb

@@ -0,0 +1,37 @@
+require "json"
+require "net/http"
+require "uri"
+
+# az keyvault secret show --vault-name $VAULT --name "demo-dev-pass" | jq -r '.value'
+module Armrest::Services::KeyVault
+  class Secret < Base
+    # Using Azure REST API since the old gem doesnt support secrets https://github.com/Azure/azure-sdk-for-ruby
+    # https://docs.microsoft.com/en-us/rest/api/keyvault/get-secret/get-secret
+    def show(options={})
+      name = options[:name]
+      @vault = options[:vault] || @options[:vault] || ENV['ARMREST_VAULT'] || self.class.vault
+      version = "/#{version}" if @options[:version]
+      begin
+        resp = api.get("/secrets/#{name}#{version}")
+      rescue SocketError => e
+        if e.message.include?("vault.azure.net")
+          message = "WARN: Vault not found. Vault: #{@vault}"
+          logger.info message.color(:yellow)
+          return message
+        else
+          raise
+        end
+      end
+
+      case resp.code.to_s
+      when /^2/
+        data = JSON.load(resp.body)
+        data['value']
+      else
+        message = standard_error_message(resp)
+        logger.info "WARN: #{message}".color(:yellow)
+        return message
+      end
+    end
+  end
+end

data/lib/armrest/services/resource_group.rb

@@ -0,0 +1,23 @@
+module Armrest::Services
+  class ResourceGroup < Base
+    # https://docs.microsoft.com/en-us/rest/api/resources/resource-groups/check-existence
+    # HEAD https://management.azure.com/subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}?api-version=2021-04-01
+    def check_existence(attrs={})
+      name = attrs[:name]
+      path = "subscriptions/#{subscription_id}/resourcegroups/#{name}"
+      resp = api.head(path)
+      resp.code == "204" # means it exists
+    end
+
+    # https://docs.microsoft.com/en-us/rest/api/resources/resource-groups/create-or-update
+    # PUT https://management.azure.com/subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}?api-version=2021-04-01
+    def create_or_update(attrs={})
+      name = attrs.delete(:name)
+      # https://docs.microsoft.com/en-us/rest/api/resources/resource-groups/create-or-update#request-body
+      attrs[:location] ||= location
+      attrs[:tags] = attrs[:tags] if attrs[:tags]
+      path = "subscriptions/#{subscription_id}/resourcegroups/#{name}"
+      api.put(path, attrs)
+    end
+  end
+end

data/lib/armrest/services/storage_account.rb

@@ -0,0 +1,36 @@
+module Armrest::Services
+  class StorageAccount < Base
+    # https://docs.microsoft.com/en-us/rest/api/storagerp/storage-accounts/check-name-availability
+    # POST https://management.azure.com/subscriptions/{subscriptionId}/providers/Microsoft.Storage/checkNameAvailability?api-version=2021-04-01
+    def check_name_availability(attrs={})
+      name = attrs[:name]
+      path = "subscriptions/#{subscription_id}/providers/Microsoft.Storage/checkNameAvailability"
+      attrs = {
+        name: name,
+        type: "Microsoft.Storage/storageAccounts",
+      }
+      res = api.post(path, attrs)
+      load_json(res)
+    end
+
+    # https://docs.microsoft.com/en-us/rest/api/storagerp/storage-accounts/create
+    # PUT https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}?api-version=2021-04-01
+    # Note there's an update api also but PUT to create will also update. So just implementing create.
+    def create(attrs={})
+      name = attrs.delete(:name)
+      # https://docs.microsoft.com/en-us/rest/api/storagerp/storage-accounts/create#request-body
+      attrs[:kind] ||= "StorageV2"
+      attrs[:location] ||= location
+      attrs[:sku] ||= {
+        name: "Standard_RAGRS", # default according to az storage account create --help
+        tier: "Standard",
+      }
+      attrs[:properties] ||= {
+        allow_blob_public_access: false
+      }
+      path = "subscriptions/#{subscription_id}/resourceGroups/#{group}/providers/Microsoft.Storage/storageAccounts/#{name}"
+      puts "StorageAccount#create attrs #{attrs}".color(:purple)
+      resp = api.put(path, attrs)
+    end
+  end
+end

data/lib/armrest/version.rb

@@ -0,0 +1,3 @@
+module Armrest
+  VERSION = "0.1.0"
+end

data/lib/armrest.rb

@@ -0,0 +1,15 @@
+$stdout.sync = true unless ENV["ARMREST_STDOUT_SYNC"] == "0"
+
+$:.unshift(File.expand_path("../", __FILE__))
+
+require "armrest/autoloader"
+Armrest::Autoloader.setup
+
+require "active_support"
+require "active_support/core_ext/string"
+require "memoist"
+require "rainbow/ext/string"
+
+module Armrest
+  class Error < StandardError; end
+end

data/spec/cli_spec.rb

@@ -0,0 +1,8 @@
+describe Armrest::CLI do
+  describe "armrest" do
+    it "version" do
+      out = execute("exe/armrest version")
+      expect(out).to be_a(String)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+ENV["ARMREST_TEST"] = "1"
+
+# CodeClimate test coverage: https://docs.codeclimate.com/docs/configuring-test-coverage
+# require 'simplecov'
+# SimpleCov.start
+
+require "pp"
+require "byebug"
+root = File.expand_path("../", File.dirname(__FILE__))
+require "#{root}/lib/armrest"
+
+module Helper
+  def execute(cmd)
+    puts "Running: #{cmd}" if show_command?
+    out = `#{cmd}`
+    puts out if show_command?
+    out
+  end
+
+  # Added SHOW_COMMAND because DEBUG is also used by other libraries like
+  # bundler and it shows its internal debugging logging also.
+  def show_command?
+    ENV['DEBUG'] || ENV['SHOW_COMMAND']
+  end
+end
+
+RSpec.configure do |c|
+  c.include Helper
+end