vagrant_cloud 2.0.0 → 3.0.1

data/lib/vagrant_cloud/data.rb

@@ -0,0 +1,293 @@
+module VagrantCloud
+  # Generic data class which provides simple attribute
+  # data storage using a Hash like interface
+  class Data
+    # Custom nil class which is used for signifying
+    # a nil value that was not set by the user. This
+    # makes it easy to filter out values which are
+    # unset vs. those that are set to nil.
+    class NilClass < BasicObject
+      include ::Singleton
+      def nil?; true; end
+      def ==(v); v.nil? || super(v); end
+      def ===(v); equal?(v); end
+      def equal?(v); v.nil? || super(v); end
+      def to_i; 0; end
+      def to_f; 0.0; end
+      def to_a; []; end
+      def to_h; {}; end
+      def to_s; ""; end
+      def &(_); false; end
+      def |(_); false; end
+      def ^(_); false; end
+      def !; true; end
+      def inspect; 'nil'; end
+    end
+
+    # Easy to use constant to access general
+    # use instance of our custom nil class
+    Nil = NilClass.instance
+
+    # Create a new instance
+    #
+    # @return [Data]
+    def initialize(**opts)
+      @data = opts
+    end
+
+    # Fetch value from data
+    #
+    # @param [String, Symbol] k Name of value
+    # @return [Object]
+    def [](k)
+      @data.key?(k.to_sym) ? @data[k.to_sym] : Nil
+    end
+
+    # @return [String]
+    def inspect
+      "<#{self.class.name}:#{sprintf("%#x", object_id)}>"
+    end
+
+    protected def data; @data; end
+
+    # Immutable data class. This class adds extra functionality to the Data
+    # class like providing attribute methods which can be defined using the
+    # `attr_required` and `attr_optional` methods. Once an instance is created
+    # the data is immutable. For example:
+    #
+    # class MyData < Immutable
+    #   attr_required :name
+    #   attr_optional :version
+    # end
+    #
+    # When creating a new instance, a name parameter _must_ be provided,
+    # but a version parameter is optional, so both are valid:
+    #
+    # instance = MyData.new(name: "testing", version: "new-version")
+    #
+    # and
+    #
+    # instance = MyData.new(name: "testing")
+    #
+    # but only providing the version is invalid:
+    #
+    # instance = MyData.new(version: "new-version") # -> Exception
+    class Immutable < Data
+      @@lock = Mutex.new
+
+      # Define attributes which are required
+      def self.attr_required(*args)
+        return @required || [] if args.empty?
+        sync do
+          @required ||= []
+          if !args.empty?
+            # Create any accessor methods which do not yet exist
+            args = args.map(&:to_sym) - @required
+            args.each do |argument_name|
+              if !method_defined?(argument_name)
+                define_method(argument_name) {
+                  send(:[], argument_name.to_sym)
+                }
+              end
+            end
+            @required += args
+          end
+          @required
+        end
+      end
+
+      # Define attributes which are optional
+      def self.attr_optional(*args)
+        return @optional || [] if args.empty?
+        sync do
+          @optional ||= []
+          if !args.empty?
+            # Create any accessor method which do not yet exist
+            args = args.map(&:to_sym) - @optional
+            args.each do |argument_name|
+              if !method_defined?(argument_name)
+                define_method(argument_name) {
+                  send(:[], argument_name.to_sym)
+                }
+              end
+            end
+            @optional += args
+          end
+          @optional
+        end
+      end
+
+      # If inherited, set attribute information
+      def self.inherited(klass)
+        klass.attr_required(*attr_required)
+        klass.attr_optional(*attr_optional)
+        klass.class_variable_set(:@@lock, Mutex.new)
+      end
+
+      # Synchronize action
+      def self.sync
+        @@lock.synchronize do
+          yield
+        end
+      end
+
+      # Create a new instance
+      #
+      # @return [Immutable]
+      def initialize(**opts)
+        super()
+        self.class.attr_required.each do |attr|
+          if !opts.key?(attr)
+            raise ArgumentError, "Missing required parameter `#{attr}`"
+          end
+          data[attr.to_sym] = opts[attr].dup
+        end
+        self.class.attr_optional.each do |attr|
+          if opts.key?(attr)
+            data[attr.to_sym] = opts[attr].dup
+          end
+        end
+        extras = opts.keys - (self.class.attr_required + self.class.attr_optional)
+        if !extras.empty?
+          raise ArgumentError, "Unknown parameters provided: #{extras.join(",")}"
+        end
+        freezer(@data)
+      end
+
+      # @return [String]
+      def inspect
+        vars = (self.class.attr_required + self.class.attr_optional).map do |k|
+          val = self.send(:[], k)
+          next if val.nil? || val.to_s.empty?
+          "#{k}=#{val.inspect}"
+        end.compact.join(", ")
+        "<#{self.class.name}:#{sprintf("%#x", object_id)} #{vars}>"
+      end
+
+      protected
+
+      # Freeze the given object and all nested
+      # objects that can be found
+      #
+      # @return [Object]
+      def freezer(obj)
+        if obj.is_a?(Enumerable)
+          obj.each do |item|
+            freezer(item)
+            item.freeze
+          end
+        end
+        obj.freeze
+      end
+    end
+
+    # Mutable data class
+    class Mutable < Immutable
+      # Define attributes which are mutable
+      def self.attr_mutable(*args)
+        sync do
+          args.each do |attr|
+            if !attr_required.include?(attr.to_sym) && !attr_optional.include?(attr.to_sym)
+              raise ArgumentError, "Unknown attribute name provided `#{attr}`"
+            end
+            define_method("#{attr}=") { |v| dirty[attr.to_sym] = v }
+          end
+        end
+      end
+
+      # Load data and create a new instance
+      #
+      # @param [Hash] options Value to initialize instance
+      # @return [Mutable]
+      def self.load(options={})
+        opts = {}.tap do |o|
+          (attr_required + attr_optional +
+            self.instance_method(:initialize).parameters.find_all { |i|
+            i.first == :key || i.first == :keyreq
+          }.map(&:last)).each do |k|
+            o[k.to_sym] = options[k.to_sym]
+          end
+        end
+        self.new(**opts)
+      end
+
+      # Create a new instance
+      #
+      # @return [Mutable]
+      def initialize(**opts)
+        super
+        @dirty = {}
+      end
+
+      # Fetch value from data
+      #
+      # @param [String, Symbol] k Name of value
+      # @return [Object]
+      def [](k)
+        if dirty?(k)
+          @dirty[k.to_sym]
+        else
+          super
+        end
+      end
+
+      # Check if instance is dirty or specific
+      # attribute if key is provided
+      #
+      # @param [Symbol] key Key to check
+      # @return [Boolean] instance is dirty
+      def dirty?(key=nil, **opts)
+        if key.nil?
+          !@dirty.empty?
+        else
+          @dirty.key?(key.to_sym)
+        end
+      end
+
+      # Load given data and ignore any fields
+      # that are provided. Flush dirty state.
+      #
+      # @param [Hash] data Attribute data to load
+      # @param [Array<Symbol>] ignores Fields to skip
+      # @param [Array<Symbol>] only Fields to update
+      # @return [self]
+      def clean(data:, ignores: [], only: [])
+        raise TypeError, "Expected type `Hash` but received `#{data.inspect}`" if
+          !data.is_a?(Hash)
+        new_data = @data.dup
+        ignores = Array(ignores).map(&:to_sym)
+        only = Array(only).map(&:to_sym)
+        data.each do |k, v|
+          k = k.to_sym
+          next if ignores.include?(k)
+          next if !only.empty? && !only.include?(k)
+          if self.respond_to?(k)
+            new_data[k] = v
+            @dirty.delete(k)
+          end
+        end
+        @data = freezer(new_data)
+        self
+      end
+
+      # Merge values from dirty cache into data
+      #
+      # @return [self]
+      def clean!
+        @data = freezer(@data.merge(@dirty))
+        @dirty.clear
+        self
+      end
+
+      # @return [self] disable freezing
+      def freeze
+        self
+      end
+
+      # @return [Hash] updated attributes
+      protected def dirty; @dirty; end
+    end
+  end
+
+  Nil = Data::Nil
+end

