occi 2.5.19 → 3.0.0.beta.0

data/lib/occi/api/client/http/httparty_fix.rb

@@ -0,0 +1,53 @@
+module HTTParty
+  class ConnectionAdapter
+
+    private
+
+    def attach_ssl_certificates(http, options)
+      if http.use_ssl?
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+        # Client certificate authentication
+        if options[:pem]
+          http.cert = OpenSSL::X509::Certificate.new(options[:pem])
+          http.key = OpenSSL::PKey::RSA.new(options[:pem], options[:pem_password])
+          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        end
+
+        # Set chain of client certificates
+        if options[:ssl_extra_chain_cert]
+          http.extra_chain_cert = []
+
+          options[:ssl_extra_chain_cert].each do |p_ca|
+            http.extra_chain_cert << OpenSSL::X509::Certificate.new(p_ca)
+          end
+        end
+
+        # SSL certificate authority file and/or directory
+        if options[:ssl_ca_file]
+          http.ca_file = options[:ssl_ca_file]
+          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        end
+
+        if options[:ssl_ca_path]
+          http.ca_path = options[:ssl_ca_path]
+          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        end
+
+        # This is only Ruby 1.9+
+        if options[:ssl_version] && http.respond_to?(:ssl_version=)
+          http.ssl_version = options[:ssl_version]
+        end
+      end
+    end
+
+  end
+
+  module ClassMethods
+
+    def ssl_extra_chain_cert(ary_of_certs)
+      default_options[:ssl_extra_chain_cert] = ary_of_certs
+    end
+
+  end
+end

data/lib/occi/api/client/http/net_http_fix.rb

@@ -0,0 +1,46 @@
+##############################################################################
+## Net::HTTP hack allowing the use of X.509 proxy certificates.
+##############################################################################
+
+# When running Ruby 1.8.x, RUBY_ENGINE is not defined
+RUBY_ENGINE = "ruby" unless defined? RUBY_ENGINE
+
+# detect jRuby
+if RUBY_ENGINE == 'jruby'
+  #TODO: add jRuby support, this doesn't work
+  module Net
+    class HTTP
+
+      SSL_ATTRIBUTES = SSL_ATTRIBUTES.concat %w(extra_chain_cert)
+
+      # An Array of certificates that will be sent to the client.
+      attr_accessor :extra_chain_cert
+
+    end
+  end
+else
+  net_http_fix_rby_ver = RUBY_VERSION.split('.')
+
+  # detect old Rubies, tested with 1.8.7-p371
+  if net_http_fix_rby_ver[1] == "8"
+    module Net
+      class HTTP
+
+        # An Array of certificates that will be sent to the client.
+        ssl_context_accessor :extra_chain_cert
+
+      end
+    end
+  else
+    module Net
+      class HTTP
+
+        SSL_ATTRIBUTES = SSL_ATTRIBUTES.concat %w(extra_chain_cert)
+
+        # An Array of certificates that will be sent to the client.
+        attr_accessor :extra_chain_cert
+
+      end
+    end
+  end
+end

data/lib/occi/api/dsl.rb

@@ -1,112 +1,116 @@
-module OCCI
-  module DSL
+module Occi
+  module Api
+    module Dsl
 
-    def connect(*args)
-      @client = OCCI::Client.new(*args)
+      def connect(protocol, *args)
 
-      true
-    end
+        case protocol
+        when :http 
+          @client = Occi::Api::Client::ClientHttp.new(*args)
+        when :amqp
+          @client = Occi::Api::Client::ClientAmqp.new(*args)
+        else
+          raise "Protocol #{protocol.to_s} is not supported!"
+        end
 
-    def list(*args)
-      check
+        true
+      end
 
-      @client.list(*args)
-    end
+      def list(*args)
+        check
 
-    def describe(*args)
-      check
+        @client.list(*args)
+      end
 
-      @client.describe(*args)
-    end
+      def describe(*args)
+        check
 
-    def create(*args)
-      check
+        @client.describe(*args)
+      end
 
-      @client.create(*args)
-    end
+      def create(*args)
+        check
 
-    def delete(*args)
-      check
+        @client.create(*args)
+      end
 
-      @client.delete(*args)
-    end
+      def delete(*args)
+        check
 
-    def trigger(*args)
-      check
+        @client.delete(*args)
+      end
 
