hetznercloud 1.3.1 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 78ef10de0c462ae7e1c5bf47c747d25a110551f817800b70b2aef7f5a045db5c
-  data.tar.gz: d9833600b525f01a5879888809a401df07bb7120f2d42db2e43220e0897cbfb5
+  metadata.gz: 0a4ca2b02a62b66c5fc5024fcfc7d1c0614f29b7008fdb7b7d92ce9839b542c3
+  data.tar.gz: 26a182b4a53db2a04731130c5b74ffa6f92eaadf17ae0d69080c64b3a0a71c50
 SHA512:
-  metadata.gz: 20a46b53f9caa94a730c512208817c3ec7eb871983ade5bdd8acf2c19f77089084a31648c7b10d4d25d7cf3004f440d6732729398836e437838315fb01ec1985
-  data.tar.gz: 6cd6709f99a23259d4e82a93285aa415358cdc51dff6489911df5c35a06c6d85005c65eee5a42021bd69a665f33b620196d3657675122bd1c78da0d2d374c869
+  metadata.gz: e57fbe462b9805f2f6615f9ddef3ef9eb1b4498620d54537dc0d73a2000e34df78ed2b8493e12032fdb842cb632887fe1e7df826cffb87f8b630d99fa002c35e
+  data.tar.gz: 2ee09e22a6c9d4dafb745ab98f204bd2af649b26eaab35f2a67370250a47fd7ff6c1060e79fe3e785c736c7c9ed5d48725479856dfc1d879147c82a0f32de79d

data/CHANGELOG.md

@@ -1,15 +1,36 @@
 # Changelog
 
-## HCloud v1.3.1
+## HCloud v1.5.0 (2023-02-01)
 
-- Add missing Server#user_data
+- 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.3.0
+## HCloud v1.4.0 (2023-01-22)
+
+- Implemented Primary IPs
+- Implemented Primary IP Actions
+- Allow calling `#update` with additional attributes to be updated
+- Return the resource when calling `#create`, `#update` or `#delete`
+- Add additional primary IP mismatch errors:
+  - `PrimaryIPAssigned`
+  - `PrimaryIPDatacenterMismatch`
+  - `PrimaryIPVersionMismatch`
+
+## HCloud v1.3.1 (2022-02-06)
+
+- Add missing `Server#user_data`
+
+## HCloud v1.3.0 (2022-02-04)
 
 - Implemented Load Balancers
 - Implemented Load Balancer Types
 
-## HCloud v1.2.0
+## HCloud v1.2.0 (2022-02-01)
 
 - Implemented Networks
 - Implemented Network Actions
@@ -17,10 +38,10 @@
 - Implemented Certificates
 - Implemented Certificate Actions
 
-## HCloud v1.1.0
+## HCloud v1.1.0 (2022-01-30)
 
 - Implemented Firewall Actions
 
-## HCloud v1.0.0
+## HCloud v1.0.0 (2022-01-16)
 
 Initial release

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/LICENSE.md

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2021 Florian Dejonckheere
+Copyright (c) 2023 Florian Dejonckheere
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -69,35 +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           |
-| 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
 
@@ -128,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

@@ -14,15 +14,21 @@ HCloud.loader.inflector.inflect(
   "ipv6" => "IPv6",
   "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|
   inflect.acronym "DNS"
   inflect.acronym "HTTP"
   inflect.acronym "IP"
+  inflect.acronym "IPv4"
+  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/creatable.rb

@@ -12,6 +12,8 @@ module HCloud
           .post("/#{resource_name.pluralize}", creatable_params)
           .tap { |r| r[resource_name.to_sym].merge!(r.slice(:root_password)) }
           .fetch(resource_name.to_sym)
+
+        self
       end
 
       def created?

data/lib/hcloud/concerns/deletable.rb

@@ -12,6 +12,8 @@ module HCloud
           .delete("/#{resource_name.pluralize}/#{id}")
 
         @deleted = true
+
+        self
       end
 
       def deleted?

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/concerns/updatable.rb

@@ -5,12 +5,16 @@ module HCloud
     extend ActiveSupport::Concern
 
     included do
-      def update
+      def update(**attributes)
         raise Errors::MissingIDError unless id
 
+        assign_attributes attributes
+
         assign_attributes client
           .put("/#{resource_name.pluralize}/#{id}", updatable_params)
           .fetch(resource_name.to_sym)
+
+        self
       end
 
       def updatable_attributes

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

@@ -43,6 +43,10 @@ module HCloud
     class NotFound < Error; end
     class PlacementError < Error; end
     class PlacementError < Error; end
+    class PrimaryIPAssigned < Error; end
+    class PrimaryIPAlreadyAssigned < Error; end
+    class PrimaryIPDatacenterMismatch < Error; end
+    class PrimaryIPVersionMismatch < Error; end
     class Protected < Error; end
     class RateLimitExceeded < Error; end
     class ResourceInUse < Error; end
@@ -52,7 +56,11 @@ module HCloud
     class ServerAlreadyAdded < Error; end
     class ServerAlreadyAttached < Error; end
     class ServerError < Error; end
+    class ServerHasIPv4 < Error; end
+    class ServerHasIPv6 < Error; end
+    class ServerIsLoadBalancerTarget < Error; end
     class ServerNotAttachedToNetwork < Error; end
+    class ServerNotStopped < Error; end
     class ServiceError < Error; end
     class SourcePortAlreadyUsed < Error; end
     class TargetAlreadyDefined < 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,17 +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