fog 0.0.84 → 0.0.85

data/lib/fog/local/models/file.rb

@@ -0,0 +1,58 @@
+require 'fog/model'
+
+module Fog
+  module Local
+
+    class File < Fog::Model
+
+      identity  :key,             'Key'
+
+      attr_accessor :body
+      attribute :content_length,  'Content-Length'
+      # attribute :content_type,    'Content-Type'
+      attribute :last_modified,   'Last-Modified'
+
+      def body
+        @body ||= if last_modified
+          collection.get(identity).body
+        else
+          ''
+        end
+      end
+
+      def directory
+        @directory
+      end
+
+      def destroy
+        requires :directory, :key
+        ::File.delete(path)
+        true
+      end
+
+      def save(options = {})
+        requires :body, :directory, :key
+        file = ::File.new(path, 'w')
+        file.write(body)
+        file.close
+        merge_attributes(
+          :content_length => ::File.size(path),
+          :last_modified  => ::File.mtime(path)
+        )
+        true
+      end
+
+      private
+
+      def directory=(new_directory)
+        @directory = new_directory
+      end
+
+      def path
+        connection.path_to(::File.join(directory.name, key))
+      end
+
+    end
+
+  end
+end

data/lib/fog/local/models/files.rb

@@ -0,0 +1,74 @@
+require 'fog/collection'
+require 'fog/local/models/file'
+
+module Fog
+  module Local
+
+    class Files < Fog::Collection
+
+      model Fog::Local::File
+
+      def all
+        if directory.collection.get(directory.name)
+          data = Dir.entries(connection.path_to(directory.name)).select do |key|
+            key[0...1] != '.' && !::File.directory?(connection.path_to(key))
+          end.map do |key|
+            path = file_path(key)
+            {
+              :content_length => ::File.size(path),
+              :key            => key,
+              :last_modified  => ::File.mtime(path)
+            }
+          end
+          load(data)
+        else
+          nil
+        end
+      end
+
+      def directory
+        @directory
+      end
+
+      def get(key, &block)
+        path = file_path(key)
+        if ::File.exists?(path)
+          data = {
+            :content_length => ::File.size(path),
+            :key            => key,
+            :last_modified  => ::File.mtime(path)
+          }
+          if block_given?
+            file = ::File.open(path)
+            while (chunk = file.read(Excon::CHUNK_SIZE)) && yield(chunk); end
+            file.close
+            new(data)
+          else
+            body = nil
+            ::File.open(path) do |file|
+              body = file.read
+            end
+            new(data.merge!(:body => body))
+          end
+        else
+          nil
+        end
+      end
+
+      def new(attributes = {})
+        super({ :directory => directory }.merge!(attributes))
+      end
+
+      private
+
+      def directory=(new_directory)
+        @directory = new_directory
+      end
+
+      def file_path(key)
+        connection.path_to(::File.join(directory.name, key))
+      end
+
+    end
+  end
+end

data/lib/fog/model.rb

@@ -110,14 +110,8 @@ module Fog
     end
 
     def wait_for(timeout = 600, &block)
-      start = Time.now
-      until instance_eval(&block)
-        if Time.now - start > timeout
-          break
-        end
-        reload
-        sleep(1)
-      end
+      reload
+      Fog.wait_for(timeout) { reload && instance_eval(&block) }
     end
 
     private

data/lib/fog/rackspace/models/files/directories.rb

@@ -26,9 +26,9 @@ module Fog
           load(data)
         end
 
-        def get(name, options = {})
-          data = connection.get_container(name, options).body
-          directory = new(:name => name)
+        def get(key, options = {})
+          data = connection.get_container(key, options).body
+          directory = new(:key => key)
           directory.files.merge_attributes(options)
           directory.files.instance_variable_set(:@loaded, true)
           data.each do |file|

data/lib/fog/rackspace/models/files/directory.rb

@@ -1,19 +1,22 @@
 require 'fog/model'
+require 'fog/rackspace/models/files/files'
 
 module Fog
   module Rackspace
     module Files
 
       class Directory < Fog::Model
+        extend Fog::Deprecation
+        deprecate(:name, :key)
 
-        identity  :name
+        identity  :key, 'name'
 
         attribute :bytes
         attribute :count
 
         def destroy
-          requires :name
-          connection.delete_container(@name)
+          requires :key
+          connection.delete_container(key)
           true
         rescue Excon::Errors::NotFound
           false