-      @client.trigger(*args)
-    end
+      def trigger(*args)
+        check
 
-    def refresh
-      check
+        @client.trigger(*args)
+      end
 
-      @client.refresh
-    end
+      def refresh
+        check
 
-    def storagelink(*args)
-      check
+        @client.refresh
+      end
 
-      @client.storagelink(*args)
-    end
+      def model
+        check
 
-    def networkinterface(*args)
-      check
+        @client.model
+      end
 
-      @client.networkinterface(*args)
-    end
+      ###
 
-    ###
+      def resource_types
+        check
 
-    def resource_types
-      check
+        @client.get_resource_types
+      end
 
-      @client.get_resource_types
-    end
+      def resource_type_identifiers
+        check
 
-    def resource_type_identifiers
-      check
+        @client.get_resource_type_identifiers
+      end
 
-      @client.get_resource_type_identifiers
-    end
+      def mixin_type_identifiers
+        check
 
-    def mixin_type_identifiers
-      check
+        @client.get_mixin_type_identifiers
+      end
 
-      @client.get_mixin_type_identifiers
-    end
+      def mixin_types
+        check
 
-    def mixin_types
-      check
+        @client.get_mixin_types
+      end
 
-      @client.get_mixin_types
-    end
+      def mixins(*args)
+        check
 
-    def mixins(*args)
-      check
+        @client.get_mixins(*args)
+      end
 
-      @client.get_mixins(*args)
-    end
+      ###
 
-    ###
+      def resource(*args)
+        check
 
-    def resource(*args)
-      check
+        @client.get_resource(*args)
+      end
 
-      @client.get_resource(*args)
-    end
+      def mixin(*args)
+        check
 
-    def mixin(*args)
-      check
+        @client.find_mixin(*args)
+      end
 
-      @client.find_mixin(*args)
-    end
+      private
 
-    private
+      def check
+        raise "You have to issue 'connect' first!" if @client.nil?
+        raise "Client is disconnected!" unless @client.connected
+      end
 
-    def check
-      raise "You have to issue 'connect' first!" if @client.nil?
-      raise "Client is disconnected!" unless @client.connected
     end
-
   end
 end

data/lib/occi/bin/helpers.rb

@@ -0,0 +1,91 @@
+# a bunch of OCCI client helpers for bin/occi
+
+def helper_list(options)
+  found = []
+
+  if resource_types.include? options.resource
+    Occi::Log.debug "#{options.resource} is a resource type."
+    found = list options.resource
+  elsif mixin_types.include? options.resource
+    Occi::Log.debug "#{options.resource} is a mixin type."
+    found = mixins options.resource
+  else
+    Occi::Log.debug "I have no idea what #{options.resource} is ..."
+    puts "Unknown resource #{options.resource}, there is nothing to list here!"
+  end
+
+  found
+end
+
+def helper_describe(options)
+  found = []
+
+  if resource_types.include? options.resource or options.resource.start_with? options.endpoint
+    Occi::Log.debug "#{options.resource} is a resource type or an actual resource."
+
+    found = describe(options.resource)
+  elsif mixin_types.include? options.resource
+    Occi::Log.debug "#{options.resourcre} is a mixin type."
+
+    mixins(options.resource).each do |mxn|
+      mxn = mxn.split("#").last
+      found << mixin(mxn, options.resource, true)
+    end
+  elsif mixin_types.include? options.resource.split('#').first
+    Occi::Log.debug "#{options.resource} is a specific mixin type."
+
+    mxn_type,mxn = options.resource.split('#')
+    found << mixin(mxn, mxn_type, true)
+  else
+    Occi::Log.debug "I have no idea what #{options.resource} is ..."
+
+    puts "Unknown resource #{options.resource}, there is nothing to describe here!"
+  end
+
+  found
+end
+
+def helper_create(options)
+  location = nil
+
+  if resource_types.include? options.resource
+    Occi::Log.debug "#{options.resource} is a resource type."
+    raise "Not yet implemented!" unless options.resource.include? "compute"
+
+    res = resource options.resource
+
+    Occi::Log.debug "Creating #{options.resource}:\n#{res.inspect}"
+    Occi::Log.debug "with mixins:#{options.mixin}"
+
+    options.mixin.keys.each do |type|
+      Occi::Log.debug "Adding mixins of type #{type} to #{options.resource}"
+      options.mixin[type].each do |name|
+        mxn = mixin name, type
+
+        raise "Unknown mixin #{type}##{name}, stopping here!" if mxn.nil?
+        Occi::Log.debug "Adding mixin #{mxn} to #{options.resource}"
+        res.mixins << mxn
+      end
+    end
+
+    #TODO: set other attributes
+    res.title = options.resource_title
+
+    Occi::Log.debug "Creating #{options.resource}:\n#{res.inspect}"
+
+    location = create res
+  else
+    Occi::Log.debug "I have no idea what #{options.resource} is ..."
+    puts "Unknown resource #{options.resource}, there is nothing to create here!"
+  end
+
+  location
+end
+
+def helper_delete(options)
+  delete options.resource
+end
+
+def helper_trigger(options)
+  raise "Not yet implemented!"
+end

