occi 2.0.0 → 2.0.1

data/.travis.yml

@@ -1,5 +1,6 @@
 language: ruby
 rvm:
+  - 1.8.7
   - 1.9.2
   - 1.9.3
 

data/README.md

@@ -8,25 +8,14 @@ Requirements
 
 The following setup is recommended
 
-* usage of the Ruby Version Manger
+* usage of the Ruby Version Manger recommended
 * Ruby 1.9.3
-* Bundler gem installed (use ```gem install bundler```)
+* RubyGems installed
 
 Installation
 ------------
 
-### Stable version
-
-Download the latest version from http://dev.opennebula.org/projects/ogf-occi/files
-
-Extract file
-
-    tar xzf rOCCI-*.tar.bz
-    unzip rOCCI-*.zip
-
-Install dependencies
-
-    bundle install --deployment
+    gem install occi
 
 ### Latest version
 
@@ -42,29 +31,6 @@ Install dependencies for deployment
 
     bundle install --deployment
 
-Configure
----------
-
-Edit etc/occi-server.conf and adapt to your setting.
-
-The default templates for the OpenNebula template are located at etc/one_templates .
-
-The default templates for EC2 are located at etc/ec2_templates .
-
-Usage
------
-
-Run Passenger
-
-    passenger start
-
-Testing
--------
-
-Use curl to request all categories
-
-    curl -X GET http://localhost:3000/-/
-
 Development
 -----------
 

data/lib/occi/version.rb

@@ -1,3 +1,3 @@
 module OCCI
-  VERSION = "2.0.0" unless defined?(::OCCI::VERSION)
+  VERSION = "2.0.1" unless defined?(::OCCI::VERSION)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: occi
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.1
   prerelease: 
 platform: ruby
 authors:
@@ -32,25 +32,6 @@ files:
 - LICENSE
 - README.md
 - Rakefile
-- lib/OpenNebula/Acl.rb
-- lib/OpenNebula/AclPool.rb
-- lib/OpenNebula/Group.rb
-- lib/OpenNebula/GroupPool.rb
-- lib/OpenNebula/Host.rb
-- lib/OpenNebula/HostPool.rb
-- lib/OpenNebula/Image.rb
-- lib/OpenNebula/ImagePool.rb
-- lib/OpenNebula/OpenNebula.rb
-- lib/OpenNebula/Pool.rb
-- lib/OpenNebula/Template.rb
-- lib/OpenNebula/TemplatePool.rb
-- lib/OpenNebula/User.rb
-- lib/OpenNebula/UserPool.rb
-- lib/OpenNebula/VirtualMachine.rb
-- lib/OpenNebula/VirtualMachinePool.rb
-- lib/OpenNebula/VirtualNetwork.rb
-- lib/OpenNebula/VirtualNetworkPool.rb
-- lib/OpenNebula/XMLUtils.rb
 - lib/occi/antlr/.gitignore
 - lib/occi/antlr/OCCI.g
 - lib/occi/antlr/OCCI.tokens
@@ -66,7 +47,6 @@ files:
 - lib/occi/backend/opennebula/network.rb
 - lib/occi/backend/opennebula/opennebula.rb
 - lib/occi/backend/opennebula/storage.rb
-- lib/occi/configuration.rb
 - lib/occi/core/action.rb
 - lib/occi/core/attribute_properties.rb
 - lib/occi/core/attributes.rb
@@ -88,7 +68,6 @@ files:
 - lib/occi/log.rb
 - lib/occi/parse.rb
 - lib/occi/registry.rb
-- lib/occi/server.rb
 - lib/occi/version.rb
 - occi.gemspec
 - spec/occi/antlr/parser_spec.rb

data/lib/OpenNebula/Acl.rb

