fog 1.4.0 → 1.5.0

data/lib/fog/rackspace/load_balancers.rb

@@ -29,6 +29,9 @@ module Fog
       model :access_rule
 
       request_path 'fog/rackspace/requests/load_balancers'
+      request :get_ssl_termination
+      request :set_ssl_termination
+      request :remove_ssl_termination
       request :create_load_balancer
       request :get_load_balancer
       request :list_load_balancers

data/lib/fog/rackspace/models/databases/database.rb

@@ -0,0 +1,32 @@
+require 'fog/core/model'
+
+module Fog
+  module Rackspace
+    class Databases
+      class Database < Fog::Model
+        identity :name
+
+        attribute :character_set
+        attribute :collate
+
+        def save
+          requires :identity, :instance
+          connection.create_database(instance.identity, identity, :character_set => character_set, :collate => collate)
+          true
+        end
+
+        def destroy
+          requires :identity, :instance
+          connection.delete_database(instance.identity, identity)
+          true
+        end
+
+        private
+
+        def instance
+          collection.instance
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/databases/databases.rb

@@ -0,0 +1,31 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/databases/database'
+
+module Fog
+  module Rackspace
+    class Databases
+      class Databases < Fog::Collection
+
+        model Fog::Rackspace::Databases::Database
+
+        attr_accessor :instance
+
+        def all
+          load(retrieve_databases)
+        end
+
+        def get(database_name)
+          data = retrieve_databases.find { |database| database['name'] == database_name }
+          data && new(data)
+        end
+
+        private
+
+        def retrieve_databases
+          requires :instance
+          data = connection.list_databases(instance.id).body['databases']
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/databases/flavor.rb

@@ -0,0 +1,15 @@
+require 'fog/core/model'
+
+module Fog
+  module Rackspace
+    class Databases
+      class Flavor < Fog::Model
+        identity :id
+
+        attribute :name
+        attribute :ram
+        attribute :links
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/databases/flavors.rb

@@ -0,0 +1,25 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/databases/flavor'
+
+module Fog
+  module Rackspace
+    class Databases
+      class Flavors < Fog::Collection
+
+        model Fog::Rackspace::Databases::Flavor
+
+        def all
+          data = connection.list_flavors.body['flavors']
+          load(data)
+        end
+
+        def get(flavor_id)
+          data = connection.get_flavor(flavor_id).body['flavor']
+          new(data)
+        rescue Fog::Rackspace::Databases::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/databases/instance.rb

@@ -0,0 +1,104 @@
+require 'fog/core/model'
+
+module Fog
+  module Rackspace
+    class Databases
+      class Instance < Fog::Model
+        # States
+        ACTIVE = 'ACTIVE'
+        BUILD = 'BUILD'
+        BLOCKED = 'BLOCKED'
+        REBOOT = 'REBOOT'
+        RESIZE = 'RESIZE'
+        SHUTDOWN = 'SHUTDOWN'
+
+        identity :id
+
+        attribute :name
+        attribute :created
+        attribute :updated
+        attribute :state, :aliases => 'status'
+        attribute :hostname
+        attribute :links
+        attribute :flavor_id, :aliases => 'flavor', :squash => 'id'
+        attribute :volume_size, :aliases => 'volume', :squash => 'size'
+
+        attr_accessor :root_user, :root_password
+
+        def save
+          requires :name, :flavor_id, :volume_size
+          data = connection.create_instance(name, flavor_id, volume_size)
+          merge_attributes(data.body['instance'])
+          true
+        end
+
+        def destroy
+          requires :identity
+          connection.delete_instance(identity)
+          true
+        end
+
+        def flavor
+          requires :flavor_id
+          @flavor ||= connection.flavors.get(flavor_id)
+        end
+
+        def databases
+          @databases ||= begin
+            Fog::Rackspace::Databases::Databases.new({
+              :connection => connection,
+              :instance => self
+            })
+          end
+        end
+
+        def users
+          @users ||= begin
+            Fog::Rackspace::Databases::Users.new({
+              :connection => connection,
+              :instance => self
+            })
+          end
+        end
+
+        def ready?
+          state == ACTIVE
+        end
+
+        def root_user_enabled?
+          requires :identity
+          connection.check_root_user(identity).body['rootEnabled']
+        end
+
+        def enable_root_user
+          requires :identity
+          data = connection.enable_root_user(identity).body['user']
+          @root_user = data['name']
+          @root_password = data['password']
+          true
+        end
+
+        def restart
+          requires :identity
+          connection.restart_instance(identity)
+          self.state = REBOOT
+          true
+        end
+
+        def resize(flavor_id)
+          requires :identity
+          connection.resize_instance(identity, flavor_id)
+          self.state = RESIZE
+          true
+        end
+
+        def resize_volume(volume_size)
+          requires :identity
+          connection.resize_instance_volume(identity, volume_size)
+          self.state = RESIZE
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/databases/instances.rb