@@ -29,8 +32,8 @@ module Fog
         end
 
         def save
-          requires :name
-          connection.put_container(@name)
+          requires :key
+          connection.put_container(key)
           true
         end
 

data/lib/fog/rackspace/models/servers/server.rb

@@ -51,10 +51,14 @@ module Fog
         end
 
         def save
-          requires :flavor_id, :image_id, :name
-          options = { 'metadata' => @metadata, 'personality' => @personality }
+          requires :flavor_id, :image_id
+          options = {
+            'metadata'    => @metadata,
+            'name'        => @name,
+            'personality' => @personality
+          }
           options = options.reject {|key, value| value.nil?}
-          data = connection.create_server(@flavor_id, @image_id, @name, options)
+          data = connection.create_server(@flavor_id, @image_id, options)
           merge_attributes(data.body['server'])
           true
         end

data/lib/fog/rackspace/requests/servers/create_server.rb

@@ -33,7 +33,7 @@ module Fog
         #     * 'name<~String> - Name of server
         #     * 'progress'<~Integer> - Progress through current status
         #     * 'status'<~String> - Current server status
-        def create_server(flavor_id, image_id, name, options = {})
+        def create_server(flavor_id, image_id, options = {})
           data = {
             'server' => {
               'flavorId'  => flavor_id,

data/lib/fog/ssh.rb

@@ -1,42 +1,108 @@
 module Fog
+  module SSH
 
-  class SSH
-
-    def initialize(address, username, options = {})
+    def self.new(address, username, options = {})
       unless options[:keys] || options[:password]
         raise ArgumentError.new(':keys or :password are required to initialize SSH')
       end
-      @address  = address
-      @username = username
-      @options  = options.merge!(:paranoid => false)
+      if Fog.mocking?
+        Fog::SSH::Mock.new(address, username, options)
+      else
+        Fog::SSH::Real.new(address, username, options)
+      end
+    end
+
+    def self.reset_data(keys=Mock.data.keys)
+      Mock.reset_data(keys)
     end
 
-    def run(commands)
-      commands = [*commands]
-      results = []
-      Net::SSH.start(@address, @username, @options) do |ssh|
-        commands.each do |command|
-          ssh.open_channel do |channel|
-            channel.request_pty
-            result = { :command => command }
-            channel.exec(command.sub(/^sudo/, %q{sudo -p 'fog sudo password:'})) do |channel, success|
-              channel.on_data do |channel, data|
-                if data.strip == 'fog sudo password:'
-                  channel.send_data("#{@options[:password]}\n")
-                else
-                  result[:data] ||= ''
-                  result[:data] << data
+    class Mock
+
+      def self.data
+        @data ||= Hash.new do |hash, key|
+          hash[key] = {}
+        end
+      end
+
+      def initialize(address, username, options)
+        @address  = address
+        @username = username
+        @options  = options
+      end
+
+      def run(commands)
+        raise MockNotImplemented.new("Contributions welcome!")
+      end
+
+    end
+
+    class Real
+
+      def initialize(address, username, options)
+        @address  = address
+        @username = username
+        @options  = options.merge!(:paranoid => false)
+      end
+
+      def run(commands)
+        commands = [*commands]
+        results  = []
+        begin
+          Net::SSH.start(@address, @username, @options) do |ssh|
+            commands.each do |command|
+              ssh.open_channel do |channel|
+                sudoable_command  = command.sub(/^sudo/, %{sudo -p 'fog sudo password:'})
+                escaped_command   = sudoable_command.sub(/'/, %{'"'"'})
+                channel.request_pty
+                result = Result.new(command)
+                channel.exec(%{bash -lc '#{escaped_command}'}) do |channel, success|
+                  unless success
+                    raise "Could not execute command: #{command.inspect}"
+                  end
+
+                  channel.on_data do |channel, data|
+                    result.stdout << data
+                  end
+
+                  channel.on_extended_data do |channel, type, data|
+                    next unless type == 1
+                    result.stderr << data
+                  end
+
+                  channel.on_request('exit-status') do |channel, data|
+                    result.status = data.read_long
+                  end
+
+                  channel.on_request('exit-signal') do |channel, data|
+                    result.status = 255
+                  end
                 end
+                results << result
               end
+              ssh.loop
             end
-            results << result
           end
-          ssh.loop
+        rescue Net::SSH::HostKeyMismatch => exception
+          exception.remember_host!
+          sleep 0.2
+          retry
         end
+        results
+      end
+
+    end
+
+    class Result
+
+      attr_accessor :command, :stderr, :stdout, :status
+
+      def initialize(command)
+        @command = command
+        @stderr = ''
+        @stdout = ''
       end
-      results
+
     end
 
   end
-
 end

data/lib/fog/terremark/bin.rb

@@ -28,14 +28,7 @@ module Terremark
               !Fog::Terremark::VCLOUD_OPTIONS.include?(k)
             end
           end
-          case key
-          when :ecloud
-            hash[key] = Fog::Terremark::Ecloud.new(credentials)
-          when :vcloud
-            hash[key] = Fog::Terremark::Vcloud.new(credentials)
-          else
-            raise "Unsupported Terremark Service"
-          end
+          hash[key] = terremark_service(key).new(credentials)
         end
         @@connections[service]
       end

data/lib/fog/terremark/ecloud.rb

@@ -5,6 +5,13 @@ module Fog
      module Bin
      end
 
+     module Defaults
+       HOST   = 'services.enterprisecloud.terremark.com'
+       PATH   = '/api/v0.8a-ext2.0'
+       PORT   = 443
+       SCHEME = 'https'
+     end
+
      extend Fog::Terremark::Shared
 
      def self.new(options={})
@@ -31,11 +38,10 @@ module Fog
         def initialize(options={})
           @terremark_password = options[:terremark_ecloud_password]
           @terremark_username = options[:terremark_ecloud_username]
-          @host   = options[:host]   || "services.enterprisecloud.terremark.com"
-          @path   = options[:path]   || "/api/v0.8a-ext2.0"
-          @port   = options[:port]   || 443
-          @scheme = options[:scheme] || 'https'
-          @cookie = get_organizations.headers['Set-Cookie']
+          @host   = options[:host]   || Fog::Terremark::Ecloud::Defaults::HOST
+          @path   = options[:path]   || Fog::Terremark::Ecloud::Defaults::PATH
+          @port   = options[:port]   || Fog::Terremark::Ecloud::Defaults::PORT
+          @scheme = options[:scheme] || Fog::Terremark::Ecloud::Defaults::SCHEME
         end
 
       end
@@ -46,6 +52,9 @@ module Fog
 
        def initialize(option = {})
          super
+         @base_url = Fog::Terremark::Ecloud::Defaults::SCHEME + "://" +
+                     Fog::Terremark::Ecloud::Defaults::HOST +
+                     Fog::Terremark::Ecloud::Defaults::PATH
          @data = self.class.data[:terremark_ecloud_username]
        end
      end

data/lib/fog/terremark/models/shared/server.rb

@@ -25,12 +25,60 @@ module Fog
           @status == '2'
         end
 
-        def reboot
+        def on?
+          @status == '4'
+        end
+
+        def off?
+          @status == '2'
+        end
+
+        def power_on(options = {})
+          requires :id
+          begin
+            connection.power_on(@id)
+          rescue Excon::Errors::InternalServerError => e
+            #Frankly we shouldn't get here ...
+            raise e unless e.to_s =~ /because it is already powered on/
+          end
+          true
+        end
+
+        def power_off
+          requires :id
+          begin
+            connection.power_off(@id)
+          rescue Excon::Errors::InternalServerError => e
+            #Frankly we shouldn't get here ...
+            raise e unless e.to_s =~ /because it is already powered off/
+          end
+          true
+        end
+
+        def shutdown
+          requires :id
+          begin
+            connection.power_shutdown(@id)
+          rescue Excon::Errors::InternalServerError => e
+            #Frankly we shouldn't get here ...
+            raise e unless e.to_s =~ /because it is already powered off/
+          end
+          true
+        end
+
+        def power_reset
           requires :id
-          connection.reset(@id)
+          connection.power_reset(@id)
           true
         end
 
+        def graceful_restart
+          requires :id
+          shutdown
+          wait_for { off? }
+          power_on
+        end
+
         def save
           requires :name
           data = connection.instantiate_vapp(@name)
@@ -48,7 +96,10 @@ module Fog
           @id = new_href.split('/').last.to_i
         end
 
-        def type=(new_type); end
+        def type=(new_type); @type = new_type; end
+        def size=(new_size); @size = new_size; end
+        def IpAddress=(new_ipaddress); @IpAddress = new_ipaddress; end
+        def Links=(new_links); @Links = new_links; end
 
       end