vagrant_cloud 2.0.3 → 3.0.0

data/lib/vagrant_cloud/instrumentor/core.rb

@@ -0,0 +1,9 @@
+module VagrantCloud
+  module Instrumentor
+    class Core
+      def instrument(*_)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/vagrant_cloud/instrumentor/logger.rb

@@ -0,0 +1,97 @@
+module VagrantCloud
+  module Instrumentor
+    class Logger < Core
+      REDACTED = "REDACTED".freeze
+
+      include VagrantCloud::Logger
+
+      # Perform event logging
+      #
+      # @param [String] name Name of event "namespace.event"
+      # @param [Hash] params Data available with event
+      def instrument(name, params = {})
+        namespace, event = name.split(".", 2)
+
+        if event == "error"
+          logger.error { "#{namespace} #{event.upcase} #{params[:error]}" }
+          return
+        end
+
+        logger.info do
+          case namespace
+          when "excon"
+            # Make a copy so we can modify
+            params = params.dup
+            info = excon(event, params)
+          else
+            info = params.dup
+          end
+          "#{namespace} #{event.upcase} #{format_output(info)}"
+        end
+
+        logger.debug do
+          "#{namespace} #{event.upcase} #{format_output(params)}"
+        end
+      end
+
+      # Format output to make it look nicer
+      #
+      # @param [Hash] info Output information
+      # @return [String]
+      def format_output(info)
+        info.map do |key, value|
+          if value.is_a?(Enumerable)
+            value = value.map{ |k,v| [k, v].compact.join(": ") }.join(", ")
+          end
+          "#{key}=#{value.inspect}"
+        end.join(" ")
+      end
+
+      # Generate information based on excon event
+      #
+      # @param [String] event Event name
+      # @param [Hash] params Event data
+      # @return [Hash] data to be printed
+      def excon(event, params)
+        # Remove noisy stuff that may be present from excon
+        params.delete(:connection)
+        params.delete(:stack)
+
+        # Remove any credential information
+        params[:password] = REDACTED if params.key?(:password)
+        params[:access_token] = REDACTED if params[:access_token]
+        if params.dig(:headers, "Authorization") || params.dig(:headers, "Proxy-Authorization")
+          params[:headers] = params[:headers].dup.tap do |h|
+            h["Authorization"] = REDACTED if h["Authorization"]
+            h["Proxy-Authorization"] = REDACTED if h["Proxy-Authorization"]
+          end
+        end
+        if params.dig(:proxy, :password)
+          params[:proxy] = params[:proxy].dup.tap do |proxy|
+            proxy[:password] = REDACTED
+          end
+        end
+
+        info = {}
+
+        case event
+        when "request", "retry"
+          info[:method] = params[:method]
+          info[:identifier] = params.dig(:headers, 'X-Request-Id')
+          info[:url] = "#{params[:scheme]}://#{File.join(params[:host], params[:path])}"
+          info[:query] = params[:query] if params[:query]
+          info[:headers] = params[:headers] if params[:headers]
+        when "response"
+          info[:status] = params[:status]
+          info[:identifier] = params.dig(:headers, 'X-Request-Id')
+          info[:body] = params[:body]
+        else
+          info = params.dup
+        end
+        duration = (params.dig(:timing, :duration).to_f * 1000).to_i
+        info[:duration] = "#{duration}ms"
+        info
+      end
+    end
+  end
+end

data/lib/vagrant_cloud/logger.rb

@@ -0,0 +1,60 @@
+module VagrantCloud
+  module Logger
+
+    @@lock = Mutex.new
+
+    # @return [Log4r::Logger] default logger
+    def self.default
+      @@lock.synchronize do
+        if !@logger
+          # Require Log4r and define the levels we'll be using
+          require 'log4r/config'
+          Log4r.define_levels(*Log4r::Log4rConfig::LogLevels)
+
+          level = nil
+          begin
+            level = Log4r.const_get(ENV.fetch("VAGRANT_CLOUD_LOG", "FATAL").upcase)
+          rescue NameError
+            # This means that the logging constant wasn't found,
+            # which is fine. We just keep `level` as `nil`. But
+            # we tell the user.
+            level = nil
+          end
+
+          # Some constants, such as "true" resolve to booleans, so the
+          # above error checking doesn't catch it. This will check to make
+          # sure that the log level is an integer, as Log4r requires.
+          level = nil if !level.is_a?(Integer)
+
+          base_formatter = Log4r::PatternFormatter.new(
+            pattern: "%d [%5l] %m",
+            date_pattern: "%F %T"
+          )
+          Log4r::Outputter.stderr.formatter = base_formatter
+          logger = Log4r::Logger.new("vagrantcloud")
+          logger.outputters = Log4r::Outputter.stderr
+          logger.level = level
+          @logger = logger
+        end
+      end
+      @logger
+    end
+
+    def self.included(klass)
+      klass.class_variable_set(:@@logger, Log4r::Logger.new(klass.name.downcase))
+      klass.class_eval { define_method(:logger) { self.class.class_variable_get(:@@logger) } }
+    end
+
+    # @return [Log4r::Logger] logger instance for current context
+    def logger
+      @@lock.synchronize do
+        if !@logger
+          @logger = Log4r::Logger.new(self.class.name.downcase)
+        end
+        @logger
+      end
+    end
+  end
+
+  Logger.default
+end

