hcloud 0.1.2 → 1.0.0

data/Rakefile

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 require 'bundler/gem_tasks'
 task default: :spec

data/bin/console

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'bundler/setup'
 require 'hcloud'

data/hcloud.gemspec

@@ -1,5 +1,6 @@
+# frozen_string_literal: true
 
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'hcloud/version'
 
@@ -19,10 +20,11 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
+  spec.add_development_dependency 'activemodel'
   spec.add_development_dependency 'activesupport'
-  spec.add_development_dependency 'bundler', '~> 1.15'
+  spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'grape'
-  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec'
   spec.add_development_dependency 'webmock'
   spec.add_runtime_dependency 'activesupport'

data/lib/hcloud.rb

@@ -1,29 +1,55 @@
+# frozen_string_literal: true
+
 require 'hcloud/version'
 require 'active_support/core_ext/object/to_query'
+require 'active_support/core_ext/hash/indifferent_access'
 
 module Hcloud
   autoload :Error, 'hcloud/errors'
   autoload :Client, 'hcloud/client'
+  autoload :TyphoeusExt, 'hcloud/typhoeus_ext'
   autoload :AbstractResource, 'hcloud/abstract_resource'
-  autoload :MultiReply, 'hcloud/multi_reply'
-  autoload :ServerResource, 'hcloud/server_resource'
   autoload :EntryLoader, 'hcloud/entry_loader'
+
+  autoload :Server, 'hcloud/server'
+  autoload :ServerResource, 'hcloud/server_resource'
+
+  autoload :ServerType, 'hcloud/server_type'
+  autoload :ServerTypeResource, 'hcloud/server_type_resource'
+
   autoload :FloatingIP, 'hcloud/floating_ip'
   autoload :FloatingIPResource, 'hcloud/floating_ip_resource'
+
   autoload :SSHKey, 'hcloud/ssh_key'
   autoload :SSHKeyResource, 'hcloud/ssh_key_resource'
-  autoload :Server, 'hcloud/server'
-  autoload :ServerType, 'hcloud/server_type'
-  autoload :ServerTypeResource, 'hcloud/server_type_resource'
+
   autoload :Datacenter, 'hcloud/datacenter'
   autoload :DatacenterResource, 'hcloud/datacenter_resource'
+
   autoload :Location, 'hcloud/location'
   autoload :LocationResource, 'hcloud/location_resource'
+
   autoload :Image, 'hcloud/image'
   autoload :ImageResource, 'hcloud/image_resource'
+
+  autoload :Network, 'hcloud/network'
+  autoload :NetworkResource, 'hcloud/network_resource'
+
+  autoload :Volume, 'hcloud/volume'
+  autoload :VolumeResource, 'hcloud/volume_resource'
+
   autoload :Action, 'hcloud/action'
   autoload :ActionResource, 'hcloud/action_resource'
+
   autoload :Iso, 'hcloud/iso'
   autoload :IsoResource, 'hcloud/iso_resource'
+
   autoload :Pagination, 'hcloud/pagination'
+
+  COLLECT_ARGS = proc do |method_name, bind|
+    query = bind.receiver.method(method_name).parameters.inject({}) do |hash, (_type, name)|
+      hash.merge(name => bind.local_variable_get(name))
+    end
+    query.delete_if { |_, v| v.nil? }
+  end
 end

data/lib/hcloud/abstract_resource.rb

@@ -1,75 +1,185 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string'
+
 module Hcloud
   class AbstractResource
     include Enumerable
 
-    attr_reader :client, :parent, :base_path
+    delegate :request, :prepare_request, to: :client
+
+    class << self
+      def bind_to(klass)
+        resource = self
+        %w[find find_by where all [] page limit per_page order
+           to_a count pagnation each].each do |method|
+          klass.define_singleton_method(method) do |*args, &block|
+            resource.new(client: Client.connection).public_send(method, *args, &block)
+          end
+        end
+      end
+
+      def filter_attributes(*keys)
+        return @filter_attributes if keys.to_a.empty?
+
+        @filter_attributes = keys
+      end
+
+      def resource_class
+        ancestors[ancestors.index(Hcloud::AbstractResource) - 1]
+      end
+
+      def resource_url(url = nil)
+        return (@resource_url = url) if url
+
+        @resource_url || resource_class.name.demodulize.gsub('Resource', '').tableize
+      end
+
+      def resource_path(path = nil)
+        return (@resource_path = path) if path
+
+        @resource_path || resource_url
+      end
 
