hcloud 0.1.2 → 1.0.3

data/lib/hcloud/server.rb

@@ -1,109 +1,76 @@
+# frozen_string_literal: true
+
 module Hcloud
   class Server
-    Attributes = {
-      id: nil,
-      name: nil,
-      status: nil,
+    require 'hcloud/server_resource'
+
+    include EntryLoader
+
+    schema(
       created: :time,
-      public_net: nil,
       server_type: ServerType,
       datacenter: Datacenter,
-      image: Image,
-      iso: nil,
-      rescue_enabled: nil,
-      locked: nil,
-      backup_window: nil,
-      outgoing_traffic: nil,
-      ingoing_traffic: nil,
-      included_traffic: nil
-    }.freeze
-
-    include EntryLoader
+      image: Image
+    )
 
-    def update(name:)
-      Server.new(
-        Oj.load(request(base_path, j: { name: name }, method: :put).run.body)['server'],
-        parent,
-        client
-      )
-    end
+    protectable :delete, :rebuild
+    updatable :name
+    destructible
 
-    def destroy
-      action(request(base_path, method: :delete))[0]
-    end
+    has_actions
 
     def enable_rescue(type: 'linux64', ssh_keys: [])
-      query = {}
-      method(:enable_rescue).parameters.inject(query) do |r, x|
-        (var = eval(x.last.to_s)).nil? ? r : r.merge!(x.last => var)
-      end
-      a, j = action(request(base_path('actions/enable_rescue'), j: query))
-      [a, j['root_password']]
+      query = COLLECT_ARGS.call(__method__, binding)
+      prepare_request('actions/enable_rescue', j: query) { |j| j[:root_password] }
     end
 
     def reset_password
-      a, j = action(request(base_path('actions/reset_password'), method: :post))
-      [a, j['root_password']]
+      prepare_request('actions/reset_password', method: :post) { |j| j[:root_password] }
     end
 
     def create_image(description: nil, type: nil)
-      query = {}
-      method(:create_image).parameters.inject(query) do |r, x|
-        (var = eval(x.last.to_s)).nil? ? r : r.merge!(x.last => var)
-      end
-      a, j = action(request(base_path('actions/create_image'), j: query))
-      [a, Image.new(j['image'], parent, client)]
+      query = COLLECT_ARGS.call(__method__, binding)
+      prepare_request('actions/create_image', j: query) { |j| Image.new(client, j[:image]) }
     end
 
     def rebuild(image:)
-      a, j = action(request(base_path('actions/rebuild'), j: { image: image }))
-      [a, j['root_password']]
+      prepare_request('actions/rebuild', j: { image: image }) { |j| j[:root_password] }
     end
 
     def change_type(server_type:, upgrade_disk: nil)
-      query = {}
-      method(:change_type).parameters.inject(query) do |r, x|
-        (var = eval(x.last.to_s)).nil? ? r : r.merge!(x.last => var)
-      end
-      action(request(base_path('actions/change_type'), j: query))[0]
+      prepare_request('actions/change_type', j: COLLECT_ARGS.call(__method__, binding))
     end
 
-    def enable_backup(backup_window:)
-      action(request(base_path('actions/enable_backup'),
-                     j: { backup_window: backup_window }))[0]
+    # Specifying a backup window is not supported anymore. We keep this method
+    # to ensure backwards compatibility, but ignore the argument if provided.
+    def enable_backup(**_kwargs)
+      prepare_request('actions/enable_backup', method: :post)
     end
 
     def attach_iso(iso:)
-      action(request(base_path('actions/attach_iso'),
-                     j: { iso: iso }))[0]
+      prepare_request('actions/attach_iso', j: { iso: iso })
+    end
+
+    def attach_to_network(network:, ip: nil, alias_ips: nil)
+      prepare_request('actions/attach_to_network', j: COLLECT_ARGS.call(__method__, binding))
+    end
+
+    def detach_from_network(network:)
+      prepare_request('actions/detach_from_network', j: { network: network })
     end
 
     %w[
       poweron poweroff shutdown reboot reset
       disable_rescue disable_backup detach_iso
+      request_console
     ].each do |action|
       define_method(action) do
-        action(request(base_path("actions/#{action}"), method: :post))[0]
+        prepare_request("actions/#{action}", method: :post)
       end
     end
 
-    def actions
-      ActionResource.new(client: client, parent: self, base_path: base_path)
-    end
-
-    private
-
-    def action(request)
-      j = Oj.load(request.run.body)
-      [
-        Action.new(j['action'], parent, client),
-        j
-      ]
-    end
-
-    def base_path(ext = nil)
-      return ["servers/#{id}", ext].compact.join('/') unless id.nil?
-      raise ResourcePathError, 'Unable to build resource path. Id is nil.'
+    def request_console
+      prepare_request('actions/request_console', method: :post) { |j| [j[:wss_url], j[:password]] }
     end
   end
 end

data/lib/hcloud/server_resource.rb

