hetznercloud 1.4.0 → 1.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1b9b0de15d2fe2aecdbfa6b00b46df9ec658855ebdafcabebe72f371dd98d50
-  data.tar.gz: 6c39c3ee93d35767d355e522408d1285ce3777fc841753968ae9c33d0916cc6c
+  metadata.gz: 3e5950847db8b1e523a027c3197efebbef0dbcf3cdece53d46817e8d22ebf90c
+  data.tar.gz: 0a142f83f2ea3ffbc104501082ac72a26986d46ace0964c70a147be945bf73fd
 SHA512:
-  metadata.gz: 7a9971d0195c839594b88759d828dc04f98e36d37eab7880d27f4299f8266d2e37676eea3b60399440bed9240e6d39190dba0af75f2d32bfe78c5e42bb160cd5
-  data.tar.gz: bbecc7998329638d8499d0a33c877cdc5857b2a94c80633672a874f6828cc69f29e67d8e3a618b21db5cd84d87cf66cecd2e2ee3ddcfa16db00f841394f0ea85
+  metadata.gz: a4de38d5d298b9b55611fac064b6bd5f6f0acff82e0286cae05195546a7d8e5b9d99bacdb58a7a03affec4bc22979baf59dfc7a54aca8107936ad22422ce0ab9
+  data.tar.gz: 1ff509622967a9c449e5db033090e3a599160fd7c3859acc32544793c2a6e0365821be729673ff75f85074188a3ce69abc11d37bafaec8254a134453d7c7e5e3

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## HCloud v1.5.1 (2023-04-20)
+
+- Add `Unavailable` error class
+- Add `architecture` attribute to `ServerType`
+
+## HCloud v1.5.0 (2023-02-01)
+
+- Add pricing for Primary IPs
+- Add server Metadata resource
+- Add support for rate limits
+- `Action#resources` now returns a list of resources instead of a list of hashes
+- Separate server protection entity from other protection entity (only server protection includes `rebuild`)
+- Add shorthand methods for `.first`, `.last`, `.count`, `.where`, `.sort`, `.each`, and `.empty?` on resource
+- Add `label_selector:` argument to `HCloud::Collection`
+
 ## HCloud v1.4.0 (2023-01-22)
 
 - Implemented Primary IPs

data/Gemfile

@@ -4,3 +4,16 @@ source "https://rubygems.org"
 
 # Specify your gem's dependencies in hcloud.gemspec
 gemspec
+
+group :development, :test do
+  gem "byebug", require: false
+  gem "dotenv", require: false
+  gem "ffaker", require: false
+  gem "rake", require: false
+  gem "rspec", require: false
+  gem "rubocop", require: false
+  gem "rubocop-performance", require: false
+  gem "rubocop-rspec", require: false
+  gem "timecop", require: false
+  gem "webmock", require: false
+end

data/README.md

@@ -69,37 +69,82 @@ It expects you to use it in a sane way.
 
 ## Features
 
