steamcannon-deltacloud-core 0.0.7.1

data/lib/deltacloud/drivers/mock/data/storage_volumes/vol1.yml

@@ -0,0 +1,6 @@
+:owner_id: fedoraproject
+:created: Thu Jul 30 14:35:11 UTC 2009
+:state: AVAILABLE
+:capacity: 1
+:device:
+:instance_id:

data/lib/deltacloud/drivers/mock/data/storage_volumes/vol2.yml

@@ -0,0 +1,6 @@
+:owner_id: mockuser
+:created: Thu Jul 30 14:35:11 UTC 2009
+:state: AVAILABLE
+:capacity: 1
+:device:
+:instance_id:

data/lib/deltacloud/drivers/mock/data/storage_volumes/vol3.yml

@@ -0,0 +1,6 @@
+:owner_id: mockuser
+:created: Thu Jul 30 14:35:11 UTC 2009
+:state: IN-USE
+:capacity: 1
+:device: /dev/sda1
+:instance_id: inst1

data/lib/deltacloud/drivers/mock/mock_driver.rb

@@ -0,0 +1,356 @@
+#
+# 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.
+
+
+require 'deltacloud/base_driver'
+require 'yaml'
+
+module Deltacloud
+  module Drivers
+    module Mock
+class MockDriver < Deltacloud::BaseDriver
+
+  def supported_collections
+    DEFAULT_COLLECTIONS + [ :buckets ]
+  end
+
+  ( REALMS = [
+    Realm.new({
+      :id=>'us',
+      :name=>'United States',
+      :limit=>:unlimited,
+      :state=>'AVAILABLE',
+    }),
+    Realm.new({
+      :id=>'eu',
+      :name=>'Europe',
+      :limit=>:unlimited,
+      :state=>'AVAILABLE',
+    }),
+  ] ) unless defined?( REALMS )
+
+  define_hardware_profile('m1-small') do
+    cpu              1
+    memory         1.7 * 1024
+    storage        160
+    architecture 'i386'
+  end
+
+  define_hardware_profile('m1-large') do
+    cpu                2
+    memory           (7.5*1024 .. 15*1024), :default => 10 * 1024
+    storage          [ 850, 1024 ]
+    architecture     'x86_64'
+  end
+
+  define_hardware_profile('m1-xlarge') do
+    cpu              4
+    memory           (12*1024 .. 32*1024)
+    storage          [ 1024, 2048, 4096 ]
+    architecture     'x86_64'
+  end
+
+  # Some clouds tell us nothing about hardware profiles (e.g., OpenNebula)
+  define_hardware_profile 'opaque'
+
+  define_instance_states do
+    start.to( :pending )       .on( :create )
+
+    pending.to( :running )     .automatically
+
+    running.to( :running )     .on( :reboot )
+    running.to( :stopped )     .on( :stop )
+
+    stopped.to( :running )     .on( :start )
+    stopped.to( :finish )      .on( :destroy )
+  end
+
+  feature :instances, :user_name
+
+  def initialize
+    if ENV["DELTACLOUD_MOCK_STORAGE"]
+      @storage_root = ENV["DELTACLOUD_MOCK_STORAGE"]
+    elsif ENV["USER"]
+      @storage_root = File::join("/var/tmp", "deltacloud-mock-#{ENV["USER"]}")
+    else
+      raise "Please set either the DELTACLOUD_MOCK_STORAGE or USER environment variable"
+    end
+    if ! File::directory?(@storage_root)
+      FileUtils::rm_rf(@storage_root)
+      FileUtils::mkdir_p(@storage_root)
+      data = Dir::glob(File::join(File::dirname(__FILE__), "data", "*"))
+      FileUtils::cp_r(data, @storage_root)
+    end
+  end
+
+  def realms(credentials, opts=nil)
+    return REALMS if ( opts.nil? )
+    results = REALMS
+    results = filter_on( results, :id, opts )
+    results
+  end
+
+  #
+  # Images
+  #
+  def images(credentials, opts=nil )
+    check_credentials( credentials )
+    images = []
+    Dir[ "#{@storage_root}/images/*.yml" ].each do |image_file|
+      image = YAML.load( File.read( image_file ) )
+      image[:id] = File.basename( image_file, ".yml" )
+      image[:name] = image[:description]
+      images << Image.new( image )
+    end
+    images = filter_on( images, :id, opts )
+    images = filter_on( images, :architecture, opts )
+    if ( opts && opts[:owner_id] == 'self' )
+      images = images.select{|e| e.owner_id == credentials.user }
+    else
+      images = filter_on( images, :owner_id, opts )
+    end
+    images.sort_by{|e| [e.owner_id,e.description]}
+  end
+
+  #
+  # Instances
+  #
+
+  def instances(credentials, opts=nil)
+    check_credentials( credentials )
+    instances = []
+    Dir[ "#{@storage_root}/instances/*.yml" ].each do |instance_file|
+      instance = YAML.load( File.read( instance_file ) )
+      if ( instance[:owner_id] == credentials.user )
+        instance[:id] = File.basename( instance_file, ".yml" )
+        instance[:actions] = instance_actions_for( instance[:state] )
+        instances << Instance.new( instance )
+      end
+    end
+    instances = filter_on( instances, :id, opts )
+    instances = filter_on( instances, :state, opts )
+    instances
+  end
+
+  def create_instance(credentials, image_id, opts)
+    check_credentials( credentials )
+    ids = Dir[ "#{@storage_root}/instances/*.yml" ].collect{|e| File.basename( e, ".yml" )}
+
+    count = 0
+    while true
+      next_id = "inst" + count.to_s
+      if not ids.include?(next_id)
+        break
+      end
+      count = count + 1
+    end
+
+    realm_id = opts[:realm_id]
+    if ( realm_id.nil? )
+      realm = realms(credentials).first
+      ( realm_id = realm.id ) if realm
+    end
+
+    hwp = find_hardware_profile(credentials, opts[:hwp_id], image_id)
+
+    name = opts[:name] || "i-#{Time.now.to_i}"
+
+    instance = {
+      :name=>name,
+      :state=>'RUNNING',
+      :image_id=>image_id,
+      :owner_id=>credentials.user,
+      :public_addresses=>["#{image_id}.#{next_id}.public.com"],
+      :private_addresses=>["#{image_id}.#{next_id}.private.com"],
+      :instance_profile => InstanceProfile.new(hwp.name, opts),
+      :realm_id=>realm_id,
+      :actions=>instance_actions_for( 'RUNNING' )
+    }
+    File.open( "#{@storage_root}/instances/#{next_id}.yml", 'w' ) {|f|
+      YAML.dump( instance, f )
+    }
+    instance[:id] = next_id
+    Instance.new( instance )
+  end
+
+  def update_instance_state(credentials, id, state)
+    instance_file = "#{@storage_root}/instances/#{id}.yml"
+    instance_yml  = YAML.load( File.read( instance_file ) )
+    instance_yml[:id] = id
+    instance_yml[:state] = state
+    instance_yml[:actions] = instance_actions_for( instance_yml[:state] )
+    File.open( instance_file, 'w' ) do |f|
+      f << YAML.dump( instance_yml )
+    end
+    Instance.new( instance_yml )
+  end
+
+  def start_instance(credentials, id)
+    update_instance_state(credentials, id, 'RUNNING')
+  end
+
+  def reboot_instance(credentials, id)
+    update_instance_state(credentials, id, 'RUNNING')
+  end
+
+  def stop_instance(credentials, id)
+    update_instance_state(credentials, id, 'STOPPED')
+  end
+
+
+  def destroy_instance(credentials, id)
+    check_credentials( credentials )
+    FileUtils.rm( "#{@storage_root}/instances/#{id}.yml" )
+  end
+
+  #
+  # Storage Volumes
+  #
+
+  def storage_volumes(credentials, opts=nil)
+    check_credentials( credentials )
+    volumes = []
+    Dir[ "#{@storage_root}/storage_volumes/*.yml" ].each do |storage_volume_file|
+      storage_volume = YAML.load( File.read( storage_volume_file ) )
+      if ( storage_volume[:owner_id] == credentials.user )
+        storage_volume[:id] = File.basename( storage_volume_file, ".yml" )
+        volumes << StorageVolume.new( storage_volume )
+      end
+    end
+    volumes = filter_on( volumes, :id, opts )
+    volumes
+  end
+
+  #
+  # Storage Snapshots
+  #
+
+  def storage_snapshots(credentials, opts=nil)
+    check_credentials( credentials )
+    snapshots = []
+    Dir[ "#{@storage_root}/storage_snapshots/*.yml" ].each do |storage_snapshot_file|
+      storage_snapshot = YAML.load( File.read( storage_snapshot_file ) )
+      if ( storage_snapshot[:owner_id] == credentials.user )
+        storage_snapshot[:id] = File.basename( storage_snapshot_file, ".yml" )
+        snapshots << StorageSnapshot.new( storage_snapshot )
+      end
+    end
+    snapshots = filter_on( snapshots, :id, opts )
+    snapshots
+  end
+
+#--
+# Buckets
+#--
+  def buckets(credentials, opts=nil)
+    check_credentials(credentials)
+    buckets=[]
+     Dir[ "#{@storage_root}/buckets/*.yml" ].each do |bucket_file|
+      bucket = YAML.load( File.read( bucket_file ) )
+      bucket[:id] = File.basename( bucket_file, ".yml" )
+      bucket[:name] = bucket[:id]
+      buckets << Bucket.new( bucket )
+    end
+    buckets = filter_on( buckets, :id, opts )
+    buckets
+  end
+
+#--
+# Create bucket
+#--
+  def create_bucket(credentials, name, opts=nil)
+    check_credentials(credentials)
+    bucket = {
+      :name=>name,
+      :size=>'0',
+      :blob_list=>[]
+    }
+    File.open( "#{@storage_root}/buckets/#{name}.yml", 'w' ) {|b| YAML.dump( bucket, b )}
+    Bucket.new(bucket)
+  end
+
+#--
+# Delete bucket
+#--
+  def delete_bucket(credentials, name, opts=nil)
+    bucket = bucket(credentials, {:id => name})
+    unless (bucket.size == "0")
+     raise Deltacloud::BackendError.new(403, self.class.to_s, "bucket-not-empty", "delete operation not valid for non-empty bucket")
+    end
+    safely do
+      File.delete("#{@storage_root}/buckets/#{name}.yml")
+    end
+  end
+
+#--
+# Blobs
+#--
+  def blobs(credentials, opts = nil)
+    check_credentials(credentials)
+    blobs=[]
+    Dir[ "#{@storage_root}/buckets/blobs/*.yml" ].each do |blob_file|
+      blob = YAML.load( File.read( blob_file ) )
+      blob[:id] = File.basename( blob_file, ".yml" )
+      blob[:name] = blob[:id]
+      blobs << Blob.new( blob )
+    end
+    blobs = filter_on( blobs, :id, opts )
+    blobs
+  end
+
+#--
+# Blob content
+#--
+  def blob_data(credentials, bucket_id, blob_id, opts = nil)
+    check_credentials(credentials)
+    blob=nil
+    Dir[ "#{@storage_root}/buckets/blobs/*.yml" ].each do |blob_file|
+      if File.basename(blob_file, ".yml") == blob_id
+        blob = YAML.load(File.read(blob_file))
+        blob[:content].each {|part| yield part}
+      end
+    end
+  end
+
+  def valid_credentials?(credentials)
+    begin
+      check_credentials(credentials)
+      return true
+    rescue Deltacloud::AuthException
+    end
+    return false
+  end
+
+  private
+
+  def check_credentials(credentials)
+    if ( credentials.user != 'mockuser' )
+      raise Deltacloud::AuthException.new
+    end
+
+    if ( credentials.password != 'mockpassword' )
+      raise Deltacloud::AuthException.new
+    end
+  end
+
+
+end
+
+    end
+  end
+end