@@ -1,54 +1,33 @@
+# frozen_string_literal: true
+
 module Hcloud
   class ServerResource < AbstractResource
+    filter_attributes :status, :name
+
+    bind_to Server
+
     def create(name:,
                server_type:,
-               datacenter: nil,
+               image:, datacenter: nil,
                location: nil,
                start_after_create: nil,
-               image:,
                ssh_keys: [],
+               networks: [],
                user_data: nil)
-      query = {}
-      method(:create).parameters.inject(query) do |r, x|
-        (var = eval(x.last.to_s)).nil? ? r : r.merge!(x.last => var)
-      end
-      j = Oj.load(request('servers', j: query, code: 200).run.body)
-      [
-        Action.new(j['action'], self, client),
-        Server.new(j['server'], self, client),
-        j['root_password']
-      ]
-    end
-
-    def all
-      mj('servers') do |j|
-        j.flat_map { |x| x['servers'].map { |x| Server.new(x, self, client) } }
+      prepare_request('servers', j: COLLECT_ARGS.call(__method__, binding),
+                                 expected_code: 201) do |response|
+        [
+          Action.new(client, response.parsed_json[:action]),
+          Server.new(client, response.parsed_json[:server]),
+          response.parsed_json[:root_password]
+        ]
       end
     end
 
-    def find(id)
-      Server.new(
-        Oj.load(request("servers/#{id.to_i}").run.body)['server'], self, client
-      )
-    end
-
     def [](arg)
       case arg
-      when Integer
-        begin
-          find(arg)
-        rescue Error::NotFound
-        end
-      when String
-        find_by(name: arg)
-      end
-    end
-
-    def find_by(name:)
-      x = Oj.load(request('servers', q: { name: name }).run.body)['servers']
-      return nil if x.none?
-      x.each do |s|
-        return Server.new(s, self, client)
+      when Integer then find_by(id: arg)
+      when String then find_by(name: arg)
       end
     end
   end

data/lib/hcloud/server_type.rb

@@ -1,15 +1,8 @@
+# frozen_string_literal: true
+
 module Hcloud
   class ServerType
-    Attributes = {
-      id: nil,
-      name: nil,
-      description: nil,
-      cores: nil,
-      memory: nil,
-      disk: nil,
-      prices: nil,
-      storage_type: nil
-    }.freeze
+    require 'hcloud/server_type_resource'
 
     include EntryLoader
   end

data/lib/hcloud/server_type_resource.rb

@@ -1,37 +1,15 @@
+# frozen_string_literal: true
+
 module Hcloud
   class ServerTypeResource < AbstractResource
-    include Enumerable
-
-    def all
-      j = Oj.load(request('server_types').run.body)
-      j['server_types'].map { |x| ServerType.new(x, self, client) }
-    end
+    filter_attributes :name
 
-    def find(id)
-      ServerType.new(
-        Oj.load(request("server_types/#{id}").run.body)['server_type'],
-        self,
-        client
-      )
-    end
-
-    def find_by(name:)
-      x = Oj.load(request('server_types', q: { name: name }).run.body)['server_types']
-      return nil if x.none?
-      x.each do |s|
-        return ServerType.new(s, self, client)
-      end
-    end
+    bind_to ServerType
 
     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

data/lib/hcloud/ssh_key.rb

@@ -1,23 +1,12 @@
+# frozen_string_literal: true
+
 module Hcloud
   class SSHKey
-    Attributes = {
-      id: nil,
-      name: nil,
-      fingerprint: nil,
-      public_key: nil
-    }.freeze
-    include EntryLoader
+    require 'hcloud/ssh_key_resource'
 
-    def update(name:)
-      j = Oj.load(request("ssh_keys/#{id.to_i}",
-                          j: { name: name },
-                          method: :put).run.body)
-      SSHKey.new(j['ssh_key'], self, client)
-    end
+    include EntryLoader
 
-    def destroy
-      request("ssh_keys/#{id}", method: :delete).run.body
-      true
-    end
+    updatable :name
+    destructible
   end
 end

data/lib/hcloud/ssh_key_resource.rb

@@ -1,41 +1,22 @@
+# frozen_string_literal: true
+
 module Hcloud
   class SSHKeyResource < AbstractResource
-    def all
-      mj('ssh_keys') do |j|
-        j.flat_map { |x| x['ssh_keys'].map { |x| SSHKey.new(x, self, client) } }
-      end
-    end
+    filter_attributes :name
 
-    def create(name:, public_key:)
-      j = Oj.load(request('ssh_keys', j: { name: name, public_key: public_key }).run.body)
-      SSHKey.new(j['ssh_key'], self, client)
-    end
-
-    def find(id)
-      SSHKey.new(
-        Oj.load(request("ssh_keys/#{id}").run.body)['ssh_key'],
-        self,
-        client
-      )
-    end
-
-    def find_by(name:)
-      x = Oj.load(request('ssh_keys', q: { name: name }).run.body)['ssh_keys']
-      return nil if x.none?
-      x.each do |s|
-        return SSHKey.new(s, self, client)
+    def [](arg)
+      case arg
+      when Integer then find_by(id: arg)
+      when String then find_by(name: arg)
       end
     end
 