-Not all Hetzner Cloud API endpoints have been implemented yet.
-
-| Resource              | State                 |
-|-----------------------|-----------------------|
-| Actions               | Implemented           |
-| Certificates          | Implemented           |
-| Certificate Actions   | Implemented           |
-| Datacenters           | Implemented           |
-| Firewalls             | Implemented           |
-| Firewall Actions      | Implemented           |
-| Floating IPs          | Implemented           |
-| Floating IP Actions   | Implemented           |
-| Images                | Implemented           |
-| Image Actions         | Implemented           |
-| ISOs                  | Implemented           |
-| Load Balancers        | Implemented           |
-| Load Balancer Actions | Not implemented       |
-| Load Balancer Types   | Implemented           |
-| Locations             | Implemented           |
-| Primary IPs           | Implemented           |
-| Primary IP Actions    | Implemented           |
-| Networks              | Implemented           |
-| Network Actions       | Implemented           |
-| Placement Groups      | Implemented           |
-| Pricing               | Implemented           |
-| Servers               | Partially implemented |
-| Server Actions        | Not implemented       |
-| Server Types          | Implemented           |
-| SSH Keys              | Implemented           |
-| Volumes               | Implemented           |
-| Volume Actions        | Implemented           |
+The following table lists the Hetzner Cloud API endpoints that are currently implemented.
+
+| Resource                                                       | State                 |
+|----------------------------------------------------------------|-----------------------|
+| [Actions](lib/hcloud/resources/action.rb)                      | Implemented           |
+| [Certificates](lib/hcloud/resources/certificate.rb)            | Implemented           |
+| [Certificate Actions](lib/hcloud/resources/certificate.rb)     | Implemented           |
+| [Datacenters](lib/hcloud/resources/datacenter.rb)              | Implemented           |
+| [Firewalls](lib/hcloud/resources/firewall.rb)                  | Implemented           |
+| [Firewall Actions](lib/hcloud/resources/firewall.rb)           | Implemented           |
+| [Floating IPs](lib/hcloud/resources/floating_ip.rb)            | Implemented           |
+| [Floating IP Actions](lib/hcloud/resources/floating_ip.rb)     | Implemented           |
+| [Images](lib/hcloud/resources/image.rb)                        | Implemented           |
+| [Image Actions](lib/hcloud/resources/image.rb)                 | Implemented           |
+| [ISOs](lib/hcloud/resources/iso.rb)                            | Implemented           |
+| [Load Balancers](lib/hcloud/resources/load_balancer.rb)        | Implemented           |
+| [Load Balancer Actions](lib/hcloud/resources/load_balancer.rb) | Not implemented       |
+| [Load Balancer Types](lib/hcloud/resources/load_balancer.rb)   | Implemented           |
+| [Locations](lib/hcloud/resources/location.rb)                  | Implemented           |
+| [Primary IPs](lib/hcloud/resources/primary_ip.rb)              | Implemented           |
+| [Primary IP Actions](lib/hcloud/resources/primary_ip.rb)       | Implemented           |
+| [Networks](lib/hcloud/resources/network.rb)                    | Implemented           |
+| [Network Actions](lib/hcloud/resources/network.rb)             | Implemented           |
+| [Placement Groups](lib/hcloud/resources/placement_group.rb)    | Implemented           |
+| [Pricing](lib/hcloud/resources/pricing.rb)                     | Implemented           |
+| [Servers](lib/hcloud/resources/server.rb)                      | Partially implemented |
+| [Server Actions](lib/hcloud/resources/server.rb)               | Not implemented       |
+| [Server Types](lib/hcloud/resources/server_type.rb)            | Implemented           |
+| [SSH Keys](lib/hcloud/resources/ssh_key.rb)                    | Implemented           |
+| [Volumes](lib/hcloud/resources/volume.rb)                      | Implemented           |
+| [Volume Actions](lib/hcloud/resources/volume.rb)               | Implemented           |
+|                                                                |                       |
+| [Metadata](lib/hcloud/resources/metadata.rb)                   | Implemented           |
+
+### Pagination
+
+Paginated resources are wrapped in a `HCloud::Collection` that automatically fetches the next page when needed.
+The collection acts as a (lazy) enumerator.
+Call `to_a` to fetch all pages and parse all resources.
+
+### Rate limiting
+
+From the [documentation](https://docs.hetzner.cloud/#rate-limiting):
+
+> The default limit is 3600 requests per hour and per Project.
+> The number of remaining requests increases gradually.
+> For example, when your limit is 3600 requests per hour, the number of remaining requests will increase by 1 every second.
+
+The client is able to handle the rate limiting by delaying the requests if necessary and executing them whenever possible.
+To enable this behaviour, pass `rate_limit: true` as argument to `HCloud::Client.new`.
+Client calls will block until possible to execute and then return.
+
+```ruby
+client = HCloud::Client.new(access_token: "my_token", rate_limit: true)
+
+# At least one request has to be made to enable the rate limiter
+client.rate_limiter.limit # => nil
+client.rate_limiter.remaining # => nil
+client.rate_limiter.reset # => nil
+
+HCloud::Server.create(...)
+
+client.rate_limiter.limit # => 3600
+client.rate_limiter.remaining # => 3599
+client.rate_limiter.reset # => 2023-01-01 00:00:00 +0100
+
+# Make a bunch of requests
+
+client.rate_limiter.remaining # => 0
+
+servers = HCloud::Server.all # Will block until remaining requests have regenerated (1 second by default) and then execute
+ssh_keys = HCloud::SSHKey.all # Will block until remaining requests have regenerated (1 second by default) and then execute
+```
+
+Since rate limits are per hour and per project, using multiple clients at the same time will interfere with the rate limiting mechanism.
+To prevent this, wrap client calls in a loop that retries the call after it fails with a `HCloud::RateLimitExceeded` error.
 
 ## Testing
 
@@ -130,7 +175,6 @@ When executing the test suite, set `LOG_LEVEL` environment variable to `debug` i
 
 `HCloud::Client` also accepts an alternate endpoint:
 
-
 ```ruby
 client = HCloud::Client.new(access_token: "my_access_token", endpoint: "https://myproxy/v1")
 ```

data/config/inflections.rb

@@ -15,9 +15,11 @@ HCloud.loader.inflector.inflect(
   "iso" => "ISO",
   "iso_type" => "ISOType",
   "primary_ip" => "PrimaryIP",
+  "primary_ip_prices" => "PrimaryIPPrices",
   "service_http" => "ServiceHTTP",
   "ssh_key" => "SSHKey",
   "target_ip" => "TargetIP",
+  "yaml" => "YAML",
 )
 
 ActiveSupport::Inflector.inflections(:en) do |inflect|
@@ -28,4 +30,5 @@ ActiveSupport::Inflector.inflections(:en) do |inflect|
   inflect.acronym "IPv6"
   inflect.acronym "ISO"
   inflect.acronym "JSON"
+  inflect.acronym "YAML"
 end

data/lib/hcloud/client.rb

@@ -19,12 +19,13 @@ module HCloud
 
     self.connection = NilConnection.new
 
-    attr_reader :access_token, :endpoint, :logger
+    attr_reader :access_token, :endpoint, :logger, :rate_limit
 
-    def initialize(access_token:, endpoint: "https://api.hetzner.cloud/v1", logger: Logger.new("/dev/null"))
+    def initialize(access_token:, endpoint: "https://api.hetzner.cloud/v1", logger: Logger.new("/dev/null"), rate_limit: false)
       @access_token = access_token
       @endpoint = endpoint
       @logger = logger
+      @rate_limit = rate_limit
     end
 
     delegate :get, :put, :post, :delete, to: :http
@@ -32,7 +33,7 @@ module HCloud
     private
 
     def http
-      @http ||= HTTP.new(access_token, endpoint, logger)
+      @http ||= HTTP.new(access_token, endpoint, logger, rate_limit)
     end
   end
 end

data/lib/hcloud/collection.rb

@@ -6,7 +6,7 @@ module HCloud
 
     attr_accessor :page, :previous_page, :next_page, :last_page, :per_page, :total_entries, :proc
 
-    attr_reader :sort_by, :filter_by
+    attr_reader :sort_by, :filter_by, :label_selector
 
     def initialize(&block)
       @proc = block
@@ -24,8 +24,9 @@ module HCloud
       self
     end
 
-    def where(**filter_by)
+    def where(label_selector: nil, **filter_by)
       @filter_by = filter_by
+      @label_selector = label_selector
 
       self
     end
@@ -70,6 +71,7 @@ module HCloud
         page: page,
         per_page: per_page,
         sort: sort_by,
+        label_selector: label_selector&.map { |k, v| "#{k}=#{v}" }&.join(","),
         **filter_by,
       }
     end

