hcloud 1.1.0 → 1.3.0

data/lib/hcloud/load_balancer.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/hash/keys'
+
+module Hcloud
+  class LoadBalancer
+    require 'hcloud/load_balancer_resource'
+
+    include EntryLoader
+
+    schema(
+      location: Location,
+      load_balancer_type: LoadBalancerType,
+      created: :time
+    )
+
+    protectable :delete
+    updatable :name
+    destructible
+
+    has_metrics
+    has_actions
+
+    %w[enable_public_interface disable_public_interface].each do |action|
+      define_method(action) do
+        prepare_request("actions/#{action}", method: :post)
+      end
+    end
+
+    def attach_to_network(network:, ip: nil)
+      raise Hcloud::Error::InvalidInput, 'no network given' if network.nil?
+
+      prepare_request('actions/attach_to_network', j: COLLECT_ARGS.call(__method__, binding))
+    end
+
+    def detach_from_network(network:)
+      raise Hcloud::Error::InvalidInput, 'no network given' if network.nil?
+
+      prepare_request('actions/detach_from_network', j: COLLECT_ARGS.call(__method__, binding))
+    end
+
+    def change_dns_ptr(ip:, dns_ptr:)
+      raise Hcloud::Error::InvalidInput, 'no IP given' if ip.blank?
+      raise Hcloud::Error::InvalidInput, 'no dns_ptr given' if dns_ptr.blank?
+
+      prepare_request('actions/change_dns_ptr', j: COLLECT_ARGS.call(__method__, binding))
+    end
+
+    def change_type(load_balancer_type:)
+      raise Hcloud::Error::InvalidInput, 'no type given' if load_balancer_type.blank?
+
+      prepare_request('actions/change_type', j: COLLECT_ARGS.call(__method__, binding))
+    end
+
+    def change_algorithm(type:)
+      raise Hcloud::Error::InvalidInput, 'no type given' if type.blank?
+
+      prepare_request('actions/change_algorithm', j: COLLECT_ARGS.call(__method__, binding))
+    end
+
+    def add_service(
+      protocol:, listen_port:, destination_port:, health_check:, proxyprotocol:, http: nil
+    )
+      validate_service_input(
+        protocol: protocol,
+        listen_port: listen_port,
+        destination_port: destination_port,
+        health_check: health_check,
+        proxyprotocol: proxyprotocol
+      )
+
+      prepare_request('actions/add_service', j: COLLECT_ARGS.call(__method__, binding))
+    end
+
+    def update_service(
+      protocol:, listen_port:, destination_port:, health_check:, proxyprotocol:, http: nil
+    )
+      validate_service_input(
+        protocol: protocol,
+        listen_port: listen_port,
+        destination_port: destination_port,
+        health_check: health_check,
+        proxyprotocol: proxyprotocol
+      )
+
+      prepare_request('actions/update_service', j: COLLECT_ARGS.call(__method__, binding))
+    end
+
+    def delete_service(listen_port:)
+      raise Hcloud::Error::InvalidInput, 'no listen_port given' if listen_port.nil?
+
+      prepare_request('actions/delete_service', j: COLLECT_ARGS.call(__method__, binding))
+    end
+
+    def add_target(type:, server: nil, label_selector: nil, ip: nil, use_private_ip: false)
+      validate_target_input(
+        type: type, server: server, label_selector: label_selector, ip: ip
+      )
+
+      prepare_request('actions/add_target', j: COLLECT_ARGS.call(__method__, binding))
+    end
+
+    def remove_target(type:, server: nil, label_selector: nil, ip: nil)
+      validate_target_input(
+        type: type, server: server, label_selector: label_selector, ip: ip
+      )
+
+      prepare_request('actions/remove_target', j: COLLECT_ARGS.call(__method__, binding))
+    end
+
+    private
+
+    def validate_service_input(
+      protocol:, listen_port:, destination_port:, health_check:, proxyprotocol:
+    )
+      raise Hcloud::Error::InvalidInput, 'no protocol given' if protocol.blank?
+      raise Hcloud::Error::InvalidInput, 'no listen_port given' if listen_port.nil?
+      raise Hcloud::Error::InvalidInput, 'no destination_port given' if destination_port.nil?
+      raise Hcloud::Error::InvalidInput, 'no health_check given' if health_check.nil?
+      raise Hcloud::Error::InvalidInput, 'no proxyprotocol given' if proxyprotocol.nil?
+    end
+
+    def validate_target_input(type:, server: nil, label_selector: nil, ip: nil)
+      raise Hcloud::Error::InvalidInput, 'no type given' if type.nil?
+
+      case type.to_sym
+      when :server
+        raise Hcloud::Error::InvalidInput, 'invalid server given' unless server.to_h.key?(:id)
+      when :ip
+        raise Hcloud::Error::InvalidInput, 'no IP given' if ip.blank?
+      when :label_selector
+        unless label_selector.to_h.key?(:selector)
+          raise Hcloud::Error::InvalidInput, 'invalid label_selector given'
+        end
+      else
+        raise Hcloud::Error::InvalidInput, 'invalid type given'
+      end
+    end
+  end
+end