data/lib/occi/bin/occi_opts.rb

@@ -0,0 +1,251 @@
+require 'ostruct'
+require 'optparse'
+require 'occi/bin/resource_output_factory'
+
+module Occi
+  module Bin
+
+    class OcciOpts
+
+      AUTH_METHODS = [:x509, :basic, :digest, :keystone, :none].freeze
+      MEDIA_TYPES = ["application/occi+json", "application/occi+xml", "text/plain,text/occi", "text/plain"].freeze
+      ACTIONS = [:list, :describe, :create, :delete, :trigger].freeze
+      LOG_OUTPUTS = [:stdout, :stderr].freeze
+
+      def self.parse(args)
+
+        options = OpenStruct.new
+        
+        options.debug = false
+        options.verbose = false
+        
+        options.log = {}
+        options.log[:out] = STDERR
+        options.log[:level] = Occi::Log::WARN
+
+        options.dump_model = false
+
+        options.interactive = false
+
+        options.endpoint = "https://localhost:3300/"
+        
+        options.auth = {}
+        options.auth[:type] = "none"
+        options.auth[:user_cert] = ENV['HOME'] + "/.globus/usercred.pem"
+        options.auth[:ca_path] = "/etc/grid-security/certificates"
+        options.auth[:username] = "anonymous"
+        options.auth[:ca_file] = nil
+
+        options.output_format = :plain
+        
+        # TODO: change media type back to occi+json after the rOCCI-server update
+        #options.media_type = "application/occi+json"
+        options.media_type = "text/plain,text/occi"
+
+        opts = OptionParser.new do |opts|
+          opts.banner = "Usage: occi [OPTIONS]"
+
+          opts.separator ""
+          opts.separator "Options:"
+
+          opts.on("-i",
+                  "--interactive",
+                  "Run as an interactive client without additional arguments") do |interactive|
+            options.interactive = interactive
+          end
+
+          opts.on("-e",
+                  "--endpoint URI",
+                  String,
+                  "OCCI server URI, defaults to '#{options.endpoint}'") do |endpoint|
+            options.endpoint = endpoint
+          end
+
+          opts.on("-n",
+                  "--auth METHOD",
+                  AUTH_METHODS,
+                  "Authentication method, defaults to '#{options.auth[:type]}'") do |auth|
+            options.auth[:type] = auth.to_s
+          end
+
+          opts.on("-u",
+                  "--username USER",
+                  String,
+                  "Username for basic or digest authentication, defaults to '#{options.auth[:username]}'") do |username|
+            options.auth[:username] = username
+          end
+
+          opts.on("-p",
+                  "--password PASSWORD",
+                  String,
+                  "Password for basic, digest or x509 authentication") do |password|
+            options.auth[:password] = password
+            options.auth[:user_cert_password] = password
+          end
+
+          opts.on("-c",
+                  "--ca-path PATH", String, "Path to CA certificates directory, defaults to '#{options.auth[:ca_path]}'") do |ca_path|
+            options.auth[:ca_path] = ca_path
+          end
+
+          opts.on("-f",
+                  "--ca-file PATH", String, "Path to CA certificates in a file") do |ca_file|
+            options.auth[:ca_file] = ca_file
+          end
+
+          opts.on("-x",
+                  "--user-cred PATH",
+                  String,
+                  "Path to user's x509 credentials, defaults to '#{options.auth[:user_cert]}'") do |user_cred|
+            options.auth[:user_cert] = user_cred
+          end
+
+          opts.on("-X",
+                  "--proxy-ca PATH", String, "Path to a file with GSI proxy's CA certificate(s)") do |proxy_ca|
+            options.auth[:proxy_ca] = proxy_ca
+          end
+
+          opts.on("-y",
+                  "--media-type MEDIA_TYPE",
+                  MEDIA_TYPES,
+                  "Media type for client <-> server communication, defaults to '#{options.media_type}'") do |media_type|
+            options.media_type = media_type
+          end
+
+          opts.on("-r",
+                  "--resource RESOURCE",
+                  String,
+                  "Resource to be queried (e.g. network, compute, storage etc.), required") do |resource|
+            options.resource = resource
+          end
+
+          opts.on("-t",
+                  "--resource-title TITLE",
+                  String,
+                  "Resource title for new resources") do |resource_title|
+            options.resource_title = resource_title
+          end
+
+          opts.on("-a",
+                  "--action ACTION",
+                  ACTIONS,
+                  "Action to be performed on the resource, required") do |action|
+            options.action = action
+          end
+
+          opts.on("-M",
+                  "--mixin NAME",
+                  String,
+                  "Type and name of the mixin as TYPE#NAME (e.g. os_tpl#monitoring, resource_tpl#medium)") do |mixin|
+            parts = mixin.split("#")
+
+            raise "Unknown mixin format! Use TYPE#NAME!" unless parts.length == 2
+
+            options.mixin = {} if options.mixin.nil?
+            options.mixin[parts[0]] = [] if options.mixin[parts[0]].nil?
+            options.mixin[parts[0]] << parts[1]
+          end
+
+          opts.on("-g",
+                  "--trigger-action TRIGGER",
+                  String,
+                  "Action to be triggered on the resource") do |trigger_action|
+            options.trigger_action = trigger_action
+          end
+
+          opts.on("-l",
+                  "--log-to OUTPUT",
+                  LOG_OUTPUTS,
+                  "Log to the specified device, defaults to 'STDERR'") do |log_to|
+            options.log[:out] = STDOUT if log_to == :stdout or log_to == :STDOUT
+          end
+
+          opts.on("-o",
+                  "--output-format FORMAT",
+                  Occi::Bin::ResourceOutputFactory.allowed_formats,
+                  "Output format, defaults to human-readable 'plain'") do |output_format|
+            options.output_format = output_format
+          end
+
+          opts.on_tail("-m",
+                       "--dump-model",
+                       "Contact the endpoint and dump its model") do |dump_model|
+            options.dump_model = dump_model
+          end
+
+          opts.on_tail("-d",
+                       "--debug",
+                       "Enable debugging messages") do |debug|
+            options.debug = debug
+            options.log[:level] = Occi::Log::DEBUG
+          end
+
+          opts.on_tail("-b",
+                       "--verbose",
+                       "Be more verbose, less intrusive than debug mode") do |verbose|
+            options.verbose = verbose
+            options.log[:level] = Occi::Log::INFO unless options.log[:level] == Occi::Log::DEBUG
+          end
+
+          opts.on_tail("-h",
+                       "--help",
+                       "Show this message") do
+            puts opts
+            exit!(true)
+          end
+
+          opts.on_tail("-v",
+                       "--version",
+                       "Show version") do
+            puts Occi::VERSION
+            exit!(true)
+          end
+
+        end
+
+        begin
+          opts.parse!(args)
+        rescue Exception => ex
+          puts ex.message.capitalize
+          puts opts
+          exit!
+        end
+
+        if options.interactive && options.dump_model
+          puts "You cannot use '--dump-model' and '--interactive' at the same time!"
+          puts opts
+
+          exit!
+        end
+
+        if !(options.interactive or options.dump_model)
+          mandatory = []
+
+          if options.action == :trigger
+            mandatory << :trigger_action
+          end
+
+          if options.action == :create
+            mandatory << :mixin << :resource_title
+          end
+
+          mandatory.concat [:resource, :action]
+          
+          options_hash = options.marshal_dump
+
+          missing = mandatory.select{ |param| options_hash[param].nil? }
+          if not missing.empty?
+            puts "Missing required arguments: #{missing.join(', ')}"
+            puts opts
+
+            exit!
+          end
+        end
+
+        options
+      end
+
+    end
+
+  end
+end