data/lib/deltacloud/drivers/opennebula/cloud_client.rb

@@ -0,0 +1,116 @@
+#--------------------------------------------------------------------------- #
+# Copyright 2002-2009, Distributed Systems Architecture Group, Universidad
+# Complutense de Madrid (dsa-research.org)
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+#--------------------------------------------------------------------------- #
+
+require 'rubygems'
+require 'uri'
+
+require 'net/https'
+
+begin
+    require 'net/http/post/multipart'
+rescue LoadError
+end
+
+###############################################################################
+# The CloudClient module contains general functionality to implement a
+# Cloud Client
+###############################################################################
+module CloudClient
+    # #########################################################################
+    # Default location for the authentication file
+    # #########################################################################
+    DEFAULT_AUTH_FILE = ENV["HOME"]+"/.one/one_auth"
+
+    # #########################################################################
+    # Gets authorization credentials from ONE_AUTH or default
+    # auth file.
+    #
+    # Raises an error if authorization is not found
+    # #########################################################################
+    def self.get_one_auth
+        if ENV["ONE_AUTH"] and !ENV["ONE_AUTH"].empty? and
+           File.file?(ENV["ONE_AUTH"])
+            one_auth=File.read(ENV["ONE_AUTH"]).strip.split(':')
+        elsif File.file?(DEFAULT_AUTH_FILE)
+            one_auth=File.read(DEFAULT_AUTH_FILE).strip.split(':')
+        else
+            raise "No authorization data present"
+        end
+
+        raise "Authorization data malformed" if one_auth.length < 2
+
+        one_auth
+    end
+
+    # #########################################################################
+    # Starts an http connection and calls the block provided. SSL flag
+    # is set if needed.
+    # #########################################################################
+    def self.http_start(url, &block)
+        http = Net::HTTP.new(url.host, url.port)
+        if url.scheme=='https'
+            http.use_ssl = true
+            http.verify_mode=OpenSSL::SSL::VERIFY_NONE
+        end
+
+        begin
+            http.start do |connection|
+                block.call(connection)
+            end
+        rescue Errno::ECONNREFUSED => e
+            str =  "Error connecting to server (#{e.to_s})."
+            str << "Server: #{url.host}:#{url.port}"
+
+            return CloudClient::Error.new(str)
+        end
+    end
+
+    # #########################################################################
+    # The Error Class represents a generic error in the Cloud Client
+    # library. It contains a readable representation of the error.
+    # #########################################################################
+    class Error
+        attr_reader :message
+
+        # +message+ a description of the error
+        def initialize(message=nil)
+            @message=message
+        end
+
+        def to_s()
+            @message
+        end
+    end
+
+    # #########################################################################
+    # Returns true if the object returned by a method of the OpenNebula
+    # library is an Error
+    # #########################################################################
+    def self.is_error?(value)
+        value.class==CloudClient::Error
+    end
+end
+
+# Command line help functions
+module CloudCLI
+    # Returns the command name
+    def cmd_name
+        File.basename($0)
+    end
+end