-    def initialize(client:, parent: nil, base_path: '')
+      def resource(res = nil)
+        return (@resource = res) if res
+        return @resource if @resource
+
+        auto_const = resource_class.name.demodulize.gsub('Resource', '').to_sym
+        return Hcloud.const_get(auto_const) if Hcloud.constants.include?(auto_const)
+
+        raise Error, "unable to lookup resource class for #{name}"
+      end
+    end
+
+    attr_reader :client
+
+    def initialize(client:, base_path: '')
       @client = client
-      @parent = parent
       @page = 1
       @per_page = 25
       @order = []
       @base_path = base_path
     end
 
+    def all
+      where
+    end
+
+    def where(**kwargs)
+      kwargs.keys.each do |key|
+        keys = self.class.filter_attributes.map(&:to_s)
+        next if keys.include?(key.to_s)
+
+        raise ArgumentError, "unknown filter #{key}, allowed keys are #{keys}"
+      end
+
+      _dup :@query, @query.to_h.merge(kwargs)
+    end
+
+    def find(id)
+      prepare_request(
+        [self.class.resource_url, id].join('/'),
+        resource_path: resource_path.to_s.singularize,
+        resource_class: self.class.resource
+      )
+    end
+
+    def [](arg)
+      find_by(id: arg)
+    end
+
+    def find_by(**kwargs)
+      if id = kwargs.delete(:id)
+        return find(id)
+      end
+
+      per_page(1).where(**kwargs).first
+    rescue Error::NotFound
+    end
+
+    # def count
+    #  per_page(1).first&.response&.pagination&.total_entries.to_i
+    # end
+
     def page(page)
-      @page = page
-      self
+      _dup :@page, page
     end
 
     def per_page(per_page)
-      @per_page = per_page
-      self
+      _dup :@per_page, per_page
     end
 
     def limit(limit)
-      @limit = limit
-      self
+      _dup :@limit, limit
     end
 
     def order(*sort)
-      @order = sort.flat_map do |s|
-        case s
-        when Symbol, String then s.to_s
-        when Hash then s.map { |k, v| "#{k}:#{v}" }
-        else
-          raise ArgumentError,
-                "Unable to resolve type for given #{s.inspect} from #{sort}"
-        end
-      end
-      self
+      _dup :@order,
+           begin
+           sort.flat_map do |s|
+             case s
+             when Symbol, String then s.to_s
+             when Hash then s.map { |k, v| "#{k}:#{v}" }
+             else
+               raise ArgumentError,
+                     "Unable to resolve type for given #{s.inspect} from #{sort}"
+             end
+           end
+         end
     end
 
-    def mj(path, **o, &block)
-      if !client.nil? && client.auto_pagination
-        requests = __entries__(path, **o)
-        if requests.all? { |x| x.is_a? Hash }
-          m = MultiReply.new(j: requests, pagination: :auto)
-          m.cb = block
-          return m
-        end
-        client.hydra.run
-        j = requests.map do |x|
-          Oj.load(x.response.body)
-        end
-        m = MultiReply.new(j: j, pagination: :auto)
-        m.cb = block
-        return m
-      end
-      m = MultiReply.new(j: [Oj.load(request(path, o.merge(ep: ep)).run.body)])
-      m.cb = block
-      m
+    def run
+      @run ||= multi_query(
+        resource_url,
+        q: @query,
+        resource_path: resource_path,
+        resource_class: self.class.resource
+      )
     end
 
     def each
-      all.each do |member|
+      run.each do |member|
         yield(member)
       end
     end
 
+    # this is just to keep the actual bevahior
+    def pagination
+      return :auto if client.auto_pagination
+
+      run.response.pagination
+    end
+
     protected
 
