vultr 0.4.3 → 1.0.0

data/lib/vultr/resources/bare_metal.rb

@@ -0,0 +1,79 @@
+module Vultr
+  class BareMetalResource < Resource
+    def list(**params)
+      response = get_request("bare-metals", params: params)
+      Collection.from_response(response, key: "bare_metals", type: BareMetal)
+    end
+
+    def create(**attributes)
+      BareMetal.new post_request("bare-metals", body: attributes).body.dig("bare_metal")
+    end
+
+    def retrieve(baremetal_id:)
+      BareMetal.new get_request("bare-metals/#{baremetal_id}").body.dig("bare_metal")
+    end
+
+    def update(baremetal_id:, **attributes)
+      BareMetal.new patch_request("bare-metals/#{baremetal_id}", body: attributes).body.dig("bare_metal")
+    end
+
+    def delete(baremetal_id:)
+      delete_request("bare-metals/#{baremetal_id}")
+    end
+
+    def start(baremetal_id:)
+      post_request("bare-metals/#{baremetal_id}/start", body: {})
+    end
+
+    def reboot(baremetal_id:)
+      post_request("bare-metals/#{baremetal_id}/reboot", body: {})
+    end
+
+    def reinstall(baremetal_id:)
+      BareMetal.new post_request("bare-metals/#{baremetal_id}/reinstall", body: {}).body.dig("bare_metal")
+    end
+
+    def halt(baremetal_id:)
+      post_request("bare-metals/#{baremetal_id}/halt", body: {})
+    end
+
+    def bandwidth(baremetal_id:)
+      Object.new get_request("bare-metals/#{baremetal_id}/bandwidth").body.dig("bandwidth")
+    end
+
+    def user_data(baremetal_id:)
+      Object.new get_request("bare-metals/#{baremetal_id}/user-data").body.dig("user_data")
+    end
+
+    def upgrades(baremetal_id:, **params)
+      Object.new get_request("bare-metals/#{baremetal_id}/upgrades", params: params).body.dig("upgrades")
+    end
+
+    def vnc(baremetal_id:)
+      Object.new get_request("bare-metals/#{baremetal_id}/vnc").body.dig("vnc")
+    end
+
+    def list_ipv4(baremetal_id:)
+      response = get_request("bare-metals/#{baremetal_id}/ipv4")
+      Collection.from_response(response, key: "ipv4s", type: Object)
+    end
+
+    def list_ipv6(baremetal_id:)
+      response = get_request("bare-metals/#{baremetal_id}/ipv6")
+      Collection.from_response(response, key: "ipv6s", type: Object)
+    end
+
+    # Bulk operations
+    def halt_instances(baremetal_ids:)
+      post_request("bare-metals/halt", body: {baremetal_ids: Array(baremetal_ids)})
+    end
+
+    def reboot_instances(baremetal_ids:)
+      post_request("bare-metals/reboot", body: {baremetal_ids: Array(baremetal_ids)})
+    end
+
+    def start_instances(baremetal_ids:)
+      post_request("bare-metals/start", body: {baremetal_ids: Array(baremetal_ids)})
+    end
+  end
+end

data/lib/vultr/resources/block_storage.rb

@@ -0,0 +1,32 @@
+module Vultr
+  class BlockStorageResource < Resource
+    def list(**params)
+      response = get_request("blocks", params: params)
+      Collection.from_response(response, key: "blocks", type: BlockStorage)
+    end
+
+    def create(**attributes)
+      BlockStorage.new post_request("blocks", body: attributes).body.dig("block")
+    end
+
+    def retrieve(block_id:)
+      BlockStorage.new get_request("blocks/#{block_id}").body.dig("block")
+    end
+
+    def update(block_id:, **attributes)
+      patch_request("blocks/#{block_id}", body: attributes)
+    end
+
+    def delete(block_id:)
+      delete_request("blocks/#{block_id}")
+    end
+
+    def attach(block_id:)
+      post_request("blocks/#{block_id}/attach", body: {})
+    end
+
+    def detach(block_id:)
+      post_request("blocks/#{block_id}/detach", body: {})
+    end
+  end
+end

data/lib/vultr/resources/dns.rb

