vultr 0.4.3 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d6d7268e2f809b3a39ccd527cd000c2aa53cb8134c8461aabc60f9a55250390
-  data.tar.gz: 7eb0da000669cc3e214e003f16bdf7f4da307dc96518634a845e2e96667f036c
+  metadata.gz: 3ebb61a34678162bb7e0884bf72d3015f41c0631599406821d51756d7b810779
+  data.tar.gz: f456cc5ade9358ea27bfa0b14a2192020517d69db788ed7487d1f58d69f2acc2
 SHA512:
-  metadata.gz: 1c8728c10baf9243e704b9663b59ab472e3c9b017fd0aaf4d30e989e60d5b577040ced421df2092263ee0d4734dd87fa93e48583be9ba86b1989ed2583056806
-  data.tar.gz: d62e65970f71259cf4d8c1d0d4eae37dab6a5e0439ef4617dea1edbfb39b4d64d4d12242d68d7bbd3e4e4236b535f3d53e99487a76ecc45d56e87cf9f1714d81
+  metadata.gz: e250cf98c8fd94545aec82859c149c431ffb9007076fbfe05898e0b25d4ddaff5e805c2a39563f58b992e7c273d0f4ff6ff074fbc5dc968b7b3d70e7f3bbaa73
+  data.tar.gz: '05628e57dad09c2983a933c25ee648b684b26a88ad34c2d9d2b46131e31209d2d3b495c4273aa318fd82091e0cb3c540c7753741e65c47b5741149546e26b57f'

data/.github/workflows/ci.yml

@@ -0,0 +1,32 @@
+name: Tests
+
+on:
+  pull_request:
+    branches:
+      - "*"
+  push:
+    branches:
+      - master
+jobs:
+  tests:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby: ["2.4", "2.5", "2.6", "2.7", "3.0"]
+
+    steps:
+      - uses: actions/checkout@master
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler: default
+          bundler-cache: true
+
+      - name: StandardRb check
+        run: bundle exec standardrb
+
+      - name: Run tests
+        run: |
+          bundle exec rake test

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+== 1.0.0
+
+* Vultr API v2 support
+
 == 0.4.3 / 2019-10-8
 
 * Relaxed Faraday dependencies

data/Gemfile

@@ -1,12 +1,7 @@
-source 'https://rubygems.org'
-
-gem 'rake', '~> 10.5.0' if RUBY_VERSION < '1.9.3'
-gem 'rake' if RUBY_VERSION >= '1.9.3'
-
-group :test do
-    gem 'coveralls', :require => false
-    gem 'minitest', '>= 5.0.5'
-    gem 'simplecov'
-end
+source "https://rubygems.org"
 
 gemspec
+
+gem "rake"
+gem "minitest", ">= 5.0.5"
+gem "standard"

data/README.md

@@ -1,24 +1,8 @@
-# VULTR Rubygem
+# Vultr API Rubygem
 
