hetznercloud 1.0.0

data/lib/hcloud/entity.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module HCloud
+  class Entity
+    include ActiveModel::Attributes
+    include ActiveModel::AttributeAssignment
+
+    def initialize(attributes = {})
+      super()
+
+      assign_attributes(attributes) if attributes
+    end
+
+    def inspect
+      "#<#{self.class} #{attributes.filter_map { |name, value| "#{name}: #{value.inspect}" }.join(', ')}>"
+    end
+
+    def to_h
+      attributes
+        .transform_values { |v| v.try(:to_h) || v }
+    end
+  end
+end

data/lib/hcloud/errors.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module HCloud
+  module Errors
+    class ActionFailed < Error; end
+    class Conflict < Error; end
+    class Error < StandardError; end
+    class FirewallResourceNotFound < Error; end
+    class Forbidden < Error; end
+    class IPNotAvailable < Error; end
+    class IncompatibleNetworkType < Error; end
+    class InvalidInput < Error; end
+    class JSONError < Error; end
+    class Locked < Error; end
+    class Maintenance < Error; end
+    class NetworksOverlap < Error; end
+    class NoSpaceLeftInLocation < Error; end
+    class NoSubnetAvailable < Error; end
+    class NotFound < Error; end
+    class PlacementError < Error; end
+    class PlacementError < Error; end
+    class Protected < Error; end
+    class RateLimitExceeded < Error; end
+    class ResourceLimitExceeded < Error; end
+    class ResourceUnavailable < Error; end
+    class ResourceInUse < Error; end
+    class ServerAlreadyAdded < Error; end
+    class ServerAlreadyAttached < Error; end
+    class ServerError < Error; end
+    class ServiceError < Error; end
+    class TokenReadonly < Error; end
+    class Unauthorized < Error; end
+    class UniquenessError < Error; end
+    class UnsupportedError < Error; end
+  end
+end

data/lib/hcloud/http.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "http"
+
+module HCloud
+  class HTTP
+    attr_reader :access_token, :endpoint, :logger, :timeout
+
+    def initialize(access_token, endpoint, logger, timeout = 10)
+      @access_token = access_token
+      @endpoint = endpoint
+      @logger = logger
+      @timeout = timeout
+    end
+
+    def get(path, params = {})
+      response = http
+        .get(url_for(path), params: transform_params(params))
+
+      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)
+    end
+
+    def put(path, body = {})
+      response = http
+        .put(url_for(path), json: body)
+
+      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)
+    end
+
+    def post(path, body = {})
+      response = http
+        .post(url_for(path), json: body)
+
+      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)
+    end
+
+    def delete(path)
+      response = http
+        .delete(url_for(path))
+
+      return if response.status.success?
+
+      data = response
+        .parse(:json)
+        .deep_symbolize_keys
+
+      raise Errors.const_get(data.dig(:error, :code).camelize), data.dig(:error, :message)
+    end
+
+    private
+
+    def http
+      @http ||= ::HTTP
+        .headers(accept: "application/json", user_agent: "#{HCloud::NAME}/#{HCloud::VERSION}")
+        .timeout(timeout)
+        .use(logging: { logger: logger })
+        .encoding("utf-8")
+        .auth("Bearer #{access_token}")
+    end
+
+    def url_for(path)
+      "#{endpoint}#{path}"
+    end
+
+    def transform_params(params)
+      params
+        .transform_values do |value|
+        # Don't transform if value is single argument: { sort: :id }
+        next value unless value.respond_to?(:each)
+
+        value.map do |element|
+          # Don't transform if element is single argument: { sort: [:id] }
+          next element unless element.respond_to?(:each)
+
+          # Join elements with : { sort: [id: :asc] }
+          element.to_a.join(":")
+        end
+      end
+        .compact
+    end
+  end
+end