@@ -0,0 +1,58 @@
+module Vultr
+  class DnsResource < Resource
+    def list(**params)
+      response = get_request("domains", params: params)
+      Collection.from_response(response, key: "domains", type: Domain)
+    end
+
+    def create(**attributes)
+      Domain.new post_request("domains", body: attributes).body.dig("domain")
+    end
+
+    def retrieve(dns_domain:)
+      Domain.new get_request("domains/#{dns_domain}").body.dig("domain")
+    end
+
+    def update(dns_domain:, **attributes)
+      put_request("domains/#{dns_domain}", body: attributes)
+    end
+
+    def delete(dns_domain:)
+      delete_request("domains/#{dns_domain}")
+    end
+
+    def soa(dns_domain:)
+      Object.new get_request("domains/#{dns_domain}/soa").body.dig("dns_soa")
+    end
+
+    def update_soa(dns_domain:, **attributes)
+      patch_request("domains/#{dns_domain}/soa", body: attributes)
+    end
+
+    # Returns an Array of strings
+    def dnssec(dns_domain:)
+      get_request("domains/#{dns_domain}/dnssec").body.dig("dns_sec")
+    end
+
+    def list_records(dns_domain:, **params)
+      response = get_request("domains/#{dns_domain}/records", params: params)
+      Collection.from_response(response, key: "records", type: Object)
+    end
+
+    def create_record(dns_domain:, **attributes)
+      Object.new post_request("domains/#{dns_domain}/records", body: attributes).body.dig("record")
+    end
+
+    def retrieve_record(dns_domain:, record_id:)
+      Object.new get_request("domains/#{dns_domain}/records/#{record_id}").body.dig("record")
+    end
+
+    def update_record(dns_domain:, record_id:, **attributes)
+      patch_request("domains/#{dns_domain}/records/#{record_id}", body: attributes)
+    end
+
+    def delete_record(dns_domain:, record_id:)
+      delete_request("domains/#{dns_domain}/records/#{record_id}")
+    end
+  end
+end

data/lib/vultr/resources/firewall.rb

@@ -0,0 +1,42 @@
+module Vultr
+  class FirewallResource < Resource
+    def list(**params)
+      response = get_request("firewalls", params: params)
+      Collection.from_response(response, key: "firewall_groups", type: FirewallGroup)
+    end
+
+    def create(**attributes)
+      FirewallGroup.new post_request("firewalls", body: attributes).body.dig("firewall_group")
+    end
+
+    def retrieve(firewall_group_id:)
+      FirewallGroup.new get_request("firewalls/#{firewall_group_id}").body.dig("firewall_group")
+    end
+
+    def update(firewall_group_id:, **attributes)
+      put_request("firewalls/#{firewall_group_id}", body: attributes)
+    end
+
+    def delete(firewall_group_id:)
+      delete_request("firewalls/#{firewall_group_id}")
+    end
+
+    # Firewall Rules
+    def list_rules(firewall_group_id:, **params)
+      response = get_request("firewalls/#{firewall_group_id}/rules", params: params)
+      Collection.from_response(response, key: "firewall_rules", type: Object)
+    end
+
+    def create_rule(firewall_group_id:, **attributes)
+      Object.new post_request("firewalls/#{firewall_group_id}/rules", body: attributes).body.dig("firewall_rule")
+    end
+
+    def retrieve_rule(firewall_group_id:, firewall_rule_id:)
+      Object.new get_request("firewalls/#{firewall_group_id}/rules/#{firewall_rule_id}").body.dig("firewall_rule")
+    end
+
+    def delete_rule(firewall_group_id:, firewall_rule_id:)
+      delete_request("firewalls/#{firewall_group_id}/rules/#{firewall_rule_id}")
+    end
+  end
+end

data/lib/vultr/resources/instances.rb