data/lib/hcloud/concerns/concerns.rb

@@ -32,6 +32,10 @@ module HCloud
       def singleton
         include Singleton
       end
+
+      def labelable
+        include Labelable
+      end
     end
   end
 end

data/lib/hcloud/concerns/labelable.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module HCloud
+  module Labelable
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :labels, default: -> { {} }
+    end
+  end
+end

data/lib/hcloud/concerns/queryable.rb

@@ -17,6 +17,8 @@ module HCloud
     end
 
     class_methods do
+      delegate :first, :last, :count, :where, :sort, :each, :empty?, :any?, to: :all
+
       def find(id)
         raise Errors::MissingIDError unless id
 

data/lib/hcloud/entities/primary_ip_prices.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module HCloud
+  class PrimaryIPPrices < Entity
+    attribute :type
+    attribute :prices, :price
+  end
+end

data/lib/hcloud/entities/private_network.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module HCloud
+  class PrivateNetwork < Entity
+    attribute :ip
+    attribute :alias_ips, array: true, default: -> { [] }
+    attribute :interface_num, :integer
+    attribute :mac_address
+    attribute :network_id, :integer
+    attribute :network_name
+    attribute :network
+    attribute :subnet
+    attribute :gateway
+  end
+end

data/lib/hcloud/entities/protection.rb