data/lib/vagrant_cloud/error.rb

@@ -0,0 +1,48 @@
+module VagrantCloud
+  class Error < StandardError
+    class ClientError < Error
+      class RequestError < ClientError
+        attr_accessor :error_arr
+        attr_accessor :error_code
+
+        def initialize(msg, http_body, http_code)
+          message = msg
+
+          begin
+            errors = JSON.parse(http_body)
+            if errors.is_a?(Hash)
+              vagrant_cloud_msg = errors['errors']
+              if vagrant_cloud_msg.is_a?(Array)
+                message = msg + ' - ' + vagrant_cloud_msg.map(&:to_s).join(', ').to_s
+              elsif !vagrant_cloud_msg.to_s.empty?
+                message = msg + ' - ' + vagrant_cloud_msg.to_s
+              end
+            end
+          rescue JSON::ParserError => err
+            vagrant_cloud_msg = err.message
+          end
+
+          @error_arr = vagrant_cloud_msg
+          @error_code = http_code.to_i
+          super(message)
+        end
+      end
+
+      class ConnectionLockedError < ClientError; end
+    end
+
+    class BoxError < Error
+      class InvalidVersionError < BoxError
+        def initialize(version_number)
+          message = 'Invalid version given: ' + version_number
+          super(message)
+        end
+      end
+      class BoxExistsError < BoxError; end
+      class ProviderNotFoundError < BoxError; end
+      class VersionExistsError < BoxError; end
+      class VersionStatusChangeError < BoxError; end
+      class VersionProviderExistsError < BoxError; end
+    end
+  end
+end

