deltacloud-client 0.0.9.8 → 0.1.0

data/lib/documentation.rb

@@ -1,98 +1,62 @@
-require 'lib/deltacloud'
+#
+# Copyright (C) 2010  Red Hat, Inc.
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.  The
+# ASF licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the
+# License.  You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+module DeltaCloud
+  class Documentation
+
+    attr_reader :api, :description, :params, :collection_operations
+    attr_reader :collection, :operation
+
+    def initialize(api, opts={})
+      @description, @api = opts[:description], api
+      @params = parse_parameters(opts[:params]) if opts[:params]
+      @collection_operations = opts[:operations] if opts[:operations]
+      @collection = opts[:collection]
+      @operation = opts[:operation]
+      self
+    end
 
-skip_methods = [ "id=", "uri=" ]
+    def operations
+      @collection_operations.collect { |o| api.documentation(@collection, o) }
+    end
 
-begin
-  @dc=DeltaCloud.new('mockuser', 'mockpassword', 'http://localhost:3001/api')
-rescue
-  puts "Please make sure that Deltacloud API is running with Mock driver"
-  exit(1)
-end
+    class OperationParameter
+      attr_reader :name
+      attr_reader :type
+      attr_reader :required
+      attr_reader :description
 
-@dc.entry_points.keys.each do |ep|
-  @dc.send(ep)
-end
+      def initialize(data)
+        @name, @type, @required, @description = data[:name], data[:type], data[:required], data[:description]
+      end
 
-class_list = DeltaCloud::classes.collect { |c| DeltaCloud::module_eval("::DeltaCloud::API::#{c}")}
+      def to_comment
+        "   # @param [#{@type}, #{@name}] #{@description}"
+      end
 
-def read_method_description(c, method)
-  if method =~ /es$/
-    "    # Read #{c.downcase} collection from Deltacloud API"
-  else
-    case method
-      when "uri"
-        "    # Return URI to API for this object"
-      when "action_urls"
-        "    # Return available actions API URL"
-      when "client"
-        "    # Return instance of API client"
-      else
-        "    # Get #{method} attribute value from #{c.downcase}"
     end
-  end
-end
 
-def read_parameters(c, method)
-  out = []
-  if method =~ /es$/
-    out << "    # @param [String, #id] Filter by ID"
-  end
-  out.join("\n")
-end
+    private
 
-def read_return_value(c, method)
-  if method =~ /es$/
-    rt = "Array"
-  else
-    rt = "String"
-  end
-  "    # @return [String] Value of #{method}"
-end
-
-out = []
-
-class_list.each do |c|
-  class_name = "#{c}".gsub(/^DeltaCloud::/, '')
-  out << "module DeltaCloud"
-  out << "  class API"
-  @dc.entry_points.keys.each do |ep|
-    out << "# Return #{ep.to_s.classify} object with given id\n"
-    out << "# "
-    out << "# #{@dc.documentation(ep.to_s).description.split("\n").join("\n# ")}"
-    out << "# @return [#{ep.to_s.classify}]"
-    out << "def #{ep.to_s.gsub(/s$/, '')}"
-    out << "end"
-    out << "# Return collection of #{ep.to_s.classify} objects"
-    out << "# "
-    out << "# #{@dc.documentation(ep.to_s).description.split("\n").join("\n# ")}"
-    @dc.documentation(ep.to_s, 'index').params.each do |p|
-      out << p.to_comment
+    def parse_parameters(params)
+      params.collect { |p| OperationParameter.new(p) }
     end
-    out << "# @return [Array] [#{ep.to_s.classify}]"
-    out << "def #{ep}(opts={})"
-    out << "end"
-  end
-  out << "  end"
-  out << "  class #{class_name}"
-  c.instance_methods(false).each do |method|
-    next if skip_methods.include?(method)
-    params = read_parameters(class_name, method)
-    retval = read_return_value(class_name, method)
-    out << read_method_description(class_name, method)
-    out << params if params
-    out << retval if retval
-    out << "    def #{method}"
-    out << "      # This method was generated dynamically from API"
-    out << "    end\n"
+
   end
-  out << "  end"
-  out << "end"
-end
 
-FileUtils.rm_r('doc') rescue nil
-FileUtils.mkdir_p('doc')
-File.open('doc/deltacloud.rb', 'w') do |f|
-  f.puts(out.join("\n"))
 end