-    def [](arg)
-      case arg
-      when Integer
-        begin
-          find(arg)
-        rescue Error::NotFound
-        end
-      when String
-        find_by(name: arg)
+    def create(name:, public_key:)
+      prepare_request(
+        'ssh_keys', j: COLLECT_ARGS.call(__method__, binding),
+                    expected_code: 201
+      ) do |response|
+        SSHKey.new(client, response.parsed_json[:ssh_key])
       end
     end
   end

data/lib/hcloud/typhoeus_ext.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/hash/indifferent_access'
+
+module Hcloud
+  module TyphoeusExt
+    Context = Struct.new(:client)
+
+    ATTRIBUTES = %i[
+      block autoload_action resource_path
+      resource_class expected_code
+    ].freeze
+
+    attr_accessor(*ATTRIBUTES)
+
+    def self.collect_attributes(kwargs)
+      hash = {}
+      ATTRIBUTES.each do |key|
+        hash[key] = kwargs.delete(key) if kwargs.key?(key)
+      end
+      hash
+    end
+
+    def attributes=(kwargs)
+      kwargs.each do |key, value|
+        public_send("#{key}=", value)
+      end
+    end
+
+    def parsed_json
+      return {} if code == 204
+
+      @parsed_json ||= Oj.load(body, symbol_keys: true).tap do |json|
+        next unless request.hydra
+
+        check_for_error(
+          e_code: json.to_h.dig(:error, :code),
+          e_message: json.to_h.dig(:error, :message)
+        )
+      end
+    rescue StandardError
+      raise Error::UnexpectedError, "unable to load body: #{body}"
+    end
+
+    def context
+      @context ||= Context.new
+    end
+
+    def check_for_error(e_code: nil, e_message: nil)
+      case code
+      when 401 then raise(Error::Unauthorized)
+      when 0 then raise(Error::ServerError, "Connection error: #{return_code}")
+      when 400...600
+        raise _error_class(e_code || error_code), e_message || error_message
+      end
+
+      raise Error::UnexpectedError, body if expected_code && expected_code != code
+    end
+
+    def pagination
+      @pagination ||= Pagination.new(parsed_json[:meta].to_h[:pagination])
+    end
+
+    def resource_attributes
+      _resource = [@resource_path].flatten.compact.map(&:to_s).map(&:to_sym)
+      return parsed_json if _resource.empty?
+
+      parsed_json.dig(*_resource)
+    end
+
+    def [](arg)
+      parsed_json[arg]
+    end
+
+    def resource
+      action = parsed_json[:action] if autoload_action
+      return [Action.new(self, action), block.call(self)].flatten(1) if block && action
+      return block.call(self) if block
+
+      @resource_class.from_response(self, autoload_action: autoload_action)
+    end
+
+    def error_code
+      error[:code]
+    end
+
+    def error_message
+      error[:message]
+    end
+
+    def error
+      parsed_json[:error].to_h
+    end
+
+    def _error_class(code)
+      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::ResourceUnavailable
+      when 'service_error' then Error::ServiceError
+      when 'uniqueness_error' then Error::UniquenessError
+      else
+        Error::ServerError
+      end
+    end
+  end
+end

data/lib/hcloud/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Hcloud
-  VERSION = '0.1.2'.freeze
+  VERSION = '1.0.3'
 end

data/lib/hcloud/volume.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Hcloud
+  class Volume
+    require 'hcloud/volume_resource'
+
+    include EntryLoader
+
+    schema(
+      created: :time,
+      location: Location
+    )
+
+    protectable :delete
+    updatable :name
+    destructible
+
+    has_actions
+
+    def attach(server:, automount:)
+      prepare_request('actions/attach', j: COLLECT_ARGS.call(__method__, binding))
+    end
+
+    def detach
+      prepare_request('actions/detach', method: :post)
+    end
+
+    def resize(size:)
+      prepare_request('actions/resize', j: COLLECT_ARGS.call(__method__, binding))
+    end
+  end
+end

data/lib/hcloud/volume_resource.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Hcloud
+  class VolumeResource < AbstractResource
+    filter_attributes :name
+
+    def [](arg)
+      case arg
+      when Integer then find_by(id: arg)
+      when String then find_by(name: arg)
+      end
+    end
+
+    def create(size:, name:, automount: nil, format: nil, location: nil, server: nil)
+      prepare_request(
+        'volumes', j: COLLECT_ARGS.call(__method__, binding),
+                   expected_code: 201
+      ) do |response|
+        [
+          Action.new(client, response.parsed_json[:action]),
+          Volume.new(client, response.parsed_json[:volume]),
+          response.parsed_json[:next_actions].map do |action|
+            Action.new(client, action)
+          end
+        ]
+      end
+    end
+  end
+end

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