+    def _dup(var, value)
+      dup.tap do |res|
+        res.instance_variable_set(var, value)
+        res.instance_variable_set(:@run, nil)
+      end
+    end
+
+    def resource_path
+      self.class.resource_path || self.class.resource_url
+    end
+
+    def resource_url
+      [@base_path.to_s, self.class.resource_url.to_s].reject(&:empty?).join('/')
+    end
+
+    def multi_query(path, **o)
+      return prepare_request(path, o.merge(ep: ep)) unless client&.auto_pagination
+
+      raise Error, 'unable to run auto paginate within concurrent excecution' if @concurrent
+
+      requests = __entries__(path, **o)
+      return requests.flat_map(&:resource) if requests.all? { |req| req.respond_to? :resource }
+
+      client.hydra.run
+      requests.flat_map { |req| req.response.resource }
+    end
+
     def page_params(per_page: nil, page: nil)
       { per_page: per_page || @per_page, page: page || @page }.to_param
     end
@@ -85,27 +195,24 @@ module Hcloud
       r.compact.join('&')
     end
 
-    def request(*args)
-      client.request(*args)
-    end
-
     def __entries__(path, **o)
-      ret = Oj.load(request(path, o.merge(ep: ep(per_page: 1, page: 1))).run.body)
-      a = ret.dig('meta', 'pagination', 'total_entries').to_i
-      return [ret] if a <= 1
+      first_page = request(path, o.merge(ep: ep(per_page: 1, page: 1))).run
+      total_entries = first_page.pagination.total_entries
+      return [first_page] if total_entries <= 1 || @limit == 1
+
       unless @limit.nil?
-        a = @limit if a > @limit
+        total_entries = @limit if total_entries > @limit
       end
-      r = a / Client::MAX_ENTRIES_PER_PAGE
-      r += 1 if a % Client::MAX_ENTRIES_PER_PAGE > 0
-      requests = r.times.map do |i|
+      pages = total_entries / Client::MAX_ENTRIES_PER_PAGE
+      pages += 1 if (total_entries % Client::MAX_ENTRIES_PER_PAGE).positive?
+      pages.times.map do |page|
         per_page = Client::MAX_ENTRIES_PER_PAGE
-        if !@limit.nil? && (r == (i + 1)) && (a % per_page != 0)
-          per_page = a % per_page
+        if !@limit.nil? && (pages == (page + 1)) && (total_entries % per_page != 0)
+          per_page = total_entries % per_page
+        end
+        request(path, o.merge(ep: ep(per_page: per_page, page: page + 1))).tap do |req|
+          client.hydra.queue req
         end
-        req = request(path, o.merge(ep: ep(per_page: per_page, page: i + 1)))
-        client.hydra.queue req
-        req
       end
     end
   end

data/lib/hcloud/action.rb

@@ -1,16 +1,14 @@
+# frozen_string_literal: true
+
 module Hcloud
   class Action
-    Attributes = {
-      id: nil,
-      command: nil,
-      status: nil,
-      progress: nil,
-      started: :time,
-      finished: :time,
-      resources: nil,
-      error: nil
-    }.freeze
+    require 'hcloud/action_resource'
 
     include EntryLoader
+
+    schema(
+      started: :time,
+      finished: :time
+    )
   end
 end

data/lib/hcloud/action_resource.rb

@@ -1,35 +1,9 @@
+# frozen_string_literal: true
 
 module Hcloud
   class ActionResource < AbstractResource
-    def all
-      mj(base_path('actions')) do |j|
-        j.flat_map { |x| x['actions'].map { |x| Action.new(x, self, client) } }
-      end
-    end
+    filter_attributes :status
 
-    def find(id)
-      Action.new(
-        Oj.load(request(base_path("actions/#{id.to_i}")).run.body)['action'],
-        self,
-        client
-      )
-    end
-
-    def [](arg)
-      find(arg)
-    rescue Error::NotFound
-    end
-
-    def where(status: nil)
-      mj(base_path('actions'), q: { status: status }) do |j|
-        j.flat_map { |x| x['actions'].map { |x| Action.new(x, self, client) } }
-      end
-    end
-
-    private
-
-    def base_path(ext)
-      [@base_path, ext].reject(&:empty?).join('/')
-    end
+    bind_to Action
   end
 end