@@ -0,0 +1,145 @@
+module Vultr
+  class InstancesResource < Resource
+    def list(**params)
+      response = get_request("instances", params: params)
+      Collection.from_response(response, key: "instances", type: Instance)
+    end
+
+    def create(**attributes)
+      Instance.new post_request("instances", body: attributes).body.dig("instance")
+    end
+
+    def retrieve(instance_id:)
+      Instance.new get_request("instances/#{instance_id}").body.dig("instance")
+    end
+
+    def update(instance_id:, **attributes)
+      patch_request("instances/#{instance_id}", body: attributes)
+    end
+
+    def delete(instance_id:)
+      delete_request("instances/#{instance_id}")
+    end
+
+    def start(instance_id:, **attributes)
+      post_request("instances/#{instance_id}/start", body: attributes)
+    end
+
+    def reboot(instance_id:, **attributes)
+      post_request("instances/#{instance_id}/reboot", body: attributes)
+    end
+
+    def reinstall(instance_id:, **attributes)
+      Instance.new post_request("instances/#{instance_id}/reinstall", body: attributes).body.dig("instance")
+    end
+
+    def restore(instance_id:, **attributes)
+      Object.new post_request("instances/#{instance_id}/restore", body: attributes).body.dig("status")
+    end
+
+    def halt(instance_id:, **attributes)
+      post_request("instances/#{instance_id}/halt", body: attributes)
+    end
+
+    def bandwidth(instance_id:)
+      Object.new get_request("instances/#{instance_id}/bandwidth").body.dig("bandwidth")
+    end
+
+    def neighbors(instance_id:)
+      get_request("instances/#{instance_id}/neighbors").body.dig("neighbors")
+    end
+
+    def user_data(instance_id:)
+      Object.new get_request("instances/#{instance_id}/user-data").body.dig("user_data")
+    end
+
+    def upgrades(instance_id:, **params)
+      Object.new get_request("instances/#{instance_id}/upgrades", params: params).body.dig("upgrades")
+    end
+
+    def list_ipv4(instance_id:, **params)
+      response = get_request("instances/#{instance_id}/ipv4", params: params)
+      Collection.from_response(response, key: "ipv4s", type: Object)
+    end
+
+    def create_ipv4(instance_id:, **params)
+      Object.new post_request("instances/#{instance_id}/ipv4", body: params).body.dig("ipv4")
+    end
+
+    def delete_ipv4(instance_id:, ipv4:)
+      delete_request("instances/#{instance_id}/ipv4/#{ipv4}")
+    end
+
+    def create_ipv4_reverse(instance_id:, **params)
+      post_request("instances/#{instance_id}/ipv4/reverse", body: params)
+    end
+
+    def set_default_reverse_dns_entry(instance_id:, **params)
+      post_request("instances/#{instance_id}/ipv4/reverse/default", body: params)
+    end
+
+    def list_ipv6(instance_id:, **params)
+      response = get_request("instances/#{instance_id}/ipv6", params: params)
+      Collection.from_response(response, key: "ipv6s", type: Object)
+    end
+
+    def ipv6_reverse(instance_id:)
+      response = get_request("instances/#{instance_id}/ipv6/reverse")
+      Collection.from_response(response, key: "reverse_ipv6s", type: Object)
+    end
+
+    def create_ipv6_reverse(instance_id:, **params)
+      post_request("instances/#{instance_id}/ipv6/reverse", body: params)
+    end
+
+    def delete_ipv6_reverse(instance_id:, ipv6:)
+      delete_request("instances/#{instance_id}/ipv6/reverse/#{ipv6}")
+    end
+
+    def list_private_networks(instance_id:, **params)
+      response = get_request("instances/#{instance_id}/private-networks", params: params)
+      Collection.from_response(response, key: "private_networks", type: PrivateNetwork)
+    end
+
+    def attach_private_network(instance_id:, network_id:)
+      post_request("instances/#{instance_id}/private-networks/attach", body: {network_id: network_id})
+    end
+
+    def detach_private_network(instance_id:, network_id:)
+      post_request("instances/#{instance_id}/private-networks/detach", body: {network_id: network_id})
+    end
+
+    def iso(instance_id:)
+      Object.new get_request("instances/#{instance_id}/iso").body.dig("iso_status")
+    end
+
+    def attach_iso(instance_id:, iso_id:)
+      Object.new post_request("instances/#{instance_id}/iso/attach", body: {iso_id: iso_id}).body.dig("iso_status")
+    end
+
+    def detach_iso(instance_id:, iso_id:)
+      Object.new post_request("instances/#{instance_id}/iso/detach", body: {iso_id: iso_id}).body.dig("iso_status")
+    end
+
+    def backup_schedule(instance_id:)
+      Object.new get_request("instances/#{instance_id}/backup-schedule").body.dig("backup_schedule")
+    end
+
+    def set_backup_schedule(instance_id:, **attributes)
+      post_request("instances/#{instance_id}/backup-schedule", body: attributes)
+    end
+
+    # Bulk operations
+    def halt_instances(instance_ids:)
+      post_request("instances/halt", body: {instance_ids: Array(instance_ids)})
+    end
+
+    def reboot_instances(instance_ids:)
+      post_request("instances/reboot", body: {instance_ids: Array(instance_ids)})
+    end
+
+    def start_instances(instance_ids:)
+      post_request("instances/start", body: {instance_ids: Array(instance_ids)})
+    end
+  end
+end