@@ -3,9 +3,7 @@
 module HCloud
   class Protection < Entity
     attribute :delete, :boolean
-    attribute :rebuild, :boolean
 
     alias delete? delete
-    alias rebuild? rebuild
   end
 end

data/lib/hcloud/entities/server_protection.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module HCloud
+  class ServerProtection < Entity
+    attribute :delete, :boolean
+    attribute :rebuild, :boolean
+
+    alias delete? delete
+    alias rebuild? rebuild
+  end
+end

data/lib/hcloud/errors.rb

@@ -66,6 +66,7 @@ module HCloud
     class TargetAlreadyDefined < Error; end
     class TokenReadonly < Error; end
     class Unauthorized < Error; end
+    class Unavailable < Error; end
     class UniquenessError < Error; end
     class UnsupportedError < Error; end
 

data/lib/hcloud/http.rb

@@ -4,12 +4,13 @@ require "http"
 
 module HCloud
   class HTTP
-    attr_reader :access_token, :endpoint, :logger, :timeout
+    attr_reader :access_token, :endpoint, :logger, :rate_limit, :timeout
 
-    def initialize(access_token, endpoint, logger, timeout = 10)
+    def initialize(access_token, endpoint, logger, rate_limit = false, timeout = 10)
       @access_token = access_token
       @endpoint = endpoint
       @logger = logger
+      @rate_limit = rate_limit
       @timeout = timeout
     end
 
@@ -80,6 +81,7 @@ module HCloud
         .headers(accept: "application/json", user_agent: "#{HCloud::NAME}/#{HCloud::VERSION}")
         .timeout(timeout)
         .use(logging: { logger: logger })
+        .then { |h| rate_limit ? h.use(:rate_limiter) : h }
         .encoding("utf-8")
         .auth("Bearer #{access_token}")
     end

data/lib/hcloud/resource_type.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+# rubocop:disable Metrics/CyclomaticComplexity,Metrics/AbcSize
 module HCloud
   class ResourceType
     class_attribute :resource_class_name
@@ -10,7 +11,6 @@ module HCloud
       @array = array
     end
 
-    # rubocop:disable Metrics/CyclomaticComplexity
     def cast(value)
       case value
       when nil, []
@@ -28,12 +28,13 @@ module HCloud
       when Hash # Attribute hash
         resource_class.new(value)
       when Array # List
+        raise ArgumentError, "cannot cast value: #{value} for type #{resource_class_name}" unless array?
+
         value.map { |v| cast(v) }
       else
         raise ArgumentError, "cannot cast value: #{value} for type #{resource_class_name}"
       end
     end
