hetznercloud 1.0.0 → 1.3.1

data/lib/hcloud/errors.rb

@@ -2,15 +2,39 @@
 
 module HCloud
   module Errors
+    class Error < StandardError
+      attr_reader :data
+
+      def initialize(data = {})
+        @data = data
+
+        super [data[:message], full_messages&.join("\n")].compact.join("\n\n")
+      end
+
+      def full_messages
+        return unless data[:details]
+
+        data[:details][:fields].flat_map do |field|
+          Array(field.fetch(:messages, data[:message])).map do |detail|
+            "#{field[:name]} #{detail}"
+          end
+        end
+      end
+    end
+
     class ActionFailed < Error; end
+    class CloudResourceIPNotAllowed < Error; end
     class Conflict < Error; end
-    class Error < StandardError; end
+    class FirewallAlreadyApplied < Error; end
+    class FirewallAlreadyRemoved < Error; end
     class FirewallResourceNotFound < Error; end
     class Forbidden < Error; end
     class IPNotAvailable < Error; end
+    class IPNotOwned < Error; end
     class IncompatibleNetworkType < Error; end
     class InvalidInput < Error; end
     class JSONError < Error; end
+    class LoadBalancerNotAttachedToNetwork < Error; end
     class Locked < Error; end
     class Maintenance < Error; end
     class NetworksOverlap < Error; end
@@ -21,16 +45,22 @@ module HCloud
     class PlacementError < Error; end
     class Protected < Error; end
     class RateLimitExceeded < Error; end
+    class ResourceInUse < Error; end
     class ResourceLimitExceeded < Error; end
     class ResourceUnavailable < Error; end
-    class ResourceInUse < Error; end
+    class RobotUnavailable < Error; end
     class ServerAlreadyAdded < Error; end
     class ServerAlreadyAttached < Error; end
     class ServerError < Error; end
+    class ServerNotAttachedToNetwork < Error; end
     class ServiceError < Error; end
+    class SourcePortAlreadyUsed < Error; end
+    class TargetAlreadyDefined < Error; end
     class TokenReadonly < Error; end
     class Unauthorized < Error; end
     class UniquenessError < Error; end
     class UnsupportedError < Error; end
+
+    class MissingIDError < Error; end
   end
 end

data/lib/hcloud/http.rb

@@ -17,39 +17,45 @@ module HCloud
       response = http
         .get(url_for(path), params: transform_params(params))
 
+      raise Errors::ServerError, response if response.status.server_error?
+
       data = response
         .parse(:json)
         .deep_symbolize_keys
 
       return data if response.status.success?
 
-      raise Errors.const_get(data.dig(:error, :code).camelize), data.dig(:error, :message)
+      raise Errors.const_get(data.dig(:error, :code).camelize), data[:error]
     end
 
     def put(path, body = {})
       response = http
         .put(url_for(path), json: body)
 
+      raise Errors::ServerError, response if response.status.server_error?
+
       data = response
         .parse(:json)
         .deep_symbolize_keys
 
       return data if response.status.success?
 
-      raise Errors.const_get(data.dig(:error, :code).camelize), data.dig(:error, :message)
+      raise Errors.const_get(data.dig(:error, :code).camelize), data[:error]
     end
 
     def post(path, body = {})
       response = http
         .post(url_for(path), json: body)
 
+      raise Errors::ServerError, response if response.status.server_error?
+
       data = response
         .parse(:json)
         .deep_symbolize_keys
 
       return data if response.status.success?
 
-      raise Errors.const_get(data.dig(:error, :code).camelize), data.dig(:error, :message)
+      raise Errors.const_get(data.dig(:error, :code).camelize), data[:error]
     end
 
     def delete(path)
@@ -58,11 +64,13 @@ module HCloud
 
       return if response.status.success?
 
+      raise Errors::ServerError, response if response.status.server_error?
+
       data = response
         .parse(:json)
         .deep_symbolize_keys
 
-      raise Errors.const_get(data.dig(:error, :code).camelize), data.dig(:error, :message)
+      raise Errors.const_get(data.dig(:error, :code).camelize), data[:error]
     end
 
     private

data/lib/hcloud/resource_type.rb

@@ -19,8 +19,12 @@ module HCloud
         value
       when Integer # ID
         resource_class.new(id: value)
-      when String # Name
-        resource_class.new(name: value)
+      when String # Name or Type
+        if resource_class.attribute_names.include?("name")
+          resource_class.new(name: value)
+        else
+          resource_class.new(type: value)
+        end
       when Hash # Attribute hash
         resource_class.new(value)
       when Array # List