data/lib/vultr/resources/iso.rb

@@ -0,0 +1,25 @@
+module Vultr
+  class IsoResource < Resource
+    def list(**params)
+      response = get_request("iso", params: params)
+      Collection.from_response(response, key: "isos", type: Iso)
+    end
+
+    def create(**attributes)
+      Iso.new post_request("iso", body: attributes).body.dig("iso")
+    end
+
+    def retrieve(iso_id:)
+      Iso.new get_request("iso/#{iso_id}").body.dig("iso")
+    end
+
+    def delete(iso_id:)
+      delete_request("iso/#{iso_id}")
+    end
+
+    def list_public(**params)
+      response = get_request("iso-public", params: params)
+      Collection.from_response(response, key: "public_isos", type: Iso)
+    end
+  end
+end

data/lib/vultr/resources/kubernetes.rb

@@ -0,0 +1,61 @@
+module Vultr
+  class KubernetesResource < Resource
+    def list(**params)
+      response = get_request("kubernetes/clusters", params: params)
+      Collection.from_response(response, key: "vke_clusters", type: KubernetesCluster)
+    end
+
+    def create(**attributes)
+      KubernetesCluster.new post_request("kubernetes/clusters", body: attributes).body.dig("vke_cluster")
+    end
+
+    def retrieve(vke_id:)
+      KubernetesCluster.new get_request("kubernetes/clusters/#{vke_id}").body.dig("vke_cluster")
+    end
+
+    def update(vke_id:, **attributes)
+      put_request("kubernetes/clusters/#{vke_id}", body: attributes)
+    end
+
+    def delete(vke_id:)
+      delete_request("kubernetes/clusters/#{vke_id}")
+    end
+
+    def config(vke_id:)
+      Object.new get_request("kubernetes/clusters/#{vke_id}/config").body
+    end
+
+    def list_resources(vke_id:)
+      Object.new get_request("kubernetes/clusters/#{vke_id}/resources").body.dig("resources")
+    end
+
+    def list_node_pools(vke_id:, **params)
+      response = get_request("kubernetes/clusters/#{vke_id}/node-pools", params: params)
+      Collection.from_response(response, key: "node_pools", type: Object)
+    end
+
+    def retrieve_node_pool(vke_id:, nodepool_id:)
+      Object.new get_request("kubernetes/clusters/#{vke_id}/node-pools/#{nodepool_id}").body.dig("node_pool")
+    end
+
+    def create_node_pool(vke_id:, **attributes)
+      Object.new post_request("kubernetes/clusters/#{vke_id}/node-pools", body: attributes).body.dig("node_pool")
+    end
+
+    def update_node_pool(vke_id:, nodepool_id:, **attributes)
+      Object.new patch_request("kubernetes/clusters/#{vke_id}/node-pools/#{nodepool_id}", body: attributes).body.dig("node_pool")
+    end
+
+    def delete_node_pool(vke_id:, nodepool_id:)
+      delete_request("kubernetes/clusters/#{vke_id}/node-pools/#{nodepool_id}")
+    end
+
+    def delete_node_pool_instance(vke_id:, nodepool_id:, node_id:)
+      delete_request("kubernetes/clusters/#{vke_id}/node-pools/#{nodepool_id}/nodes/#{node_id}")
+    end
+
+    def recycle_node_pool_instance(vke_id:, nodepool_id:, node_id:)
+      post_request("kubernetes/clusters/#{vke_id}/node-pools/#{nodepool_id}/nodes/#{node_id}/recycle", body: {})
+    end
+  end
+end