-system("yardoc -m markdown --readme README --title 'Deltacloud Client Library' 'lib/*.rb' 'doc/deltacloud.rb' --verbose")
-FileUtils.rm('doc/deltacloud.rb')

data/lib/hwp_properties.rb

@@ -0,0 +1,64 @@
+#
+# Copyright (C) 2009  Red Hat, Inc.
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.  The
+# ASF licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the
+# License.  You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+module DeltaCloud
+
+  module HWP
+
+   class Property
+      attr_reader :name, :unit, :value, :kind
+
+      def initialize(xml, name)
+        @name, @kind, @value, @unit = xml['name'], xml['kind'].to_sym, xml['value'], xml['unit']
+        declare_ranges(xml)
+        self
+      end
+
+      def present?
+        ! @value.nil?
+      end
+
+      private
+
+      def declare_ranges(xml)
+        case xml['kind']
+          when 'range' then
+            self.class.instance_eval do
+              attr_reader :range
+            end
+            @range = { :from => xml.xpath('range').first['first'], :to => xml.xpath('range').first['last'] }
+          when 'enum' then
+            self.class.instance_eval do
+              attr_reader :options
+            end
+            @options = xml.xpath('enum/entry').collect { |e| e['value'] }
+        end
+      end
+
+    end
+
+    # FloatProperty is like Property but return value is Float instead of String.
+    class FloatProperty < Property
+      def initialize(xml, name)
+        super(xml, name)
+        @value = @value.to_f if @value
+      end
+    end
+  end
+
+end

data/lib/instance_state.rb

@@ -0,0 +1,29 @@
+module DeltaCloud
+  module InstanceState
+
+    class State
+      attr_reader :name
+      attr_reader :transitions
+
+      def initialize(name)
+        @name, @transitions = name, []
+      end
+    end
+
+    class Transition
+      attr_reader :to
+      attr_reader :action
+
+      def initialize(to, action)
+        @to = to
+        @action = action
+      end
+
+      def auto?
+        @action.nil?
+      end
+    end
+
+  end
+
+end

data/lib/string.rb

@@ -0,0 +1,53 @@
+#
+# Copyright (C) 2010  Red Hat, Inc.
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.  The
+# ASF licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the
+# License.  You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+class String
+
+  unless method_defined?(:classify)
+    # Create a class name from string
+    def classify
+      self.singularize.camelize
+    end
+  end
+
+  unless method_defined?(:camelize)
+    # Camelize converts strings to UpperCamelCase
+    def camelize
+      self.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+    end
+  end
+
+  unless method_defined?(:singularize)
+    # Strip 's' character from end of string
+    def singularize
+      self.gsub(/s$/, '')
+    end
+  end
+
+  # Convert string to float if string value seems like Float
+  def convert
+    return self.to_f if self.strip =~ /^([\d\.]+$)/
+    self
+  end
+
+  # Simply converts whitespaces and - symbols to '_' which is safe for Ruby
+  def sanitize
+    self.strip.gsub(/(\W+)/, '_')
+  end
+
+end

data/specs/hardware_profiles_spec.rb

@@ -31,13 +31,15 @@ describe "hardware_profiles" do
   it_should_behave_like "all resources"
 
   it "should allow retrieval of all hardware profiles" do
-    DeltaCloud.new( API_NAME, API_PASSWORD, API_URL ) do |client|
-      hardware_profiles = client.hardware_profiles
-      hardware_profiles.should_not be_empty
-      hardware_profiles.each do |hwp|
-        hwp.uri.should_not be_nil
-        hwp.uri.should be_a(String)
-        prop_check(hwp.architecture, String)  if hwp.architecture
+    [API_URL, API_URL_REDIRECT].each do |entry_point|
+      DeltaCloud.new( API_NAME, API_PASSWORD, entry_point ) do |client|
+        hardware_profiles = client.hardware_profiles
+        hardware_profiles.should_not be_empty
+        hardware_profiles.each do |hwp|
+          hwp.uri.should_not be_nil
+          hwp.uri.should be_a(String)
+          prop_check(hwp.architecture, String)  if hwp.architecture
+        end
       end
     end
   end
@@ -62,7 +64,7 @@ describe "hardware_profiles" do
   it "should allow fetching different hardware_profiles" do
     client = DeltaCloud.new( API_NAME, API_PASSWORD, API_URL )
     hwp1 = client.hardware_profile( 'm1-small' )
