hcloud 0.1.2 → 1.0.0

data/lib/hcloud/image_resource.rb

@@ -1,46 +1,15 @@
+# frozen_string_literal: true
+
 module Hcloud
   class ImageResource < AbstractResource
-    def all
-      mj('images') do |j|
-        j.flat_map { |x| x['images'].map { |x| Image.new(x, self, client) } }
-      end
-    end
+    filter_attributes :type, :bound_to, :name
+
+    bind_to Image
 
     def [](arg)
       case arg
-      when Integer
-        begin
-          find(arg)
-        rescue Error::NotFound
-        end
-      when String
-        find_by(name: arg)
-      end
-    end
-
-    def find(id)
-      Image.new(
-        Oj.load(request("images/#{id.to_i}").run.body)['image'],
-        self,
-        client
-      )
-    end
-
-    def where(sort: nil, type: nil, bound_to: nil, name: nil)
-      query = {}
-      method(:where).parameters.inject(query) do |r, x|
-        (var = eval(x.last.to_s)).nil? ? r : r.merge!(x.last => var)
-      end
-      mj('images', q: query) do |j|
-        j.flat_map { |x| x['images'].map { |x| Image.new(x, self, client) } }
-      end
-    end
-
-    def find_by(name:)
-      j = Oj.load(request('images', q: { name: name }).run.body)['images']
-      return if j.none?
-      j.each do |x|
-        return Image.new(x, self, client)
+      when Integer then find_by(id: arg)
+      when String then find_by(name: arg)
       end
     end
   end

data/lib/hcloud/iso.rb

@@ -1,10 +1,13 @@
+# frozen_string_literal: true
+
 module Hcloud
   class Iso
     Attributes = {
       id: nil,
       name: nil,
       description: nil,
-      type: nil
+      type: nil,
+      deprecated: :time
     }.freeze
 
     include EntryLoader

data/lib/hcloud/iso_resource.rb

@@ -1,36 +1,15 @@
+# frozen_string_literal: true
+
 module Hcloud
   class IsoResource < AbstractResource
-    def all
-      mj('isos') do |j|
-        j.flat_map { |x| x['isos'].map { |x| Iso.new(x, self, client) } }
-      end
-    end
+    filter_attributes :name
+
+    bind_to Iso
 
     def [](arg)
       case arg
-      when Integer
-        begin
-          find(arg)
-        rescue Error::NotFound
-        end
-      when String
-        find_by(name: arg)
-      end
-    end
-
-    def find(id)
-      Iso.new(
-        Oj.load(request("isos/#{id.to_i}").run.body)['iso'],
-        self,
-        client
-      )
-    end
-
-    def find_by(name:)
-      j = Oj.load(request('isos', q: { name: name }).run.body)['isos']
-      return if j.none?
-      j.each do |x|
-        return Iso.new(x, self, client)
+      when Integer then find_by(id: arg)
+      when String then find_by(name: arg)
       end
     end
   end

data/lib/hcloud/location.rb

@@ -1,14 +1,8 @@
+# frozen_string_literal: true
+
 module Hcloud
   class Location
-    Attributes = {
-      id: nil,
-      name: nil,
-      description: nil,
-      country: nil,
-      city: nil,
-      longitude: nil,
-      latitude: nil
-    }.freeze
+    require 'hcloud/location_resource'
 
     include EntryLoader
   end

data/lib/hcloud/location_resource.rb

@@ -1,36 +1,15 @@
+# frozen_string_literal: true
+
 module Hcloud
   class LocationResource < AbstractResource
-    def all
-      mj('locations') do |j|
-        j.flat_map { |x| x['locations'].map { |x| Location.new(x, self, client) } }
-      end
-    end
+    filter_attributes :name
 
-    def find(id)
-      Location.new(
-        Oj.load(request("locations/#{id}").run.body)['location'],
-        self,
-        client
-      )
-    end
-
-    def find_by(name:)
-      x = Oj.load(request('locations', q: { name: name }).run.body)['locations']
-      return nil if x.none?
-      x.each do |s|
-        return Location.new(s, self, client)
-      end
-    end
+    bind_to Location
 
     def [](arg)
       case arg
-      when Integer
-        begin
-          find(arg)
-        rescue Error::NotFound
-        end
-      when String
-        find_by(name: arg)
+      when Integer then find_by(id: arg)
+      when String then find_by(name: arg)
       end
     end
   end

