fog-brightbox 0.0.1

data/lib/fog/brightbox/models/compute/images.rb

@@ -0,0 +1,28 @@
+require 'fog/core/collection'
+require 'fog/brightbox/models/compute/image'
+
+module Fog
+  module Compute
+    class Brightbox
+
+      class Images < Fog::Collection
+
+        model Fog::Compute::Brightbox::Image
+
+        def all
+          data = service.list_images
+          load(data)
+        end
+
+        def get(identifier)
+          data = service.get_image(identifier)
+          new(data)
+        rescue Excon::Errors::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/brightbox/models/compute/load_balancer.rb

@@ -0,0 +1,107 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class Brightbox
+
+      class LoadBalancer < Fog::Model
+
+        identity :id
+        attribute :url
+        attribute :resource_type
+
+        attribute :name
+        attribute :status
+
+        attribute :policy
+        attribute :nodes
+        attribute :healthcheck
+        attribute :listeners
+
+        # These SSL attributes act only as setters. You can not read certs or keys via the API
+        attribute :certificate_pem
+        attribute :certificate_private_key
+
+        # These SSL attributes act only as getters for metadata
+        attribute :certificate_valid_from
+        attribute :certificate_expires_at
+        attribute :certificate_issuer
+        attribute :certificate_subject
+
+        # Times
+        attribute :created_at, :type => :time
+        attribute :deleted_at, :type => :time
+
+        # Links - to be replaced
+        attribute :account
+        attribute :server
+        attribute :cloud_ip
+
+        def ready?
+          status == 'active'
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
+          requires :nodes, :listeners, :healthcheck
+          options = {
+            :nodes => nodes,
+            :listeners => listeners,
+            :healthcheck => healthcheck,
+            :policy => policy,
+            :name => name,
+            :certificate_pem => certificate_pem,
+            :certificate_private_key => certificate_private_key
+          }.delete_if { |k, v| v.nil? || v == "" }
+          data = service.create_load_balancer(options)
+          merge_attributes(data)
+          true
+        end
+
+        def destroy
+          requires :identity
+          service.destroy_load_balancer(identity)
+          true
+        end
+
+        # SSL cert metadata for expiration of certificate
+        def certificate_expires_at
+          attributes[:certificate_expires_at]
+        end
+
+        # SSL cert metadata for subject
+        def certificate_subject
+          attributes[:certificate_subject]
+        end
+
+        # Sets the certificate metadata from the JSON object that contains it.
+        #
+        # It is used by fog's attribute setting and should not be used for attempting to set a
+        # certificate on a load balancer.
+        #
+        # @private
+        def certificate=(cert_metadata)
+          if cert_metadata
+            attributes[:certificate_valid_from] = time_or_original(cert_metadata["valid_from"])
+            attributes[:certificate_expires_at] = time_or_original(cert_metadata["expires_at"])
+            attributes[:certificate_issuer] = cert_metadata["issuer"]
+            attributes[:certificate_subject] = cert_metadata["subject"]
+          else
+            attributes[:certificate_valid_from] = nil
+            attributes[:certificate_expires_at] = nil
+            attributes[:certificate_issuer] = nil
+            attributes[:certificate_subject] = nil
+          end
+        end
+
+        private
+
+        def time_or_original(value)
+          Time.parse(value)
+        rescue TypeError, ArgumentError
+          value
+        end
+      end
+    end
+  end
+end

data/lib/fog/brightbox/models/compute/load_balancers.rb

@@ -0,0 +1,28 @@
+require 'fog/core/collection'
+require 'fog/brightbox/models/compute/load_balancer'
+
+module Fog
+  module Compute
+    class Brightbox
+
+      class LoadBalancers < Fog::Collection
+
+        model Fog::Compute::Brightbox::LoadBalancer
+
+        def all
+          data = service.list_load_balancers
+          load(data)
+        end
+
+        def get(identifier)
+          data = service.get_load_balancer(identifier)
+          new(data)
+        rescue Excon::Errors::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/brightbox/models/compute/server.rb