-[![Build Status](https://img.shields.io/travis/tolbkni/vultr.rb.svg)](https://travis-ci.org/tolbkni/vultr.rb)
-[![Gem Version](https://badge.fury.io/rb/vultr.svg)](https://badge.fury.io/rb/vultr)
+[![Build Status](https://github.com/tolbkni/vultr.rb/workflows/Tests/badge.svg)](https://github.com/tolbkni/vultr.rb/actions)
 
-
-The easiest and most complete rubygem for [VULTR](https://www.vultr.com).
-
-```ruby
-Vultr.api_key = "your_api_key"
-r = Vultr::Server.list
-# => {
-#    :status=>200,
-#    :result=>[40, 11, 45, 29, 41, 61, 46, 35, 12, 30, 42, 3, 39, 13, 60, 36, 37, 43, 27, 28, 38]
-# }
-
-r[:status]
-r[:result]
-```
-
-You can find your keys at [https://my.vultr.com/settings/#API](https://my.vultr.com/settings/#API)
+The easiest and most complete rubygem for [Vultr](https://www.vultr.com). Currently supports [API v2](https://www.vultr.com/api/v2).
 
 ## Installation
 
@@ -36,123 +20,309 @@ Or install it yourself as:
 
 ## Usage
 
-### List Servers
-
-```ruby
-Vultr::Server.list
-```
-
-### Create Server
-
-```ruby
-Vultr::Server.create({DCID: dc_id, VPSPLANID: vps_plan_id, OSID: os_id})
-```
-
-## Available Commands
-
-```ruby
-Vultr::Account.info
-
-Vultr::App.list
-
-Vultr::Auth.info
-
-Vultr::Backup.list
-
-Vultr::Block.attach({SUBID: sub_id, attach_to_SUBID: attach_to_sub_id})
-Vultr::Block.create({DCID: dc_id, size_gb: size_gb, label: label})
-Vultr::Block.delete(SUBID: sub_id)
-Vultr::Block.detach(SUBID: sub_id)
-Vultr::Block.label_set({SUBID: sub_id, label: label})
-Vultr::Block.list(SUBID: sub_id)
-Vultr::Block.resize({SUBID: sub_id, size_gb: size_gb})
-
-Vultr::DNS.create_domain({domain: domain, serverip: server_ip})
-Vultr::DNS.create_record({domain: domain, name: name, type: type, data: data, ttl: ttl, priority: priority})
-Vultr::DNS.delete_domain(domain: domain)
-Vultr::DNS.delete_record({domain: domain, RECORDID: record_id})
-Vultr::DNS.list
-Vultr::DNS.records(domain: domain)
-Vultr::DNS.update_record({domain: domain, RECORDID: record_id, name: name, type: type, data: data, ttl: ttl, priority: priority})
-
-Vultr::ISO.list
-
-Vultr::OS.list
-
-Vultr::Plans.list
-Vultr::Plans.list_vc2
-Vultr::Plans.list_vdc2
-
-Vultr::Regions.list
-Vultr::Regions.availability(DCID: dc_id)
-
-Vultr::ReservedIP.attach({ip_address: ip_address, attach_SUBID: attach_sub_id})
-Vultr::ReservedIP.convert({SUBID: sub_id, ip_address: ip_address, label: label})
-Vultr::ReservedIP.create({DCID: dc_id, ip_type: ip_type, label: label})
-Vultr::ReservedIP.destroy(ip_address: ip_address)
-Vultr::ReservedIP.detach({ip_address: ip_address, detach_SUBID: detach_sub_id})
-Vultr::ReservedIP.list
-
-Vultr::Server.app_change({SUBID: sub_id, APPID: app_id})
-Vultr::Server.app_change_list(SUBID: sub_id)
-Vultr::Server.backup_disable(SUBID: sub_id)
-Vultr::Server.backup_enable(SUBID: sub_id)
-Vultr::Server.backup_get_schedule(SUBID: sub_id)
-Vultr::Server.backup_set_schedule({SUBID: sub_id, cron_type: cron_type, hour: hour, dow: dow, dom: dom})
-Vultr::Server.bandwidth(SUBID: sub_id)
-Vultr::Server.create({DCID: dc_id, VPSPLANID: vps_plan_id, OSID: os_id, ipxe_chain_url: ipxe_chain_url, ISOID: iso_id,
-                      SCRIPTID: script_id, SNAPSHOTID: snapshot_id, enable_ipv6: enable_ipv6, enable_private_network: enable_private_network,
-                      private_network: private_network, label: label, SSHKEYID: sshkey_id, auto_backups: auto_backups, APPID: app_id,
-                      userdata: userdata, notify_activate: notify_activate, ddos_protection: ddos_protection, reserved_ip_v4: reserved_ipv4,
-                      hostname: hostname, tag: tag})
-Vultr::Server.create_ipv4（{SUBID: sub_id, reboot: reboot})
-Vultr::Server.destroy(SUBID: sub_id)
-Vultr::Server.destroy_ipv4({SUBID: sub_id, ip: ip})
-Vultr::Server.get_app_inf(SUBID: sub_id)
-Vultr::Server.get_user_data(SUBID: sub_id)
-Vultr::Server.halt(SUBID: sub_id)
-Vultr::Server.iso_attach({SUBID: sub_id, ISOID: iso_id})
-Vultr::Server.iso_detach(SUBID: sub_id)
-Vultr::Server.iso_status(SUBID: sub_id)
-Vultr::Server.label_set({SUBID: sub_id, label: label})
-Vultr::Server.list({SUBID: sub_id, tag: tag})
-Vultr::Server.list_ipv4(SUBID: sub_id)
-Vultr::Server.list_ipv6(SUBID: sub_id)
-Vultr::Server.neighbors(SUBID: sub_id)
-Vultr::Server.os_change({SUBID: sub_id, OSID: os_id})
-Vultr::Server.os_change_list(SUBID: sub_id)
-Vultr::Server.reboot(SUBID: sub_id)
-Vultr::Server.reinstall({SUBID: sub_id, hostname: hostname})
-Vultr::Server.restore_backup({SUBID: sub_id, BACKUPID: backup_id})
-Vultr::Server.restore_snapshot({SUBID: sub_id, SNAPSHOTID: snapshot_id})
-Vultr::Server.reverse_default_ipv4({SUBID: sub_id, ip: ip})
-Vultr::Server.reverse_delete_ipv6({SUBID: sub_id, ip: ip})
-Vultr::Server.reverse_list_ipv6(SUBID: sub_id)
-Vultr::Server.reverse_set_ipv4({SUBID: sub_id, ip: ip, entry: entry})
-Vultr::Server.reverse_set_ipv6({SUBID: sub_id, ip: ip, entry: entry})
-Vultr::Server.set_user_data({SUBID: sub_id, userdata: userdata})
-Vultr::Server.start(SUBID: sub_id)
-Vultr::Server.upgrade_plan({SUBID: sub_id, VPSPLANID: vpsplan_id})
-Vultr::Server.upgrade_plan_list(SUBID: sub_id)
-
-Vultr::Snapshot.create(SUBID: sub_id)
-Vultr::Snapshot.destroy(SNAPSHOTID: snapshot_id)
-Vultr::Snapshot.list
-
-Vultr::SSHKey.create({name: name, ssh_key: ssh_key})
-Vultr::SSHKey.destroy(SSHKEYID: sshkey_id)
-Vultr::SSHKey.list
-Vultr::SSHKey.update({SSHKEYID: sshkey_id, name: name, ssh_key: ssh_key})
-
-Vultr::StartupScript.create({name: name, script: script, type: type})
-Vultr::StartupScript.destroy(SCRIPTID: script_id)
-Vultr::StartupScript.list
-Vultr::StartupScript.update({SCRIPTID: script_id, name: name, script: script})
-
-Vultr::User.create({email: email, name: name, password: password, api_enabled: api_enabled, acls: acls})
-Vultr::User.delete(USERID: user_id)
-Vultr::User.list
-Vultr::User.update({USERID: user_id, email: email, name: name, password: password, api_enabled: api_enabled, acls: acls})
+To access the API, you'll need to create a `Vultr::Client` and pass in your API key. You can find your API key at [https://my.vultr.com/settings](https://my.vultr.com/settings/#settingsapi)
+
+```ruby
+client = Vultr::Client.new(api_key: ENV["VULTR_API_KEY"])
+```
+
+The client then gives you access to each of the resources.
+
+## Resources
+
+The gem maps as closely as we can to the Vultr API so you can easily convert API examples to gem code.
+
+Responses are created as objects like `Vultr::Account`. Having types like `Vultr::User` is handy for understanding what type of object you're working with. They're built using OpenStruct so you can easily access data in a Ruby-ish way.
+
+##### Pagination
+
+ `list` endpoints return pages of results. The result object will have a `data` key to access the results, as well as metadata like `next_cursor` and `prev_cursor` for retrieving the next and previous pages. You may also specify the
+
+```ruby
+results = client.applications.list(per_page: 5)
+#=> Vultr::Collection
+
+results.total
+#=> 48
+
+results.data
+#=> [#<Vultr::Application>, #<Vultr::Application>]
+
+results.next_cursor
+#=> "bmV4dF9fMTU="
+
+# Retrieve the next page
+client.applications.list(per_page: 5, cursor: results.next_cursor)
+#=> Vultr::Collection
+```
+
+### Account
+
+```ruby
+client.account.info
+```
+
+### Applications
+
+```ruby
+client.applications.list
+```
+
+### Backups
+
+```ruby
+client.backups.list
+client.backups.get(backup_id: "id")
+```
+
+### Bare Metal
+
+```ruby
+client.bare_metal.list
+client.bare_metal.create({})
+client.bare_metal.retrieve(baremetal_id: "id")
+client.bare_metal.update(baremetal_id: "id", {})
+client.bare_metal.delete(baremetal_id: "id")
+client.bare_metal.start(baremetal_id: "id")
+client.bare_metal.reboot(baremetal_id: "id")
+client.bare_metal.reinstall(baremetal_id: "id")
+client.bare_metal.halt(baremetal_id: "id")
+client.bare_metal.bandwidth(baremetal_id: "id")
+client.bare_metal.user_data(baremetal_id: "id")
+client.bare_metal.upgrades(baremetal_id: "id")
+client.bare_metal.vnc(baremetal_id: "id")
+client.bare_metal.list_ipv4(baremetal_id: "id")
+client.bare_metal.list_ipv6(baremetal_id: "id")
+
+# Bulk operations
+client.bare_metal.start_instances(baremetal_ids: [id1, id2])
+client.bare_metal.halt_instances(baremetal_ids: [id1, id2])
+client.bare_metal.reboot_instances(baremetal_ids: [id1, id2])
+```
+
+### Block Storage
+
+```ruby
+client.block_storage.list
+client.block_storage.create({})
+client.block_storage.retrieve(block_id: "id")
+client.block_storage.update(block_id: "id", {})
+client.block_storage.delete(block_id: "id")
+client.block_storage.attach(block_id: "id", {})
+client.block_storage.detach(block_id: "id")
+```
+
+### DNS (Domains)
+
+```ruby
+client.dns.list
+client.dns.create({})
+client.dns.retrieve(dns_domain: "id")
+client.dns.update(dns_domain: "id", {})
+client.dns.delete(dns_domain: "id")
+client.dns.soa(dns_domain: "id")
+client.dns.update_soa(dns_domain: "id", {})
+client.dns.dnssec(dns_domain: "id")
+client.dns.list_records(dns_domain: "id")
+client.dns.retrieve_record(dns_domain: "id", record_id: "id")
+client.dns.create_record(dns_domain: "id", {})
+client.dns.update_record(dns_domain: "id", record_id: "id", {})
+client.dns.delete_record(dns_domain: "id", record_id: "id")
+```
+
+### Firewall
+
+```ruby
+client.firewall.list
+client.firewall.create({})
+client.firewall.retrieve(firewall_group_id: "id")
+client.firewall.update(firewall_group_id: "id", {})
+client.firewall.delete(firewall_group_id: "id")
+client.firewall.list_rules(firewall_group_id: "id")
+client.firewall.create_rule(firewall_group_id: "id", {})
+client.firewall.retrieve_rule(firewall_group_id: "id", firewall_rule_id: "id")
+client.firewall.delete_rule(firewall_group_id: "id", firewall_rule_id: "id")
+```
+
+### Instances
+
+```ruby
+client.instances.list
+client.instances.create({})
+client.instances.retrieve(instance_id: "id")
+client.instances.update(instance_id: "id", {})
+client.instances.delete(instance_id: "id")
+client.instances.start(instance_id: "id")
+client.instances.reboot(instance_id: "id")
+client.instances.reinstall(instance_id: "id")
+client.instances.restore(instance_id: "id", {})
+client.instances.halt(instance_id: "id")
+client.instances.bandwidth(instance_id: "id")
+client.instances.neighbors(instance_id: "id")
+client.instances.user_data(instance_id: "id")
+client.instances.upgrades(instance_id: "id")
+client.instances.list_ipv4(instance_id: "id")
+client.instances.create_ipv4(instance_id: "id", {})
+client.instances.delete_ipv4(instance_id: "id", ipv4: "id")
+client.instances.create_ipv4_reverse(instance_id: "id", {})
+client.instances.set_default_reverse_dns_entry(instance_id: "id", {})
+client.instances.list_ipv6(instance_id: "id")
+client.instances.ipv6_reverse(instance_id: "id")
+client.instances.create_ipv6_reverse(instance_id: "id", {})
+client.instances.delete_ipv6_reverse(instance_id: "id", ipv6: "id")
+client.instances.list_private_networks(instance_id: "id")
+client.instances.attach_private_network(instance_id: "id", network_id: "id")
+client.instances.detach_private_network(instance_id: "id", network_id: "id")
+client.instances.iso(instance_id: "id")
+client.instances.attach_iso(instance_id: "id", iso_id: "id")
+client.instances.detach_iso(instance_id: "id", iso_id: "id")
+client.instances.backup_schedule(instance_id: "id")
+client.instances.set_backup_schedule(instance_id: "id", {})
+
+# Bulk operations
+client.instances.start_instances(instance_ids: [id1, id2])
+client.instances.halt_instances(instance_ids: [id1, id2])
+client.instances.reboot_instances(instance_ids: [id1, id2])
+```
+
+### ISO
+
+```ruby
+client.iso.list
+client.iso.create({})
+client.iso.retrieve(iso_id: "id")
+client.iso.delete(iso_id: "id")
+client.iso.list_public
+```
+
+### Kubernetes
+
+```ruby
+client.kubernetes.list
+client.kubernetes.create({})
+client.kubernetes.retrieve(vke_id: "id")
+client.kubernetes.update(vke_id: "id", {})
+client.kubernetes.delete(vke_id: "id")
+client.kubernetes.config(vke_id: "id")
+client.kubernetes.list_resources(vke_id: "id")
+client.kubernetes.list_node_pools(vke_id: "id")
+client.kubernetes.retrieve_node_pool(vke_id: "id", nodepool_id: "id")
+client.kubernetes.create_node_pool(vke_id: "id", {})
+client.kubernetes.update_node_pool(vke_id: "id", nodepool_id: "id", {})
+client.kubernetes.delete_node_pool(vke_id: "id", nodepool_id: "id")
+client.kubernetes.delete_node_pool_instance(vke_id: "id", nodepool_id: "id", node_id: "id")
+client.kubernetes.recycle_node_pool_instance(vke_id: "id", nodepool_id: "id", node_id: "id")
+```
+
+### Load Balancers
+
+```ruby
+client.load_balancers.list
+client.load_balancers.create({})
+client.load_balancers.retrieve(load_balancer_id: "id")
+client.load_balancers.update(load_balancer_id: "id", {})
+client.load_balancers.delete(load_balancer_id: "id")
+client.load_balancers.list_forwarding_rules(load_balancer_id: "id")
+client.load_balancers.create_forwarding_rule(load_balancer_id: "id", {})
+client.load_balancers.retrieve_forwarding_rule(load_balancer_id: "id", forwarding_rule_id: "id")
+client.load_balancers.delete_forwarding_rule(load_balancer_id: "id", forwarding_rule_id: "id")
+client.load_balancers.list_firewall_rules(load_balancer_id: "id")
+client.load_balancers.retrieve_firewall_rule(load_balancer_id: "id", firewall_rule_id: "id")
+```
+
+### Object Storage
+
+```ruby
+client.object_storage.list
+client.object_storage.create({})
+client.object_storage.retrieve(object_storage_id: "id")
+client.object_storage.update(object_storage_id: "id", {})
+client.object_storage.delete(object_storage_id: "id")
+client.object_storage.regenerate_keys(object_storage_id: "id")
+client.object_storage.list_clusters()
+```
+
+### Operating Systems
+
+```ruby
+client.operating_systems.list
+```
+
+### Plans
+
+```ruby
+client.plans.list
+client.plans.list_metal
+```
+
+### Private Networks
+
+```ruby
+client.private_networks.list
+client.private_networks.create({})
+client.private_networks.retrieve(network_id: "id")
+client.private_networks.update(network_id: "id", {})
+client.private_networks.delete(network_id: "id")
+```
+
+### Regions
+
+```ruby
+client.regions.list
+client.regions.list_availability(region_id: "id")
+```
+
+### Reserved IPs
+
+```ruby
+client.reserved_ips.list
+client.reserved_ips.create({})
+client.reserved_ips.retrieve(reserved_ip: "id")
+client.reserved_ips.delete(reserved_ip: "id")
+client.reserved_ips.attach(reserved_ip: "id", instance_id: "id")
+client.reserved_ips.detach(reserved_ip: "id")
+client.reserved_ips.convert({})
+```
+
+### Snapshots
+
+```ruby
+client.snapshots.list
+client.snapshots.create({})
+client.snapshots.retrieve(snapshot_id: "id")
+client.snapshots.create_from_url("https://...")
+client.snapshots.update(snapshot_id: "id", {})
+client.snapshots.delete(snapshot_id: "id")
+```
+
+### SSH Keys
+
+```ruby
+client.ssh_keys.list
+client.ssh_keys.create({})
+client.ssh_keys.retrieve(ssh_key_id: "id")
+client.ssh_keys.update(ssh_key_id: "id", {})
+client.ssh_keys.delete(ssh_key_id: "id")
+```
+
+### Startup Scripts
+
+```ruby
+client.startup_scripts.list
+client.startup_scripts.create({})
+client.startup_scripts.retrieve(startup_script_id: "id")
+client.startup_scripts.update(startup_script_id: "id", {})
+client.startup_scripts.delete(startup_script_id: "id")
+```
+
+### Users
+
+```ruby
+client.users.list
+client.users.create({})
+client.users.retrieve(user_id: "id")
+client.users.update(user_id: "id", {})
+client.users.delete(user_id: "id")
 ```
 
 ## Contributing