-    hwp2 = client.hardware_profile( 'm1-xlarge' )
+    hwp2 = client.hardware_profile( 'm1-large' )
     hwp1.storage.value.should_not eql(hwp2.storage.value)
     hwp1.memory.value.should_not eql(hwp2.memory.value)
   end

data/specs/images_spec.rb

@@ -24,19 +24,21 @@ describe "images" do
   it_should_behave_like "all resources"
 
   it "should allow retrieval of all images" do
-    DeltaCloud.new( API_NAME, API_PASSWORD, API_URL ) do |client|
-      images = client.images
-      images.should_not be_empty
-      images.size.should eql( 3 )
-      images.each do |image|
-        image.uri.should_not be_nil
-        image.uri.should be_a(String)
-        image.description.should_not be_nil
-        image.description.should be_a(String)
-        image.architecture.should_not be_nil
-        image.architecture.should be_a(String)
-        image.owner_id.should_not be_nil
-        image.owner_id.should be_a(String)
+    [API_URL, API_URL_REDIRECT].each do |entry_point|
+      DeltaCloud.new( API_NAME, API_PASSWORD, entry_point ) do |client|
+        images = client.images
+        images.should_not be_empty
+        images.size.should eql( 3 )
+        images.each do |image|
+          image.uri.should_not be_nil
+          image.uri.should be_a(String)
+          image.description.should_not be_nil
+          image.description.should be_a(String)
+          image.architecture.should_not be_nil
+          image.architecture.should be_a(String)
+          image.owner_id.should_not be_nil
+          image.owner_id.should be_a(String)
+        end
       end
     end
   end

data/specs/initialization_spec.rb

@@ -28,12 +28,14 @@ describe "initializing the client" do
   end
 
   it "should discover entry points upon connection" do
-    DeltaCloud.new( "name", "password", API_URL ) do |client|
-      client.entry_points[:hardware_profiles].should eql( "#{API_URL}/hardware_profiles" )
-      client.entry_points[:images].should            eql( "#{API_URL}/images" )
-      client.entry_points[:instances].should         eql( "#{API_URL}/instances" )
-      client.entry_points[:storage_volumes].should   eql( "#{API_URL}/storage_volumes" )
-      client.entry_points[:storage_snapshots].should eql( "#{API_URL}/storage_snapshots" )
+    [API_URL, API_URL_REDIRECT].each do |entry_point|
+      DeltaCloud.new( "name", "password", entry_point ) do |client|
+        client.entry_points[:hardware_profiles].should eql( "#{API_URL}/hardware_profiles" )
+        client.entry_points[:images].should            eql( "#{API_URL}/images" )
+        client.entry_points[:instances].should         eql( "#{API_URL}/instances" )
+        client.entry_points[:storage_volumes].should   eql( "#{API_URL}/storage_volumes" )
+        client.entry_points[:storage_snapshots].should eql( "#{API_URL}/storage_snapshots" )
+      end
     end
   end
 

data/specs/instance_states_spec.rb

@@ -33,23 +33,25 @@ describe "instance-states" do
   it_should_behave_like "all resources"
 
   it "should allow retrieval of instance-state information" do
-    DeltaCloud.new( API_NAME, API_PASSWORD, API_URL ) do |client|
-      instance_states = client.instance_states
-      instance_states.should_not be_nil
-      instance_states.should_not be_empty
+    [API_URL, API_URL_REDIRECT].each do |entry_point|
+      DeltaCloud.new( API_NAME, API_PASSWORD, entry_point ) do |client|
+        instance_states = client.instance_states
+        instance_states.should_not be_nil
+        instance_states.should_not be_empty
 
-      instance_states[0].name.should eql( 'start' )
-      instance_states[0].transitions.size.should eql( 1 )
-      instance_states[0].transitions[0].should_not be_auto
+        instance_states[0].name.should eql( 'start' )
+        instance_states[0].transitions.size.should eql( 1 )
+        instance_states[0].transitions[0].should_not be_auto
 
-      instance_states[1].name.should eql( 'pending' )
-      instance_states[1].transitions.size.should eql( 1 )
-      instance_states[1].transitions[0].should be_auto
+        instance_states[1].name.should eql( 'pending' )
+        instance_states[1].transitions.size.should eql( 1 )
+        instance_states[1].transitions[0].should be_auto
 