@@ -0,0 +1,217 @@
+require 'fog/compute/models/server'
+
+module Fog
+  module Compute
+    class Brightbox
+
+      class Server < Fog::Compute::Server
+
+        identity  :id
+        attribute :resource_type
+        attribute :url
+
+        attribute :name
+        attribute :state,       :aliases => 'status'
+
+        attribute :hostname
+        attribute :fqdn
+        attribute :user_data
+        attribute :console_url
+        attribute :fqdn
+        attribute :console_token
+
+        # Times
+        attribute :created_at, :type => :time
+        attribute :started_at, :type => :time
+        attribute :console_token_expires, :type => :time
+        attribute :deleted_at, :type => :time
+
+        # Links - to be replaced
+        attribute :account_id,  :aliases => "account",      :squash => "id"
+        attribute :image_id,    :aliases => "image",        :squash => "id"
+
+        attribute :snapshots
+        attribute :cloud_ips
+        attribute :interfaces
+        attribute :server_groups
+        attribute :zone
+        attribute :server_type
+
+        def initialize(attributes = {})
+          # Call super first to initialize the service object for our default image
+          super
+          self.image_id ||= service.default_image
+        end
+
+        def zone_id
+          if t_zone_id = attributes[:zone_id]
+            t_zone_id
+          elsif zone
+            zone[:id] || zone['id']
+          end
+        end
+
+        def flavor_id
+          if t_flavour_id = attributes[:flavor_id]
+            t_flavour_id
+          elsif server_type
+            server_type[:id] || server_type['id']
+          end
+        end
+
+        def zone_id=(incoming_zone_id)
+          attributes[:zone_id] = incoming_zone_id
+        end
+
+        def flavor_id=(incoming_flavour_id)
+          attributes[:flavor_id] = incoming_flavour_id
+        end
+
+        def snapshot
+          requires :identity
+          service.snapshot_server(identity)
+        end
+
+        # Directly requesting a server reboot is not supported in the API
+        # so needs to attempt a shutdown/stop, wait and start again.
+        #
+        # Default behaviour is a hard reboot because it is more reliable
+        # because the state of the server's OS is irrelevant.
+        #
+        # @param [Boolean] use_hard_reboot
+        # @return [Boolean]
+        def reboot(use_hard_reboot = true)
+          requires :identity
+          if ready?
+            if use_hard_reboot
+              hard_reboot
+            else
+              soft_reboot
+            end
+          else
+            # Not able to reboot if not ready in the first place
+            false
+          end
+        end
+
+        def start
+          requires :identity
+          service.start_server(identity)
+          true
+        end
+
+        def stop
+          requires :identity
+          service.stop_server(identity)
+          true
+        end
+
+        def shutdown
+          requires :identity
+          service.shutdown_server(identity)
+          true
+        end
+
+        def destroy
+          requires :identity
+          service.destroy_server(identity)
+          true
+        end
+
+        def flavor
+          requires :flavor_id
+          service.flavors.get(flavor_id)
+        end
+
+        def image
+          requires :image_id
+          service.images.get(image_id)
+        end
+
+        # Returns the public DNS name of the server
+        #
+        # @return [String]
+        #
+        def dns_name
+          ["public", fqdn].join(".")
+        end
+
+        def private_ip_address
+          if interfaces.empty?
+            nil
+          else
+            interfaces.first["ipv4_address"]
+          end
+        end
+
+        def public_ip_address
+          if cloud_ips.empty?
+            nil
+          else
+            cloud_ips.first["public_ip"]
+          end
+        end
+
+        def ready?
+          state == "active"
+        end
+
+        def activate_console
+          requires :identity
+          response = service.activate_console_server(identity)
+          [response["console_url"], response["console_token"], response["console_token_expires"]]
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
+          requires :image_id
+          options = {
+            :image => image_id,
+            :name => name,
+            :zone => zone_id,
+            :user_data => user_data,
+            :server_groups => server_groups
+          }.delete_if { |k, v| v.nil? || v == "" }
+
+          options.merge!(:server_type => flavor_id) unless flavor_id.nil? || flavor_id == ""
+
+          data = service.create_server(options)
+          merge_attributes(data)
+          true
+        end
+
+        # Replaces the server's identifier with it's interface's identifier for Cloud IP mapping
+        #
+        # @return [String] the identifier to pass to a Cloud IP mapping request
+        def mapping_identity
+          interfaces.first["id"]
+        end
+
+        private
+
+        # Hard reboots are fast, avoiding the OS by doing a "power off"
+        def hard_reboot
+          stop
+          wait_for { !ready? }
+          start
+        end
+
+        # Soft reboots often timeout if the OS missed the request so we do more
+        # error checking trying to detect the timeout
+        #
+        # @todo Needs cleaner error handling when the OS times out
+        def soft_reboot
+          shutdown
+          # FIXME: Using side effect of wait_for's (evaluated block) to detect timeouts
+          begin
+            wait_for(20) { !ready? }
+            start
+          rescue Fog::Errors::Timeout
+            false
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/brightbox/models/compute/server_group.rb

@@ -0,0 +1,94 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class Brightbox
+      # A server group is a collection of servers
+      #
+      # Certain actions can accept a server group and affect all members
+      class ServerGroup < Fog::Model
+
+        identity :id
+
+        attribute :url
+        attribute :resource_type
+        attribute :name
+        attribute :description
+        attribute :default
+        attribute :created_at, :type => :time
+
+        attribute :server_ids, :aliases => "servers"
+
+        def save
+          options = {
+            :name => name,
+            :description => description
+          }.delete_if { |k, v| v.nil? || v == "" }
+          data = service.create_server_group(options)
+          merge_attributes(data)
+          true
+        end
+
+        def servers
+          srv_ids = server_ids.map { |srv| srv["id"] }
+          srv_ids.map do |srv_id|
+            service.servers.get(srv_id)
+          end
+        end
+
+        # Adds specified servers to this server group
+        #
+        # @param [Array] identifiers array of server identifier strings to add
+        # @return [Fog::Compute::ServerGroup]
+        def add_servers(identifiers)
+          requires :identity
+          options = {
+            :servers => server_references(identifiers)
+          }
+          data = service.add_servers_server_group identity, options
+          merge_attributes data
+        end
+
+        # Removes specified servers from this server group
+        #
+        # @param [Array] identifiers array of server identifier strings to remove
+        # @return [Fog::Compute::ServerGroup]
+        def remove_servers(identifiers)
+          requires :identity
+          options = {
+            :servers => server_references(identifiers)
+          }
+          data = service.remove_servers_server_group identity, options
+          merge_attributes data
+        end
+
+        # Moves specified servers from this server group to the specified destination server group
+        #
+        # @param [Array] identifiers array of server identifier strings to move
+        # @param [String] destination_group_id destination server group identifier
+        # @return [Fog::Compute::ServerGroup]
+        def move_servers(identifiers, destination_group_id)
+          requires :identity
+          options = {
+            :servers => server_references(identifiers),
+            :destination => destination_group_id
+          }
+          data = service.move_servers_server_group identity, options
+          merge_attributes data
+        end
+
+        def destroy
+          requires :identity
+          service.destroy_server_group(identity)
+          true
+        end
+
+        protected
+
+        def server_references(identifiers)
+          identifiers.map { |id| { "server" => id } }
+        end
+      end
+    end
+  end
+end