fog-maestrodev 1.7.0.20121114190951

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

@@ -0,0 +1,73 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class Server < Fog::Model
+
+      attr_writer :username, :private_key, :private_key_path, :public_key, :public_key_path
+
+      def username
+        @username ||= 'root'
+      end
+
+      def private_key_path
+        @private_key_path ||= Fog.credentials[:private_key_path]
+        @private_key_path &&= File.expand_path(@private_key_path)
+      end
+
+      def private_key
+        @private_key ||= private_key_path && File.read(private_key_path)
+      end
+
+      def public_key_path
+        @public_key_path ||= Fog.credentials[:public_key_path]
+        @public_key_path &&= File.expand_path(@public_key_path)
+      end
+
+      def public_key
+        @public_key ||= public_key_path && File.read(public_key_path)
+      end
+
+
+      def scp(local_path, remote_path, upload_options = {})
+        require 'net/scp'
+        requires :public_ip_address, :username
+
+        scp_options = {:port => ssh_port}
+        scp_options[:key_data] = [private_key] if private_key
+        Fog::SCP.new(public_ip_address, username, scp_options).upload(local_path, remote_path, upload_options)
+      end
+
+      alias_method :scp_upload, :scp
+
+      def scp_download(remote_path, local_path, download_options = {})
+        require 'net/scp'
+        requires :public_ip_address, :username
+
+        scp_options = {:port => ssh_port}
+        scp_options[:key_data] = [private_key] if private_key
+        Fog::SCP.new(public_ip_address, username, scp_options).download(remote_path, local_path, download_options)
+      end
+
+      def ssh(commands, options={}, &blk)
+        require 'net/ssh'
+        requires :public_ip_address, :username
+
+        options[:key_data] = [private_key] if private_key
+        options[:port] ||= ssh_port
+        Fog::SSH.new(public_ip_address, username, options).run(commands, &blk)
+      end
+
+      def ssh_port
+        22
+      end
+
+      def sshable?
+        ready? && !public_ip_address.nil? && !!Timeout::timeout(8) { ssh 'pwd' }
+      rescue SystemCallError, Net::SSH::AuthenticationFailed, Timeout::Error
+        false
+      end
+
+    end
+  end
+end

data/lib/fog/compute.rb

