steamcannon-deltacloud-core 0.0.7.1-java

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

@@ -0,0 +1,241 @@
+#--------------------------------------------------------------------------- #
+# 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 'deltacloud/base_driver'
+
+require 'erb'
+require 'rexml/document'
+
+path = File.dirname(__FILE__)
+$: << path
+
+require 'occi_client'
+
+module Deltacloud
+  module Drivers
+    module Opennebula
+
+class OpennebulaDriver < Deltacloud::BaseDriver
+
+  ######################################################################
+  # Hardware profiles
+  ######################################################################
+
+  define_hardware_profile 'small'
+
+  define_hardware_profile 'medium'
+
+  define_hardware_profile 'large'
+
+  ######################################################################
+  # Realms
+  ######################################################################
+
+  (REALMS = [
+	Realm.new( {
+		:id=>'Any id',
+		:name=>'Any name',
+		:limit=>:unlimited,
+		:state=>'Any state',
+	} ),
+  ] ) unless defined?( REALMS )
+
+
+  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)
+	occi_client = new_client(credentials)
+
+	images = []
+	imagesxml = occi_client.get_images
+
+	storage = REXML::Document.new(imagesxml)
+	storage.root.elements.each do |d|
+		id = d.attributes['href'].split("/").last
+
+		diskxml = occi_client.get_image(id)
+
+		images << convert_image(diskxml.to_s(), credentials)
+	end
+	images
+  end
+
+
+  ######################################################################
+  # Instances
+  ######################################################################
+
+  define_instance_states do
+	start.to( :pending )			.on( :create )
+
+	pending.to( :running )			.automatically
+
+	running.to( :stopped )			.on( :stop )
+
+	stopped.to( :running )			.on( :start )
+	stopped.to( :finish )			.on( :destroy )
+  end
+
+
+  def instances(credentials, opts=nil)
+	occi_client = new_client(credentials)
+
+	instances = []
+	instancesxml = occi_client.get_vms
+
+	computes = REXML::Document.new(instancesxml)
+	computes.root.elements.each do |d|
+		vm_id = d.attributes['href'].split("/").last
+
+		computexml = occi_client.get_vm(vm_id)
+
+		instances << convert_instance(computexml.to_s(), credentials)
+	end
+        instances = filter_on( instances, :id, opts )
+        instances = filter_on( instances, :state, opts )
+	instances
+  end
+
+
+  def create_instance(credentials, image_id, opts=nil)
+	occi_client = new_client(credentials)
+
+	hwp_id = opts[:hwp_id] || 'small'
+
+	instancexml = ERB.new(OCCI_VM).result(binding)
+	instancefile = "|echo '#{instancexml}'"
+
+	xmlvm = occi_client.post_vms(instancefile)
+
+	convert_instance(xmlvm.to_s(), credentials)
+  end
+
+
+  def start_instance(credentials, id)
+	occi_action(credentials, id, 'RESUME')
+  end
+
+
+  def stop_instance(credentials, id)
+	occi_action(credentials, id, 'STOPPED')
+  end
+
+
+  def destroy_instance(credentials, id)
+	occi_action(credentials, id, 'DONE')
+  end
+
+
+
+  private
+
+  def new_client(credentials)
+	OCCIClient::Client.new(nil,	credentials.user, credentials.password, false)
+  end
+
+
+  def convert_image(diskxml, credentials)
+	disk = REXML::Document.new(diskxml)
+	diskhash = disk.root.elements
+
+	Image.new( {
+		:id=>diskhash['ID'].text,
+		:name=>diskhash['NAME'].text,
+		:description=>diskhash['NAME'].text,
+		:owner_id=>credentials.user,
+		:architecture=>'Any architecture',
+	} )
+  end
+
+
+  def convert_instance(computexml, credentials)
+	compute = REXML::Document.new(computexml)
+	computehash = compute.root.elements
+
+	imageid = computehash['STORAGE/DISK[@type="disk"]'].attributes['href'].split("/").last
+
+	state = (computehash['STATE'].text == "ACTIVE") ? "RUNNING" : "STOPPED"
+
+	hwp_name = computehash['INSTANCE_TYPE'] || 'small'
+
+	networks = []
+	(computehash['NETWORK'].each do |n|
+		networks << n.attributes['ip']
+	end) unless computehash['NETWORK'].nil?
+
+	Instance.new( {
+		:id=>computehash['ID'].text,
+		:owner_id=>credentials.user,
+		:name=>computehash['NAME'].text,
+		:image_id=>imageid,
+		:instance_profile=>InstanceProfile.new(hwp_name),
+		:realm_id=>'Any realm',
+		:state=>state,
+		:public_addreses=>networks,
+		:private_addreses=>networks,
+		:actions=> instance_actions_for( state )
+	} )
+  end
+
+
+  def occi_action(credentials, id, strstate)
+	occi_client = new_client(credentials)
+
+	actionxml = ERB.new(OCCI_ACTION).result(binding)
+	actionfile = "|echo '#{actionxml}'"
+
+	xmlvm = occi_client.put_vm(actionfile)
+
+	convert_instance(xmlvm.to_s(), credentials)
+  end
+
+
+  (OCCI_VM = %q{
+	<COMPUTE>
+		<NAME><%=opts[:name]%></NAME>
+		<INSTANCE_TYPE><%= hwp_id %></INSTANCE_TYPE>
+		<STORAGE>
+			<DISK image="<%= image_id %>" dev="sda1" />
+		</STORAGE>
+	</COMPUTE>
+  }.gsub(/^        /, '') ) unless defined?( OCCI_VM )
+
+
+  (OCCI_ACTION = %q{
+	<COMPUTE>
+		<ID><%= id %></ID>
+		<STATE><%= strstate %></STATE>
+	</COMPUTE>
+  }.gsub(/^        /, '') ) unless defined?( OCCI_ACTION )
+
+ end
+
+    end
+  end
+end