-    # rubocop:enable Metrics/CyclomaticComplexity
 
     def resource_class
       @resource_class ||= resource_class_name.constantize
@@ -52,8 +53,32 @@ module HCloud
         .tap { |klass| HCloud.const_set(:"#{class_name.demodulize}ResourceType", klass) }
     end
     # rubocop:enable Naming/MethodName
+
+    class GenericType < ResourceType
+      def cast(value)
+        case value
+        when nil, []
+          array? ? [] : nil
+        when HCloud::Resource # Class
+          value
+        when Hash # Attribute hash
+          ActiveModel::Type
+            .lookup(value.fetch(:type).to_sym)
+            .cast(value.except(:type))
+        when Array # List
+          raise ArgumentError, "cannot cast value: #{value} for generic type" unless array?
+
+          value.map { |v| cast(v) }
+        else
+          raise ArgumentError, "cannot cast value: #{value} for generic type"
+        end
+      rescue KeyError => e
+        raise ArgumentError, "cannot cast value: #{value} for generic type: #{e.message}"
+      end
+    end
   end
 end
+# rubocop:enable Metrics/CyclomaticComplexity,Metrics/AbcSize
 
 ActiveModel::Type.register(:action, HCloud::ResourceType.Type("HCloud::Action"))
 ActiveModel::Type.register(:algorithm, HCloud::ResourceType.Type("HCloud::Algorithm"))