@@ -0,0 +1,123 @@
+module Fog
+  module Compute
+
+    def self.[](provider)
+      self.new(:provider => provider)
+    end
+
+    def self.new(attributes)
+      attributes = attributes.dup # prevent delete from having side effects
+      provider = attributes.delete(:provider).to_s.downcase.to_sym
+
+      case provider
+      when :aws
+        require 'fog/aws/compute'
+        Fog::Compute::AWS.new(attributes)
+      when :bluebox
+        require 'fog/bluebox/compute'
+        Fog::Compute::Bluebox.new(attributes)
+      when :brightbox
+        require 'fog/brightbox/compute'
+        Fog::Compute::Brightbox.new(attributes)
+      when :cloudstack
+        require 'fog/cloudstack/compute'
+        Fog::Compute::Cloudstack.new(attributes)
+      when :clodo
+        require 'fog/clodo/compute'
+        Fog::Compute::Clodo.new(attributes)
+      when :ecloud
+        require 'fog/ecloud/compute'
+        Fog::Compute::Ecloud.new(attributes)
+      when :glesys
+        require 'fog/glesys/compute'
+        Fog::Compute::Glesys.new(attributes)
+      when :gogrid
+        require 'fog/go_grid/compute'
+        Fog::Compute::GoGrid.new(attributes)
+      when :hp
+        require 'fog/hp/compute'
+        Fog::Compute::HP.new(attributes)
+      when :ibm
+        require 'fog/ibm/compute'
+        Fog::Compute::IBM.new(attributes)
+      when :joyent
+        require 'fog/joyent/compute'
+        Fog::Compute::Joyent.new(attributes)
+      when :libvirt
+        require 'fog/libvirt/compute'
+        Fog::Compute::Libvirt.new(attributes)
+      when :linode
+        require 'fog/linode/compute'
+        Fog::Compute::Linode.new(attributes)
+      when :new_servers
+        require 'fog/bare_metal_cloud/compute'
+        warn "[DEPRECATION] `new_servers` is deprecated. Please use `bare_metal_cloud` instead."
+        Fog::Compute::BareMetalCloud.new(attributes)
+      when :baremetalcloud
+        require 'fog/bare_metal_cloud/compute'
+        Fog::Compute::BareMetalCloud.new(attributes)
+      when :ninefold
+        require 'fog/ninefold/compute'
+        Fog::Compute::Ninefold.new(attributes)
+      when :openstack
+        require 'fog/openstack/compute'
+        Fog::Compute::OpenStack.new(attributes)
+      when :ovirt
+        require 'fog/ovirt/compute'
+        Fog::Compute::Ovirt.new(attributes)
+      when :rackspace
+        version = attributes.delete(:version) 
+        version = version.to_s.downcase.to_sym unless version.nil?
+        if version == :v2
+          require 'fog/rackspace/compute_v2'
+          Fog::Compute::RackspaceV2.new(attributes)
+        else
+          require 'fog/rackspace/compute'
+          Fog::Compute::Rackspace.new(attributes)
+        end
+      when :serverlove
+        require 'fog/serverlove/compute'
+        Fog::Compute::Serverlove.new(attributes)
+      when :stormondemand
+        require 'fog/storm_on_demand/compute'
+        Fog::Compute::StormOnDemand.new(attributes)
+      when :vcloud
+        require 'fog/vcloud/compute'
+        Fog::Vcloud::Compute.new(attributes)
+      when :virtualbox
+        require 'fog/virtual_box/compute'
+        Fog::Compute::VirtualBox.new(attributes)
+      when :vmfusion
+        require 'fog/vmfusion/compute'
+        Fog::Compute::Vmfusion.new(attributes)
+      when :voxel
+        require 'fog/voxel/compute'
+        Fog::Compute::Voxel.new(attributes)
+      when :vsphere
+        require 'fog/vsphere/compute'
+        Fog::Compute::Vsphere.new(attributes)
+      when :xenserver
+        require 'fog/xenserver/compute'
+        Fog::Compute::XenServer.new(attributes)
+      else
+        raise ArgumentError.new("#{provider} is not a recognized compute provider")
+      end
+    end
+
+    def self.providers
+      Fog.services[:compute]
+    end
+
+    def self.servers
+      servers = []
+      for provider in self.providers
+        begin
+          servers.concat(self[provider].servers)
+        rescue # ignore any missing credentials/etc
+        end
+      end
+      servers
+    end
+
+  end
+end

data/lib/fog/core/attributes.rb