data/lib/vagrant_cloud/instrumentor.rb

@@ -0,0 +1,7 @@
+module VagrantCloud
+  module Instrumentor
+    autoload :Collection, "vagrant_cloud/instrumentor/collection"
+    autoload :Core, "vagrant_cloud/instrumentor/core"
+    autoload :Logger, "vagrant_cloud/instrumentor/logger"
+  end
+end

data/lib/vagrant_cloud/instrumentor/collection.rb

@@ -0,0 +1,123 @@
+module VagrantCloud
+  module Instrumentor
+    class Collection < Core
+      # @return [Set<Instrumentor::Core>]
+      attr_reader :instrumentors
+      # @return [Set<Callable>]
+      attr_reader :subscriptions
+
+      # Create a new instance
+      #
+      # @param [Array<Core>] instrumentors Instrumentors to add to collection
+      def initialize(instrumentors: [])
+        @lock = Mutex.new
+        @subscriptions = Set.new
+        @instrumentors = Set.new
+        # Add our default
+        @instrumentors << Logger.new
+
+        Array(instrumentors).each do |i|
+          if !i.is_a?(Core) && !i.respond_to?(:instrument)
+            raise TypeError, "Instrumentors must implement `#instrument`"
+          end
+          @instrumentors << i
+        end
+        @instrumentors.freeze
+      end
+
+      # Add a new instrumentor
+      #
+      # @param [Core] instrumentor New instrumentor to add
+      # @return [self]
+      def add(instrumentor)
+        @lock.synchronize do
+          if !instrumentor.is_a?(Core) && !instrumentor.respond_to?(:instrument)
+            raise TypeError, "Instrumentors must implement `#instrument`"
+          end
+
+          @instrumentors = (instrumentors + [instrumentor]).freeze
+        end
+        self
+      end
+
+      # Remove instrumentor
+      #
+      # @param [Core] instrumentor Remove instrumentor from collection
+      # @return [self]
+      def remove(instrumentor)
+        @lock.synchronize do
+          @instrumentors = instrumentors.dup.tap{|i| i.delete(instrumentor)}.freeze
+        end
+        self
+      end
+
+      # Add a subscription for events
+      #
+      # @param [Regexp, String] event Event to match
+      def subscribe(event, callable=nil, &block)
+        if callable && block
+          raise ArgumentError, "Callable argument or block expected, not both"
+        end
+        c = callable || block
+        if !c.respond_to?(:call)
+          raise TypeError, "Callable action is required for subscription"
+        end
+        entry = [event, c]
+        @lock.synchronize do
+          @subscriptions = (@subscriptions + [entry]).freeze
+        end
+        self
+      end
+
+      def unsubscribe(callable)
+        @lock.synchronize do
+          subscriptions = @subscriptions.dup
+          subscriptions.delete_if { |entry| entry.last == callable }
+          @subscriptions = subscriptions.freeze
+        end
+        self
+      end
+
+      # Call all instrumentors in collection with given parameters
+      def instrument(name, params = {})
+        # Log the start time
+        timing = {start_time: Time.now}
+
+        # Run the action
+        result = yield if block_given?
+
+        # Log the completion time and calculate duration
+        timing[:complete_time] = Time.now
+        timing[:duration] = timing[:complete_time] - timing[:start_time]
+
+        # Insert timing into params
+        params[:timing] = timing
+
+        # Call any instrumentors we know about
+        @lock.synchronize do
+          # Call our instrumentors first
+          instrumentors.each do |i|
+            i.instrument(name, params)
+          end
+          # Now call any matching subscriptions
+          subscriptions.each do |event, callable|
+            if event.is_a?(Regexp)
+              next if !event.match(name)
+            else
+              next if event != name
+            end
+            args = [name, params]
+
+            if callable.arity > -1
+              args = args[0, callable.arity]
+            end
+
+            callable.call(*args)
+          end
+        end
+
+        result
+      end
+    end
+  end
+end