data/lib/deltacloud/drivers/rackspace/rackspace_client.rb

@@ -0,0 +1,130 @@
+#
+# 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 "net/http"
+require "net/https"
+require 'rubygems'
+require 'json'
+
+#
+# author: Michael Neale
+# TODO: catch generic errors in JSON response and throw (probably)
+#
+module Deltacloud
+  module Drivers
+    module Rackspace
+
+class RackspaceClient
+
+  @@AUTH_API = URI.parse('https://auth.api.rackspacecloud.com/v1.0')
+
+  def initialize(username, auth_key)
+    http = Net::HTTP.new(@@AUTH_API.host,@@AUTH_API.port)
+    http.use_ssl = true
+    authed = http.get(@@AUTH_API.path, {'X-Auth-User' => username, 'X-Auth-Key' => auth_key})
+    if authed.is_a?(Net::HTTPUnauthorized)
+      raise Deltacloud::AuthException, "Failed to authenticate to Rackspace"
+    elsif !authed.is_a?(Net::HTTPSuccess)
+      backend_error!(resp)
+    end
+    @auth_token  = authed.header['X-Auth-Token']
+    @service_uri = URI.parse(authed.header['X-Server-Management-Url'])
+    @service = Net::HTTP.new(@service_uri.host, @service_uri.port)
+    @service.use_ssl = true
+  end
+
+  def list_flavors
+    JSON.parse(get('/flavors/detail'))['flavors']
+  end
+
+  def list_images
+    JSON.parse(get('/images/detail'))['images']
+  end
+
+  def list_servers
+      JSON.parse(get('/servers/detail'))['servers']
+  end
+
+
+  def load_server_details( server_id )
+    JSON.parse(get("/servers/#{server_id}"))['server']
+  end
+
+
+  def start_server(image_id, flavor_id, name)
+    json = { :server => { :name => name,
+                          :imageId => image_id.to_i,
+                          :flavorId => flavor_id.to_i }}.to_json
+    # FIXME: The response has the root password in 'adminPass'; we somehow
+    # need to communicate this back since it's the only place where we can
+    # get it from
+    JSON.parse(post("/servers", json, headers).body)["server"]
+  end
+
+  def delete_server(server_id)
+    delete("/servers/#{server_id}", headers)
+  end
+
+  def reboot_server(server_id)
+    json = { :reboot => { :type => :SOFT }}.to_json
+    post("/servers/#{server_id}/action", json, headers)
+  end
+
+
+  def headers
+    {"Accept" => "application/json", "X-Auth-Token" => @auth_token, "Content-Type" => "application/json"}
+  end
+
+  private
+  def get(path)
+    resp = @service.get(@service_uri.path + path, {"Accept" => "application/json", "X-Auth-Token" => @auth_token})
+    unless resp.is_a?(Net::HTTPSuccess)
+      backend_error!(resp)
+    end
+    resp.body
+  end
+
+  def post(path, json, headers)
+    resp = @service.post(@service_uri.path + path, json, headers)
+    unless resp.is_a?(Net::HTTPSuccess)
+      backend_error!(resp)
+    end
+    resp
+  end
+
+  def delete(path, headers)
+    resp = @service.delete(@service_uri.path + path, headers)
+    unless resp.is_a?(Net::HTTPSuccess)
+      backend_error!(resp)
+    end
+    resp
+  end
+
+  def backend_error!(resp)
+    json = JSON.parse(resp.body)
+    cause = json.keys[0]
+    code = json[cause]["code"]
+    message = json[cause]["message"]
+    details = json[cause]["details"]
+    raise Deltacloud::BackendError.new(code, cause, message, details)
+  end
+
+end
+    end
+  end
+end