@@ -0,0 +1,204 @@
+module Fog
+  module Attributes
+    module ClassMethods
+
+      def _load(marshalled)
+        new(Marshal.load(marshalled))
+      end
+
+      def aliases
+        @aliases ||= {}
+      end
+
+      def attributes
+        @attributes ||= []
+      end
+
+      def attribute(name, options = {})
+        class_eval <<-EOS, __FILE__, __LINE__
+          def #{name}
+            attributes[:#{name}]
+          end
+        EOS
+        case options[:type]
+        when :boolean
+          class_eval <<-EOS, __FILE__, __LINE__
+            def #{name}=(new_#{name})
+              attributes[:#{name}] = case new_#{name}
+              when true,'true'
+                true
+              when false,'false'
+                false
+              end
+            end
+          EOS
+        when :float
+          class_eval <<-EOS, __FILE__, __LINE__
+            def #{name}=(new_#{name})
+              attributes[:#{name}] = new_#{name}.to_f
+            end
+          EOS
+        when :integer
+          class_eval <<-EOS, __FILE__, __LINE__
+            def #{name}=(new_#{name})
+              attributes[:#{name}] = new_#{name}.to_i
+            end
+          EOS
+        when :string
+          class_eval <<-EOS, __FILE__, __LINE__
+            def #{name}=(new_#{name})
+              attributes[:#{name}] = new_#{name}.to_s
+            end
+          EOS
+        when :time
+          class_eval <<-EOS, __FILE__, __LINE__
+            def #{name}=(new_#{name})
+              attributes[:#{name}] = if new_#{name}.nil? || new_#{name} == "" || new_#{name}.is_a?(Time)
+                new_#{name}
+              else
+                Time.parse(new_#{name})
+              end
+            end
+          EOS
+        when :array
+          class_eval <<-EOS, __FILE__, __LINE__
+          def #{name}=(new_#{name})
+            attributes[:#{name}] = [*new_#{name}]
+          end
+          EOS
+        else
+          if squash = options[:squash]
+            class_eval <<-EOS, __FILE__, __LINE__
+              def #{name}=(new_data)
+                if new_data.is_a?(Hash)
+                  if new_data.has_key?(:'#{squash}')
+                    attributes[:#{name}] = new_data[:'#{squash}']
+                  elsif new_data.has_key?("#{squash}")
+                    attributes[:#{name}] = new_data["#{squash}"]
+                  else
+                    attributes[:#{name}] = [ new_data ]
+                  end
+                else
+                  attributes[:#{name}] = new_data
+                end
+              end
+            EOS
+          else
+            class_eval <<-EOS, __FILE__, __LINE__
+              def #{name}=(new_#{name})
+                attributes[:#{name}] = new_#{name}
+              end
+            EOS
+          end
+        end
+        @attributes ||= []
+        @attributes |= [name]
+        for new_alias in [*options[:aliases]]
+          aliases[new_alias] = name
+        end
+      end
+
+      def identity(name, options = {})
+        @identity = name
+        self.attribute(name, options)
+      end
+
+      def ignore_attributes(*args)
+        @ignored_attributes = args
+      end
+
+      def ignored_attributes
+        @ignored_attributes ||= []
+      end
+
+    end
+
+    module InstanceMethods
+
+      def _dump(level)
+        Marshal.dump(attributes)
+      end
+
+      def attributes
+        @attributes ||= {}
+      end
+
+      def dup
+        copy = super
+        copy.dup_attributes!
+        copy
+      end
+
+      def identity
+        send(self.class.instance_variable_get('@identity'))
+      end
+
+      def identity=(new_identity)
+        send("#{self.class.instance_variable_get('@identity')}=", new_identity)
+      end
+
+      def merge_attributes(new_attributes = {})
+        for key, value in new_attributes
+          unless self.class.ignored_attributes.include?(key)
+            if aliased_key = self.class.aliases[key]
+              send("#{aliased_key}=", value)
+            elsif self.respond_to?("#{key}=",true)
+              send("#{key}=", value)
+            else
+              attributes[key] = value
+            end
+          end
+        end
+        self
+      end
+
+      def new_record?
+        !identity
+      end
+
+      # check that the attributes specified in args exist and is not nil
+      def requires(*args)
+        missing = missing_attributes(args)
+        if missing.length == 1
+          raise(ArgumentError, "#{missing.first} is required for this operation")
+        elsif missing.any?
+          raise(ArgumentError, "#{missing[0...-1].join(", ")} and #{missing[-1]} are required for this operation")
+        end
+      end
+
+      def requires_one(*args)
+        missing = missing_attributes(args)
+        if missing.length == args.length
+          raise(ArgumentError, "#{missing[0...-1].join(", ")} or #{missing[-1]} are required for this operation")
+        end
+      end
+
+      protected
+
+      def missing_attributes(args)
+        missing = []
+        for arg in [:connection] | args
+          unless send("#{arg}") || attributes.has_key?(arg)
+            missing << arg
+          end
+        end
+        missing
+      end
+
+      def dup_attributes!
+        @attributes = @attributes.dup if @attributes
+      end
+
+      private
+
+      def remap_attributes(attributes, mapping)
+        for key, value in mapping
+          if attributes.key?(key)
+            attributes[value] = attributes.delete(key)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/core/collection.rb

@@ -0,0 +1,134 @@
+module Fog
+  class Collection < Array
+
+    extend Fog::Attributes::ClassMethods
+    include Fog::Attributes::InstanceMethods
+
+    Array.public_instance_methods(false).each do |method|
+      unless [:reject, :select, :slice].include?(method.to_sym)
+        class_eval <<-EOS, __FILE__, __LINE__
+          def #{method}(*args)
+            unless @loaded
+              lazy_load
+            end
+            super
+          end
+        EOS
+      end
+    end
+
+    %w[reject select slice].each do |method|
+      class_eval <<-EOS, __FILE__, __LINE__
+        def #{method}(*args)
+          unless @loaded
+            lazy_load
+          end
+          data = super
+          self.clone.clear.concat(data)
+        end
+      EOS
+    end
+
+    def self.model(new_model=nil)
+      if new_model == nil
+        @model
+      else
+        @model = new_model
+      end
+    end
+
+    attr_accessor :connection
+
+    remove_method :clear
+    def clear
+      @loaded = true
+      super
+    end
+
+    def create(attributes = {})
+      object = new(attributes)
+      object.save
+      object
+    end
+
+    def destroy(identity)
+      object = new(:identity => identity)
+      object.destroy
+    end
+
+    def initialize(attributes = {})
+      @loaded = false
+      merge_attributes(attributes)
+    end
+
+    remove_method :inspect
+    def inspect
+      Thread.current[:formatador] ||= Formatador.new
+      data = "#{Thread.current[:formatador].indentation}<#{self.class.name}\n"
+      Thread.current[:formatador].indent do
+        unless self.class.attributes.empty?
+          data << "#{Thread.current[:formatador].indentation}"
+          data << self.class.attributes.map {|attribute| "#{attribute}=#{send(attribute).inspect}"}.join(",\n#{Thread.current[:formatador].indentation}")
+          data << "\n"
+        end
+        data << "#{Thread.current[:formatador].indentation}["
+        unless self.empty?
+          data << "\n"
+          Thread.current[:formatador].indent do
+            data << self.map {|member| member.inspect}.join(",\n")
+            data << "\n"
+          end
+          data << Thread.current[:formatador].indentation
+        end
+        data << "]\n"
+      end
+      data << "#{Thread.current[:formatador].indentation}>"
+      data
+    end
+
+    def load(objects)
+      clear
+      for object in objects
+        self << new(object)
+      end
+      self
+    end
+
+    def model
+      self.class.instance_variable_get('@model')
+    end
+
+    def new(attributes = {})
+      unless attributes.is_a?(::Hash)
+        raise(ArgumentError.new("Initialization parameters must be an attributes hash, got #{attributes.class} #{attributes.inspect}"))
+      end
+      model.new(
+        attributes.merge(
+          :collection => self,
+          :connection => connection
+        )
+      )
+    end
+
+    def reload
+      clear
+      lazy_load
+      self
+    end
+
+    def table(attributes = nil)
+      Formatador.display_table(self.map {|instance| instance.attributes}, attributes)
+    end
+
+    def to_json(options = {})
+      Fog::JSON.encode(self.map {|member| member.attributes})
+    end
+
+    private
+
+    def lazy_load
+      self.all
+    end
+
+  end
+end

data/lib/fog/core/connection.rb

@@ -0,0 +1,35 @@
+module Fog
+  class Connection
+
+    def initialize(url, persistent=false, params={})
+      @excon = Excon.new(url, params)
+      @persistent = persistent
+    end
+
+    def request(params, &block)
+      unless @persistent
+        reset
+      end
+      unless block_given?
+        if (parser = params.delete(:parser))
+          body = Nokogiri::XML::SAX::PushParser.new(parser)
+          params[:response_block] = lambda { |chunk, remaining, total| body << chunk }
+        end
+      end
+
+      response = @excon.request(params, &block)
+
+      if parser
+        body.finish
+        response.body = parser.response
+      end
+
+      response
+    end
+
+    def reset
+      @excon.reset
+    end
+
+  end
+end

data/lib/fog/core/credentials.rb

@@ -0,0 +1,65 @@
+require 'yaml'
+
+module Fog
+  require 'fog/core/deprecation'
+
+  # Assign a new credential to use from configuration file
+  #   @param [String, Symbol] new_credential name of new credential to use
+  #   @ return [Symbol] name of the new credential
+  def self.credential=(new_credential)
+    @credentials = nil
+    @credential = new_credential && new_credential.to_sym
+  end
+
+  # @return [String, Symbol] The credential to use in Fog
+  def self.credential
+    @credential ||= ( ENV["FOG_CREDENTIAL"] && ENV["FOG_CREDENTIAL"].to_sym ) || :default
+  end
+
+  # @return [String] The path for configuration_file
+  def self.credentials_path
+    @credential_path ||= begin
+      path = ENV["FOG_RC"] || (ENV['HOME'] && File.directory?(ENV['HOME']) && '~/.fog')
+      File.expand_path(path) if path
+    rescue
+      nil
+    end
+  end
+
+  # @return [String] The new path for credentials file
+  def self.credentials_path=(new_credentials_path)
+    @credentials = nil
+    @credential_path = new_credentials_path
+  end
+
+  # @return [Hash] The credentials pulled from the configuration file
+  # @raise [LoadError] Configuration unavailable in configuration file
+  def self.credentials
+    @credentials  ||= begin
+      if credentials_path && File.exists?(credentials_path)
+        credentials = self.symbolize_credentials(YAML.load_file(credentials_path))
+        (credentials && credentials[credential]) || Fog::Errors.missing_credentials
+      else
+        {}
+      end
+    end
+  end
+
+  # @return [Hash] The newly assigned credentials
+  def self.credentials=(new_credentials)
+    @credentials = new_credentials
+  end
+
+  def self.symbolize_credentials(args)
+    if args.is_a? Hash
+      copy = Array.new
+      args.each do |key, value|
+        copy.push(key.to_sym, self.symbolize_credentials(value))
+      end
+      Hash[*copy]
+    else
+      args
+    end
+  end
+
+end

data/lib/fog/core/current_machine.rb

@@ -0,0 +1,34 @@
+require 'thread'
+module Fog
+  class CurrentMachine
+    @@lock = Mutex.new
+    AMAZON_AWS_CHECK_IP = 'http://checkip.amazonaws.com'
+
+    def self.ip_address= ip_address
+      @@lock.synchronize do
+        @@ip_address = ip_address
+      end
+    end
+
+    # Get the ip address of the machine from which this command is run. It is
+    # recommended that you surround calls to this function with a timeout block
+    # to ensure optimum performance in the case where the amazonaws checkip
+    # service is unavailable.
+    #
+    # @example Get the current ip address
+    #   begin
+    #     Timeout::timeout(5) do
+    #       puts "Your ip address is #{Fog::CurrentMachine.ip_address}"
+    #     end
+    #   rescue Timeout::Error
+    #     puts "Service timeout"
+    #   end
+    #
+    # @raise [Excon::Errors::Error] if the net/http request fails.
+    def self.ip_address
+      @@lock.synchronize do
+        @@ip_address ||= Excon.get(AMAZON_AWS_CHECK_IP).body.chomp
+      end
+    end
+  end
+end

data/lib/fog/core/deprecation.rb

@@ -0,0 +1,23 @@
+module Fog
+  module Deprecation
+
+    def deprecate(older, newer)
+      module_eval <<-EOS, __FILE__, __LINE__
+        def #{older}(*args)
+          Fog::Logger.deprecation("#{self} => ##{older} is deprecated, use ##{newer} instead [light_black](#{caller.first})[/]")
+          send(:#{newer}, *args)
+        end
+      EOS
+    end
+
+    def self_deprecate(older, newer)
+      module_eval <<-EOS, __FILE__, __LINE__
+        def self.#{older}(*args)
+          Fog::Logger.deprecation("#{self} => ##{older} is deprecated, use ##{newer} instead [light_black](#{caller.first})[/]")
+          send(:#{newer}, *args)
+        end
+      EOS
+    end
+
+  end
+end