vultr 0.4.3 → 2.0.0

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

data/lib/vultr/resources/load_balancers.rb

@@ -0,0 +1,50 @@
+module Vultr
+  class LoadBalancersResource < Resource
+    def list(**params)
+      response = get_request("load-balancers", params: params)
+      Collection.from_response(response, key: "load_balancers", type: LoadBalancer)
+    end
+
+    def create(**attributes)
+      LoadBalancer.new post_request("load-balancers", body: attributes).body.dig("load_balancer")
+    end
+
+    def retrieve(load_balancer_id:)
+      LoadBalancer.new get_request("load-balancers/#{load_balancer_id}").body.dig("load_balancer")
+    end
+
+    def update(load_balancer_id:, **attributes)
+      LoadBalancer.new patch_request("load-balancers/#{load_balancer_id}", body: attributes).body.dig("load_balancer")
+    end
+
+    def delete(load_balancer_id:)
+      delete_request("load-balancers/#{load_balancer_id}")
+    end
+
+    def list_forwarding_rules(load_balancer_id:, **params)
+      response = get_request("load-balancers/#{load_balancer_id}/forwarding-rules", params: params)
+      Collection.from_response(response, key: "forwarding_rules", type: Object)
+    end
+
+    def create_forwarding_rule(load_balancer_id:, **attributes)
+      Object.new post_request("load-balancers/#{load_balancer_id}/forwarding-rules", body: attributes).body.dig("forwarding_rule")
+    end
+
+    def retrieve_forwarding_rule(load_balancer_id:, forwarding_rule_id:)
+      Object.new get_request("load-balancers/#{load_balancer_id}/forwarding-rules/#{forwarding_rule_id}").body.dig("forwarding_rule")
+    end
+
+    def delete_forwarding_rule(load_balancer_id:, forwarding_rule_id:)
+      delete_request("load-balancers/#{load_balancer_id}/forwarding-rules/#{forwarding_rule_id}")
+    end
+
+    def list_firewall_rules(load_balancer_id:, **params)
+      response = get_request("load-balancers/#{load_balancer_id}/firewall-rules", params: params)
+      Collection.from_response(response, key: "firewall_rules", type: Object)
+    end
+
+    def retrieve_firewall_rule(load_balancer_id:, firewall_rule_id:)
+      Object.new get_request("load-balancers/#{load_balancer_id}/firewall-rules/#{firewall_rule_id}").body.dig("firewall_rule")
+    end
+  end
+end

data/lib/vultr/resources/object_storage.rb

@@ -0,0 +1,33 @@
+module Vultr
+  class ObjectStorageResource < Resource
+    def list(**params)
+      response = get_request("object-storage", params: params)
+      Collection.from_response(response, key: "object_storages", type: ObjectStorage)
+    end
+
+    def create(**attributes)
+      ObjectStorage.new post_request("object-storage", body: attributes).body.dig("object_storage")
+    end
+
+    def retrieve(object_storage_id:)
+      ObjectStorage.new get_request("object-storage/#{object_storage_id}").body.dig("object_storage")
+    end
+
+    def update(object_storage_id:, **attributes)
+      put_request("object-storage/#{object_storage_id}", body: attributes)
+    end
+
+    def delete(object_storage_id:)
+      delete_request("object-storage/#{object_storage_id}")
+    end
+
+    def regenerate_keys(object_storage_id:)
+      Object.new post_request("object-storage/#{object_storage_id}/regenerate-keys", body: {}).body
+    end
+
+    def list_clusters(**params)
+      response = get_request("object-storage/clusters", params: params)
+      Collection.from_response(response, key: "clusters", type: Object)
+    end
+  end
+end

data/lib/vultr/resources/operating_systems.rb

@@ -0,0 +1,8 @@
+module Vultr
+  class OperatingSystemsResource < Resource
+    def list(**params)
+      response = get_request("os", params: params)
+      Collection.from_response(response, key: "os", type: OperatingSystem)
+    end
+  end
+end

data/lib/vultr/resources/plans.rb

@@ -0,0 +1,13 @@
+module Vultr
+  class PlansResource < Resource
+    def list(**params)
+      response = get_request("plans", params: params)
+      Collection.from_response(response, key: "plans", type: Plan)
+    end
+
+    def list_metal(**params)
+      response = get_request("plans-metal", params: params)
+      Collection.from_response(response, key: "plans_metal", type: Plan)
+    end
+  end
+end

data/lib/vultr/resources/private_networks.rb

@@ -0,0 +1,24 @@
+module Vultr
+  class PrivateNetworksResource < Resource
+    def list(**params)
+      response = get_request("private-networks", params: params)
+      Collection.from_response(response, key: "networks", type: PrivateNetwork)
+    end
+
+    def create(**attributes)
+      PrivateNetwork.new post_request("private-networks", body: attributes).body.dig("network")
+    end
+
+    def retrieve(network_id:)
+      PrivateNetwork.new get_request("private-networks/#{network_id}").body.dig("network")
+    end
+
+    def update(network_id:, **attributes)
+      put_request("private-networks/#{network_id}", body: attributes)
+    end
+
+    def delete(network_id:)
+      delete_request("private-networks/#{network_id}")
+    end
+  end
+end

data/lib/vultr/resources/regions.rb

