occi-core 4.0.0.alpha.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ebef6c43e395ded42db83bb1f066f3d2513f4f8a
+  data.tar.gz: 2d16d544304fac4f15bf90fa8d69a6785c2ffeb0
+SHA512:
+  metadata.gz: 340f7fbb10f0cf02b07c9c6f4833ed1b4c1733ce8cd54cf9f23e938f44b1401009828b8800f1dfcd85cd5e42a1984a0d345d04ee8434c7acbbe61d6a18302861
+  data.tar.gz: dae77c9cc1033df83ede5d42405ddbfa02baef2f56288927c83963c59471174591bc5b04258eccf537383a24db62bffa5cb944ca58db89e6c2aa65fce3090cfe

data/.gitignore

@@ -0,0 +1,15 @@
+*.gem
+*.swp
+.project
+.idea
+.yardoc
+.bundle
+.rvmrc
+lib/occiantlr/output/
+pkg
+tmp
+log
+coverage
+vendor
+collection
+Gemfile.lock

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper --color --format documentation

data/.travis.yml

@@ -0,0 +1,43 @@
+language: ruby
+
+before_install:
+ - sudo apt-get install -qq libonig-dev
+
+rvm:
+  - 1.8.7
+  - 1.9.3
+  - 2.0.0
+  - ruby-head
+  - jruby-19mode
+  - jruby-head
+
+jdk:
+  - openjdk7
+  - oraclejdk7
+  - openjdk6
+
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-head
+  exclude:
+    - rvm: 1.8.7
+      jdk: openjdk7
+    - rvm: 1.8.7
+      jdk: oraclejdk7
+    - rvm: 1.9.3
+      jdk: openjdk7
+    - rvm: 1.9.3
+      jdk: oraclejdk7
+    - rvm: 2.0.0
+      jdk: openjdk7
+    - rvm: 2.0.0
+      jdk: oraclejdk7
+    - rvm: ruby-head
+      jdk: openjdk7
+    - rvm: ruby-head
+      jdk: oraclejdk7
+
+branches:
+  only:
+    - master

data/.yardopts

@@ -0,0 +1 @@
+--title "Documentation of the OCCI gem" --markup markdown --private

data/AUTHORS

@@ -0,0 +1,9 @@
+rOcci was designed and is mainly developed by Florian Feldhaus (GWDG) and Piotr Kasprzak (GWDG) in Germany.
+
+Special thanks to the following extraordinary individuals, whithout whom rOcci would not be possible:
+
+* Hayati Bice - who wrote the initial version of an Occi server rOcci is based on
+* Max Günther - who wrote the EC2 backend
+* Andre Thevapalan - for his input regarding the JSON rendering
+* Boris Parak - especially for his input regarding the Client / Client DSL and CLI
+* the OCCI Working Group - for developing OCCI

data/Gemfile

@@ -0,0 +1,11 @@
+source "https://rubygems.org/"
+
+gemspec
+
+group :development do
+  gem 'rubygems-tasks', :git => 'git://github.com/postmodern/rubygems-tasks.git'
+end
+
+platforms :ruby_18 do
+  gem 'oniguruma'
+end

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2012 GWDG
+
+Licensed 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.

data/README.md

