profitbricks-sdk-ruby 1.0.2

data/docs/reference.md

@@ -0,0 +1,376 @@
+
+# Table of Contents
+
+* [Resource Methods](#resource-methods)
+* [Datacenter](#datacenter)
+* [Server](#server)
+    * [Server Volumes](#server-volumes)
+    * [Server CD-ROMs](#server-cd-roms)
+* [NIC](#nic)
+* [Firewall Rule](#firewall-rule)
+* [Volume](#volume)
+* [Loadbalancer](#loadbalancer)
+* [LAN](#lan)
+* [Location](#location)
+* [IP Block](#ip-block)
+* [Image](#image)
+* [Snapshot](#snapshot)
+* [Request](#request)
+
+# Resource Methods
+
+```wait_for(timeout, interval)``` - Poll a resource until the **DONE** status is returned.
+
+    datacenter = Datacenter.create(name: "dc1", location: "us/las")
+    datacenter.wait_for( { ready? }
+    server = datacenter.create(name: "server1", cores: 1, ram: 1024)
+    server.wait_for { ready? }
+
+```reload``` - Retrieve latest properties of a resource.
+
+    datacenter.reload
+    server.reload
+
+# Datacenter
+
+List all datacenters:
+
+    Datacenter.list
+
+Retrieve a single datacenter:
+
+    datacenter = Datacenter.get(datacenter_id)
+
+Create a datacenter:
+
+    datacenter = Datacenter.create(name: "dc1", description: "My Datacenter", location: "las/us")
+
+Update a datacenter:
+
+    datacenter.update(description: "New datacenter description")
+
+Remove a datacenter:
+
+    datacenter.delete
+
+# Server
+
+List all servers within a datacenter:
+
+    datacenter = Datacenter.get(datacenter_id)
+    servers = datacenter.list_servers
+
+Retrieve a server within a datacenter:
+
+    datacenter = Datacenter.get(datacenter_id)
+    server = datacenter.get_server(server_id)
+
+Create a server:
+
+    datacenter = Datacenter.get(datacenter_id)
+    server = datacenter.create_server(name: "server1", cores: 2, ram: 4096)
+
+Update a server:
+
+    server.update(description: "My Server", cores: 4)
+
+Remove a server:
+
+    server.delete
+
+Start a server:
+
+    server.start
+
+Stop a server:
+
+    server.stop
+
+Restart a server:
+
+    server.reboot
+
+## Server Volumes
+
+List attached server volumes:
+
+    server.list_volumes
+
+Retrieve an attached volume:
+
+    server.get_volume(volume_id)
+
+Attach volume to a server:
+
+    server.attach_volume(volume_id)
+
+Detach volume from a server:
+
+    server.detach_volume(volume_id)
+
+## Server CD-ROMs
+
+List attached CD-ROMs:
+
+    server.list_cdroms
+
+Retrieve attached CD-ROMs:
+
+    server.get_cdrom(image_id)
+
+Attach CD-ROM to a server:
+
+    server.attach_cdrom(image_id)
+
+Detach CD-ROM from a server:
+
+    server.detach_cdrom(image_id)
+
+# NIC
+
+List all NICs:
+
+    server = datacenter.get_server(server_id)
+    server.list_nics
+
+Retrieve a NIC:
+
+    server = datacenter.get_server(server_id)
+    server.get_nic(nic_id)
+
+Create a NIC:
+
+    server.create_nic(name: "nic1")
+
+Update a NIC:
+
+    nic = server.get_nic(nic_id)
+    nic.update(name: "nic1_rename")
+
+Remove NIC:
+
+    nic = server.get_nic(nic_id)
+    nic.delete
+
+# Firewall Rule
+
+List all NIC firewall rules:
+
+    server = datacenter.get_server(server_id)
+    nic = server.get_nic(nic_id)
+    nic.list_firewall_rules
+
+*Alias method*: ```nic.list_fwrules```
+
+Retrieve a NIC firewall rule:
+
+    server = datacenter.get_server(server_id)
+    nic = server.get_nic(nic_id)
+    fwrule = nic.get_firewall_rule(fwrule_id)
+
+*Alias method*: ```nic.get_fwrule(fwrule_id)```
+
+Create a firewall rule:
+
+    fwrule = nic.create_firewall_rule(name: "OpenSSH port", protocol: "TCP", sourceMac: "01:23:45:67:89:00", portRangeStart: 22, portRangeEnd: 22)
+
+*Alias method*: ```nic.create_fwrule(name: "OpenSSH port", ...)```
+
+Update a firewall rule:
+
+    fwrule.update(name: "SSH port")
+
+Remove a firewall rule:
+
+    fwrule.delete
+
+# Volume
+
+List all volumes within a datacenter:
+
+    datacenter = Datacenter.get(datacenter_id)
+    datacenter.list_volumes
+
+Retrieve a volume:
+
+    volume = datacenter.get_volume(volume_id)
+
+Create a volume:
+
+    volume = datacenter.create_volume(name: "volume1", size: 20)
+
+Update a volume:
+
+    volume.update(description: "My Volume", size: 40)
+
+Remove a volume:
+
+    volume.delete
+
+Attach volume to a server:
+
+    volume.attach(server_id)
+
+Detach volume from a server:
+
+    volume.detach
+
+Create volume snapshot:
+
+    volume.create_snapshot(name: "snapshot1", description: My Snapshot")
+
+Restore a snapshot:
+
+    volume.restore_snapshot(snapshot_id)
+
+# Loadbalancer
+
+List all loadbalancers within a datacenter:
+
+    datacenter = Datacenter.get(datacenter_id)
+    datacenter.list_loadbalancers
+
+Retrieve a loadbalancer:
+
+    lb = datacenter.get_loadbalancer(lb_id)
+
+Create a loadbalancer:
+
+    lb = datacenter.create_loadbalancer(name: “lb1”, …)
+
+Update a loadbalancer:
+
+    lb.update(name: “lb1_rename”)
+
+Remove a loadbalancer:
+
+    lb.delete
+
+List all balanced NICs:
+
+    lb.list_balanced_nics
+
+*Alias method*: lb.list_nics
+
+Associate NIC with a loadbalancer:
+
+    lb.associate_balanced_nic(nic_id)
+
+*Alias method*: lb.associate_nic(nic_id)
+
+Retrieve a balanced NIC:
+
+    lb.get_balanced_nic(nic_id)
+
+*Alias method*: lb.get_nic(nic_id)
+
+Remove a balanced NIC:
+
+    lb = datacenter.get_loadbalancer(lb_id)
+    balanced_nic = lb.get_balanced_nic(nic_id)
+    balanced_nic.remove
+
+# LAN
+
+List all LANs:
+
+    datacenter = Datacenter.get(datacenter_id)
+    datacenter.list_lans
+
+Retrieve a LAN:
+
+    lan = datacenter.get_lan(lan_id)
+
+Create a LAN:
+
+    lan = datacenter.create_lan(name: "lan1", public: "true")
+
+Update a LAN:
+
+    lan.update(name: "lan1_rename")
+
+Remove LAN:
+
+    lan.delete
+
+List LAN Members:
+
+    lan.list_members
+
+# Location
+
+List all locations:
+
+    Locations.list
+
+Retrieve a location:
+
+    Location.get(location_id)
+
+# IP Block
+
+List reserved IP blocks:
+
+    IPBlock.list
+
+Retrieve an IP block:
+
+    ipblock = IPBlock.get(ipblock_id)
+
+Reserve an IP block:
+
+    ipblock = IPBlock.reserve(location: "us/las", size: 5)
+
+Release an IP block:
+
+    ipblock.release
+
+# Image
+
+List all images:
+
+    Image.list
+
+Retrieve an image:
+
+    image = Image.get(image_id)
+
+Update an image:
+
+    image.update(name: "image1_rename")
+
+Remove an image:
+
+    image.delete
+
+# Snapshot
+
+List all snapshots:
+
+    Snapshot.list
+
+Retrieve a snapshot:
+
+    snapshot = Snapshot.get(snapshot_id)
+
+Update a snapshot:
+
+    snapshot.update(name: "snapshot1_rename")
+
+Remove a snapshot:
+
+    snapshot.delete
+
+# Request
+
+List all requests:
+
+    Request.list
+
+Retrieve a request:
+
+    request = Request.get(request_id)
+
+Retrieve status of a request:
+
+    request.status

data/lib/profitbricks/config.rb

@@ -0,0 +1,30 @@
+module ProfitBricks
+  class Config
+    class << self
+      # ProfitBricks URL, default: https://api.profitbricks.com
+      attr_accessor :url
+      # ProfitBricks username (required)
+      attr_accessor :username 
+      # ProfitBricks password (required)
+      attr_accessor :password
+      # ProfitBricks URL protocol, default: https
+      attr_accessor :protocol
+      # ProfitBricks URL host
+      attr_accessor :host
+      # ProfitBricks URL port, default: 443
+      attr_accessor :port
+      # ProfitBricks URL path prefix, default: /rest/
+      attr_accessor :path_prefix
+      # Custom HTTP request headers
+      attr_accessor :headers
+      # Disable namespacing the classes, set to false to avoid name conflicts, default: true
+      attr_accessor :global_classes
+      # Timeout value for wait_for() method, default: 60 seconds
+      attr_accessor :timeout
+      # Polling interval value for wait_for() method, default: 3 seconds
+      attr_accessor :interval
+      # Enable or disable Excon debugging, default: false
+      attr_accessor :debug
+    end
+  end
+end

data/lib/profitbricks/datacenter.rb

@@ -0,0 +1,113 @@
+module ProfitBricks
+  # Datacenter class
+  class Datacenter < ProfitBricks::Model
+    def delete
+      ProfitBricks.request(
+        method: :delete,
+        path: "/datacenters/#{self.id}",
+        expects: 202
+      )
+    end
+
+    def update(options = {})
+      response = ProfitBricks.request(
+        path: "/datacenters/#{self.id}",
+        method: :patch,
+        expects: 202,
+        body: options.to_json
+      )
+      if response
+        # @properties = @properties.merge!(response['properties'])
+        @properties.merge!(response['properties'])
+      end
+      self
+    end
+
+    def list_servers
+      ProfitBricks::Server.list(self.id)
+    end
+
+    def get_server(server_id)
+      ProfitBricks::Server.get(self.id, server_id)
+    end
+
+    def create_server(options = {})
+      ProfitBricks::Server.create(self.id, options)
+    end
+
+    def list_volumes
+      ProfitBricks::Volume.list(self.id)
+    end
+
+    def get_volume(volume_id)
+      ProfitBricks::Volume.get(self.id, nil, volume_id)
+    end
+
+    def create_volume(options = {})
+      ProfitBricks::Volume.create(self.id, options)
+    end
+
+    def list_loadbalancers
+      ProfitBricks::Loadbalancer.list(self.id)
+    end
+
+    def get_loadbalancer(loadbalancer_id)
+      ProfitBricks::Loadbalancer.get(self.id, loadbalancer_id)
+    end
+
+    def create_loadbalancer(options = {})
+      ProfitBricks::Loadbalancer.create(self.id, options)
+    end
+
+    def list_lans
+      ProfitBricks::LAN.list(self.id)
+    end
+
+    def get_lan(lan_id)
+      ProfitBricks::LAN.get(self.id, lan_id)
+    end
+
+    def create_lan(options = {})
+      ProfitBricks::LAN.create(self.id, options)
+    end
+
+    alias_method :server, :get_server
+    alias_method :servers, :list_servers
+    alias_method :volume, :get_volume
+    alias_method :volumes, :list_volumes
+    alias_method :loadbalancer, :get_loadbalancer
+    alias_method :loadbalancers, :list_loadbalancers
+    alias_method :lan, :get_lan
+    alias_method :lans, :list_lans
+
+    class << self
+      def create(options = {})
+        response = ProfitBricks.request(
+          method: :post,
+          path: '/datacenters',
+          body: { properties: options }.to_json,
+          expects: 202
+        )
+        instantiate_objects(response)
+      end
+
+      def list
+        response = ProfitBricks.request(
+          method: :get,
+          path: '/datacenters',
+          expects: 200
+        )
+        instantiate_objects(response)
+      end
+
+      def get(datacenter_id)
+        response = ProfitBricks.request(
+          method: :get,
+          path: "/datacenters/#{datacenter_id}",
+          expects: 200
+        )
+        instantiate_objects(response)
+      end
+    end
+  end
+end

data/lib/profitbricks/firewall.rb

@@ -0,0 +1,65 @@
+module ProfitBricks
+  # Firewall class
+  class Firewall < ProfitBricks::Model
+
+    # Delete the firewall rule.
+    def delete
+      ProfitBricks.request(
+        method: :delete,
+        path: "/datacenters/#{self.datacenterId}/servers/#{self.serverId}/nics/#{self.nicId}/firewallrules/#{self.id}",
+        expects: 202
+      )
+    end
+
+    # Update the firewall rule.
+    def update(options = {})
+      response = ProfitBricks.request(
+        method: :patch,
+        path: "/datacenters/#{self.datacenterId}/servers/#{self.serverId}/nics/#{self.nicId}/firewallrules/#{self.id}",
+        expects: 202,
+        body: options.to_json
+      )
+      if response
+        @properties = @properties.merge(response['properties'])
+      end
+      self
+    end
+
+    class << self
+
+      # Create a new firewall rule.
+      def create(datacenter_id, server_id, nic_id, options = {})
+        response = ProfitBricks.request(
+          method: :post,
+          path: "/datacenters/#{datacenter_id}/servers/#{server_id}/nics/#{nic_id}/firewallrules",
+          expects: 202,
+          body: { properties: options }.to_json
+        )
+        add_parent_identities(response)
+        instantiate_objects(response)
+      end
+
+      # List all firewall rules assigned to a NIC.
+      def list(datacenter_id, server_id, nic_id)
+        response = ProfitBricks.request(
+          method: :get,
+          path: "/datacenters/#{datacenter_id}/servers/#{server_id}/nics/#{nic_id}/firewallrules",
+          expects: 200
+        )
+        add_parent_identities(response)
+        instantiate_objects(response)
+      end
+
+      # Retrieve a firewall rule assigned to a NIC.
+      def get(datacenter_id, server_id, nic_id, fwrule_id)
+        response = ProfitBricks.request(
+          method: :get,
+          path: "/datacenters/#{datacenter_id}/servers/#{server_id}/nics/#{nic_id}/firewallrules/#{fwrule_id}",
+          expects: 200
+        )
+        add_parent_identities(response)
+        instantiate_objects(response)
+      end
+    end
+  end
+end

data/lib/profitbricks/image.rb

@@ -0,0 +1,51 @@
+module ProfitBricks
+  # Image class
+  class Image < ProfitBricks::Model
+
+    # Delete the image.
+    def delete
+      ProfitBricks.request(
+        method: :delete,
+        path: "/images/#{self.id}",
+        expects: 202
+      )
+    end
+
+    # Update the image.
+    def update(options = {})
+      response = ProfitBricks.request(
+        method: :patch,
+        path: "/images/#{self.id}",
+        expects: 202,
+        body: options.to_json
+      )
+      if response
+        @properties = @properties.merge(response['properties'])
+      end
+      self
+    end
+
+    class << self
+
+      # List all images.
+      def list
+        response = ProfitBricks.request(
+          method: :get,
+          path: '/images',
+          expects: 200
+        )
+        instantiate_objects(response)
+      end
+
+      # Retrieve an image.
+      def get(image_id)
+        response = ProfitBricks.request(
+          method: :get,
+          path: "/images/#{image_id}",
+          expects: 200
+        )
+        instantiate_objects(response)
+      end
+    end
+  end
+end

data/lib/profitbricks/ipblock.rb

@@ -0,0 +1,74 @@
+module ProfitBricks
+  # IPBlock class
+  class IPBlock < ProfitBricks::Model
+    # Release an IP block.
+    def release
+      ProfitBricks.request(
+        method: :delete,
+        path: "/ipblocks/#{self.id}",
+        expects: 202
+      )
+    end
+
+    alias_method :delete, :release
+
+    class << self
+      # Reserve an IP block.
+      #
+      # ==== Parameters
+      # * +options+<Hash>:
+      #   - +location+<String> - *Required*, must be one of the following locations:
+      #     * +us/las+ - United States / Las Vegas
+      #     * +de/fra+ - Germany / Frankfurt
+      #     * +de/fkb+ - Germany / Karlsruhe
+      #   - +size+<Integer> - *Required*, the desired size of the IP block.
+      #
+      # ==== Returns
+      # * +id+<String> - Universally unique identifer of resource
+      # * +type+<String> - Resource type
+      # * +href+<String> - Resource URL representation
+      # * +metadata+<Hash>:
+      #   - +lastModifiedDate+
+      #   - +lastModifiedBy+
+      #   - +createdDate+
+      #   - +createdBy+
+      #   - +etag+
+      # * +properties+<Hash>:
+      #   - +size+<Integer> - Size of the IP block
+      #   - +ips+<Array> - A collection of IP addresses associated with the IP block
+      #   - +location+<String> - Location of IP block
+      #
+      def reserve(options = {})
+        response = ProfitBricks.request(
+          method: :post,
+          path: '/ipblocks',
+          expects: 202,
+          body: { properties: options }.to_json
+        )
+        instantiate_objects(response)
+      end
+
+      # List all reserved IP blocks.
+      def list
+        response = ProfitBricks.request(
+          method: :get,
+          path: '/ipblocks',
+          expects: 200
+        )
+        instantiate_objects(response)
+      end
+
+      # Retrieve a reserved IP block.
+      def get(ipblock_id)
+        response = ProfitBricks.request(
+          method: :get,
+          path: "/ipblocks/#{ipblock_id}",
+          expects: 200
+        )
+        instantiate_objects(response)
+      end
+
+      alias_method :create, :reserve
+    end
+  end
+end