@@ -0,0 +1,25 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/databases/instance'
+
+module Fog
+  module Rackspace
+    class Databases
+      class Instances < Fog::Collection
+
+        model Fog::Rackspace::Databases::Instance
+
+        def all
+          data = connection.list_instances.body['instances']
+          load(data)
+        end
+
+        def get(instance_id)
+          data = connection.get_instance(instance_id).body['instance']
+          new(data)
+        rescue Fog::Rackspace::Databases::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/databases/user.rb

@@ -0,0 +1,32 @@
+require 'fog/core/model'
+
+module Fog
+  module Rackspace
+    class Databases
+      class User < Fog::Model
+        identity :name
+
+        attribute :password
+        attribute :databases
+
+        def save
+          requires :identity, :instance, :password
+          connection.create_user(instance.identity, identity, password, :databases => databases)
+          true
+        end
+
+        def destroy
+          requires :identity, :instance
+          connection.delete_user(instance.identity, identity)
+          true
+        end
+
+        private
+
+        def instance
+          collection.instance
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/databases/users.rb

@@ -0,0 +1,31 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/databases/user'
+
+module Fog
+  module Rackspace
+    class Databases
+      class Users < Fog::Collection
+
+        model Fog::Rackspace::Databases::User
+
+        attr_accessor :instance
+
+        def all
+          load(retrieve_users)
+        end
+
+        def get(user_name)
+          data = retrieve_users.find { |database| database['name'] == user_name }
+          data && new(data)
+        end
+
+        private
+
+        def retrieve_users
+          requires :instance
+          data = connection.list_users(instance.identity).body['users']
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/identity/credential.rb

@@ -0,0 +1,13 @@
+require 'fog/core/model'
+
+module Fog
+  module Rackspace
+    class Identity
+      class Credential < Fog::Model
+        identity :apiKey
+
+        attribute :username
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/identity/credentials.rb

@@ -0,0 +1,32 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/identity/credential'
+
+module Fog
+  module Rackspace
+    class Identity
+      class Credentials < Fog::Collection
+
+        model Fog::Rackspace::Identity::Credential
+
+        attr_accessor :user
+
+        def all
+          requires :user
+          load(retrieve_credentials)
+        end
+
+        def get(id)
+          requires :user
+          data = retrieve_credentials.find{ |credential| credential['id'] == id }
+          data && new(data)
+        end
+
+        private
+
+        def retrieve_credentials
+          data = connection.list_credentials(user.identity).body['credentials']
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/identity/role.rb

@@ -0,0 +1,14 @@
+require 'fog/core/model'
+
+module Fog
+  module Rackspace
+    class Identity
+      class Role < Fog::Model
+        identity :id
+
+        attribute :name
+        attribute :description
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/identity/roles.rb

@@ -0,0 +1,32 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/identity/role'
+
+module Fog
+  module Rackspace
+    class Identity
+      class Roles < Fog::Collection
+
+        model Fog::Rackspace::Identity::Role
+
+        attr_accessor :user
+
+        def all
+          requires :user
+          load(retrieve_roles)
+        end
+
+        def get(id)
+          requires :user
+          data = retrieve_roles.find{ |role| role['id'] == id }
+          data && new(data)
+        end
+
+        private
+
+        def retrieve_roles
+          data = connection.list_user_roles(user.identity).body['roles']
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/identity/tenant.rb

@@ -0,0 +1,15 @@
+require 'fog/core/model'
+
+module Fog
+  module Rackspace
+    class Identity
+      class Tenant < Fog::Model
+        identity :id
+
+        attribute :name
+        attribute :description
+        attribute :enabled
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/identity/tenants.rb

@@ -0,0 +1,28 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/identity/tenant'
+
+module Fog
+  module Rackspace
+    class Identity
+      class Tenants < Fog::Collection
+
+        model Fog::Rackspace::Identity::Tenant
+
+        def all
+          load(retrieve_tenants)
+        end
+
+        def get(id)
+          data = retrieve_tenants.find{ |tenant| tenant['id'] == id }
+          data && new(data)
+        end
+
+        private
+
+        def retrieve_tenants
+          data = connection.list_tenants.body['tenants']
+        end
+      end
+    end
+  end
+end