@@ -0,0 +1,212 @@
+rOCCI-core - A Ruby OCCI Framework
+=================================
+
+[![Build Status](https://secure.travis-ci.org/gwdg/rOCCI-core.png)](http://travis-ci.org/gwdg/rOCCI-core)
+[![Dependency Status](https://gemnasium.com/gwdg/rOCCI-core.png)](https://gemnasium.com/gwdg/rOCCI-core)
+[![Gem Version](https://fury-badge.herokuapp.com/rb/occi-core.png)](https://badge.fury.io/rb/occi-core)
+[![Code Climate](https://codeclimate.com/github/gwdg/rOCCI-core.png)](https://codeclimate.com/github/gwdg/rOCCI-core)
+
+Requirements
+------------
+
+Ruby
+* at least version 1.8.7 is required
+
+The following setup is recommended
+
+* usage of the Ruby Version Manager
+* Ruby 1.9.3
+* RubyGems installed
+
+The following libraries / packages may be required to use rOCCI
+
+* libxslt-dev
+* libxml2-dev
+* **only if using Ruby 1.8.7:** libonig-dev (Linux) or oniguruma (Mac)
+
+Installation
+------------
+
+**[Mac OS X has some special requirements for the installation. Detailed information can be found in
+doc/macosx.md.](doc/macosx.md)**
+
+To install the most recent stable version
+
+    gem install occi-core
+
+To install the most recent beta version
+
+    gem install occi-core --pre
+
+### Installation from source
+
+To use rOCCI from source it is very much recommended to use RVM. [Install RVM](https://rvm.io/rvm/install/) with
+
+    curl -L https://get.rvm.io | bash -s stable --ruby
+
+#### Ruby
+
+To build and install the bleeding edge version from master
+
+    git clone git://github.com/gwdg/rOCCI-core.git
+    cd rOCCI-core
+    rvm install ruby-1.9.3
+    rvm --create --ruby-version use 1.9.3@rOCCI-core
+    bundle install
+    rake test
+
+Usage
+-----
+#### Logging
+
+The OCCI gem includes its own logging mechanism using a message queue. By default, no one is listening to that queue.
+A new OCCI Logger can be initialized by specifying the log destination (either a filename or an IO object like
+STDOUT) and the log level.
+
+    Occi::Log.new(STDOUT,Occi::Log::INFO)
+
+You can create multiple Loggers to receive the log output.
+
+You can always, even if there is no logger defined, log output using the class methods of OCCI::Log e.g.
+
+    Occi::Log.info("Test message")
+
+#### Registering categories in the OCCI Model
+
+Before the parser may be used, the available categories have to be registered in the OCCI Model.
+
+For categories already specified by the OCCI WG a method exists in the OCCI Model class to register them:
+
+    model = Occi::Model.new
+    model.register_infrastructure
+
+Further categories can either be registered from files which include OCCI collections in JSON formator or from parsed
+ JSON objects (e.g. from the query interface of an OCCI service endpoint).
+
+#### Parsing OCCI messages
+
+The OCCI gem includes a Parser to easily parse OCCI messages. With a given media type (e.g. json,
+xml or plain text) the parser analyses the content of the message body and, if supplied,
+the message header. As the text/plain and text/occi media type do not clearly distinguish between a message with a
+category and a message with an entity which has a kind, it has to be specified if the message contains a category (e
+.g. for user defined mixins)
+
+OCCI messages can be parsed to an OCCI collection for example like
+
+    media_type = 'text/plain'
+    body = %Q|Category: compute; scheme="http://schemas.ogf.org/occi/infrastructure#"; class="kind"|
+    collection=Occi::Parser.parse(media_type, body)
+
+#### Parsing OVF / OVA files
+
+Parsing of OVF/OVA files is partly supported and will be improved in future versions.
+
+The example in [DMTF DSP 2021](http://www.dmtf.org/sites/default/files/standards/documents/DSP2021_1.0.0.tar) is
+bundled with rOCCI and can be parsed to an OCCI collection with
+
+    require 'open-uri'
+    ova=open 'https://raw.github.com/gwdg/rOCCI/master/spec/occi/test.ova'
+    collection=Occi::Parser.ova(ova.read)
+
+Currently only the following entries of OVF files are parsed
+
+* File in References
+* Disk in the DiskSection
+* Network in the NetworkSection
+* In the VirutalSystemSection:
+** Info
+** in the VirtualHardwareSection the items regarding
+*** Processor
+*** Memory
+*** Ethernet Adapter
+*** Parallel port
+
+### Using the OCCI model
+
+The occi-core gem includes all OCCI Core classes necessary to handly arbitrary OCCI objects.
+
+Changelog
+---------
+
+### Version 3.1
+* added basic OS Keystone support
+* added support for PKCS12 credentials for X.509 authN
+* updated templates for plain output formatting
+* minor client API changes
+* several bugfixes
+
+### Version 3.0
+
+* many bugfixes
+* rewrote Core classes to use metaprogramming techniques
+* added VCR cassettes for reliable testing against prerecorded server responses
+* several updates to the OCCI Client
+* started work on an OCCI Client using AMQP as transport protocol
+* added support for keystone authentication to be used with the OpenStack OCCI server
+* updated dependencies
+* updated rspec tests
+* started work on cucumber features
+
+### Version 2.5
+
+* improved OCCI Client
+* improved documentation
+* several bugfixes
+
+### Version 2.4
+
+* Changed OCCI attribute properties from lowercase to first letter uppercase (e.g. type -> Type, default -> Default, ...)
+
+### Version 2.3
+
+* OCCI objects are now initialized with a list of attributes instead of a hash. Thus it is easier to check which
+attributes are expected by a class and helps prevent errors.
+* Parsing of a subset of the OVF specification is supported. Further parts of the specification will be covered in
+future versions of rOCCI.
+
+### Version 2.2
+
+* OCCI Client added. The client simplifies the execution of OCCI commands and provides shortcuts for often used steps.
+
+### Version 2.1
+
+* Several improvements to the gem structure and code documentation. First rSpec test were added. Readme has been extended to include instructions how the gem can be used.
+
+### Version 2.0
+
+* Starting with version 2.0 Florian Feldhaus and Piotr Kasprzak took over the development of the OCCI gem. The codebase was taken from the rOCCI framework and improved to be bundled as a standalone gem.
+
+### Version 1.X
+
+* Version 1.X of the OCCI gem has been developed by retr0h and served as a simple way to access the first OpenNebula OCCI implementation.
+
+Development
+-----------
+
+Checkout latest version from git:
+
+    git clone git://github.com/gwdg/rOCCI-core.git
+
+Change to rOCCI-core folder
+
+    cd rOCCI-core
+
+Install dependencies
+
+    bundle install
+
+### Code Documentation
+
+[Code Documentation for rOCCI by YARD](http://rubydoc.info/github/gwdg/rOCCI-core/)
+
+### Continuous integration
+
+[Continuous integration for rOCCI by Travis-CI](http://travis-ci.org/gwdg/rOCCI-core/)
+
+### Contribute
+
+1. Fork it.
+2. Create a branch (git checkout -b my_markup)
+3. Commit your changes (git commit -am "My changes")
+4. Push to the branch (git push origin my_markup)
+5. Create an Issue with a link to your branch

data/Rakefile

@@ -0,0 +1,28 @@
+require 'rubygems'
+require 'rubygems/tasks'
+
+task :default => 'test'
+
+desc "Run all tests; includes rspec and coverage reports"
+task :test => 'rcov:all'
+
+Gem::Tasks.new(:build => {:tar => true, :zip => true}, :sign => {:checksum => true, :pgp => false})
+
+namespace :rcov do
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new(:rspec) do |t|
+    ENV['COVERAGE'] = "true"
+  end
+
+  desc "Run rspec to generate aggregated coverage"
+  task :all do |t|
+    rm "coverage/coverage.data" if File.exist?("coverage/coverage.data")
+    Rake::Task['rcov:rspec'].invoke
+  end
+end
+
+require 'yard'
+YARD::Rake::YardocTask.new(:yard) do |t|
+  t.options = ['--any', '--extra', '--opts'] # optional
+end

data/config/occi.yml

@@ -0,0 +1,4 @@
+# config/occi.yml
+core: &core
+  compatibility: true
+  verify_attribute_pattern: false

data/ext/mkrf_conf.rb

@@ -0,0 +1,35 @@
+require 'rubygems'
+require 'rubygems/command.rb'
+require 'rubygems/dependency_installer.rb' 
+
+begin
+  Gem::Command.build_args = ARGV
+rescue NoMethodError
+  # do nothing but warn the user
+  warn "Gem::Command doesn't have a method named 'build_args'!"
+end 
+
+warn 'Installing platform-specific dependencies.'
+
+warn 'Installing the most recent version of \'rake\''
+inst = Gem::DependencyInstaller.new
+inst.install "rake"
+
+if RUBY_PLATFORM == "java"
+  # Nothing to install for rOCCI-core
+  #warn 'Installing dependencies specific for jRuby'
+else
+  warn 'Installing dependencies specific for Ruby'
+
+  rver = RUBY_VERSION.split('.').map{ |elm| elm.to_i }
+  if rver[0] == 1 && rver[1] < 9
+    warn 'Installing \'oniguruma\' for Ruby 1.8.x'
+    warn 'Make sure you have \'libonig-dev\' installed!'
+    inst.install "oniguruma"
+  end
+end
+
+# create dummy rakefile to indicate success
+f = File.open(File.join(File.dirname(__FILE__), "Rakefile"), "w")
+f.write "task :default\n"
+f.close

data/lib/occi/collection.rb

@@ -0,0 +1,192 @@
+module Occi
+  class Collection
+
+    include Occi::Helpers::Inspect
+
+    attr_accessor :kinds, :mixins, :actions, :resources, :links, :action, :model
+
+    # Initialize a new OCCI Collection by initializing all supplied OCCI objects
+    #
+    # @param [Hash] collection including one or more of the keys kinds, mixins, actions, resources, links
+    def initialize(collection={}, model = Occi::Model.new)
+      collection = Hashie::Mash.new(collection) unless collection.kind_of? Occi::Collection
+
+      @kinds = Occi::Core::Kinds.new
+      @mixins = Occi::Core::Mixins.new
+      @actions = Occi::Core::Actions.new
+      @resources = Occi::Core::Resources.new
+      @links = Occi::Core::Links.new
+
+      self.model = model if model
+
+      @kinds.merge collection.kinds.to_a.collect { |kind| Occi::Core::Kind.new(kind.scheme, kind.term, kind.title, kind.attributes, kind.related, kind.actions) }
+      @mixins.merge collection.mixins.to_a.collect { |mixin| Occi::Core::Mixin.new(mixin.scheme, mixin.term, mixin.title, mixin.attributes, mixin.related, mixin.actions) }
+      @actions.merge collection.actions.to_a.collect { |action| Occi::Core::Action.new(action.scheme, action.term, action.title, action.attributes) }
+      @resources.merge collection.resources.to_a.collect { |resource| Occi::Core::Resource.new(resource.kind, resource.mixins, resource.attributes, resource.links) }
+      @links.merge collection.links.to_a.collect { |link| Occi::Core::Link.new(link.kind, link.mixins, link.attributes) }
+      @action = Occi::Core::ActionInstance.new(collection.action, collection.attributes) if collection.action
+    end
+
+    def <<(object)
+      object.kind_of? Occi::Core::Kind and self.kinds << object
+      object.kind_of? Occi::Core::Mixin and self.mixins << object
+      object.kind_of? Occi::Core::Action and self.actions << object
+      object.kind_of? Occi::Core::Resource and self.resources << object
+      object.kind_of? Occi::Core::Link and self.links << object
+    end
+
+    def ==(category)
+      not intersect(category).empty?
+    end
+
+    # @return [Occi::Core::Categories] categories combined list of all kinds, mixins and actions
+    def categories
+      Occi::Core::Categories.new(@kinds + @mixins + @actions)
+    end
+
+    # @return [Occi::Core::Entities] entities combined list of all resources and links
+    def entities
+      Occi::Core::Entities.new(@resources + @links)
+    end
+
+    # @param [Occi::Core::Model] model
+    # @return [Occi::Core::Model]
+    def model=(model)
+      @model = model
+      @kinds.model = model
+      @mixins.model = model
+      @actions.model = model
+      @resources.model = model
+      @links.model = model
+    end
+
+    def check
+      @resources.check
+      @links.check
+      # TODO: check action instance format, should check be applicable?
+      #@action.check
+    end
+
+    # @param [Occi::Collection] other_collection
+    # @return [Occi::Collection]
+    def merge!(other_collection)
+      merge other_collection, self
+    end
+
+    # @param [Occi::Collection] other_collection
+    # @param [Occi::Collection] collection
+    # @return [Occi::Collection]
+    def merge(other_collection, collection=self.clone)
+      collection.kinds.merge other_collection.kinds.select { |kind| get_by_id(kind.type_identifier).nil? }
+      collection.mixins.merge other_collection.mixins.select { |mixin| get_by_id(mixin.type_identifier).nil? }
+      collection.actions.merge other_collection.actions.select { |action| get_by_id(action.type_identifier).nil? }
+      collection.resources.merge other_collection.resources.select { |resource| get_by_id(resource.id).nil? }
+      collection.links.merge other_collection.links.select { |link| get_by_id(link.type_identifier).nil? }
+      collection.action = other_collection.action if other_collection.action
+      collection
+    end
+
+    # @param [Occi::Collection] other_collection
+    # @return [Occi::Collection]
+    def intersect!(other_collection)
+      intersect other_collection, self
+    end
+
+    # @param [Occi::Collection] other_collection
+    # @param [Occi::Collection] collection
+    # @return [Occi::Collection]
+    def intersect(other_collection, collection=self.clone)
+      collection.kinds.replace other_collection.kinds.select { |kind| get_by_id(kind.type_identifier) }
+      collection.mixins.replace other_collection.mixins.select { |mixin| get_by_id(mixin.type_identifier) }
+      collection.actions.replace other_collection.actions.select { |action| get_by_id(action.type_identifier) }
+      collection.resources.replace other_collection.resources.select { |resource| get_by_id(resource.id) }
+      collection.links.replace other_collection.links.select { |link| get_by_id(link.type_identifier) }
+      if collection.action == other_collection.action
+        collection.action = other_collection.action
+      else
+        collection.action = nil
+      end
+      collection
+    end
+
+    # Returns the category corresponding to a given id
+    #
+    # @param [String] id
+    # @return [Occi::Core::Category]
+    def get_by_id(id)
+      object = self.categories.select { |category| category.type_identifier == id }
+      object = self.entities.select { |entity| entity.id == id } if object.empty?
+      object.first
+    end
+
+    # Returns the category corresponding to a given location
+    #
+    # @param [URI] location
+    # @return [Occi::Core::Category]
+    def get_by_location(location)
+      self.categories.select { |category| category.location == location }.first
+    end
+
+    # @return [true,false] true if collection is empty, false otherwise
+    def empty?
+      @kinds.empty? && @mixins.empty? && @actions.empty? && @resources.empty? && @links.empty? && @action.nil?
+    end
+
+    # Returns a collection with all categories related to the specified category
+    #
+    # @param [Occi::Core::Category] category
+    # @return [Occi::Core::Collection]
+    def get_related_to(category)
+      collection = self.class.new
+      collection.kinds = @kinds.get_related_to(category)
+      collection.mixins = @mixins.get_related_to(category)
+      collection
+    end
+
+    # @return [Hashie::Mash] json representation
+    def as_json(options = {})
+      collection = Hashie::Mash.new
+      collection.kinds = @kinds.collect { |kind| kind.as_json } if @kinds.any?
+      collection.mixins = @mixins.collect { |mixin| mixin.as_json } if @mixins.any?
+      collection.actions = @actions.collect { |action_category| action_category.as_json } if @actions.any?
+      collection.resources = @resources.collect { |resource| resource.as_json } if @resources.any?
+      # if there is only one resource and the links inside the resource have no location,
+      # then these links must be rendered as separate links inside the collection
+      if !collection.resources.nil? && collection.resources.size == 1
+        if collection.resources.first.links.blank? && @links.empty?
+          lnks = @resources.first.links
+        else
+          lnks = @links
+        end
+      else
+        lnks = @links
+      end
+      collection.links = lnks.collect { |link| link.as_json } if lnks.to_a.any?
+      collection.action = @action.as_json if @action
+      collection
+    end
+
+    # @return [String] text representation
+    def to_text
+      text = ""
+      text << self.categories.collect { |category| category.to_text }.join("\n")
+      text << "\n" if self.categories.any?
+      raise "Only one resource allowed for rendering to text/plain" if self.resources.size > 1
+      text << self.resources.collect { |resource| resource.to_text }.join("\n")
+      text << self.links.collect { |link| link.to_text_link }.join("\n")
+      text << self.action.to_text if self.action
+      text
+    end
+
+    def to_header
+      header = Hashie::Mash.new
+      header['Category'] = self.categories.collect { |category| category.to_string_short }.join(',') if self.categories.any?
+      raise "Only one resource allowed for rendering to text/occi" if self.resources.size > 1
+      header = self.resources.first.to_header if self.resources.any?
+      header['Link'] = self.links.collect { |link| link.to_string }.join(',') if self.links.any?
+      header = self.action.to_header if self.action
+      header
+    end
+
+  end
+end

data/lib/occi/core/action.rb

@@ -0,0 +1,32 @@
+module Occi
+  module Core
+    class Action < Occi::Core::Category
+
+      # @param [String ] scheme
+      # @param [String] term
+      # @param [String] title
+      # @param [Hash] attributes
+      def initialize(scheme='http://schemas.ogf.org/occi/core#',
+          term='action',
+          title=nil,
+          attributes=Occi::Core::Attributes.new)
+        super scheme, term, title, attributes
+      end
+
+      # @return [String] text representation
+      def to_text
+        text = super
+        text << ';attributes=' + @attributes.names.join(' ').inspect if @attributes.any?
+        text
+      end
+
+      # @return [Hash] hash containing the HTTP headers of the text/occi rendering
+      def to_header
+        header = super
+        header["Category"] << ';attributes=' + @attributes.names.join(' ').inspect if @attributes.any?
+        header
+      end
+
+    end
+  end
+end

data/lib/occi/core/action_instance.rb

@@ -0,0 +1,38 @@
+module Occi
+  module Core
+    class ActionInstance
+
+      include Occi::Helpers::Inspect
+
+      attr_accessor :action, :attributes, :model
+
+      class_attribute :action, :attributes
+
+      self.attributes = Occi::Core::Attributes.new
+
+      self.action = Occi::Core::Action.new scheme='http://schemas.ogf.org/occi/core#',
+                                           term='action_instance',
+                                           title='action',
+                                           attributes=self.attributes
+
+      def initialize(action = self.action, attributes=self.attributes)
+        if action.kind_of? String
+          scheme, term = action.split '#'
+          action = Occi::Core::Action.new(scheme, term)
+        end
+        @action = action
+        @attributes = attributes.convert
+      end
+
+      # @param [Hash] options
+      # @return [Hashie::Mash] json representation
+      def as_json(options={})
+        action = Hashie::Mash.new
+        action.action = @action.to_s if @action
+        action.attributes = @attributes if @attributes.any?
+        action
+      end
+
+    end
+  end
+end

data/lib/occi/core/actions.rb

@@ -0,0 +1,20 @@
+module Occi
+  module Core
+    class Actions < Occi::Core::Categories
+
+      private
+
+      def convert(category)
+        category = super category
+
+        if category.kind_of? String
+          scheme, term = category.split '#'
+          scheme       += '#'
+          category = Occi::Core::Action.new(scheme, term)
+        end
+        category
+      end
+
+    end
+  end
+end