data/lib/vagrant_cloud/organization.rb

@@ -0,0 +1,62 @@
+module VagrantCloud
+  class Organization < Data::Mutable
+    attr_reader :account
+
+    attr_required :username
+    attr_optional :boxes, :avatar_url, :profile_html, :profile_markdown
+
+    attr_mutable :boxes
+
+    def initialize(account:, **opts)
+      @account = account
+      opts[:boxes] ||= []
+      super(**opts)
+      bxs = boxes.map do |b|
+        if !b.is_a?(Box)
+          b = Box.load(organization: self, **b)
+        end
+        b
+      end
+      clean(data: {boxes: bxs})
+    end
+
+    # Add a new box to the organization
+    #
+    # @param [String] name Name of the box
+    # @return [Box]
+    def add_box(name)
+      if boxes.any? { |b| b.name == name }
+        raise Error::BoxError::BoxExistsError,
+          "Box with name #{name} already exists"
+      end
+      b = Box.new(organization: self, name: name)
+      clean(data: {boxes: boxes + [b]})
+      b
+    end
+
+    # Check if this instance is dirty
+    #
+    # @param [Boolean] deep Check nested instances
+    # @return [Boolean] instance is dirty
+    def dirty?(key=nil, deep: false)
+      if key
+        super(key)
+      else
+        d = super()
+        if deep && !d
+          d = boxes.any? { |b| b.dirty?(deep: true) }
+        end
+        d
+      end
+    end
+
+    # Save the organization
+    #
+    # @return [self]
+    # @note This only saves boxes within organization
+    def save
+      boxes.map(&:save)
+      self
+    end
+  end
+end

data/lib/vagrant_cloud/response.rb

@@ -0,0 +1,7 @@
+module VagrantCloud
+  class Response < Data::Immutable
+    autoload :CreateToken, "vagrant_cloud/response/create_token"
+    autoload :Request2FA, "vagrant_cloud/response/request_2fa"
+    autoload :Search, "vagrant_cloud/response/search"
+  end
+end

data/lib/vagrant_cloud/response/create_token.rb

@@ -0,0 +1,7 @@
+module VagrantCloud
+  class Response
+    class CreateToken < Response
+      attr_required :token, :token_hash, :created_at, :description
+    end
+  end
+end

data/lib/vagrant_cloud/response/request_2fa.rb

@@ -0,0 +1,7 @@
+module VagrantCloud
+  class Response
+    class Request2FA < Response
+      attr_required :destination
+    end
+  end
+end

data/lib/vagrant_cloud/response/search.rb

@@ -0,0 +1,65 @@
+module VagrantCloud
+  class Response
+    class Search < Response
+      # @return [Account]
+      attr_reader :account
+      # @return [Hash] search parameters
+      attr_reader :search_parameters
+
+      attr_optional :boxes
+
+      def initialize(account:, params:, **opts)
+        if !account.is_a?(Account)
+          raise TypeError,
+            "Expected type `#{Account.name}` but received `#{account.class.name}`"
+        end
+        @account = account
+        @search_parameters = params
+        opts[:boxes] = reload_boxes(opts[:boxes])
+        super(**opts)
+      end
+
+      # @return [Integer]
+      def page
+        pg = @search_parameters.fetch(:page, 0).to_i
+        pg > 0 ? pg : 1
+      end
+
+      # @return [Search] previous page of search results
+      def previous
+        if page <= 1
+          raise ArgumentError,
+            "Cannot request page results less than one"
+        end
+        account.searcher.from_response(self) do |s|
+          s.prev_page
+        end
+      end
+
+      # @return [Search] next page of search results
+      def next
+        account.searcher.from_response(self) do |s|
+          s.next_page
+        end
+      end
+
+      protected
+
+      # Load all the box data into proper instances
+      def reload_boxes(boxes)
+        org_cache = {}
+        boxes.map do |b|
+          org_name = b[:username]
+          if !org_cache[org_name]
+            org_cache[org_name] = account.organization(name: org_name)
+          end
+          org = org_cache[org_name]
+          box = Box.new(organization: org, **b)
+          org.boxes = org.boxes + [box]
+          org.clean!
+          box
+        end
+      end
+    end
+  end
+end