data/lib/deltacloud/drivers/rackspace/rackspace_driver.rb

@@ -0,0 +1,290 @@
+#
+# 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 'deltacloud/drivers/rackspace/rackspace_client'
+require 'cloudfiles'
+
+module Deltacloud
+  module Drivers
+    module Rackspace
+
+class RackspaceDriver < Deltacloud::BaseDriver
+
+  feature :instances, :user_name
+
+  def supported_collections
+    DEFAULT_COLLECTIONS + [ :buckets ]
+  end
+
+  def hardware_profiles(credentials, opts = nil)
+    racks = new_client( credentials )
+    results=""
+    safely do
+      results = racks.list_flavors.map do |flav|
+        HardwareProfile.new(flav["id"].to_s) do
+          architecture 'x86_64'
+          memory flav["ram"].to_i
+          storage flav["disk"].to_i
+        end
+      end
+    end
+    filter_hardware_profiles(results, opts)
+  end
+
+  def images(credentials, opts=nil)
+    racks = new_client( credentials )
+    results=""
+    safely do
+      results = racks.list_images.map do |img|
+        Image.new( {
+                     :id=>img["id"].to_s,
+                     :name=>img["name"],
+                     :description => img["name"] + " " + img["status"] + "",
+                     :owner_id=>"root",
+                     :architecture=>'x86_64'
+                   } )
+      end
+    end
+    results.sort_by{|e| [e.description]}
+    results = filter_on( results, :id, opts )
+    results
+  end
+
+  #rackspace does not at this stage have realms... its all US/TX, all the time (at least at time of writing)
+  def realms(credentials, opts=nil)
+    [Realm.new( {
+      :id=>"us",
+      :name=>"United States",
+      :state=> "AVAILABLE"
+    } )]
+  end
+
+  def reboot_instance(credentials, id)
+    racks = new_client(credentials)
+    safely do
+      racks.reboot_server(id)
+    end
+    Instance.new( {
+      :id => id,
+      :state => "RUNNING",
+      :actions => instance_actions_for( "RUNNING" ),
+    } )
+  end
+
+  def stop_instance(credentials, id)
+    destroy_instance(credentials, id)
+  end
+
+  def destroy_instance(credentials, id)
+    racks = new_client(credentials)
+    safely do
+      racks.delete_server(id)
+    end
+    Instance.new( {
+      :id => id,
+      :state => "STOPPED",
+      :actions => instance_actions_for( "STOPPED" ),
+    } )
+  end
+
+
+  #
+  # create instance. Default to flavor 1 - really need a name though...
+  # In rackspace, all flavors work with all images.
+  #
+  def create_instance(credentials, image_id, opts)
+    racks = new_client( credentials )
+    hwp_id = opts[:hwp_id] || 1
+    name = Time.now.to_s
+    if (opts[:name]) then name = opts[:name] end
+    safely do
+      return convert_srv_to_instance(racks.start_server(image_id, hwp_id, name))
+    end
+  end
+
+  #
+  # Instances
+  #
+  def instances(credentials, opts=nil)
+    racks = new_client(credentials)
+    instances = []
+    safely do
+      if (opts.nil?)
+        instances = racks.list_servers.map do |srv|
+          convert_srv_to_instance(srv)
+        end
+      else
+        instances << convert_srv_to_instance(racks.load_server_details(opts[:id]))
+      end
+    end
+    instances = filter_on( instances, :id, opts )
+    instances = filter_on( instances, :state, opts )
+    instances
+  end
+
+  def valid_credentials?(credentials)
+    begin
+      new_client(credentials)
+    rescue
+      return false
+    end
+    true
+  end
+
+
+
+
+  define_instance_states do
+    start.to( :pending )          .on( :create )
+
+    pending.to( :running )        .automatically
+
+    running.to( :running )        .on( :reboot )
+    running.to( :shutting_down )  .on( :stop )
+
+    shutting_down.to( :stopped )  .automatically
+
+    stopped.to( :finish )         .automatically
+  end
+
+#--
+# Buckets
+#--
+  def buckets(credentials, opts)
+    bucket_list = []
+    cf = cloudfiles_client(credentials)
+    safely do
+      cf.containers.each do |container_name|
+        current = cf.container(container_name)
+        bucket_list << convert_container(current)
+      end #containers.each
+    end #safely
+    bucket_list = filter_on(bucket_list, :id, opts)
+    bucket_list
+  end
+
+#--
+# Create Bucket
+#--
+  def create_bucket(credentials, name, opts)
+    bucket = nil
+    cf = cloudfiles_client(credentials)
+    safely do
+      new_bucket = cf.create_container(name)
+      bucket = convert_container(new_bucket)
+    end
+    bucket
+  end
+
+#--
+# Delete Bucket
+#--
+  def delete_bucket(credentials, name, opts)
+    cf = cloudfiles_client(credentials)
+    safely do
+      cf.delete_container(name)
+    end
+  end
+
+#--
+# Blobs
+#--
+  def blobs(credentials, opts)
+    cf = cloudfiles_client(credentials)
+    blobs = []
+    safely do
+      cf_container = cf.container(opts['bucket'])
+      cf_container.objects.each do |object_name|
+        blobs << convert_object(cf_container.object(object_name))
+      end
+    end
+    blobs = filter_on(blobs, :id, opts)
+    blobs
+  end
+
+#-
+# Blob data
+#-
+  def blob_data(credentials, bucket_id, blob_id, opts)
+    cf = cloudfiles_client(credentials)
+    cf.container(bucket_id).object(blob_id).data_stream do |chunk|
+      yield chunk
+    end
+  end
+
+private
+
+  def convert_srv_to_instance(srv)
+    inst = Instance.new(:id => srv["id"].to_s,
+                        :owner_id => "root",
+                        :realm_id => "us")
+    inst.name = srv["name"]
+    inst.state = srv["status"] == "ACTIVE" ? "RUNNING" : "PENDING"
+    inst.actions = instance_actions_for(inst.state)
+    inst.image_id = srv["imageId"].to_s
+    inst.instance_profile = InstanceProfile.new(srv["flavorId"].to_s)
+    if srv["addresses"]
+      inst.public_addresses  = srv["addresses"]["public"]
+      inst.private_addresses = srv["addresses"]["private"]
+    end
+    inst
+  end
+
+  def new_client(credentials)
+    safely do
+      return RackspaceClient.new(credentials.user, credentials.password)
+    end
+  end
+
+  def convert_container(cf_container)
+    Bucket.new({ :id => cf_container.name,
+                    :name => cf_container.name,
+                    :size => cf_container.count,
+                    :blob_list => cf_container.objects
+                 })
+  end
+
+  def convert_object(cf_object)
+    Blob.new({   :id => cf_object.name,
+                 :bucket => cf_object.container.name,
+                 :content_length => cf_object.bytes,
+                 :content_type => cf_object.content_type,
+                 :last_modified => cf_object.last_modified
+              })
+  end
+
+  def cloudfiles_client(credentials)
+    safely do
+      CloudFiles::Connection.new(credentials.user, credentials.password)
+    end
+  end
+
+  def safely(&block)
+    begin
+      block.call
+    rescue Exception => e
+      raise Deltacloud::BackendError.new(500, e.class.to_s, e.message, e.backtrace)
+    end
+  end
+
+end
+
+    end
+  end
+end