data/lib/hcloud/network.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Hcloud
+  class Network
+    include EntryLoader
+
+    schema(
+      created: :time
+    )
+
+    protectable :delete
+    updatable :name
+    destructible
+
+    has_actions
+
+    def add_subnet(type:, ip_range: nil, network_zone:)
+      prepare_request('actions/add_subnet', j: COLLECT_ARGS.call(__method__, binding))
+    end
+
+    def del_subnet(ip_range:)
+      prepare_request('actions/del_subnet', j: COLLECT_ARGS.call(__method__, binding))
+    end
+
+    def add_route(destination:, gateway:)
+      prepare_request('actions/add_route', j: COLLECT_ARGS.call(__method__, binding))
+    end
+
+    def del_route(destination:, gateway:)
+      prepare_request('actions/del_route', j: COLLECT_ARGS.call(__method__, binding))
+    end
+  end
+end

data/lib/hcloud/network_resource.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Hcloud
+  class NetworkResource < AbstractResource
+    filter_attributes :name
+
+    bind_to Network
+
+    def [](arg)
+      case arg
+      when Integer then find_by(id: arg)
+      when String then find_by(name: arg)
+      end
+    end
+
+    def create(name:, ip_range:, subnets: nil, routes: nil)
+      prepare_request(
+        'networks', j: COLLECT_ARGS.call(__method__, binding),
+                    expected_code: 201
+      ) do |response|
+        Network.new(client, response.parsed_json[:network])
+      end
+    end
+  end
+end

data/lib/hcloud/pagination.rb

@@ -1,14 +1,7 @@
+# frozen_string_literal: true
+
 module Hcloud
   class Pagination
-    Attributes = {
-      page: nil,
-      per_page: nil,
-      previous_page: nil,
-      next_page: nil,
-      last_page: nil,
-      total_entries: nil
-    }.freeze
-
     include EntryLoader
   end
 end

data/lib/hcloud/server.rb

@@ -1,109 +1,76 @@
+# frozen_string_literal: true
+
 module Hcloud
   class Server
-    Attributes = {
-      id: nil,
-      name: nil,
-      status: nil,
+    require 'hcloud/server_resource'
+
+    include EntryLoader
+
+    schema(
       created: :time,
-      public_net: nil,
       server_type: ServerType,
       datacenter: Datacenter,
-      image: Image,
-      iso: nil,
-      rescue_enabled: nil,
-      locked: nil,
-      backup_window: nil,
-      outgoing_traffic: nil,
-      ingoing_traffic: nil,
-      included_traffic: nil
-    }.freeze
-
-    include EntryLoader
+      image: Image
+    )
 
-    def update(name:)
-      Server.new(
-        Oj.load(request(base_path, j: { name: name }, method: :put).run.body)['server'],
-        parent,
-        client
-      )
-    end
+    protectable :delete, :rebuild
+    updatable :name
+    destructible
 
-    def destroy
-      action(request(base_path, method: :delete))[0]
-    end
+    has_actions
 
     def enable_rescue(type: 'linux64', ssh_keys: [])
-      query = {}
-      method(:enable_rescue).parameters.inject(query) do |r, x|
-        (var = eval(x.last.to_s)).nil? ? r : r.merge!(x.last => var)
-      end
-      a, j = action(request(base_path('actions/enable_rescue'), j: query))
-      [a, j['root_password']]
+      query = COLLECT_ARGS.call(__method__, binding)
+      prepare_request('actions/enable_rescue', j: query) { |j| j[:root_password] }
     end
 
     def reset_password
-      a, j = action(request(base_path('actions/reset_password'), method: :post))
-      [a, j['root_password']]
+      prepare_request('actions/reset_password', method: :post) { |j| j[:root_password] }
     end
 
     def create_image(description: nil, type: nil)
-      query = {}
-      method(:create_image).parameters.inject(query) do |r, x|
-        (var = eval(x.last.to_s)).nil? ? r : r.merge!(x.last => var)
-      end
-      a, j = action(request(base_path('actions/create_image'), j: query))
-      [a, Image.new(j['image'], parent, client)]
+      query = COLLECT_ARGS.call(__method__, binding)
+      prepare_request('actions/create_image', j: query) { |j| Image.new(client, j[:image]) }
     end
 
     def rebuild(image:)