data/lib/hcloud/load_balancer_resource.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Hcloud
+  class LoadBalancerResource < AbstractResource
+    filter_attributes :name, :label_selector
+
+    bind_to LoadBalancer
+
+    def [](arg)
+      case arg
+      when Integer then find_by(id: arg)
+      when String then find_by(name: arg)
+      end
+    end
+
+    def create(
+      name:, load_balancer_type:, algorithm:, location: nil, network_zone: nil,
+      network: nil, public_interface: nil, services: nil, targets: nil,
+      labels: {}
+    )
+      raise Hcloud::Error::InvalidInput, 'no name given' if name.blank?
+      raise Hcloud::Error::InvalidInput, 'no type given' if load_balancer_type.blank?
+      if !algorithm.to_h.key?(:type) || algorithm[:type].blank?
+        raise Hcloud::Error::InvalidInput, 'invalid algorithm given'
+      end
+      if location.blank? && network_zone.blank?
+        raise Hcloud::Error::InvalidInput, 'either location or network_zone must be given'
+      end
+
+      prepare_request(
+        'load_balancers', j: COLLECT_ARGS.call(__method__, binding),
+                          expected_code: 201
+      ) do |response|
+        action = Action.new(client, response[:action]) if response[:action]
+        [action, LoadBalancer.new(client, response[:load_balancer])]
+      end
+    end
+  end
+end

data/lib/hcloud/load_balancer_type.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Hcloud
+  class LoadBalancerType
+    require 'hcloud/load_balancer_type_resource'
+
+    include EntryLoader
+
+    schema(
+      deprecated: :time
+    )
+  end
+end

data/lib/hcloud/load_balancer_type_resource.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Hcloud
+  class LoadBalancerTypeResource < AbstractResource
+    filter_attributes :name
+
+    bind_to LoadBalancerType
+
+    def [](arg)
+      case arg
+      when Integer then find_by(id: arg)
+      when String then find_by(name: arg)
+      end
+    end
+  end
+end

data/lib/hcloud/network.rb

@@ -15,19 +15,36 @@ module Hcloud
     has_actions
 
     def add_subnet(type:, network_zone:, ip_range: nil)
+      raise Hcloud::Error::InvalidInput, 'no type given' if type.blank?
+      raise Hcloud::Error::InvalidInput, 'no network_zone given' if network_zone.blank?
+
       prepare_request('actions/add_subnet', j: COLLECT_ARGS.call(__method__, binding))
     end
 
     def del_subnet(ip_range:)
+      raise Hcloud::Error::InvalidInput, 'no ip_range given' if ip_range.blank?
+
       prepare_request('actions/delete_subnet', j: COLLECT_ARGS.call(__method__, binding))
     end
 
     def add_route(destination:, gateway:)
+      raise Hcloud::Error::InvalidInput, 'no destination given' if destination.blank?
+      raise Hcloud::Error::InvalidInput, 'no gateway given' if gateway.blank?
+
       prepare_request('actions/add_route', j: COLLECT_ARGS.call(__method__, binding))
     end
 
     def del_route(destination:, gateway:)
+      raise Hcloud::Error::InvalidInput, 'no destination given' if destination.blank?
+      raise Hcloud::Error::InvalidInput, 'no gateway given' if gateway.blank?
+
       prepare_request('actions/delete_route', j: COLLECT_ARGS.call(__method__, binding))
     end
+
+    def change_ip_range(ip_range:)
+      raise Hcloud::Error::InvalidInput, 'no ip_range given' if ip_range.blank?
+
+      prepare_request('actions/change_ip_range', j: COLLECT_ARGS.call(__method__, binding))
+    end
   end
 end

data/lib/hcloud/network_resource.rb

@@ -14,6 +14,9 @@ module Hcloud
     end
 
     def create(name:, ip_range:, subnets: nil, routes: nil, labels: {})