data/lib/deltacloud/drivers/opennebula/occi_client.rb

@@ -0,0 +1,204 @@
+#--------------------------------------------------------------------------- #
+# Copyright 2002-2009, Distributed Systems Architecture Group, Universidad
+# Complutense de Madrid (dsa-research.org)
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+#--------------------------------------------------------------------------- #
+
+require 'rubygems'
+require 'uri'
+require 'rexml/document'
+
+require 'deltacloud/drivers/opennebula/cloud_client'
+
+
+module OCCIClient
+
+    #####################################################################
+    #  Client Library to interface with the OpenNebula OCCI Service
+    #####################################################################
+    class Client
+
+        ######################################################################
+        # Initialize client library
+        ######################################################################
+        def initialize(endpoint_str=nil, user=nil, pass=nil, debug_flag=true)
+            @debug = debug_flag
+
+            # Server location
+            if endpoint_str
+                @endpoint =  endpoint_str
+            elsif ENV["OCCI_URL"]
+                @endpoint = ENV["OCCI_URL"]
+            else
+                @endpoint = "http://localhost:4567"
+            end
+
+            # Autentication
+            if user && pass
+                @occiauth = [user, pass]
+            else
+                @occiauth = CloudClient::get_one_auth
+            end
+
+            if !@occiauth
+                raise "No authorization data present"
+            end
+
+            @occiauth[1] = Digest::SHA1.hexdigest(@occiauth[1])
+        end
+
+        #################################
+        # Pool Resource Request Methods #
+        #################################
+
+        ######################################################################
+        # Post a new VM to the VM Pool
+        # :instance_type
+        # :xmlfile
+        ######################################################################
+        def post_vms(xmlfile)
+            xml=File.read(xmlfile)
+
+            url = URI.parse(@endpoint+"/compute")
+
+            req = Net::HTTP::Post.new(url.path)
+            req.body=xml
+
+            req.basic_auth @occiauth[0], @occiauth[1]
+
+            res = CloudClient::http_start(url) do |http|
+                http.request(req)
+            end
+
+            if CloudClient::is_error?(res)
+                return res
+            else
+                return res.body
+            end
+        end
+
+        ######################################################################
+        # Retieves the pool of Virtual Machines
+        ######################################################################
+        def get_vms
+            url = URI.parse(@endpoint+"/compute")
+            req = Net::HTTP::Get.new(url.path)
+
+            req.basic_auth @occiauth[0], @occiauth[1]
+
+            res = CloudClient::http_start(url) {|http|
+                http.request(req)
+            }
+
+            if CloudClient::is_error?(res)
+                return res
+            else
+                return res.body
+            end
+        end
+
+        ######################################################################
+        # Retieves the pool of Images owned by the user
+        ######################################################################
+        def get_images
+            url = URI.parse(@endpoint+"/storage")
+            req = Net::HTTP::Get.new(url.path)
+
+            req.basic_auth @occiauth[0], @occiauth[1]
+
+            res = CloudClient::http_start(url) {|http|
+                http.request(req)
+            }
+
+            if CloudClient::is_error?(res)
+                return res
+            else
+                return res.body
+            end
+        end
+
+        ####################################
+        # Entity Resource Request Methods  #
+        ####################################
+
+        ######################################################################
+        # :id VM identifier
+        ######################################################################
+        def get_vm(id)
+            url = URI.parse(@endpoint+"/compute/" + id.to_s)
+            req = Net::HTTP::Get.new(url.path)
+
+            req.basic_auth @occiauth[0], @occiauth[1]
+
+            res = CloudClient::http_start(url) {|http|
+                http.request(req)
+            }
+
+            if CloudClient::is_error?(res)
+                return res
+            else
+                return res.body
+            end
+        end
+
+        ######################################################################
+        # Puts a new Compute representation in order to change its state
+        # :xmlfile Compute OCCI xml representation
+        ######################################################################
+        def put_vm(xmlfile)
+            xml=File.read(xmlfile)
+            vm_info=REXML::Document.new(xml).root.elements
+
+            url = URI.parse(@endpoint+'/compute/' + vm_info['ID'].text)
+
+            req = Net::HTTP::Put.new(url.path)
+            req.body = xml
+
+            req.basic_auth @occiauth[0], @occiauth[1]
+
+            res = CloudClient::http_start(url) do |http|
+                http.request(req)
+            end
+
+            if CloudClient::is_error?(res)
+                return res
+            else
+                return res.body
+            end
+        end
+
+       #######################################################################
+        # Retieves an Image
+        # :image_uuid Image identifier
+        ######################################################################
+        def get_image(image_uuid)
+            url = URI.parse(@endpoint+"/storage/"+image_uuid)
+            req = Net::HTTP::Get.new(url.path)
+
+            req.basic_auth @occiauth[0], @occiauth[1]
+
+            res = CloudClient::http_start(url) {|http|
+                http.request(req)
+            }
+
+            if CloudClient::is_error?(res)
+                return res
+            else
+                return res.body
+            end
+        end
+    end
+end