@@ -1,256 +0,0 @@
-# -------------------------------------------------------------------------- #
-# Copyright 2002-2012, OpenNebula Project Leads (OpenNebula.org)             #
-#                                                                            #
-# 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.                                             #
-#--------------------------------------------------------------------------- #
-
-
-module OpenNebula
-
-    # Abstract rules of the type USER RESOURCE RIGHTS
-    # which are:
-    #     USER      -> #<num>
-    #                  @<num>
-    #                  ALL
-    #     RESOURCE  -> + separated list and "/{#,@}<num>|ALL"
-    #                  VM,
-    #                  HOST
-    #                  NET
-    #                  IMAGE
-    #                  USER
-    #                  TEMPLATE
-    #                  GROUP
-    #                  ACL
-    #     RIGHTS    -> + separated list
-    #                  USE
-    #                  MANAGE
-    #                  ADMIN
-    #                  CREATE
-    class Acl < PoolElement
-
-        USERS = {
-            "UID"           => 0x100000000,
-            "GID"           => 0x200000000,
-            "ALL"           => 0x400000000
-        }
-
-        RESOURCES =
-        {
-            "VM"            => 0x1000000000,
-            "HOST"          => 0x2000000000,
-            "NET"           => 0x4000000000,
-            "IMAGE"         => 0x8000000000,
-            "USER"          => 0x10000000000,
-            "TEMPLATE"      => 0x20000000000,
-            "GROUP"         => 0x40000000000
-        }
-
-        RIGHTS =
-        {
-            "USE"           => 0x1,  # Auth. to use an object
-            "MANAGE"        => 0x2,  # Auth. to perform management actions
-            "ADMIN"         => 0x4,  # Auth. to perform administrative actions
-            "CREATE"        => 0x8   # Auth. to create an object
-        }
-
-        # Constructor
-        #
-        # @param xml [String] must be an xml built with {#build_xml}
-        # @param client [Client] represents an XML-RPC connection
-        def initialize(xml, client)
-            super(xml,client)
-        end
-
-        # Creates an empty XML representation. It contains the id, if it is
-        # specified.
-        #
-        # @param pe_id [Integer] rule ID
-        # @param client [Client] represents an XML-RPC connection
-        #
-        # @return [String] an empty XML representation
-        def self.build_xml(pe_id=nil)
-            if pe_id
-                acl_xml = "<ACL><ID>#{pe_id}</ID></ACL>"
-            else
-                acl_xml = "<ACL></ACL>"
-            end
-
-            XMLElement.build_xml(acl_xml,'ACL')
-        end
-
-        # Creates a new ACL rule.
-        #
-        # @param user [String]
-        #   A string containing a hex number, e.g. 0x100000001
-        # @param resource [String]
-        #   A string containing a hex number, e.g. 0x2100000001
-        # @param rights [String]
-        #   A string containing a hex number, e.g. 0x10
-        #
-        # @return [nil, OpenNebula::Error] nil in case of success, Error
-        #   otherwise
-        def allocate(user, resource, rights)
-            return super( AclPool::ACL_POOL_METHODS[:addrule],
-                          user,
-                          resource,
-                          rights )
-        end
-
-        # Deletes the Acl rule
-        #
-        # @return [nil, OpenNebula::Error] nil in case of success, Error
-        #   otherwise
-        def delete()
-            super(AclPool::ACL_POOL_METHODS[:delrule])
-        end
-
-        # Does nothing, individual ACL rules info can't be retrieved from
-        # OpenNebula
-        #
-        # @return [nil] nil
-        def info()
-            return nil
-        end
-
-        # Parses a rule string, e.g. "#5 HOST+VM/@12 INFO+CREATE+DELETE"
-        #
-        # @param rule_str [String] an ACL rule in string format
-        #
-        # @return [Array] an Array containing 3 strings (hex 64b numbers),
-        # or OpenNebula::Error objects
-        def self.parse_rule(rule_str)
-            ret = Array.new
-
-            rule_str = rule_str.split(" ")
-
-            if rule_str.length != 3
-                return OpenNebula::Error.new(
-                    "String needs three components: User, Resource, Rights")
-            end
-
-            ret << parse_users(rule_str[0])
-            ret << parse_resources(rule_str[1])
-            ret << parse_rights(rule_str[2])
-
-            errors=ret.map do |arg|
-                if OpenNebula.is_error?(arg)
-                    arg.message
-                else
-                    nil
-                end
-            end
-
-            errors.compact!
-
-            if errors.length>0
-                return OpenNebula::Error.new(errors.join(', '))
-            end
-
-            return ret
-        end
-
-private
-
-        # Converts a string in the form [#<id>, @<id>, *] to a hex. number
-        #
-        # @param users [String] Users component string
-        #
-        # @return [String] A string containing a hex number
-        def self.parse_users(users)
-           begin
-               return calculate_ids(users).to_i.to_s(16)
-           rescue Exception  => e
-               return OpenNebula::Error.new(e.message)
-           end
-        end
-
-        # Converts a resources string to a hex. number
-        #
-        # @param resources [String] Resources component string
-        #
-        # @return [String] A string containing a hex number
-        def self.parse_resources(resources)
-            begin
-                ret = 0
-                resources = resources.split("/")
-
-                if resources.size != 2
-                    raise "Resource '#{resources}' malformed"
-                end
-
-                resources[0].split("+").each{ |resource|
-                    if !RESOURCES[resource.upcase]
-                        raise "Resource '#{resource}' does not exist"
-                    end
-                    ret += RESOURCES[resource.upcase]
-                }
-
-                ret += calculate_ids(resources[1])
-
-                return ret.to_i.to_s(16)
-            rescue Exception  => e
-                return OpenNebula::Error.new(e.message)
-            end
-        end
-
-        # Converts a rights string to a hex. number
-        #
-        # @param rights [String] Rights component string
-        #
-        # @return [String] A string containing a hex number
-        def self.parse_rights(rights)
-            begin
-                ret = 0
-                rights = rights.split("+")
-
-                rights.each{ |right|
-                    raise "Right '#{right}' does not exist" if !RIGHTS[right.upcase]
-
-                    ret += RIGHTS[right.upcase]
-                }
-
-                return ret.to_i.to_s(16)
-            rescue Exception  => e
-                return OpenNebula::Error.new(e.message)
-            end
-        end
-
-        # Calculates the numeric value for a String containing an individual
-        # (#<id>), group (@<id>) or all (*) ID component
-        #
-        # @param id_str [String] Rule Id string
-        #
-        # @return [Integer] the numeric value for the given id_str
-        def self.calculate_ids(id_str)
-            raise "ID string '#{id_str}' malformed" if
-                !id_str.match(/^([\#@]\d+|\*)$/)
-
-            value = 0
-
-            case id_str[0..0]
-                when "#"
-                    value = USERS["UID"]
-                    users_value = id_str[1..-1].to_i + value
-
-                when "@"
-                    value = USERS["GID"]
-                    users_value = id_str[1..-1].to_i + value
-
-                when "*"
-                    users_value = USERS["ALL"]
-            end
-
-            return users_value
-        end
-    end
-end

data/lib/OpenNebula/AclPool.rb

@@ -1,53 +0,0 @@
-# -------------------------------------------------------------------------- #
-# Copyright 2002-2012, OpenNebula Project Leads (OpenNebula.org)             #
-#                                                                            #
-# 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.                                             #
-#--------------------------------------------------------------------------- #
-
-
-require 'OpenNebula/Pool'
-
-module OpenNebula
-    class AclPool < Pool
-
-        #######################################################################
-        # Constants and Class Methods
-        #######################################################################
-
-
-        ACL_POOL_METHODS = {
-            :info       => "acl.info",
-            :addrule    => "acl.addrule",
-            :delrule    => "acl.delrule"
-        }
-
-        # Class constructor
-        def initialize(client)
-            super('ACL_POOL','ACL',client)
-        end
-
-        def factory(element_xml)
-            OpenNebula::Acl.new(element_xml, @client)
-        end
-
-        #######################################################################
-        # XML-RPC Methods
-        #######################################################################
-
-        # Retrieves the ACL Pool
-        def info()
-        # Retrieves all the Acls in the pool.
-            super(ACL_POOL_METHODS[:info])
-        end
-    end
-end

data/lib/OpenNebula/Group.rb

@@ -1,147 +0,0 @@
-# -------------------------------------------------------------------------- #
-# Copyright 2002-2012, OpenNebula Project Leads (OpenNebula.org)             #
-#                                                                            #
-# 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.                                             #
-#--------------------------------------------------------------------------- #
-
-
-require 'OpenNebula/Pool'
-
-module OpenNebula
-    class Group < PoolElement
-        #######################################################################
-        # Constants and Class Methods
-        #######################################################################
-
-
-        GROUP_METHODS = {
-            :info       => "group.info",
-            :allocate   => "group.allocate",
-            :delete     => "group.delete"
-        }
-
-        # Flag for requesting connected user's group info
-        SELF = -1
-
-        #Default location for group ACL's
-        if ENV['ONE_LOCATION']
-            GROUP_DEFAULT = ENV['ONE_LOCATION'] + "/etc/group.default"
-        else
-            GROUP_DEFAULT = "/etc/one/group.default"
-        end
-
-        # Creates a Group description with just its identifier
-        # this method should be used to create plain Group objects.
-        # +id+ the id of the user
-        #
-        # Example:
-        #   group = Group.new(Group.build_xml(3),rpc_client)
-        #
-        def Group.build_xml(pe_id=nil)
-            if pe_id
-                group_xml = "<GROUP><ID>#{pe_id}</ID></GROUP>"
-            else
-                group_xml = "<GROUP></GROUP>"
-            end
-
-            XMLElement.build_xml(group_xml,'GROUP')
-        end
-
-        # Class constructor
-        def initialize(xml, client)
-            super(xml,client)
-        end
-
-        #######################################################################
-        # Group utils
-        #######################################################################
-
-        # Creates ACLs for the group. The ACL rules are described in a file
-        def create_acls(filename = GROUP_DEFAULT)
-            if !File.readable?(filename)
-                return -1, "Can not read deafult ACL file for group"
-            end
-
-            msg = String.new
-
-            File.open(filename).each_line{ |l|
-                next if l.match(/^#/)
-
-                rule  = "@#{@pe_id} #{l}"
-                parse = OpenNebula::Acl.parse_rule(rule)
-
-                if OpenNebula.is_error?(parse)
-                    return -1, "Error parsing rule #{rule}: #{parse.message}"
-                end
-
-                xml = OpenNebula::Acl.build_xml
-                acl = OpenNebula::Acl.new(xml, @client)
-
-                rc = acl.allocate(*parse)
-
-                if OpenNebula.is_error?(rc)
-                    return -1, "Error creating rule #{rule}: #{rc.message}"
-                else
-                    msg << "ACL_ID: #{acl.id}\n"
-                end
-            }
-
-            return 0, msg
-        end
-
-        #######################################################################
-        # XML-RPC Methods for the Group Object
-        #######################################################################
-
-        # Retrieves the information of the given Group.
-        def info()
-            super(GROUP_METHODS[:info], 'GROUP')
-        end
-
-        # Allocates a new Group in OpenNebula
-        #
-        # +groupname+ A string containing the name of the Group.
-        def allocate(groupname)
-            super(GROUP_METHODS[:allocate], groupname)
-        end
-
-        # Deletes the Group
-        def delete()
-            super(GROUP_METHODS[:delete])
-        end
-
-        # ---------------------------------------------------------------------
-        # Helpers to get information
-        # ---------------------------------------------------------------------
-
-        # Returns whether or not the user with id 'uid' is part of this group
-        def contains(uid)
-            #This doesn't work in ruby 1.8.5
-            #return self["USERS/ID[.=#{uid}]"] != nil
-
-            id_array = retrieve_elements('USERS/ID')
-            return id_array != nil && id_array.include?(uid.to_s)
-        end
-
-        # Returns an array with the numeric user ids
-        def user_ids
-            array = Array.new
-
-            self.each("USERS/ID") do |id|
-                array << id.text.to_i
-            end
-
-            return array
-        end
-    end
-end