+      raise Hcloud::Error::InvalidInput, 'no name given' if name.blank?
+      raise Hcloud::Error::InvalidInput, 'no IP range given' if ip_range.blank?
+
       prepare_request(
         'networks', j: COLLECT_ARGS.call(__method__, binding),
                     expected_code: 201

data/lib/hcloud/placement_group.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Hcloud
+  class PlacementGroup
+    require 'hcloud/placement_group_resource'
+
+    include EntryLoader
+
+    schema(
+      created: :time
+    )
+
+    updatable :name
+    destructible
+  end
+end

data/lib/hcloud/placement_group_resource.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Hcloud
+  class PlacementGroupResource < AbstractResource
+    filter_attributes :type, :name, :label_selector
+
+    bind_to PlacementGroup
+
+    def [](arg)
+      return find_by(name: arg) if arg.is_a?(String)
+
+      super
+    end
+
+    # currently only spread is available
+    def create(name:, type: 'spread', labels: {})
+      if type.to_s != 'spread'
+        raise Hcloud::Error::InvalidInput, "invalid type #{type.inspect}, only 'spread' is allowed"
+      end
+      raise Hcloud::Error::InvalidInput, 'no name given' if name.blank?
+
+      prepare_request(
+        'placement_groups', j: COLLECT_ARGS.call(__method__, binding),
+                            expected_code: 201
+      ) do |response|
+        PlacementGroup.new(client, response.parsed_json[:placement_group])
+      end
+    end
+  end
+end

data/lib/hcloud/primary_ip.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Hcloud
+  class PrimaryIP
+    require 'hcloud/primary_ip_resource'
+
+    include EntryLoader
+
+    schema(
+      datacenter: Datacenter,
+      created: :time
+    )
+
+    protectable :delete
+    updatable :name, :auto_delete
+    destructible
+
+    def assign(assignee_id:, assignee_type: 'server')
+      raise Hcloud::Error::InvalidInput, 'no assignee_id given' if assignee_id.nil?
+      raise Hcloud::Error::InvalidInput, 'no assignee_type given' if assignee_type.nil?
+
+      prepare_request('actions/assign', j: COLLECT_ARGS.call(__method__, binding))
+    end
+
+    def unassign
+      prepare_request('actions/unassign', method: :post)
+    end
+
+    def change_dns_ptr(ip:, dns_ptr:)
+      raise Hcloud::Error::InvalidInput, 'no IP given' if ip.blank?
+
+      prepare_request('actions/change_dns_ptr', j: { ip: ip, dns_ptr: dns_ptr })
+    end
+  end
+end

data/lib/hcloud/primary_ip_resource.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Hcloud
+  class PrimaryIPResource < AbstractResource
+    filter_attributes :name, :label_selector, :ip
+
+    bind_to PrimaryIP
+
+    def [](arg)
+      case arg
+      when Integer then find_by(id: arg)
+      when String then find_by(name: arg)
+      end
+    end
+
+    def create(
+      name:,
+      type:,
+      assignee_id: nil,
+      assignee_type: 'server',
+      datacenter: nil,
+      auto_delete: nil,
+      labels: {}
+    )
+      raise Hcloud::Error::InvalidInput, 'no name given' if name.blank?
+
+      unless %w[ipv4 ipv6].include?(type.to_s)
+        raise Hcloud::Error::InvalidInput, 'invalid type given'
+      end
+
+      raise Hcloud::Error::InvalidInput, 'no assignee_type given' if assignee_type.blank?
+
+      if assignee_id.nil? && datacenter.nil?
+        raise Hcloud::Error::InvalidInput, 'either assignee_id or datacenter must be given'
+      end
+
+      prepare_request(
+        'primary_ips', j: COLLECT_ARGS.call(__method__, binding),
+                       expected_code: 201
+      ) do |response|
+        action = Action.new(client, response[:action]) if response[:action]
+        [action, PrimaryIP.new(client, response[:primary_ip])]
+      end
+    end
+  end
+end

data/lib/hcloud/resource_loader.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module Hcloud
+  class ResourceLoader
+    def initialize(schema, client:)
+      @schema = schema
+      @client = client
+    end
+
+    def load(data)
+      load_with_schema(@schema, data)
+    end
+
+    private
+
+    def load_with_schema(schema, data)
+      if schema.respond_to?(:call)
+        schema.call(data, @client)
+      elsif schema.is_a?(Array) && schema.count.positive? && data.is_a?(Array)
+        load_array(schema, data)
+      elsif schema.is_a?(Hash) && data.is_a?(Hash)
+        load_hash(schema, data)
+      else
+        load_single_item(schema, data)
+      end
+    end
+
+    def load_array(schema, data)
+      data.map do |item|
+        load_with_schema(schema[0], item)
+      end
+    end
+
+    def load_hash(schema, data)
+      data.map do |key, value|
+        [key, load_with_schema(schema[key], value)]
+      end.to_h
+    end
+
+    def load_single_item(definition, value)
+      if definition == :time
+        return value ? Time.parse(value) : nil
+      end
+
+      if definition.is_a?(Class) && definition.include?(EntryLoader)
+        return if value.nil?
+
+        # If value is an integer, this is the id of an object which's class can be
+        # retreived from definition. Load a future object that can on access retreive the
+        # data from the api and convert it to a proper object.
+        return Future.new(@client, definition, value) if value.is_a?(Integer)
+
+        # Otherwise the value *is* the content of the object
+        return definition.new(@client, value)
+      end
+
+      value
+    end
+  end
+end

data/lib/hcloud/server.rb

@@ -12,7 +12,24 @@ module Hcloud
       datacenter: Datacenter,
       image: Image,
       iso: Iso,
+      load_balancers: [LoadBalancer],
+      placement_group: PlacementGroup,
       private_net: [Network],
+      public_net: {
+        ipv4: lambda do |data, client|
+          Future.new(client, PrimaryIP, data[:id]) if data.to_h[:id].is_a?(Integer)
+        end,
+        ipv6: lambda do |data, client|
+          Future.new(client, PrimaryIP, data[:id]) if data.to_h[:id].is_a?(Integer)
+        end,
+        floating_ips: [FloatingIP],
+        firewalls: [
+          lambda do |data, client|
+            Future.new(client, Firewall, data[:id], raw_data: data) if data.to_h[:id].is_a?(Integer)
+          end
+        ]
+        # firewalls: [{ id: Firewall }]
+      },
       volumes: [Volume]
     )
 