-      instance_states[2].name.should eql( 'running' )
-      instance_states[2].transitions.size.should eql( 2 )
-      includes_transition( instance_states[2].transitions, :reboot, :running ).should be_true
-      includes_transition( instance_states[2].transitions, :stop, :stopped ).should be_true
+        instance_states[2].name.should eql( 'running' )
+        instance_states[2].transitions.size.should eql( 2 )
+        includes_transition( instance_states[2].transitions, :reboot, :running ).should be_true
+        includes_transition( instance_states[2].transitions, :stop, :stopped ).should be_true
+      end
     end
   end
 

data/specs/instances_spec.rb

@@ -24,26 +24,28 @@ describe "instances" do
   it_should_behave_like "all resources"
 
   it "should allow retrieval of all instances" do
-    DeltaCloud.new( API_NAME, API_PASSWORD, API_URL ) do |client|
-      instances = client.instances
-      instances.should_not be_empty
-      instances.each do |instance|
-        instance.uri.should_not be_nil
-        instance.uri.should be_a( String )
-        instance.owner_id.should_not be_nil
-        instance.owner_id.should be_a( String )
-        instance.image.should_not be_nil
-        instance.image.should be_a( DeltaCloud::API::Image )
-        instance.hardware_profile.should_not be_nil
-        instance.hardware_profile.should be_a( DeltaCloud::API::HardwareProfile )
-        instance.state.should_not be_nil
-        instance.state.should be_a( String )
-        instance.public_addresses.should_not be_nil
-        instance.public_addresses.should_not be_empty
-        instance.public_addresses.should be_a( Array )
-        instance.private_addresses.should_not be_nil
-        instance.private_addresses.should_not be_empty
-        instance.private_addresses.should be_a( Array )
+    [API_URL, API_URL_REDIRECT].each do |entry_point|
+      DeltaCloud.new( API_NAME, API_PASSWORD, entry_point ) do |client|
+        instances = client.instances
+        instances.should_not be_empty
+        instances.each do |instance|
+          instance.uri.should_not be_nil
+          instance.uri.should be_a( String )
+          instance.owner_id.should_not be_nil
+          instance.owner_id.should be_a( String )
+          instance.image.should_not be_nil
+          instance.image.should be_a( DeltaCloud::API::Image )
+          instance.hardware_profile.should_not be_nil
+          instance.hardware_profile.should be_a( DeltaCloud::API::HardwareProfile )
+          instance.state.should_not be_nil
+          instance.state.should be_a( String )
+          instance.public_addresses.should_not be_nil
+          instance.public_addresses.should_not be_empty
+          instance.public_addresses.should be_a( Array )
+          instance.private_addresses.should_not be_nil
+          instance.private_addresses.should_not be_empty
+          instance.private_addresses.should be_a( Array )
+        end
       end
     end
   end
@@ -83,7 +85,7 @@ describe "instances" do
 
   it "should allow creation of new instances with reasonable defaults" do
     DeltaCloud.new( API_NAME, API_PASSWORD, API_URL ) do |client|
-      instance = client.create_instance( 'img1', :name=>'TestInstance' )
+      instance = client.create_instance( 'img1', :name=>'TestInstance', :hardware_profile => 'm1-large' )
       instance.should_not be_nil
       instance.uri.should match( %r{#{API_URL}/instances/inst[0-9]+} )
       instance.id.should match( /inst[0-9]+/ )
@@ -96,7 +98,7 @@ describe "instances" do
 
   it "should allow creation of new instances with specific realm" do
     DeltaCloud.new( API_NAME, API_PASSWORD, API_URL ) do |client|
-      instance = client.create_instance( 'img1', :realm=>'eu' )
+      instance = client.create_instance( 'img1', :realm=>'eu', :hardware_profile => 'm1-large' )
       instance.should_not be_nil
       instance.uri.should match( %r{#{API_URL}/instances/inst[0-9]+} )
       instance.id.should match( /inst[0-9]+/ )
@@ -184,7 +186,8 @@ describe "instances" do
         instance = client.instance( 'inst1' )
         instance.should_not be_nil
         instance.state.should eql( "RUNNING" )
-        lambda{instance.start}.should raise_error
+        instance.start!
+        instance.state.should eql( "RUNNING" )
       end
     end
   end