@@ -86,18 +111,23 @@ ActiveModel::Type.register(:load_balancer_public_net, HCloud::ResourceType.Type(
 ActiveModel::Type.register(:load_balancer_type, HCloud::ResourceType.Type("HCloud::LoadBalancerType"))
 ActiveModel::Type.register(:load_balancer_type_price, HCloud::ResourceType.Type("HCloud::LoadBalancerTypePrice"))
 ActiveModel::Type.register(:location, HCloud::ResourceType.Type("HCloud::Location"))
+ActiveModel::Type.register(:metadata, HCloud::ResourceType.Type("HCloud::Metadata"))
 ActiveModel::Type.register(:network, HCloud::ResourceType.Type("HCloud::Network"))
 ActiveModel::Type.register(:placement_group, HCloud::ResourceType.Type("HCloud::PlacementGroup"))
 ActiveModel::Type.register(:price, HCloud::ResourceType.Type("HCloud::Price"))
 ActiveModel::Type.register(:pricing, HCloud::ResourceType.Type("HCloud::Pricing"))
 ActiveModel::Type.register(:primary_ip, HCloud::ResourceType.Type("HCloud::PrimaryIP"))
+ActiveModel::Type.register(:primary_ip_prices, HCloud::ResourceType.Type("HCloud::PrimaryIPPrices"))
 ActiveModel::Type.register(:private_net, HCloud::ResourceType.Type("HCloud::PrivateNet"))
+ActiveModel::Type.register(:private_network, HCloud::ResourceType.Type("HCloud::PrivateNetwork"))
 ActiveModel::Type.register(:protection, HCloud::ResourceType.Type("HCloud::Protection"))
 ActiveModel::Type.register(:public_net, HCloud::ResourceType.Type("HCloud::PublicNet"))
+ActiveModel::Type.register(:resource, HCloud::ResourceType::GenericType)
 ActiveModel::Type.register(:route, HCloud::ResourceType.Type("HCloud::Route"))
 ActiveModel::Type.register(:rule, HCloud::ResourceType.Type("HCloud::Rule"))
 ActiveModel::Type.register(:server, HCloud::ResourceType.Type("HCloud::Server"))
 ActiveModel::Type.register(:server_backup_price, HCloud::ResourceType.Type("HCloud::ServerBackupPrice"))
+ActiveModel::Type.register(:server_protection, HCloud::ResourceType.Type("HCloud::ServerProtection"))
 ActiveModel::Type.register(:server_type, HCloud::ResourceType.Type("HCloud::ServerType"))
 ActiveModel::Type.register(:server_type_price, HCloud::ResourceType.Type("HCloud::ServerTypePrice"))
 ActiveModel::Type.register(:service, HCloud::ResourceType.Type("HCloud::Service"))

data/lib/hcloud/resources/action.rb

@@ -11,18 +11,18 @@ module HCloud
   #
   # == Sort actions
   #
-  #     HCloud::Action.all.sort(command: :desc)
+  #     HCloud::Action.sort(command: :desc)
   #     # => [#<HCloud::Action id: 1, ...>, ...]
   #
-  #     HCloud::Action.all.sort(:id, command: :asc)
+  #     HCloud::Action.sort(:id, command: :asc)
   #     # => [#<HCloud::Action id: 1, ...>, ...]
   #
   # == Search actions
   #
-  #     HCloud::Action.all.where(command: "my_action")
+  #     HCloud::Action.where(command: "my_action")
   #     # => #<HCloud::Action id: 1, ...>
   #
-  #     HCloud::Action.all.where(status: "success")
+  #     HCloud::Action.where(status: "success")
   #     # => #<HCloud::Action id: 1, ...>
   #
   # == Find action by ID
@@ -43,7 +43,6 @@ module HCloud
     attribute :status
     attribute :error, :error
 
-    # TODO: return array of resources
-    attribute :resources, array: true, default: -> { [] }
+    attribute :resources, :resource, array: true, default: -> { [] }
   end
 end

data/lib/hcloud/resources/certificate.rb

@@ -11,18 +11,21 @@ module HCloud
   #
   # == Sort certificates
   #
-  #     HCloud::Certificate.all.sort(name: :desc)
+  #     HCloud::Certificate.sort(name: :desc)
   #     # => [#<HCloud::Certificate id: 1, ...>, ...]
   #
-  #     HCloud::Certificate.all.sort(:id, name: :asc)
+  #     HCloud::Certificate.sort(:id, name: :asc)
   #     # => [#<HCloud::Certificate id: 1, ...>, ...]
   #
   # == Search certificates
   #
-  #     HCloud::Certificate.all.where(name: "my_certificate")
+  #     HCloud::Certificate.where(name: "my_certificate")
   #     # => #<HCloud::Certificate id: 1, ...>
   #
-  #     HCloud::Certificate.all.where(type: "uploaded")
+  #     HCloud::Certificate.where(type: "uploaded")
+  #     # => #<HCloud::Certificate id: 1, ...>
+  #
+  #     HCloud::Certificate.where(label_selector: { environment: "production" })
   #     # => #<HCloud::Certificate id: 1, ...>
   #
   # == Find certificate by ID
@@ -94,6 +97,7 @@ module HCloud
     creatable
     updatable
     deletable
+    labelable
 
     attribute :id, :integer
     attribute :name
@@ -116,8 +120,6 @@ module HCloud
     # TODO: dynamically return resource classes
     attribute :used_by, :used_by, array: true, default: -> { [] }
 
-    attribute :labels, default: -> { {} }
-
     action :retry
 
     def creatable_attributes

data/lib/hcloud/resources/datacenter.rb

@@ -11,7 +11,7 @@ module HCloud
   #
   # == Search datacenters
   #
-  #     HCloud::Datacenter.all.where(name: "fsn1-dc8")
+  #     HCloud::Datacenter.where(name: "fsn1-dc8")
   #     # => #<HCloud::Datacenter id: 2, ...>
   #
   # == Find datacenter by ID

data/lib/hcloud/resources/firewall.rb

@@ -11,15 +11,18 @@ module HCloud
   #
   # == Sort firewalls
   #
-  #     HCloud::Firewall.all.sort(name: :desc)
+  #     HCloud::Firewall.sort(name: :desc)
   #     # => [#<HCloud::Firewall id: 1, ...>, ...]
   #
-  #     HCloud::Firewall.all.sort(:id, name: :asc)
+  #     HCloud::Firewall.sort(:id, name: :asc)
   #     # => [#<HCloud::Firewall id: 1, ...>, ...]
   #
   # == Search firewalls
   #
-  #     HCloud::Firewall.all.where(name: "my_firewall")
+  #     HCloud::Firewall.where(name: "my_firewall")
+  #     # => #<HCloud::Firewall id: 1, ...>
+  #
+  #     HCloud::Firewall.where(label_selector: { environment: "production" })
   #     # => #<HCloud::Firewall id: 1, ...>
   #
   # == Find firewall by ID
@@ -107,6 +110,7 @@ module HCloud
     creatable
     updatable
     deletable
+    labelable
 
     attribute :id, :integer
     attribute :name
@@ -117,8 +121,6 @@ module HCloud
 
     attribute :rules, :rule, array: true, default: -> { [] }
 
-    attribute :labels, default: -> { {} }
-
     action :apply_to_resources
     action :remove_from_resources
     action :set_rules

data/lib/hcloud/resources/floating_ip.rb

@@ -11,15 +11,18 @@ module HCloud
   #
   # == Sort floating IPs
   #
-  #     HCloud::FloatingIP.all.sort(id: :asc)
+  #     HCloud::FloatingIP.sort(id: :asc)
   #     # => [#<HCloud::FloatingIP id: 1, ...>, ...]
   #
-  #     HCloud::FloatingIP.all.sort(:id, created: :asc)
+  #     HCloud::FloatingIP.sort(:id, created: :asc)
   #     # => [#<HCloud::FloatingIP id: 1, ...>, ...]
   #
   # == Search floating IPs
   #
-  #     HCloud::FloatingIP.all.where(name: "my_floating_ip")
+  #     HCloud::FloatingIP.where(name: "my_floating_ip")
+  #     # => #<HCloud::FloatingIP id: 1, ...>
+  #
+  #     HCloud::FloatingIP.where(label_selector: { environment: "production" })
   #     # => #<HCloud::FloatingIP id: 1, ...>
   #
   # == Find floating IP by ID
@@ -104,6 +107,7 @@ module HCloud
     creatable
     updatable
     deletable
+    labelable
 
     attribute :id, :integer
     attribute :name
@@ -121,8 +125,6 @@ module HCloud
 
     attribute :server, :server
 
-    attribute :labels, default: -> { {} }
-
     alias blocked? blocked
 
     action :assign

data/lib/hcloud/resources/image.rb

@@ -11,21 +11,21 @@ module HCloud
   #
   # == Sort images
   #
-  #     HCloud::Image.all.sort(name: :desc)
+  #     HCloud::Image.sort(name: :desc)
   #     # => [#<HCloud::Image id: 1, ...>, ...]
   #
-  #     HCloud::Image.all.sort(:id, name: :asc)
+  #     HCloud::Image.sort(:id, name: :asc)
   #     # => [#<HCloud::Image id: 1, ...>, ...]
   #
   # == Search images
   #
-  #     HCloud::Image.all.where(name: "my_image")
+  #     HCloud::Image.where(name: "my_image")
   #     # => #<HCloud::Image id: 1, ...>
   #
-  #     HCloud::Image.all.where(status: "available", include_deprecated: false)
+  #     HCloud::Image.where(status: "available", include_deprecated: false)
   #     # => #<HCloud::Image id: 1, ...>
   #
-  #     HCloud::Image.all.where(type: "backup", bound_to: 1)
+  #     HCloud::Image.where(type: "backup", bound_to: 1)
   #     # => #<HCloud::Image id: 1, ...>
   #
   # == Find image by ID
@@ -85,6 +85,7 @@ module HCloud
     queryable
     updatable
     deletable
+    labelable
 
     attribute :id, :integer
     attribute :name
@@ -113,8 +114,6 @@ module HCloud
 
     attribute :rapid_deploy
 
-    attribute :labels, default: -> { {} }
-
     action :change_protection
 
     def created?