data/lib/hcloud/resource.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module HCloud
+  class Resource
+    include ActiveModel::Attributes
+    include ActiveModel::AttributeAssignment
+
+    include Concerns
+
+    def initialize(attributes = {})
+      super()
+
+      assign_attributes(attributes) if attributes
+    end
+
+    delegate :[], to: :attributes
+
+    def inspect
+      "#<#{self.class} #{attributes.filter_map { |name, value| "#{name}: #{value.inspect}" }.join(', ')}>"
+    end
+
+    def to_h
+      {
+        id: id,
+      }
+    end
+
+    def ==(other)
+      id && id == other.id
+    end
+
+    def self.resource_name
+      name.demodulize.underscore
+    end
+
+    def self.client
+      HCloud::Client.connection
+    end
+
+    delegate :client, :resource_name, to: :class
+  end
+end

data/lib/hcloud/resource_type.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module HCloud
+  class ResourceType
+    class_attribute :resource_class_name
+
+    attr_reader :array
+
+    def initialize(array: false)
+      @array = array
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity
+    def cast(value)
+      case value
+      when nil, []
+        array? ? [] : nil
+      when resource_class # Class
+        value
+      when Integer # ID
+        resource_class.new(id: value)
+      when String # Name
+        resource_class.new(name: value)
+      when Hash # Attribute hash
+        resource_class.new(value)
+      when Array # List
+        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
+    end
+
+    alias array? array
+
+    def assert_valid_value(_); end
+
+    # rubocop:disable Naming/MethodName
+    def self.Type(class_name)
+      Class
+        .new(ResourceType) { self.resource_class_name = class_name }
+        .tap { |klass| HCloud.const_set(:"#{class_name.demodulize}ResourceType", klass) }
+    end
+    # rubocop:enable Naming/MethodName
+  end
+end
+
+ActiveModel::Type.register(:action, HCloud::ResourceType.Type("HCloud::Action"))
+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(: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(:image, HCloud::ResourceType.Type("HCloud::Image"))
+ActiveModel::Type.register(:iso, HCloud::ResourceType.Type("HCloud::ISO"))
+ActiveModel::Type.register(:location, HCloud::ResourceType.Type("HCloud::Location"))
+ActiveModel::Type.register(:placement_group, HCloud::ResourceType.Type("HCloud::PlacementGroup"))
+ActiveModel::Type.register(:price, HCloud::ResourceType.Type("HCloud::Price"))
+ActiveModel::Type.register(:protection, HCloud::ResourceType.Type("HCloud::Protection"))
+ActiveModel::Type.register(:rule, HCloud::ResourceType.Type("HCloud::Rule"))
+ActiveModel::Type.register(:server, HCloud::ResourceType.Type("HCloud::Server"))
+ActiveModel::Type.register(:server_type, HCloud::ResourceType.Type("HCloud::ServerType"))
+ActiveModel::Type.register(:ssh_key, HCloud::ResourceType.Type("HCloud::SSHKey"))
+ActiveModel::Type.register(:volume, HCloud::ResourceType.Type("HCloud::Volume"))

data/lib/hcloud/resources/action.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module HCloud
+  ##
+  # Represents an action
+  #
+  # == List all actions
+  #
+  #     HCloud::Action.all
+  #     # => [#<HCloud::Action id: 1, ...>, ...]
+  #
+  # == Sort actions
+  #
+  #     HCloud::Action.all.sort(command: :desc)
+  #     # => [#<HCloud::Action id: 1, ...>, ...]
+  #
+  #     HCloud::Action.all.sort(:id, command: :asc)
+  #     # => [#<HCloud::Action id: 1, ...>, ...]
+  #
+  # == Search actions
+  #
+  #     HCloud::Action.all.where(command: "my_action")
+  #     # => #<HCloud::Action id: 1, ...>
+  #
+  #     HCloud::Action.all.where(status: "success")
+  #     # => #<HCloud::Action id: 1, ...>
+  #
+  # == Find action by ID
+  #
+  #     HCloud::Action.find(1)
+  #     # => #<HCloud::Action id: 1, ...>
+  #
+  class Action < Resource
+    queryable
+
+    attribute :id, :integer
+    attribute :command
+
+    attribute :started, :datetime
+    attribute :finished, :datetime
+    attribute :progress, :integer
+
+    attribute :status
+    attribute :error, :error
+
+    # TODO: return array of resources
+    attribute :resources, array: true, default: -> { [] }
+  end
+end

data/lib/hcloud/resources/datacenter.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module HCloud
+  ##
+  # Represents a datacenter
+  #
+  # == List all datacenters
+  #
+  #     HCloud::Datacenter.all
+  #     # => [#<HCloud::Datacenter id: 2, ...>, ...]
+  #
+  # == Search datacenters
+  #
+  #     HCloud::Datacenter.all.where(name: "fsn1-dc8")
+  #     # => #<HCloud::Datacenter id: 2, ...>
+  #
+  # == Find datacenter by ID
+  #
+  #     HCloud::Datacenter.find(2)
+  #     # => #<HCloud::Datacenter id: 2, ...>
+  #
+  # == Get datacenter recommendation
+  #
+  #     HCloud::Datacenter.recommendation
+  #     # => #<HCloud::Datacenter id: 2, ...>
+  #
+  class Datacenter < Resource
+    queryable
+
+    attribute :id, :integer
+    attribute :name
+    attribute :description
+
+    attribute :location, :location
+    attribute :server_types, :datacenter_server_type
+
+    def self.recommendation
+      find client
+        .get("/#{resource_name.pluralize}")
+        .fetch(:recommendation)
+    end
+  end
+end

data/lib/hcloud/resources/firewall.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module HCloud
+  ##
+  # Represents a firewall
+  #
+  # == List all firewalls
+  #
+  #     HCloud::Firewall.all
+  #     # => [#<HCloud::Firewall id: 1, ...>, ...]
+  #
+  # == Sort firewalls
+  #
+  #     HCloud::Firewall.all.sort(name: :desc)
+  #     # => [#<HCloud::Firewall id: 1, ...>, ...]
+  #
+  #     HCloud::Firewall.all.sort(:id, name: :asc)
+  #     # => [#<HCloud::Firewall id: 1, ...>, ...]
+  #
+  # == Search firewalls
+  #
+  #     HCloud::Firewall.all.where(name: "my_irewall")
+  #     # => #<HCloud::Firewall id: 1, ...>
+  #
+  # == Find firewall by ID
+  #
+  #     HCloud::Firewall.find(1)
+  #     # => #<HCloud::Firewall id: 1, ...>
+  #
+  # == Create firewall
+  #
+  #     firewall = HCloud::Firewall.new(name: "my_firewall")
+  #     firewall.create
+  #     firewall.created?
+  #     # => true
+  #
+  #     firewall = HCloud::Firewall.create(name: "my_firewall")
+  #     # => #<HCloud::Firewall id: 1, ...>
+  #
+  # == Update firewall
+  #
+  #     firewall = HCloud::Firewall.find(1)
+  #     firewall.name = "another_firewall"
+  #     firewall.update
+  #
+  # == Delete firewall
+  #
+  #     firewall = HCloud::Firewall.find(1)
+  #     firewall.delete
+  #     firewall.deleted?
+  #     # => true
+  #
+  # TODO: firewall actions
+  #
+  class Firewall < Resource
+    queryable
+    creatable
+    updatable
+    deletable
+
+    attribute :id, :integer
+    attribute :name
+
+    attribute :applied_to, :applied_to, array: true, default: -> { [] }
+    # Only used for creation
+    attribute :apply_to, :apply_to, array: true, default: -> { [] }
+
+    attribute :rules, :rule, array: true, default: -> { [] }
+
+    attribute :labels, default: -> { {} }
+
+    def creatable_attributes
+      [:name, :labels, :apply_to, :rules]
+    end
+
+    def updatable_attributes
+      [:name, :labels]
+    end
+  end
+end

data/lib/hcloud/resources/floating_ip.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module HCloud
+  ##
+  # Represents a floating IP
+  #
+  # == List all floating IPs
+  #
+  #     HCloud::FloatingIP.all
+  #     # => [#<HCloud::FloatingIP id: 1, ...>, ...]
+  #
+  # == Sort floating IPs
+  #
+  #     HCloud::FloatingIP.all.sort(id: :asc)
+  #     # => [#<HCloud::FloatingIP id: 1, ...>, ...]
+  #
+  #     HCloud::FloatingIP.all.sort(:id, created: :asc)
+  #     # => [#<HCloud::FloatingIP id: 1, ...>, ...]
+  #
+  # == Search floating IPs
+  #
+  #     HCloud::FloatingIP.all.where(name: "my_floating_ip")
+  #     # => #<HCloud::FloatingIP id: 1, ...>
+  #
+  # == Find floating IP by ID
+  #
+  #     HCloud::FloatingIP.find(1)
+  #     # => #<HCloud::FloatingIP id: 1, ...>
+  #
+  # == Create floating IP
+  #
+  #     floating IP = HCloud::FloatingIP.new(name: "my_floating_ip", type: "ipv4", home_location: "fsn1")
+  #     floating IP.create
+  #     floating IP.created?
+  #     # => true
+  #
+  #     firewall = HCloud::FloatingIP.create(name: "my_floating_ip")
+  #     # => #<HCloud::FloatingIP id: 1, ...>
+  #
+  # == Update floating IP
+  #
+  #     floating IP = HCloud::FloatingIP.find(1)
+  #     floating IP.name = "another_floating_ip"
+  #     floating IP.update
+  #
+  # == Delete floating IP
+  #
+  #     floating IP = HCloud::FloatingIP.find(1)
+  #     floating IP.delete
+  #     floating IP.deleted?
+  #     # => true
+  #
+  # = Actions
+  # == List actions
+  #
+  #     actions = HCloud::FloatingIP.find(1).actions
+  #     # => [#<HCloud::Action id: 1, ...>, ...]
+  #
+  # == Sort actions
+  #
+  #     HCloud::FloatingIP.find(1).actions.sort(finished: :desc)
+  #     # => [#<HCloud::Action id: 1, ...>, ...]
+  #
+  #     HCloud::FloatingIP.find(1).actions.sort(:command, finished: :asc)
+  #     # => [#<HCloud::Actions id: 1, ...>, ...]
+  #
+  # == Search actions
+  #
+  #     HCloud::FloatingIP.find(1).actions.where(command: "assign_floating_ip")
+  #     # => #<HCloud::Action id: 1, ...>
+  #
+  #     HCloud::FloatingIP.find(1).actions.where(status: "success")
+  #     # => #<HCloud::Action id: 1, ...>
+  #
+  # == Find action by ID
+  #
+  #     HCloud::FloatingIP.find(1).actions.find(1)
+  #     # => #<HCloud::Action id: 1, ...>
+  #
+  # = Floating IP-specific actions
+  # == Assign a floating IP to a server
+  #
+  #     HCloud::FloatingIP.find(1).assign(server: 1)
+  #     # => #<HCloud::Action id: 1, ...>
+  #
+  # == Unassign a floating IP from a server
+  #
+  #     HCloud::FloatingIP.find(1).unassign
+  #     # => #<HCloud::Action id: 1, ...>
+  #
+  # == Change reverse DNS entry
+  #
+  #     HCloud::FloatingIP.find(1).change_dns_ptr(dns_ptr: "server.example.com", ip: "1.2.3.4")
+  #     # => #<HCloud::Action id: 1, ...>
+  #
+  # == Change protection
+  #
+  #     HCloud::FloatingIP.find(1).change_protection(delete: true)
+  #     # => #<HCloud::Action id: 1, ...>
+  #
+  class FloatingIP < Resource
+    actionable
+    queryable
+    creatable
+    updatable
+    deletable
+
+    attribute :id, :integer
+    attribute :name
+    attribute :description
+
+    attribute :type
+    attribute :ip
+    attribute :dns_ptr, :dns_pointer, array: true, default: -> { [] }
+
+    attribute :blocked, :boolean
+
+    attribute :home_location, :location
+
+    attribute :protection, :protection
+
+    # TODO: return Server object
+    attribute :server, :integer
+
+    attribute :labels, default: -> { {} }
+
+    alias blocked? blocked
+
+    action :assign
+    action :unassign
+
+    action :change_dns_ptr
+
+    action :change_protection
+
+    def creatable_attributes
+      [:name, :description, :type, :labels, home_location: [:id, :name], server: [:id, :name]]
+    end
+
+    def updatable_attributes
+      [:name, :labels]
+    end
+  end
+end