hcloud 0.1.2 → 1.0.3

data/lib/hcloud/abstract_resource.rb

@@ -1,75 +1,183 @@
+# 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 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:, parent: nil, base_path: '')
+    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.each_key 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|
-        yield(member)
-      end
+    def each(&block)
+      run.each(&block)
+    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,28 +193,25 @@ module Hcloud
       r.compact.join('&')
     end
 
-    def request(*args)
-      client.request(*args)
-    end
-
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
     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
-      unless @limit.nil?
-        a = @limit if a > @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|
+      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
+
+      total_entries = @limit if !@limit.nil? && (total_entries > @limit)
+      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
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
   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,18 +1,52 @@
+# frozen_string_literal: true
+
 autoload :Typhoeus, 'typhoeus'
 autoload :Oj, 'oj'
 
+require 'delegate'
+
 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 +90,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) # rubocop:disable Lint/MissingSuper
+        @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
@@ -68,41 +128,22 @@ module Hcloud
         q << x.to_param
       end
       path = path.dup
-      path << '?' + q.join('&')
+      path << "?#{q.join('&')}"
       r = Typhoeus::Request.new(
         "https://api.hetzner.cloud/v1/#{path}",
         {
           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

data/lib/hcloud/datacenter.rb

@@ -1,13 +1,13 @@
+# frozen_string_literal: true
+
 module Hcloud
   class Datacenter
-    Attributes = {
-      id: nil,
-      name: nil,
-      description: nil,
-      location: Location,
-      server_types: nil
-    }.freeze
+    require 'hcloud/datacenter_resource'
 
     include EntryLoader
+
+    schema(
+      location: Location
+    )
   end
 end

data/lib/hcloud/datacenter_resource.rb

@@ -1,44 +1,19 @@
+# frozen_string_literal: true
+
 module Hcloud
   class DatacenterResource < AbstractResource
-    include Enumerable
+    filter_attributes :name
 
-    def all
-      j = Oj.load(request('datacenters').run.body)
-      dc = j['datacenters'].map { |x| Datacenter.new(x, self, client) }
-      dc.reject { |x| x.id == j['recommendation'] }.unshift(
-        dc.find { |x| x.id == j['recommendation'] }
-      )
-    end
+    bind_to Datacenter
 
     def recommended
       all.first
     end
 
-    def find(id)
-      Datacenter.new(
-        Oj.load(request("datacenters/#{id}").run.body)['datacenter'],
-        self,
-        client
-      )
-    end
-
-    def find_by(name:)
-      x = Oj.load(request('datacenters', q: { name: name }).run.body)['datacenters']
-      return nil if x.none?
-      x.each do |s|
-        return Datacenter.new(s, self, client)
-      end
-    end
-
     def [](arg)
       case arg
-      when Integer
-        begin
-          find(arg)
-        rescue Error::NotFound
-        end
-      when String
-        find_by(name: arg)
+      when Integer then find_by(id: arg)
+      when String then find_by(name: arg)
       end
     end
   end