@@ -40,6 +44,8 @@ module HCloud
     def assert_valid_value(_); end
 
     # rubocop:disable Naming/MethodName
+    # Limitation: resource types cannot be nested, because the types
+    # are registered as soon as possible, and the modules may not exist yet.
     def self.Type(class_name)
       Class
         .new(ResourceType) { self.resource_class_name = class_name }
@@ -50,24 +56,57 @@ module HCloud
 end
 
 ActiveModel::Type.register(:action, HCloud::ResourceType.Type("HCloud::Action"))
+ActiveModel::Type.register(:algorithm, HCloud::ResourceType.Type("HCloud::Algorithm"))
 ActiveModel::Type.register(:amount, HCloud::ResourceType.Type("HCloud::Amount"))
 ActiveModel::Type.register(:applied_to, HCloud::ResourceType.Type("HCloud::AppliedTo"))
 ActiveModel::Type.register(:applied_to_resource, HCloud::ResourceType.Type("HCloud::AppliedToResource"))
 ActiveModel::Type.register(:apply_to, HCloud::ResourceType.Type("HCloud::ApplyTo"))
+ActiveModel::Type.register(:certificate, HCloud::ResourceType.Type("HCloud::Certificate"))
+ActiveModel::Type.register(:certificate_status, HCloud::ResourceType.Type("HCloud::CertificateStatus"))
 ActiveModel::Type.register(:datacenter, HCloud::ResourceType.Type("HCloud::Datacenter"))
 ActiveModel::Type.register(:datacenter_server_type, HCloud::ResourceType.Type("HCloud::DatacenterServerType"))
 ActiveModel::Type.register(:dns_pointer, HCloud::ResourceType.Type("HCloud::DNSPointer"))
 ActiveModel::Type.register(:error, HCloud::ResourceType.Type("HCloud::Error"))
 ActiveModel::Type.register(:firewall, HCloud::ResourceType.Type("HCloud::Firewall"))
 ActiveModel::Type.register(:floating_ip, HCloud::ResourceType.Type("HCloud::FloatingIP"))
+ActiveModel::Type.register(:floating_ip_price, HCloud::ResourceType.Type("HCloud::FloatingIPPrice"))
+ActiveModel::Type.register(:floating_ip_prices, HCloud::ResourceType.Type("HCloud::FloatingIPPrices"))
+ActiveModel::Type.register(:health_check, HCloud::ResourceType.Type("HCloud::HealthCheck"))
+ActiveModel::Type.register(:health_check_http, HCloud::ResourceType.Type("HCloud::HealthCheckHTTP"))
+ActiveModel::Type.register(:health_status, HCloud::ResourceType.Type("HCloud::HealthStatus"))
 ActiveModel::Type.register(:image, HCloud::ResourceType.Type("HCloud::Image"))
+ActiveModel::Type.register(:image_price, HCloud::ResourceType.Type("HCloud::ImagePrice"))
+ActiveModel::Type.register(:ipv4, HCloud::ResourceType.Type("HCloud::IPv4"))
+ActiveModel::Type.register(:ipv6, HCloud::ResourceType.Type("HCloud::IPv6"))
 ActiveModel::Type.register(:iso, HCloud::ResourceType.Type("HCloud::ISO"))