@@ -21,6 +38,7 @@ module Hcloud
     destructible
 
     has_actions
+    has_metrics
 
     def enable_rescue(type: 'linux64', ssh_keys: [])
       query = COLLECT_ARGS.call(__method__, binding)
@@ -37,10 +55,15 @@ module Hcloud
     end
 
     def rebuild(image:)
+      raise Hcloud::Error::InvalidInput, 'no image given' if image.blank?
+
       prepare_request('actions/rebuild', j: { image: image }) { |j| j[:root_password] }
     end
 
-    def change_type(server_type:, upgrade_disk: nil)
+    def change_type(server_type:, upgrade_disk:)
+      raise Hcloud::Error::InvalidInput, 'no server_type given' if server_type.blank?
+      raise Hcloud::Error::InvalidInput, 'no upgrade_disk given' if upgrade_disk.nil?
+
       prepare_request('actions/change_type', j: COLLECT_ARGS.call(__method__, binding))
     end
 
@@ -51,21 +74,47 @@ module Hcloud
     end
 
     def attach_iso(iso:)
+      raise Hcloud::Error::InvalidInput, 'no iso given' if iso.blank?
+
       prepare_request('actions/attach_iso', j: { iso: iso })
     end
 
     def attach_to_network(network:, ip: nil, alias_ips: nil)
+      raise Hcloud::Error::InvalidInput, 'no network given' if network.nil?
+
       prepare_request('actions/attach_to_network', j: COLLECT_ARGS.call(__method__, binding))
     end
 
     def detach_from_network(network:)
+      raise Hcloud::Error::InvalidInput, 'no network given' if network.nil?
+
       prepare_request('actions/detach_from_network', j: { network: network })
     end
 
+    def add_to_placement_group(placement_group:)
+      raise Hcloud::Error::InvalidInput, 'no placement_group given' if placement_group.nil?
+
+      prepare_request('actions/add_to_placement_group', j: COLLECT_ARGS.call(__method__, binding))
+    end
+
+    def change_alias_ips(alias_ips:, network:)
+      raise Hcloud::Error::InvalidInput, 'no alias_ips given' if alias_ips.to_a.count.zero?
+      raise Hcloud::Error::InvalidInput, 'no network given' if network.nil?
+
+      prepare_request('actions/change_alias_ips', j: COLLECT_ARGS.call(__method__, binding))
+    end
+
+    def change_dns_ptr(ip:, dns_ptr:)
+      raise Hcloud::Error::InvalidInput, 'no IP given' if ip.blank?
+      raise Hcloud::Error::InvalidInput, 'no dns_ptr given' if dns_ptr.blank?
+
+      prepare_request('actions/change_dns_ptr', j: COLLECT_ARGS.call(__method__, binding))
+    end
+
     %w[
       poweron poweroff shutdown reboot reset
       disable_rescue disable_backup detach_iso
-      request_console
+      request_console remove_from_placement_group
     ].each do |action|
       define_method(action) do
         prepare_request("actions/#{action}", method: :post)