data/lib/hcloud/client.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 autoload :Typhoeus, 'typhoeus'
 autoload :Oj, 'oj'
 
@@ -5,14 +7,43 @@ module Hcloud
   class Client
     MAX_ENTRIES_PER_PAGE = 50
 
-    attr_reader :token, :auto_pagination, :hydra
-    def initialize(token:, auto_pagination: false, concurrency: 20)
+    class << self
+      attr_writer :connection
+
+      def connection
+        return @connection if @connection.is_a? Hcloud::Client
+
+        raise ArgumentError, "client not correctly initialized, actually #{@client.inspect}"
+      end
+    end
+
+    attr_reader :token, :auto_pagination, :hydra, :user_agent
+    def initialize(token:, auto_pagination: false, concurrency: 20, user_agent: nil)
       @token = token
+      @user_agent = user_agent || "hcloud-ruby v#{VERSION}"
       @auto_pagination = auto_pagination
       @concurrency = concurrency
       @hydra = Typhoeus::Hydra.new(max_concurrency: concurrency)
     end
 
+    def concurrent
+      @concurrent = true
+      ret = yield
+      ret.each do |element|
+        next unless element.is_a?(AbstractResource)
+
+        element.run
+      end
+      hydra.run
+      ret
+    ensure
+      @concurrent = nil
+    end
+
+    def concurrent?
+      !@concurrent.nil?
+    end
+
     def authorized?
       request('server_types').run
       true
@@ -56,8 +87,34 @@ module Hcloud
       FloatingIPResource.new(client: self)
     end
 
-    def request(path, **options)
-      code = options.delete(:code)
+    def networks
+      NetworkResource.new(client: self)
+    end
+
+    def volumes
+      VolumeResource.new(client: self)
+    end
+
+    class ResourceFuture < Delegator
+      def initialize(request)
+        @request = request
+      end
+
+      def __getobj__
+        @__getobj__ ||= @request&.response&.resource
+      end
+    end
+
+    def prepare_request(url, **args, &block)
+      req = request(url, **args.merge(block: block))
+      return req.run.resource unless concurrent?
+
+      hydra.queue req
+      ResourceFuture.new(req)
+    end
+
+    def request(path, **options) # rubocop:disable Metrics/MethodLength
+      hcloud_attributes = TyphoeusExt.collect_attributes(options)
       if x = options.delete(:j)
         options[:body] = Oj.dump(x, mode: :compat)
         options[:method] ||= :post
@@ -74,35 +131,16 @@ module Hcloud
         {
           headers: {
             'Authorization' => "Bearer #{token}",
+            'User-Agent' => user_agent,
             'Content-Type' => 'application/json'
           }
         }.merge(options)
       )
       r.on_complete do |response|
-        case response.code
-        when code
-          raise Error::UnexpectedError, response.body
-        when 401
-          raise Error::Unauthorized
-        when 0
-          raise Error::ServerError, "Connection error: #{response.return_code}"
-        when 400...600
-          j = Oj.load(response.body)
-          code = j.dig('error', 'code')
-          error_class = case code
-                        when 'invalid_input' then Error::InvalidInput
-                        when 'forbidden' then Error::Forbidden
-                        when 'locked' then Error::Locked
-                        when 'not_found' then Error::NotFound
-                        when 'rate_limit_exceeded' then Error::RateLimitExceeded
-                        when 'resource_unavailable' then Error::ResourceUnavilable
-                        when 'service_error' then Error::ServiceError
-                        when 'uniqueness_error' then Error::UniquenessError
-                        else
-                          Error::ServerError
-                        end
-          raise error_class, j.dig('error', 'message')
-        end
+        response.extend(TyphoeusExt)
+        response.attributes = hcloud_attributes
+        response.context.client = self
+        response.check_for_error unless response.request.hydra
       end
       r
     end