+ActiveModel::Type.register(:label_selector, HCloud::ResourceType.Type("HCloud::LabelSelector"))
+ActiveModel::Type.register(:load_balancer, HCloud::ResourceType.Type("HCloud::LoadBalancer"))
+ActiveModel::Type.register(:load_balancer_private_net, HCloud::ResourceType.Type("HCloud::LoadBalancerPrivateNet"))
+ActiveModel::Type.register(:load_balancer_public_net, HCloud::ResourceType.Type("HCloud::LoadBalancerPublicNet"))
+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(: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(:private_net, HCloud::ResourceType.Type("HCloud::PrivateNet"))
 ActiveModel::Type.register(:protection, HCloud::ResourceType.Type("HCloud::Protection"))
+ActiveModel::Type.register(:public_net, HCloud::ResourceType.Type("HCloud::PublicNet"))
+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_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"))
+ActiveModel::Type.register(:service_http, HCloud::ResourceType.Type("HCloud::ServiceHTTP"))
 ActiveModel::Type.register(:ssh_key, HCloud::ResourceType.Type("HCloud::SSHKey"))
+ActiveModel::Type.register(:subnet, HCloud::ResourceType.Type("HCloud::Subnet"))
+ActiveModel::Type.register(:target, HCloud::ResourceType.Type("HCloud::Target"))
+ActiveModel::Type.register(:targets, HCloud::ResourceType.Type("HCloud::Targets"))
+ActiveModel::Type.register(:target_ip, HCloud::ResourceType.Type("HCloud::TargetIP"))
+ActiveModel::Type.register(:traffic_price, HCloud::ResourceType.Type("HCloud::TrafficPrice"))
+ActiveModel::Type.register(:used_by, HCloud::ResourceType.Type("HCloud::UsedBy"))
 ActiveModel::Type.register(:volume, HCloud::ResourceType.Type("HCloud::Volume"))
+ActiveModel::Type.register(:volume_price, HCloud::ResourceType.Type("HCloud::VolumePrice"))

data/lib/hcloud/resources/certificate.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module HCloud
+  ##
+  # Represents a certificate
+  #
+  # == List all certificates
+  #
+  #     HCloud::Certificate.all
+  #     # => [#<HCloud::Certificate id: 1, ...>, ...]
+  #
+  # == Sort certificates
+  #
+  #     HCloud::Certificate.all.sort(name: :desc)
+  #     # => [#<HCloud::Certificate id: 1, ...>, ...]
+  #
+  #     HCloud::Certificate.all.sort(:id, name: :asc)
+  #     # => [#<HCloud::Certificate id: 1, ...>, ...]
+  #
+  # == Search certificates
+  #
+  #     HCloud::Certificate.all.where(name: "my_certificate")
+  #     # => #<HCloud::Certificate id: 1, ...>
+  #
+  #     HCloud::Certificate.all.where(type: "uploaded")
+  #     # => #<HCloud::Certificate id: 1, ...>
+  #
+  # == Find certificate by ID
+  #
+  #     HCloud::Certificate.find(1)
+  #     # => #<HCloud::Certificate id: 1, ...>
+  #
+  # == Create certificate
+  #
+  #     certificate = HCloud::Certificate.new(name: "my_certificate", type: "managed", domain_names: ["example.com"])
+  #     certificate.create
+  #     certificate.created?
+  #     # => true
+  #
+  #     certificate = HCloud::Certificate.create(name: "my_certificate", type: "managed", domain_names: ["example.com"])
+  #     # => #<HCloud::Certificate id: 1, ...>
+  #
+  # == Update certificate
+  #
+  #     certificate = HCloud::Certificate.find(1)
+  #     certificate.name = "another_certificate"
+  #     certificate.update
+  #
+  # == Delete certificate
+  #
+  #     certificate = HCloud::Certificate.find(1)
+  #     certificate.delete
+  #     certificate.deleted?
+  #     # => true
+  #
+  # = Actions
+  # == List actions
+  #
+  #     actions = HCloud::Certificate.find(1).actions
+  #     # => [#<HCloud::Action id: 1, ...>, ...]
+  #
+  # == Sort actions
+  #
+  #     HCloud::Certificate.find(1).actions.sort(finished: :desc)
+  #     # => [#<HCloud::Action id: 1, ...>, ...]
+  #
+  #     HCloud::Certificate.find(1).actions.sort(:command, finished: :asc)
+  #     # => [#<HCloud::Actions id: 1, ...>, ...]
+  #
+  # == Search actions
+  #
+  #     HCloud::Certificate.find(1).actions.where(command: "set_rules")
+  #     # => #<HCloud::Action id: 1, ...>
+  #
+  #     HCloud::Certificate.find(1).actions.where(status: "success")
+  #     # => #<HCloud::Action id: 1, ...>
+  #
+  # == Find action by ID
+  #
+  #     HCloud::Certificate.find(1).actions.find(1)
+  #     # => #<HCloud::Action id: 1, ...>
+  #
+  # = Resource-specific actions
+  # == Retry issuance or renewal
+  #
+  #     certificate = HCloud::Certificate.find(1)
+  #
+  #     certificate.retry
+  #     # => #<HCloud::Action ...>
+  #
+  class Certificate < Resource
+    actionable
+    queryable
+    creatable
+    updatable
+    deletable
+
+    attribute :id, :integer
+    attribute :name
+
+    attribute :type
+
+    attribute :certificate
+    attribute :fingerprint
+
+    # TODO: use only for creation
+    attribute :private_key
+
+    attribute :not_valid_before, :datetime
+    attribute :not_valid_after, :datetime
+
+    attribute :domain_names, array: true, default: -> { [] }
+
+    attribute :status, :certificate_status
+
+    # TODO: dynamically return resource classes
+    attribute :used_by, :used_by, array: true, default: -> { [] }
+
+    attribute :labels, default: -> { {} }
+
+    action :retry
+
+    def creatable_attributes
+      [:name, :labels, :type, :private_key, :certificate, :domain_names]
+    end
+
+    def updatable_attributes
+      [:name, :labels]
+    end
+  end
+end

data/lib/hcloud/resources/firewall.rb

@@ -19,7 +19,7 @@ module HCloud
   #
   # == Search firewalls
   #
-  #     HCloud::Firewall.all.where(name: "my_irewall")
+  #     HCloud::Firewall.all.where(name: "my_firewall")
   #     # => #<HCloud::Firewall id: 1, ...>
   #
   # == Find firewall by ID
@@ -50,9 +50,59 @@ module HCloud
   #     firewall.deleted?
   #     # => true
   #
-  # TODO: firewall actions
+  # = Actions
+  # == List actions
+  #
+  #     actions = HCloud::Firewall.find(1).actions
+  #     # => [#<HCloud::Action id: 1, ...>, ...]
+  #
+  # == Sort actions
+  #
+  #     HCloud::Firewall.find(1).actions.sort(finished: :desc)
+  #     # => [#<HCloud::Action id: 1, ...>, ...]
+  #
+  #     HCloud::Firewall.find(1).actions.sort(:command, finished: :asc)
+  #     # => [#<HCloud::Actions id: 1, ...>, ...]
+  #
+  # == Search actions
+  #
+  #     HCloud::Firewall.find(1).actions.where(command: "set_rules")
+  #     # => #<HCloud::Action id: 1, ...>
+  #
+  #     HCloud::Firewall.find(1).actions.where(status: "success")
+  #     # => #<HCloud::Action id: 1, ...>
+  #
+  # == Find action by ID
+  #
+  #     HCloud::Firewall.find(1).actions.find(1)
+  #     # => #<HCloud::Action id: 1, ...>
+  #
+  # = Resource-specific actions
+  # == Apply a firewall to resources
+  #
+  #     firewall = HCloud::Firewall.find(1)
+  #     server = HCloud::Server.find(1)
+  #
+  #     firewall.apply_to_resources(apply_to: [{ type: "server", server: { id: server.id } }])
+  #     # => #<HCloud::Action ...>
+  #
+  # == Remove a firewall from resources
+  #
+  #     firewall = HCloud::Firewall.find(1)
+  #     server = HCloud::Server.find(1)
+  #
+  #     firewall.remove_from_resources(remove_from: [{ type: "server", server: { id: server.id } }])
+  #     # => #<HCloud::Action ...>
+  #
+  # == Set firewall rules
+  #
+  #     firewall = HCloud::Firewall.find(1)
+  #
+  #     firewall.set_rules(rules: [{ direction: "in", protocol: "tcp", ... }])
+  #     # => #<HCloud::Action ...>
   #
   class Firewall < Resource
+    actionable
     queryable
     creatable
     updatable
@@ -62,13 +112,17 @@ module HCloud
     attribute :name
 
     attribute :applied_to, :applied_to, array: true, default: -> { [] }
-    # Only used for creation
+    # TODO: use only for creation
     attribute :apply_to, :apply_to, array: true, default: -> { [] }
 
     attribute :rules, :rule, array: true, default: -> { [] }
 
     attribute :labels, default: -> { {} }
 
+    action :apply_to_resources
+    action :remove_from_resources
+    action :set_rules
+
     def creatable_attributes
       [:name, :labels, :apply_to, :rules]
     end

data/lib/hcloud/resources/floating_ip.rb

@@ -77,7 +77,7 @@ module HCloud
   #     HCloud::FloatingIP.find(1).actions.find(1)
   #     # => #<HCloud::Action id: 1, ...>
   #
-  # = Floating IP-specific actions
+  # = Resource-specific actions
   # == Assign a floating IP to a server
   #
   #     HCloud::FloatingIP.find(1).assign(server: 1)
@@ -119,8 +119,7 @@ module HCloud
 
     attribute :protection, :protection
 
-    # TODO: return Server object
-    attribute :server, :integer
+    attribute :server, :server
 
     attribute :labels, default: -> { {} }
 

data/lib/hcloud/resources/image.rb

@@ -74,7 +74,7 @@ module HCloud
   #     HCloud::Image.find(1).actions.find(1)
   #     # => #<HCloud::Action id: 1, ...>
   #
-  # = Image-specific actions
+  # = Resource-specific actions
   # == Change protection
   #
   #     HCloud::Image.find(1).change_protection(delete: true)

data/lib/hcloud/resources/load_balancer.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module HCloud
+  ##
+  # Represents a load balancer
+  #
+  # == List all load balancers
+  #
+  #     HCloud::LoadBalancer.all
+  #     # => [#<HCloud::LoadBalancer id: 1, ...>, ...]
+  #
+  # == Sort load balancers
+  #
+  #     HCloud::LoadBalancer.all.sort(name: :desc)
+  #     # => [#<HCloud::LoadBalancer id: 1, ...>, ...]
+  #
+  #     HCloud::LoadBalancer.all.sort(:id, name: :asc)
+  #     # => [#<HCloud::LoadBalancer id: 1, ...>, ...]
+  #
+  # == Search load balancers
+  #
+  #     HCloud::LoadBalancer.all.where(name: "my_load_balancer")
+  #     # => #<HCloud::LoadBalancer id: 1, ...>
+  #
+  # == Find load balancer by ID
+  #
+  #     HCloud::LoadBalancer.find(1)
+  #     # => #<HCloud::LoadBalancer id: 1, ...>
+  #
+  # == Create load balancer
+  #
+  #     load_balancer = HCloud::LoadBalancer.new(name: "my_load_balancer", algorithm: { type: "round_robin" }, load_balancer_type: "lb11", location: "nbg1")
+  #     load_balancer.create
+  #     load_balancer.created?
+  #     # => true
+  #
+  #     load_balancer = HCloud::LoadBalancer.create(name: "my_load_balancer", algorithm: { type: "round_robin" }, load_balancer_type: "lb11", location: "nbg1")
+  #     # => #<HCloud::LoadBalancer id: 1, ...>
+  #
+  # == Update load balancer
+  #
+  #     load_balancer = HCloud::LoadBalancer.find(1)
+  #     load_balancer.name = "another_load_balancer"
+  #     load_balancer.update
+  #
+  # == Delete load balancer
+  #
+  #     load_balancer = HCloud::LoadBalancer.find(1)
+  #     load_balancer.delete
+  #     load_balancer.deleted?
+  #     # => true
+  #
+  # == Get metrics
+  #
+  #     load_balancer = HCloud::LoadBalancer.find(1)
+  #     load_balancer.metrics(type: :bandwidth, from: 2.minutes.ago, to: 1.minute.ago)
+  #     # => #<HCloud::Metrics ...>
+  #
+  #     load_balancer.metrics(type: [:connections_per_second, :requests_per_second], from: 2.minutes.ago, to: 1.minute.ago, step: 60)
+  #     # => #<HCloud::Metrics ...>
+  #
+  class LoadBalancer < Resource
+    queryable
+    creatable
+    updatable
+    deletable
+    meterable
+
+    attribute :id, :integer
+    attribute :name
+
+    attribute :algorithm, :algorithm
+
+    attribute :included_traffic, :integer
+    attribute :ingoing_traffic, :integer
+    attribute :outgoing_traffic, :integer
+
+    attribute :load_balancer_type, :load_balancer_type
+
+    attribute :location, :location
+
+    # TODO: use only for creation
+    attribute :network_zone
+    # TODO: use only for creation
+    attribute :network, :network
+    # TODO: use only for creation
+    attribute :public_interface, :boolean
+
+    attribute :private_net, :load_balancer_private_net
+    attribute :public_net, :load_balancer_public_net
+
+    attribute :services, :service, array: true, default: -> { [] }
+    attribute :targets, :target, array: true, default: -> { [] }
+
+    attribute :protection, :protection
+
+    attribute :labels, default: -> { {} }
+
+    def creatable_attributes
+      [:name, :labels, :algorithm, :network_zone, :public_interface, :services, :targets, load_balancer_type: [:id, :name], location: [:id, :name], network: [:id, :name]]
+    end
+
+    def updatable_attributes
+      [:name, :labels]
+    end
+  end
+end

data/lib/hcloud/resources/load_balancer_type.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module HCloud
+  ##
+  # Represents a load balancer type
+  #
+  # == List all load balancer types
+  #
+  #     HCloud::LoadBalancerType.all
+  #     # => [#<HCloud::LoadBalancerType id: 1, ...>, ...]
+  #
+  # == Search load balancer types
+  #
+  #     HCloud::LoadBalancerType.all.where(name: "cx11")
+  #     # => #<HCloud::LoadBalancerType id: 1, ...>
+  #
+  # == Find load balancer type by ID
+  #
+  #     HCloud::LoadBalancerType.find(1)
+  #     # => #<HCloud::LoadBalancerType id: 1, ...>
+  #
+  class LoadBalancerType < Resource
+    queryable
+
+    attribute :id, :integer
+    attribute :name
+    attribute :description
+
+    attribute :max_assigned_certificates, :integer
+    attribute :max_connections, :integer
+    attribute :max_services, :integer
+    attribute :max_targets, :integer
+
+    attribute :prices, :price, array: true, default: -> { [] }
+
+    attribute :deprecated, :datetime
+  end
+end