data/lib/vagrant_cloud/search.rb

@@ -1,9 +1,37 @@
 module VagrantCloud
   class Search
-    attr_accessor :account
+    # @return [Account]
+    attr_reader :account
 
-    def initialize(access_token = nil, custom_server = nil)
-      @client = Client.new(access_token, custom_server)
+    # Create a new search instance
+    #
+    # @param [String] access_token Authentication token
+    # @param [Account] account Account instance
+    # @param [Client] client Client instance
+    # @return [Search]
+    def initialize(access_token: nil, account: nil, client: nil)
+      args = {access_token: access_token, account: account, client: client}.compact
+      if args.size > 1
+        raise ArgumentError,
+          "Search accepts `access_token`, `account`, or `client` but received multiple (#{args.keys.join(", ")})"
+      end
+      if client
+        if !client.is_a?(Client)
+          raise TypeError,
+            "Expecting type `#{Client.name}` but received `#{client.class.name}`"
+        end
+        @account = Account.new(client: client)
+      elsif account
+        if !account.is_a?(Account)
+          raise TypeError,
+            "Expecting type `#{Account.name}` but received `#{account.class.name}`"
+        end
+        @account = account
+      else
+        @account = Account.new(access_token: access_token)
+      end
+      @params = {}
+      @lock = Mutex.new
     end
 
     # Requests a search based on the given parameters
@@ -14,18 +42,88 @@ module VagrantCloud
     # @param [String] order
     # @param [String] limit
     # @param [String] page
-    # @return [Hash]
-    def search(query = nil, provider = nil, sort = nil, order = nil, limit = nil, page = nil)
-      params = {
-        q: query,
-        provider: provider,
-        sort: sort,
-        order: order,
-        limit: limit,
-        page: page
-      }.delete_if { |_, v| v.nil? }
-
-      @client.request('get', '/search', params)
+    # @return [Response::Search]
+    def search(query: Data::Nil, provider: Data::Nil, sort: Data::Nil, order: Data::Nil, limit: Data::Nil, page: Data::Nil)
+      @lock.synchronize do
+        @params = {
+          query: query,
+          provider: provider,
+          sort: sort,
+          order: order,
+          limit: limit,
+          page: page
+        }
+        execute
+      end
+    end
+
+    # Request the next page of the search results
+    #
+    # @param [Response::Search]
+    def next_page
+      @lock.synchronize do
+        if @params.empty?
+          raise ArgumentError, "No active search currently cached"
+        end
+        page = @params[:page].to_i
+        page = 1 if page < 1
+        @params[:page] = page + 1
+        execute
+      end
+    end
+
+    # Request the previous page of the search results
+    #
+    # @param [Response::Search]
+    def prev_page
+      @lock.synchronize do
+        if @params.empty?
+          raise ArgumentError, "No active search currently cached"
+        end
+        page = @params[:page].to_i - 1
+        @params[:page] = page < 1 ? 1 : page
+        execute
+      end
+    end
+
+    # @return [Boolean] Search terms are stored
+    def active?
+      !@params.empty?
+    end
+
+    # Clear the currently cached search parameters
+    #
+    # @return [self]
+    def clear!
+      @lock.synchronize { @params.clear }
+      self
+    end
+
+    # Seed the parameters
+    #
+    # @return [self]
+    def seed(**params)
+      @lock.synchronize { @params = params }
+      self
+    end
+
+    # Generate a new instance seeded with search
+    # parameters from given response
+    #
+    # @param [Response::Search] response Search response
+    # @yieldparam [Search] Seeded search instance
+    # @return [Object] result of given block
+    def from_response(response)
+      s = self.class.new(account: account)
+      yield s.seed(**response.search_parameters)
+    end
+
+    protected
+
+    # @return [Response::Search]
+    def execute
+      r = account.client.search(**@params)
+      Response::Search.new(account: account, params: @params, **r)
     end
   end
 end