data/lib/hcloud/server_resource.rb

@@ -12,15 +12,23 @@ module Hcloud
                location: nil,
                start_after_create: nil,
                ssh_keys: [],
+               public_net: nil,
+               firewalls: nil,
                networks: [],
+               placement_group: nil,
                user_data: nil,
+               volumes: nil,
+               automount: nil,
                labels: {})
       prepare_request('servers', j: COLLECT_ARGS.call(__method__, binding),
                                  expected_code: 201) do |response|
         [
           Action.new(client, response.parsed_json[:action]),
           Server.new(client, response.parsed_json[:server]),
-          response.parsed_json[:root_password]
+          response.parsed_json[:root_password],
+          response.parsed_json[:next_actions].to_a.map do |action|
+            Action.new(client, action)
+          end
         ]
       end
     end

data/lib/hcloud/ssh_key.rb

@@ -6,6 +6,10 @@ module Hcloud
 
     include EntryLoader
 
+    schema(
+      created: :time
+    )
+
     updatable :name
     destructible
   end

data/lib/hcloud/ssh_key_resource.rb

@@ -2,7 +2,7 @@
 
 module Hcloud
   class SSHKeyResource < AbstractResource
-    filter_attributes :name, :label_selector
+    filter_attributes :name, :label_selector, :fingerprint
 
     def [](arg)
       case arg
@@ -12,6 +12,12 @@ module Hcloud
     end
 
     def create(name:, public_key:, labels: {})
+      raise Hcloud::Error::InvalidInput, 'no name given' if name.blank?
+
+      unless public_key.to_s.starts_with?('ssh')
+        raise Hcloud::Error::InvalidInput, 'no valid SSH key given'
+      end
+
       prepare_request(
         'ssh_keys', j: COLLECT_ARGS.call(__method__, binding),
                     expected_code: 201

data/lib/hcloud/typhoeus_ext.rb

@@ -30,7 +30,7 @@ module Hcloud
     def parsed_json
       return {} if code == 204
 
-      @parsed_json ||= Oj.load(body, symbol_keys: true).tap do |json|
+      @parsed_json ||= Oj.load(body, symbol_keys: true, mode: :compat).tap do |json|
         next unless request.hydra
 
         check_for_error(

data/lib/hcloud/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Hcloud
-  VERSION = '1.1.0'
+  VERSION = '1.3.0'
 end

data/lib/hcloud/volume.rb

@@ -17,7 +17,9 @@ module Hcloud
 
     has_actions
 
-    def attach(server:, automount:)
+    def attach(server:, automount: nil)
+      raise Hcloud::Error::InvalidInput, 'no server given' if server.nil?
+
       prepare_request('actions/attach', j: COLLECT_ARGS.call(__method__, binding))
     end
 
@@ -26,6 +28,8 @@ module Hcloud
     end
 
     def resize(size:)
+      raise Hcloud::Error::InvalidInput, 'invalid size given' unless size.to_i > self.size
+
       prepare_request('actions/resize', j: COLLECT_ARGS.call(__method__, binding))
     end
   end

data/lib/hcloud/volume_resource.rb

@@ -2,7 +2,7 @@
 
 module Hcloud
   class VolumeResource < AbstractResource
-    filter_attributes :name, :label_selector
+    filter_attributes :name, :label_selector, :status
 
     def [](arg)
       case arg
@@ -12,6 +12,12 @@ module Hcloud
     end
 
     def create(size:, name:, automount: nil, format: nil, location: nil, server: nil, labels: {})
+      raise Hcloud::Error::InvalidInput, 'no name given' if name.blank?
+      raise Hcloud::Error::InvalidInput, 'invalid size given' unless size.to_i >= 10
+      if location.blank? && server.nil?
+        raise Hcloud::Error::InvalidInput, 'location or server must be given'
+      end
+
       prepare_request(
         'volumes', j: COLLECT_ARGS.call(__method__, binding),
                    expected_code: 201