fog 1.21.0 → 1.22.0

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

@@ -1,217 +0,0 @@
-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/providers/brightbox/lib/fog/brightbox/models/compute/server_group.rb

@@ -1,94 +0,0 @@
-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

data/providers/brightbox/lib/fog/brightbox/models/compute/server_groups.rb

@@ -1,29 +0,0 @@
-require 'fog/core/collection'
-require 'fog/brightbox/models/compute/server_group'
-
-module Fog
-  module Compute
-    class Brightbox
-
-      class ServerGroups < Fog::Collection
-
-        model Fog::Compute::Brightbox::ServerGroup
-
-        def all
-          data = service.list_server_groups
-          load(data)
-        end
-
-        def get(identifier)
-          return nil if identifier.nil? || identifier == ""
-          data = service.get_server_group(identifier)
-          new(data)
-        rescue Excon::Errors::NotFound
-          nil
-        end
-
-      end
-
-    end
-  end
-end

data/providers/brightbox/lib/fog/brightbox/models/compute/servers.rb

@@ -1,61 +0,0 @@
-require 'fog/core/collection'
-require 'fog/brightbox/models/compute/server'
-
-module Fog
-  module Compute
-    class Brightbox
-
-      class Servers < Fog::Collection
-
-        model Fog::Compute::Brightbox::Server
-
-        def all
-          data = service.list_servers
-          load(data)
-        end
-
-        # Creates a server and maps an Cloud IP
-        #
-        # By default the public SSH key you have registered with
-        # Brightbox is already made available in an AWS compatible
-        # metdata service.
-        #
-        # @todo Support uploading of arbitary SSH keys
-        #
-        # @param [Hash] options
-        # @option options [String] name      Name for the server
-        # @option options [String] flavor_id Identifier for virtual hardware type to request
-        # @option options [String] image_id  Identifier for image to use when creating
-        # @option options [String] zone_id   Identifer for preferred zone to locate server in
-        # @option options [Array<String>] server_groups List of group identifiers for the server to join
-        #
-        # @return Fog::Compute::Brightbox::Server
-        #
-        def bootstrap(options = {})
-          server = create(options)
-
-          # Ensure server is now available
-          server.wait_for { ready? }
-
-          # To get a public IP address we need to map a cloud IP address
-          cip = service.cloud_ips.allocate
-          cip.map(server)
-          cip.wait_for { mapped? }
-
-          # Reload so the public IP is now available
-          server.reload
-        end
-
-        def get(identifier)
-          return nil if identifier.nil? || identifier == ""
-          data = service.get_server(identifier)
-          new(data)
-        rescue Excon::Errors::NotFound
-          nil
-        end
-
-      end
-
-    end
-  end
-end

data/providers/brightbox/lib/fog/brightbox/models/compute/user.rb

@@ -1,43 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module Compute
-    class Brightbox
-
-      class User < Fog::Model
-
-        identity :id
-        attribute :resource_type
-        attribute :url
-
-        attribute :name
-        attribute :email_address
-        attribute :ssh_key
-
-        # Boolean flags
-        attribute :email_verified
-        attribute :messaging_pref
-
-        # Links - to be replaced
-        attribute :account_id, :aliases => "default_account", :squash => "id"
-        attribute :accounts
-
-        def save
-          requires :identity
-
-          options = {
-            :email_address => email_address,
-            :ssh_key => ssh_key,
-            :name => name
-          }
-
-          data = service.update_user(identity, options)
-          merge_attributes(data)
-          true
-        end
-
-      end
-
-    end
-  end
-end

data/providers/brightbox/lib/fog/brightbox/models/compute/user_collaboration.rb

@@ -1,44 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module Compute
-    class Brightbox
-      class UserCollaboration < Fog::Model
-        identity  :id
-        attribute :status
-        attribute :email
-        attribute :role
-        attribute :role_label
-        attribute :account
-        attribute :user
-        attribute :inviter
-
-        def account_id
-          account['id'] || account[:id]
-        end
-
-        def accept
-          requires :identity
-          data = service.accept_user_collaboration(identity)
-          merge_attributes(data)
-          true
-        end
-
-        def reject
-          requires :identity
-          data = service.reject_user_collaboration(identity)
-          merge_attributes(data)
-          true
-        end
-
-        def destroy
-          requires :identity
-          data = service.destroy_user_collaboration(identity)
-          merge_attributes(data)
-          true
-        end
-
-      end
-    end
-  end
-end