@@ -0,0 +1,12 @@
+module Vultr
+  class RegionsResource < Resource
+    def list(**params)
+      response = get_request("regions", params: params)
+      Collection.from_response(response, key: "regions", type: Region)
+    end
+
+    def list_availability(region_id:)
+      Object.new get_request("regions/#{region_id}/availability").body
+    end
+  end
+end

data/lib/vultr/resources/reserved_ips.rb

@@ -0,0 +1,32 @@
+module Vultr
+  class ReservedIpsResource < Resource
+    def list(**params)
+      response = get_request("reserved-ips", params: params)
+      Collection.from_response(response, key: "reserved_ips", type: ReservedIp)
+    end
+
+    def create(**attributes)
+      ReservedIp.new post_request("reserved-ips", body: attributes).body.dig("reserved_ip")
+    end
+
+    def retrieve(reserved_ip:)
+      ReservedIp.new get_request("reserved-ips/#{reserved_ip}").body.dig("reserved_ip")
+    end
+
+    def delete(reserved_ip:)
+      delete_request("reserved-ips/#{reserved_ip}")
+    end
+
+    def attach(reserved_ip:, instance_id:)
+      post_request("reserved-ips/#{reserved_ip}/attach", body: {instance_id: instance_id})
+    end
+
+    def detach(reserved_ip:)
+      post_request("reserved-ips/#{reserved_ip}/detach", body: {})
+    end
+
+    def convert(**attributes)
+      ReservedIp.new post_request("reserved-ips/convert", body: attributes).body.dig("reserved_ip")
+    end
+  end
+end

data/lib/vultr/resources/snapshots.rb

@@ -0,0 +1,28 @@
+module Vultr
+  class SnapshotsResource < Resource
+    def list(**params)
+      response = get_request("snapshots", params: params)
+      Collection.from_response(response, key: "snapshots", type: Snapshot)
+    end
+
+    def create(**attributes)
+      Snapshot.new post_request("snapshots", body: attributes).body.dig("snapshot")
+    end
+
+    def retrieve(snapshot_id:)
+      Snapshot.new get_request("snapshots/#{snapshot_id}").body.dig("snapshot")
+    end
+
+    def create_from_url(url)
+      Snapshot.new post_request("snapshots/create-from-url", body: {url: url}).body.dig("snapshot")
+    end
+
+    def update(snapshot_id:, **attributes)
+      put_request("snapshots/#{snapshot_id}", body: attributes)
+    end
+
+    def delete(snapshot_id:)
+      delete_request("snapshots/#{snapshot_id}")
+    end
+  end
+end

data/lib/vultr/resources/ssh_keys.rb

@@ -0,0 +1,24 @@
+module Vultr
+  class SshKeysResource < Resource
+    def list(**params)
+      response = get_request("ssh-keys", params: params)
+      Collection.from_response(response, key: "ssh_keys", type: SshKey)
+    end
+
+    def create(**attributes)
+      SshKey.new post_request("ssh-keys", body: attributes).body.dig("ssh_key")
+    end
+
+    def retrieve(ssh_key_id:)
+      SshKey.new get_request("ssh-keys/#{ssh_key_id}").body.dig("ssh_key")
+    end
+
+    def update(ssh_key_id:, **attributes)
+      patch_request("ssh-keys/#{ssh_key_id}", body: attributes)
+    end
+
+    def delete(ssh_key_id:)
+      delete_request("ssh-keys/#{ssh_key_id}")
+    end
+  end
+end

data/lib/vultr/resources/startup_scripts.rb

@@ -0,0 +1,24 @@
+module Vultr
+  class StartupScriptsResource < Resource
+    def list(**params)
+      response = get_request("startup-scripts", params: params)
+      Collection.from_response(response, key: "startup_scripts", type: StartupScript)
+    end
+
+    def create(**attributes)
+      StartupScript.new post_request("startup-scripts", body: attributes).body.dig("startup_script")
+    end
+
+    def retrieve(startup_script_id:)
+      StartupScript.new get_request("startup-scripts/#{startup_script_id}").body.dig("startup_script")
+    end
+
+    def update(startup_script_id:, **attributes)
+      patch_request("startup-scripts/#{startup_script_id}", body: attributes)
+    end
+
+    def delete(startup_script_id:)
+      delete_request("startup-scripts/#{startup_script_id}")
+    end
+  end
+end

data/lib/vultr/resources/users.rb

@@ -0,0 +1,24 @@
+module Vultr
+  class UserResource < Resource
+    def list(**params)
+      response = get_request("users", params: params)
+      Collection.from_response(response, key: "users", type: User)
+    end
+
+    def create(**attributes)
+      User.new post_request("users", body: attributes).body.dig("user")
+    end
+
+    def retrieve(user_id:)
+      User.new get_request("users/#{user_id}").body.dig("user")
+    end
+
+    def update(user_id:, **attributes)
+      patch_request("users/#{user_id}", body: attributes)
+    end
+
+    def delete(user_id:)
+      delete_request("users/#{user_id}")
+    end
+  end
+end

data/lib/vultr/version.rb

@@ -1,10 +1,3 @@
 module Vultr
-  module VERSION
-    MAJOR = 0
-    MINOR = 4
-    TINY  = 3
-    PRE   = nil
-
-    STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
-  end
+  VERSION = "2.0.0"
 end