-      a, j = action(request(base_path('actions/rebuild'), j: { image: image }))
-      [a, j['root_password']]
+      prepare_request('actions/rebuild', j: { image: image }) { |j| j[:root_password] }
     end
 
     def change_type(server_type:, upgrade_disk: nil)
-      query = {}
-      method(:change_type).parameters.inject(query) do |r, x|
-        (var = eval(x.last.to_s)).nil? ? r : r.merge!(x.last => var)
-      end
-      action(request(base_path('actions/change_type'), j: query))[0]
+      prepare_request('actions/change_type', j: COLLECT_ARGS.call(__method__, binding))
     end
 
-    def enable_backup(backup_window:)
-      action(request(base_path('actions/enable_backup'),
-                     j: { backup_window: backup_window }))[0]
+    # Specifying a backup window is not supported anymore. We keep this method
+    # to ensure backwards compatibility, but ignore the argument if provided.
+    def enable_backup(**_kwargs)
+      prepare_request('actions/enable_backup', method: :post)
     end
 
     def attach_iso(iso:)
-      action(request(base_path('actions/attach_iso'),
-                     j: { iso: iso }))[0]
+      prepare_request('actions/attach_iso', j: { iso: iso })
+    end
+
+    def attach_to_network(network:, ip: nil, alias_ips: nil)
+      prepare_request('actions/attach_to_network', j: COLLECT_ARGS.call(__method__, binding))
+    end
+
+    def detach_from_network(network:)
+      prepare_request('actions/detach_from_network', j: { network: network })
     end
 
     %w[
       poweron poweroff shutdown reboot reset
       disable_rescue disable_backup detach_iso
+      request_console
     ].each do |action|
       define_method(action) do
-        action(request(base_path("actions/#{action}"), method: :post))[0]
+        prepare_request("actions/#{action}", method: :post)
       end
     end
 
-    def actions
-      ActionResource.new(client: client, parent: self, base_path: base_path)
-    end
-
-    private
-
-    def action(request)
-      j = Oj.load(request.run.body)
-      [
-        Action.new(j['action'], parent, client),
-        j
-      ]
-    end
-
-    def base_path(ext = nil)
-      return ["servers/#{id}", ext].compact.join('/') unless id.nil?
-      raise ResourcePathError, 'Unable to build resource path. Id is nil.'
+    def request_console
+      prepare_request('actions/request_console', method: :post) { |j| [j[:wss_url], j[:password]] }
     end
   end
 end

data/lib/hcloud/server_resource.rb

@@ -1,5 +1,11 @@
+# frozen_string_literal: true
+
 module Hcloud
   class ServerResource < AbstractResource
+    filter_attributes :status, :name
+
+    bind_to Server
+
     def create(name:,
                server_type:,
                datacenter: nil,
@@ -7,48 +13,22 @@ module Hcloud
                start_after_create: nil,
                image:,
                ssh_keys: [],
+               networks: [],
                user_data: nil)
-      query = {}
-      method(:create).parameters.inject(query) do |r, x|
-        (var = eval(x.last.to_s)).nil? ? r : r.merge!(x.last => var)
-      end
-      j = Oj.load(request('servers', j: query, code: 200).run.body)
-      [
-        Action.new(j['action'], self, client),
-        Server.new(j['server'], self, client),
-        j['root_password']
-      ]
-    end
-
-    def all
-      mj('servers') do |j|
-        j.flat_map { |x| x['servers'].map { |x| Server.new(x, self, client) } }
+      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]
+        ]
       end
     end
 
-    def find(id)
-      Server.new(
-        Oj.load(request("servers/#{id.to_i}").run.body)['server'], self, client
-      )
-    end
-
     def [](arg)
       case arg
-      when Integer
-        begin
-          find(arg)
-        rescue Error::NotFound
-        end
-      when String
-        find_by(name: arg)
-      end
-    end
-
-    def find_by(name:)
-      x = Oj.load(request('servers', q: { name: name }).run.body)['servers']
-      return nil if x.none?
-      x.each do |s|
-        return Server.new(s, self, client)
+      when Integer then find_by(id: arg)
+      when String then find_by(name: arg)
       end
     end
   end