hcloud 0.1.2 → 1.0.0

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,112 @@
+# 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 ||= begin
+                         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
+                       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.0'
 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

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: hcloud
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Tim Foerster
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-02-27 00:00:00.000000000 Z
+date: 2020-02-12 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -28,16 +42,16 @@ dependencies:
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: grape
   requirement: !ruby/object:Gem::Requirement
@@ -56,16 +70,16 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -150,6 +164,7 @@ files:
 - ".travis.yml"
 - CHANGELOG.md
 - Gemfile
+- Gemfile.lock
 - README.md
 - Rakefile
 - bin/console
@@ -172,7 +187,8 @@ files:
 - lib/hcloud/iso_resource.rb
 - lib/hcloud/location.rb
 - lib/hcloud/location_resource.rb
-- lib/hcloud/multi_reply.rb
+- lib/hcloud/network.rb
+- lib/hcloud/network_resource.rb
 - lib/hcloud/pagination.rb
 - lib/hcloud/server.rb
 - lib/hcloud/server_resource.rb
@@ -180,7 +196,10 @@ files:
 - lib/hcloud/server_type_resource.rb
 - lib/hcloud/ssh_key.rb
 - lib/hcloud/ssh_key_resource.rb
+- lib/hcloud/typhoeus_ext.rb
 - lib/hcloud/version.rb
+- lib/hcloud/volume.rb
+- lib/hcloud/volume_resource.rb
 homepage: https://github.com/tonobo/hcloud
 licenses: []
 metadata: {}
@@ -199,8 +218,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2.2
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: HetznerCloud native Ruby client

data/lib/hcloud/multi_reply.rb

@@ -1,21 +0,0 @@
-module Hcloud
-  class MultiReply
-    include Enumerable
-    attr_accessor :cb
-
-    def initialize(j:, pagination: nil)
-      @j = j
-      @pagination = pagination
-    end
-
-    def pagination
-      @pagination || Pagination.new(@j.first.to_h['meta'].to_h['pagination'], nil, nil)
-    end
-
-    def each
-      @cb.call(@j).each do |member|
-        yield(member)
-      end
-    end
-  end
-end