Fedora summer-coding Planet

http://localhost/conductor · qmlscript

  yum install aeolus-all
  aeolus-configure
   :conductor:
     :url: https://localhost/conductor/api
     :username: admin
     :password: password
   # yum install aeolus-cli
   $ aeolus --help

   $  aeolus hwp list

   $  aeolus hwp create --name demo

   $  aeolus image --help
  # yum install deltacloud-core deltacloud-core-rhevm deltacloud-core-openstack
  # API_PROVIDER='https://ovirt:8443/api'  /usr/bin/ruby /usr/bin/deltacloudd -i rhevm -e production --port 3004 --host localhost -u nobody -g nobody
  # API_PROVIDER='https://openstack:5000/v2.0'  /usr/bin/ruby /usr/bin/deltacloudd -i openstack  -e production --port 3005 --host localhost -u nobody -g nobody
  $ irb
  > require 'deltacloud'
  > c = DeltaCloud.new('admin@internal', 'cloudpass', 'http://localhost:3004/api')
  => <DeltaCloud::API:0x00000002d75968 @password="cloudpass", @username="admin@internal",
                                        @api_uri=#<URI::HTTP:0x00000002d75580 URL:http://localhost:3004/api>,
                                        @entry_points={:instances=>"http://localhost:3004/api/instances",
                                                       :images=>"http://localhost:3004/api/images",
                                                       :drivers=>"http://localhost:3004/api/drivers",
                                                       :instance_states=>"http://localhost:3004/api/instance_states",
                                                       :storage_volumes=>"http://localhost:3004/api/storage_volumes",
                                                       :realms=>"http://localhost:3004/api/realms",
                                                       :hardware_profiles=>"http://localhost:3004/api/hardware_profiles"},
                                        @features={:instances=>[:user_name, :user_data]},
                                        @verbose=false, @driver_name="rhevm", @api_version="1.0.0">

  > c.instances.collect { |i| [i.id, i.name] }
  => [["8b347be3-0a76-4c84-aa79-c017557540f5", "demo6"],        ["894fb094-c75d-49a8-b49d-5523346b46a3", "demo7"],
      ["98511559-46a3-4eb2-aba2-4c81c4e0d5b5", "i-1347974040"], ["29c4d6ae-87ab-46cd-8424-af05b96b1d91", "i-1348008963"],
      ["c1844032-45d4-4b17-9405-224b4942ace7", "i-1348425727"], ["12f8c82e-2837-49e0-8d41-745aa208021a", "i-1348516821"],
      ["9f3e115f-e097-4fdc-bfa3-5d634141c38a", "i-1348586396"], ["76b5bc43-6bc5-4c06-a92a-c86595bfc303", "inst1"]]

  > c.images.collect { |i| [i.id, i.name] }
  => [["00000000-0000-0000-0000-000000000000", "Blank"], ["d0a8df2e-1563-470e-bfd7-8384a400380f", "e3280dab-e719-4e6e-b954-55578acfe4b7"]]

  > i = c.create_instance("00000000-0000-0000-0000-000000000000")
  => <DeltaCloud::API::Stateful::Instance:0x000000025ddb60 @base_name="instance", @client=<DeltaCloud::API:0x00000002d75968 ...>,
                                                            @url="http://localhost:3004/api/instances/d637ee52-787d-48de-a6c4-a92b854677b4",
                                                            @id="d637ee52-787d-48de-a6c4-a92b854677b4",
                                                            @objects=[{:method_name=>"stopped?", :type=>:state, :state=>"STOPPED"},
                                                                      {:method_name=>"running?", :type=>:state, :state=>"RUNNING"},
                                                                      {:method_name=>"pending?", :type=>:state, :state=>"PENDING"},
                                                                      {:method_name=>"shutting_down?", :type=>:state, :state=>"SHUTTING_DOWN"},
                                                                      {:type=>:text, :method_name=>"name", :value=>"i-1348597714"},
                                                                      {:type=>:text, :method_name=>"owner_id", :value=>"admin@internal"},
                                                                      {:type=>:link, :method_name=>"image", :id=>"00000000-0000-0000-0000-000000000000"},
                                                                      {:type=>:text, :method_name=>"image_id", :value=>"00000000-0000-0000-0000-000000000000"},
                                                                      {:type=>:link, :method_name=>"realm", :id=>"99408929-82cf-4dc7-a532-9d998063fa95"},
                                                                      {:type=>:text, :method_name=>"realm_id", :value=>"99408929-82cf-4dc7-a532-9d998063fa95"},
                                                                      {:type=>:text, :method_name=>"state", :value=>"STOPPED"},
                                                                      {:type=>:link, :method_name=>"hardware_profile", :id=>"DESKTOP"},
                                                                      {:type=>:text, :method_name=>"hardware_profile_id", :value=>"DESKTOP"},
                                                                      {:type=>:action_link, :method_name=>"start!",
                                                                       :id=>"d637ee52-787d-48de-a6c4-a92b854677b4",
                                                                       :href=>"http://localhost:3004/api/instances/d637ee52-787d-48de-a6c4-a92b854677b4/start",
                                                                       :rel=>"start", :method=>"post"},
                                                                      {:type=>:action_link, :method_name=>"destroy!",
                                                                       :id=>"d637ee52-787d-48de-a6c4-a92b854677b4",
                                                                       :href=>"http://localhost:3004/api/instances/d637ee52-787d-48de-a6c4-a92b854677b4",
                                                                       :rel=>"destroy", :method=>"delete"},
                                                                      {:type=>:action_link, :method_name=>"create_image!",
                                                                       :id=>"d637ee52-787d-48de-a6c4-a92b854677b4",
                                                                       :href=>"http://localhost:3004/api/create_image;instance_id=d637ee52-787d-48de-a6c4-a92b854677b4",
                                                                       :rel=>"create_image", :method=>"post"},
                                                                      {:type=>:collection, :method_name=>"public_addresses",
                                                                       :values=>[{:address=>"127.0.0.1", :type=>"vnc"}]},
                                                                                 {:type=>:collection, :method_name=>"private_addresses", :values=>[]},
                                                                                 {:type=>:text, :method_name=>"storage_volumes", :value=>""}],
                                                            @action_urls=["http://localhost:3004/api/instances/d637ee52-787d-48de-a6c4-a92b854677b4/start",
                                                                          "http://localhost:3004/api/instances/d637ee52-787d-48de-a6c4-a92b854677b4",
                                                                          "http://localhost:3004/api/create_image;instance_id=d637ee52-787d-48de-a6c4-a92b854677b4"],
                                                            @actions=[["start", "http://localhost:3004/api/instances/d637ee52-787d-48de-a6c4-a92b854677b4/start"],
                                                                      ["destroy", "http://localhost:3004/api/instances/d637ee52-787d-48de-a6c4-a92b854677b4"],
                                                                      ["create_image", "http://localhost:3004/api/create_image;instance_id=d637ee52-787d-48de-a6c4-a92b854677b4"]],
                                                            @state="STOPPED">

  > i.actions
  => [["start",        "http://localhost:3004/api/instances/d637ee52-787d-48de-a6c4-a92b854677b4/start"],
      ["destroy",      "http://localhost:3004/api/instances/d637ee52-787d-48de-a6c4-a92b854677b4"],
      ["create_image", "http://localhost:3004/api/create_image;instance_id=d637ee52-787d-48de-a6c4-a92b854677b4"]]

  > i.state
  => "STOPPED"

  > i.start!
  > i.state
  => "PENDING"

  # and after a little while
  > i.state
  => "RUNNING"
  $ irb
  > require 'deltacloud'

  > c = DeltaCloud.new('admin+admin', 'cloudpass', 'http://localhost:3005/api')
  => <DeltaCloud::API:0x0000000149fc90 @password="cloudpass", @username="admin+admin",
                                        @api_uri=#<URI::HTTP:0x000000014a7530 URL:http://localhost:3005/api>,
                                        @entry_points={:instances=>"http://localhost:3005/api/instances",
                                                       :buckets=>"http://localhost:3005/api/buckets",
                                                       :images=>"http://localhost:3005/api/images",
                                                       :drivers=>"http://localhost:3005/api/drivers",
                                                       :instance_states=>"http://localhost:3005/api/instance_states",
                                                       :realms=>"http://localhost:3005/api/realms",
                                                       :hardware_profiles=>"http://localhost:3005/api/hardware_profiles"},
                                        @features={:instances=>[:user_name, :user_files, :authentication_password]},
                                        @verbose=false, @driver_name="openstack", @api_version="1.0.0">

  > c.instances.collect { |i| [i.id, i.name] }
  => [["f6915123-c3de-4a3c-bb0e-e88143ea838f", "2012-09-25 11:32:43 -0400"]]

  > c.images.collect { |i| [i.id, i.name] }
  => [["a4180f79-c4bf-4d61-a801-b5990b590fb0", "f16-jeos"]]

  > i = c.create_instance('a4180f79-c4bf-4d61-a801-b5990b590fb0')
  => <DeltaCloud::API::Stateful::Instance:0x000000014fe1a0 @base_name="instance", @client=#<DeltaCloud::API:0x0000000149fc90 ...>,
                                                            @url="http://localhost:3005/api/instances/c32688e4-eeb0-468f-a08f-cdf047d36b45",
                                                            @id="c32688e4-eeb0-468f-a08f-cdf047d36b45",
                                                            @objects=[{:method_name=>"stopped?", :type=>:state, :state=>"STOPPED"},
                                                                      {:method_name=>"running?", :type=>:state, :state=>"RUNNING"},
                                                                      {:method_name=>"pending?", :type=>:state, :state=>"PENDING"},
                                                                      {:method_name=>"shutting_down?", :type=>:state, :state=>"SHUTTING_DOWN"},
                                                                      {:type=>:text, :method_name=>"name", :value=>"2012-09-25 14:39:31 -0400"},
                                                                      {:type=>:text, :method_name=>"owner_id", :value=>"admin"},
                                                                      {:type=>:link, :method_name=>"image", :id=>"a4180f79-c4bf-4d61-a801-b5990b590fb0"},
                                                                      {:type=>:text, :method_name=>"image_id", :value=>"a4180f79-c4bf-4d61-a801-b5990b590fb0"},
                                                                      {:type=>:link, :method_name=>"realm", :id=>"default"},
                                                                      {:type=>:text, :method_name=>"realm_id", :value=>"default"},
                                                                      {:type=>:text, :method_name=>"state", :value=>"PENDING"},
                                                                      {:type=>:link, :method_name=>"hardware_profile", :id=>"1"},
                                                                      {:type=>:text, :method_name=>"hardware_profile_id", :value=>"1"},
                                                                      {:type=>:collection, :method_name=>"public_addresses", :values=>[]},
                                                                      {:type=>:collection, :method_name=>"private_addresses", :values=>[]},
                                                                      {:type=>:text, :method_name=>"storage_volumes", :value=>""},
                                                                      {:type=>:collection, :method_name=>"authentication", :values=>{:username=>"removed"}}],
                                                            @action_urls=[],
                                                            @actions=[],
                                                            @state="PENDING">
  irb(main):006:0> i.state
  => "PENDING"

  > c.instances.collect { |i| [i.id, i.name] }
  => [["c32688e4-eeb0-468f-a08f-cdf047d36b45", "2012-09-25 14:39:31 -0400"],
      ["f6915123-c3de-4a3c-bb0e-e88143ea838f", "2012-09-25 11:32:43 -0400"]]

  # openstack instances autostart
  > c.instances.first.state
  => "RUNNING"
  # yum install imagefactory
  # yum install git
  $ git clone git://github.com/aeolusproject/imagefactory.git
  $ cd imagefactory
  $ make rpms
  $ cd imagefactory-plugins
  $ make rpms
  $ rpm -ivh <imagefactory.rpm> <imagefactory-plugins.rpm>
  $ rpmbuild --rebuild http://repos.fedorapeople.org/repos/aeolus/imagefactory/testing/latest_bindings/ovirt-engine-sdk-3.1.0.3-1.fc14.src.rpm
  $ rpm -ivh <ovirt-engine-sdk.rpm>
  $ mount ovirt:/ext/ovirt31export /mnt/ovirt
  $ cat rhevm.json 
      {"nfs-dir": "/mnt/ovirt", "nfs-path": "/ext/ovirt31export",
       "nfs-host": "ovirt", "cluster": "_any_",
       "api-url": "http://ovirt/api", "timeout": 1800 }

  $ cat rhevm.xml 
      <provider_credentials><rhevm_credentials><username>admin@internal</username><password>cloudpass</password></rhevm_credentials></provider_credentials>
  $ cat openstack.json 
    {"glance-host": "openstack", "glance-port": 9292 }

  $ cat openstack.xml 
    <provider_credentials><openstack_credentials><username>admin</username><tenant>admin</tenant><password>cloudpass</password><strategy>keystone</strategy><auth_url>http://openstack:5000/v2.0</auth_url></openstack_credentials></provider_credentials>
  $ sudo imagefactory base_image template.xml
  $ sudo imagefactory --debug target_image --id b55b42f1-aa2d-418f-b635-252e5f343209 rhevm
  $ sudo imagefactory --debug provider_image --id "2492c8c2-ada4-4325-a783-da3c37871ba7" --target rhevm rhevm.json rhevm.xml
# example server from the RJR documentation:
# define a rpc method called 'hello' which takes
# one argument and returns it in upper case
RJR::Dispatcher.add_handler("hello") { |arg|
  arg.upcase
}

# listen for this method via amqp, websockets, http calls
amqp_node  = RJR::AMQPNode.new  :node_id => 'server', :broker => 'localhost'
ws_node    = RJR::WSNode.new    :node_id => 'server', :host   => 'localhost', :port => 8080
www_node   = RJR::WebNode.new   :node_id => 'server', :host   => 'localhost', :port => 8888

# start the server and block
multi_node = RJR::MultiNode.new :nodes => [amqp_node, ws_node, www_node]
multi_node.listen
multi_node.join
# example clients from the documentation
# invoke the method over amqp
amqp_node = RJR::AMQPNode.new :node_id => 'client', :broker => 'localhost'
puts amqp_node.invoke_request('server-queue', 'hello', 'world')

# invoke the method over http using rjr
client = RJR::WebNode.new :node_id => 'client'
puts client.invoke_request('http://localhost:8888', 'hello', 'mo')

# Invoking json-rpc requests over http using curl
# $ curl -X POST http://localhost:8888 -d '{"jsonrpc":"2.0","method":"hello","params" ["mo"],"id":"123"}'
# > {"jsonrpc":"2.0","id":"123","result":"Hello mo!"}
import os
import time
import threading
import twitter
from gi.repository import Gtk, Gdk, GObject

INPUT_TEXT='twitter username'

GLADE_FILE = os.path.join(os.path.dirname( __file__ ), 'layout.glade')

# A worker thread to get twitter data
class WorkerThread(threading.Thread):
    terminate = False
    twitter_username = None
    twitter_text = ''

    def set_buffer(self, buffer):
      self.buffer = buffer

    def run(self):
       while(not self.terminate):
         api = twitter.Api()
         self.twitter_text = ''
         if self.twitter_username != None:
           try:
             for status in api.GetUserTimeline(self.twitter_username):
               self.twitter_text += status.text + "\n"
           except:
             pass
           Gdk.threads_enter()
           self.buffer.set_text(self.twitter_text)
           Gdk.threads_leave()
         time.sleep(5)

# The Main Window
class SyrlugDemoWindow:
    def __init__(self):
       self.builder = Gtk.Builder() 
       self.builder.add_objects_from_file(GLADE_FILE, ["syrlug_demo", "twitter_username", "twitter_text"])
       self.window = self.builder.get_object("syrlug_demo") 
       self.username_input = self.builder.get_object("twitter_username") 

       self.username_input.set_text(INPUT_TEXT)

       self.worker = WorkerThread()
       self.worker.set_buffer(self.builder.get_object("twitter_text").get_buffer());
       self.worker.start()

       self.builder.connect_signals(self)
       self.window.connect("destroy", self.close_window)
       self.window.show()

    def close_window(self, widget):
        self.worker.terminate = True
        Gtk.main_quit()

    def subscribe_button_clicked(self, widget):
        input_text = self.username_input.get_text() 
        if input_text != INPUT_TEXT and input_text != "":
            self.worker.twitter_username = input_text

    def twitter_username_focus_in(self, widget, param):
        if widget.get_text() == INPUT_TEXT:
            widget.set_text("")
            #widget.set_visibility(False)

    def twitter_username_focus_out(self, widget, param):
        if widget.get_text() == "":
            widget.set_text(INPUT_TEXT)
            #widget.set_visibility(True)

if __name__ == "__main__":
    # initialize window
    win = SyrlugDemoWindow()

    # start gtk loop
    Gdk.threads_init()
    GObject.threads_init()
    Gdk.threads_enter()
    Gtk.main()
    Gdk.threads_leave()
require 'uri'

# A puppet resource type used to access resources on the World Wide Web
Puppet::Type.newtype(:web_request) do
    @doc = "Issue a request to a resource on the world wide web"

    private

    # Validates uris passed in
    def self.validate_uri(url)
      begin
        uri = URI.parse(url)
        raise ArgumentError, "Specified uri #{url} is not valid" if ![URI::HTTP, URI::HTTPS].include?(uri.class)
      rescue URI::InvalidURIError
        raise ArgumentError, "Specified uri #{url} is not valid"
      end
    end

    # Validates http statuses passed in
    def self.validate_http_status(status)
      status = [status] unless status.is_a?(Array)
      status.each { |stat|
        stat = stat.to_s
        unless ['100', '101', '102', '122',
                '200', '201', '202', '203', '204', '205', '206', '207', '226',
                '300', '301', '302', '303', '304', '305', '306', '307',
                '400', '401', '402', '403', '404', '405', '406', '407', '408', '409',
                '410', '411', '412', '413', '414', '415', '416', '417', '418',
                '422', '423', '424', '425', '426', '444', '449', '450', '499',
                '500', '501', '502', '503', '504', '505', '506', '507', '508', ' 509', '510'
                ].include?(stat)
          raise ArgumentError, "Invalid http status code #{stat} specified"
        end
      }
    end

    # Convert singular params into arrays of strings
    def self.munge_array_params(value)
      value = [value] unless value.is_a?(Array)
      value = value.collect { |val| val.to_s }
      value
    end

    newparam :name

    newproperty(:get) do
      desc "Issue get request to the specified uri"
      validate do |value| Puppet::Type::Web_request.validate_uri(value) end
    end

    newproperty(:post) do
      desc "Issue post request to the specified uri"
      validate do |value| Puppet::Type::Web_request.validate_uri(value) end
    end

    newproperty(:delete) do
      desc "Issue delete request to the specified uri"
      validate do |value| Puppet::Type::Web_request.validate_uri(value) end
    end

    newproperty(:put) do
      desc "Issue put request to the specified uri"
      validate do |value| Puppet::Type::Web_request.validate_uri(value) end
    end

    newparam(:parameters) do
      desc "Hash of parameters to include in the web request"
    end

    newparam(:file_parameters) do
      desc "Hash of file parameters to include in the web request"
    end

    newparam(:follow) do
      desc "Boolean indicating if redirects should be followed"
      newvalues(:true, :false)
    end

    newparam(:store_cookies_at) do
      desc "String indicating where session cookies should be stored"
    end

    newparam(:use_cookies_at) do
      desc "String indicating where session cookies should be read from"
    end

    newparam(:remove_cookies) do
      desc "Boolean indicating if cookies should be removed after using them"
      newvalues(:true, :false)
    end

    newparam(:returns) do
      desc "Expected http return codes of the request"
      defaultto ["200"]
      validate do |value| Puppet::Type::Web_request.validate_http_status(value) end
      munge    do |value| Puppet::Type::Web_request.munge_array_params(value)   end
    end

    newparam(:does_not_return) do
      desc "Unexecpected http return codes of the request"
      validate do |value| Puppet::Type::Web_request.validate_http_status(value) end
      munge    do |value| Puppet::Type::Web_request.munge_array_params(value)   end
    end

    newparam(:contains) do
      desc "XPath to verify as part of the result"
      munge    do |value| Puppet::Type::Web_request.munge_array_params(value)   end
    end

    newparam(:does_not_contain) do
      desc "XPath to verify as not being part of the result"
      munge    do |value| Puppet::Type::Web_request.munge_array_params(value)   end
    end

    newparam(:log_to) do
      desc "Log requests/responses to the specified file or directory"
    end

    newparam(:only_log_errors) do
      desc "Boolean indicating if we should only log responses which did not pass validations"
      newvalues(:true, :false)
    end

    newparam(:if) do
      desc "Invoke request only if the specified request returns true"
    end

    newparam(:unless) do
      desc "Invoke request unless the specified request returns true"
    end

    newparam(:username) do
      desc "HTTP authentication username"
    end

    newparam(:password) do
      desc "HTTP authentication password"
    end

end
require 'fileutils'

# Provides an interface to curl using the curb gem for puppet
require 'curb'

# uses nokogiri to verify responses w/ xpath
require 'nokogiri'

class Curl::Easy

  # Format request parameters for the specified request method
  def self.format_params(method, params, file_params)
    if([:get, :delete].include?(method))
      return params.collect { |k,v| "#{k}=#{v}" }.join("&") unless params.nil?
      return ""
    end
    # post, put:
    cparams = []
    params.each_pair      { |k,v| cparams << Curl::PostField.content(k,v) } unless params.nil?
    file_params.each_pair { |k,v| cparams << Curl::PostField.file(k,v)    } unless file_params.nil?
    return cparams
  end

  # Format a url for the specified request method, base uri, and parameters
  def self.format_url(method, uri, params)
    if([:get, :delete].include?(method))
      url = uri
      url +=  ";" + format_params(method, params)
      return url
    end
    # post, put:
    return uri
  end

  # Invoke a new curl request and return result
  def self.web_request(method, uri, params = {})
    raise Puppet::Error, "Must specify http method (#{method}) and uri (#{uri})" if method.nil? || uri.nil?

    curl = self.new

    if params.has_key?(:cookie) && !params[:cookie].nil?
      curl.enable_cookies = true
      curl.cookiefile = params[:cookie]
      curl.cookiejar  = params[:cookie]
    end

    if params.has_key?(:username) && !params[:username].nil?
      curl.username = params[:username]
    end

    if params.has_key?(:password) && !params[:password].nil?
      curl.password = params[:password]
    end

    curl.follow_location = (params.has_key?(:follow) && params[:follow])
    request_params = params[:parameters]
    file_params    = params[:file_parameters]

    case(method)
    when 'get'
      curl.url = format_url(method, uri, request_params)
      curl.http_get
      return curl

    when 'post'
      curl.url = format_url(method, uri, request_params)
      curl.multipart_form_post = true if !file_params.nil? && file_params.size > 0
      curl.http_post(*format_params(method, request_params, file_params))
      return curl

    when 'put'
      curl.url = format_url(method, uri, request_params)
      curl.multipart_form_post = true if !file_params.nil? && file_params.size > 0
      curl.http_put(*format_params(method, request_params, file_params))
      return curl

    when 'delete'
      curl.url = format_url(method, uri, request_params)
      curl.http_delete
      return curl
    end
  end

  def valid_status_code?(valid_values=[])
    valid_values.include?(response_code.to_s)
  end

  def valid_xpath?(xpath="/")
    !Nokogiri::HTML(body_str.to_s).xpath(xpath.to_s).empty?
  end

end

# Puppet provider definition
Puppet::Type.type(:web_request).provide :curl do
  desc "Use curl to access web resources"

  def get
    @uri
  end

  def post
    @uri
  end

  def delete
    @uri
  end

  def put
    @uri
  end

  def get=(uri)
    @uri = uri
    process_params('get', @resource, uri)
  end

  def post=(uri)
    @uri = uri
    process_params('post', @resource, uri)
  end

  def delete=(uri)
    @uri = uri
    process_params('delete', @resource, uri)
  end

  def put=(uri)
    @uri = uri
    process_params('put', @resource, uri)
  end

  private

  # Helper to process/parse web parameters
  def process_params(request_method, params, uri)
    begin
      error = nil
      cookies = nil
      if params[:store_cookies_at]
        if File.exist?(params[:store_cookies_at])
          File.truncate(params[:store_cookies_at], 0)
        else
          FileUtils.touch(params[:store_cookies_at])
        end
        cookies = params[:store_cookies_at]
      elsif params[:use_cookies_at]
        cookies = params[:use_cookies_at]
      end

      # verify that we should actually run the request
      return if skip_request?(params, cookies)

      # Actually run the request and verify the result
      result = Curl::Easy::web_request(request_method, uri,
                                       :parameters => params[:parameters],
                                       :file_parameters => params[:file_parameters],
                                       :cookie => cookies,
                                       :follow => params[:follow],
                                       :username => params[:username],
                                       :password => params[:password])

      result_body = result.body_str.to_s

      verify_result(result,
                    :returns          => params[:returns],
                    :does_not_return  => params[:does_not_return],
                    :contains         => params[:contains],
                    :does_not_contain => params[:does_not_contain] )

      result.close

    rescue Exception => e
      error = e
      raise Puppet::Error, "An exception was raised when invoking web request: #{e}"

    ensure
      unless result.nil?
        log_response(:result => result_body,
                     :method => request_method, :uri => uri,
                     :puppet_params => params,  :error => error)
      end
      FileUtils.rm_f(cookies) if params[:remove_cookies]
    end
  end

  # Helper to determine if we should skip the request
  def skip_request?(params, cookie = nil)
    [:if, :unless].each { |c|
      condition = params[c]
      unless condition.nil?
        method = (condition.keys & ['get', 'post', 'delete', 'put']).first
        result = Curl::Easy::web_request(method, condition[method],
                                         :parameters => condition['parameters'],
                                         :file_parameters => condition['file_parameters'],
                                         :cookie => cookie, :follow => params[:follow])
        result_succeeded = true
        begin
          verify_result(result, condition)
        rescue Puppet::Error
          result_succeeded = false
        end
        return true if (c == :if && !result_succeeded) || (c == :unless && result_succeeded)
      end
    }
    return false
  end

  # Helper to verify the response
  def verify_result(result, verify = {})
    verify[:returns]          = verify['returns']          if verify[:returns].nil?          && !verify['returns'].nil?
    verify[:does_not_return]  = verify['does_not_return']  if verify[:does_not_return].nil?  && !verify['does_not_return'].nil?
    verify[:contains]         = verify['contains']         if verify[:contains].nil?         && !verify['contains'].nil?
    verify[:does_not_contain] = verify['does_not_contain'] if verify[:does_not_contain].nil? && !verify['does_not_contain'].nil?

    if !verify[:returns].nil? &&
       !result.valid_status_code?(verify[:returns])
         raise Puppet::Error, "Invalid HTTP Return Code: #{result.response_code},
                               was expecting one of #{verify[:returns].join(", ")}"
    end

    if !verify[:does_not_return].nil? &&
       result.valid_status_code?(verify[:does_not_return])
         raise Puppet::Error, "Invalid HTTP Return Code: #{result.response_code},
                               was not expecting one of #{verify[:does_not_return].join(", ")}"
    end

    if !verify[:contains].nil? &&
       !result.valid_xpath?(verify[:contains])
         raise Puppet::Error, "Expecting #{verify[:contains]} in the result"
    end

    if !verify[:does_not_contain].nil? &&
       result.valid_xpath?(verify[:does_not_contain])
         raise Puppet::Error, "Not expecting #{verify[:does_not_contain]} in the result"
    end
  end

  def log_response(params)
    method  = params[:method]
    uri     = params[:uri]
    result  = params[:result]
    error   = params[:error]
    puppet_params = params[:puppet_params]

    if puppet_params[:log_to]
      return if puppet_params[:only_log_errors] == :true && error.nil?
      logfile = puppet_params[:log_to].strip
      exists = File.exists?(logfile)
      isfile = File.file?(logfile) || (!exists && (logfile[-1].chr != '/'))
      if !isfile
        FileUtils.mkdir_p(logfile) if !exists
	      logfile += puppet_params[:name]
      end

      f = File.open(logfile, 'a')
      f.write("=====BEGIN=====\n")
      f.write(Time.now.strftime("%Y-%m-%d %H:%M:%S"))
      f.write(" #{method} request to #{uri}\n")
      f.write(result.to_s)
      f.write("\n=====END=====\n\n")
      f.close
    end
  end
end
<div id="jquery_drag_drop_example_container"
     style="width: 300px; height: 300px; background: #C0C0C0; float:left;">
</div>
<div style="background: #FFFF99; float:left; width: 20%; margin-left: 10px;">
<ul style="list-style-type: none; list-style-position: inside;">
  <li><img class="jquery_drag_drop_example_img" src="example_0.png" /></li>
  <li><img class="jquery_drag_drop_example_img" src="example_1.png" /></li>
  <li><img class="jquery_drag_drop_example_img" src="example_2.png" /></li>
  <li><img class="jquery_drag_drop_example_img" src="example_3.png" /></li>
  <li><img class="jquery_drag_drop_example_img" src="example_4.png" /></li>
</ul>
</div>
<div style="clear: both;"></div>
<script type="text/javascript">
$(function(){
  $('.jquery_drag_drop_example_img').draggable({
    helper: 'clone',
  }); 
  $('#jquery_drag_drop_example_container').droppable({
    accept: '.jquery_drag_drop_example_img',
    drop: function(event, ui){
      var newitem = $(ui.draggable).clone();
      $(this).append(newitem);
      $(newitem).addClass("jquery_drag_drop_example_img_clone");
      $(newitem).removeClass("ui-draggable jquery_drag_drop_example_img");
      $(newitem).draggable({containment: 'parent'});
      $(newitem).css('position', 'absolute');
      $(newitem).css('top', ui.position.top ); 
      $(newitem).css('left', ui.position.left);
      //alert(event.dataTransfer.getData('text'));
    }   
  }); 
});
</script>
typedef struct _myData{
  ...fields...
} myData;

typedef myDataPtr *myData;
typedef struct _privateData privateData;
typedef privateDataPtr *privateData;

privateDataPtr createPrivateData(...params...);
typedef struct _externalDataInfo {
  ...fields about data managed elsewhere...
} externalDataInfo;

typedef externalDataInfoPtr *externalDataInfo;

externalDataInfoPtr getExternalDataInfo(privateDataPtr private_data);
[kevin@laptop64 x86_64]$ rpm -qp --provides kdeplasma-addons-4.6.3-1.fc15.x86_64.rpm
kcm_krunner_audioplayercontrol.so()(64bit)  
kcm_krunner_charrunner.so()(64bit)  
kcm_krunner_spellcheck.so()(64bit)  
kcm_plasma_runner_events.so()(64bit)  
krunner_audioplayercontrol.so()(64bit)  
krunner_browserhistory.so()(64bit)  
krunner_charrunner.so()(64bit)  
krunner_contacts.so()(64bit)  
krunner_converter.so()(64bit)  
krunner_katesessions.so()(64bit)  
krunner_konquerorsessions.so()(64bit)  
krunner_konsolesessions.so()(64bit)  
krunner_kopete.so()(64bit)  
krunner_mediawiki.so()(64bit)  
krunner_spellcheckrunner.so()(64bit)  
plasma-applet_systemloadviewer.so()(64bit)  
plasma-dataengine-comic = 4.6.3-1.fc15
plasma-dataengine-microblog = 4.6.3-1.fc15
plasma-dataengine-ocs = 4.6.3-1.fc15
plasma-dataengine-potd = 4.6.3-1.fc15
plasma-runner-events = 0.3.0-100
plasma4(applet-comic) = 1.0
plasma4(applet-dict) = 1.0
plasma4(applet-fileWatcher) = 1.0
plasma4(applet-frame) = 1.0
plasma4(applet-incomingmsg) = 1.0
plasma4(applet-kdeobservatory) = 0.2
plasma4(applet-knowledgebase) = 0.1
plasma4(applet-konqprofiles) = 1.0
plasma4(applet-konsoleprofiles) = 1.0
plasma4(applet-lancelot_launcher) = 1.9.5
plasma4(applet-lancelot_part) = 1.5
plasma4(applet-leavenote) = 1.0
plasma4(applet-life) = 0.8
plasma4(applet-magnifique) = 0.1
plasma4(applet-mediaplayer) = 0.1
plasma4(applet-nowplaying) = 1.0
plasma4(applet-opendesktop) = 0.1
plasma4(applet-opendesktop_activities) = 0.1
plasma4(applet-pastebin) = 1.0
plasma4(applet-plasma_applet_notes) = 1.0
plasma4(applet-plasma_applet_rtm) = 0.1
plasma4(applet-previewer) = 1.0
plasma4(applet-qalculate) = 0.7.2
plasma4(containment-org.kde.griddesktop) = 0.1
plasma4(containment-org.kde.groupingdesktop) = 0.1
plasma4(containment-org.kde.groupingpanel) = 0.1
plasma4(dataengine-comic)  
plasma4(dataengine-kdeobservatory) = 0.1
plasma4(dataengine-microblog)  
plasma4(dataengine-potd)  
plasma4(dataengine-rtm) = 0.1
plasma4(packagestructure-comic) = pre0.1
plasma4(runner-CharacterRunner) = 1
plasma4(runner-audioplayercontrol) = 0.1
plasma4(runner-browserhistory) = 1.0
plasma4(runner-katesessions) = 1.0
plasma4(runner-konquerorsessions) = 1.0
plasma4(runner-konsolesessions) = 1.0
plasma4(runner-kopete_runner) = 0.1
plasma4(runner-krunner_spellcheck) = 1.0
plasma4(runner-org.kde.datetime) = 1.0
plasma4(runner-org.kde.events_runner) = 0.3.0
plasma4(runner-techbase) = 1.0
plasma4(runner-unitconverter) = 1.0
plasma4(runner-wikipedia) = 1.0
plasma4(runner-wikitravel) = 1.0
plasma_applet_bball.so()(64bit)  
plasma_applet_binaryclock.so()(64bit)  
plasma_applet_blackboard.so()(64bit)  
plasma_applet_bookmarks.so()(64bit)  
plasma_applet_bubblemon.so()(64bit)  
plasma_applet_calculator.so()(64bit)  
plasma_applet_charselect.so()(64bit)  
plasma_applet_comic.so()(64bit)  
plasma_applet_dict.so()(64bit)  
plasma_applet_eyes.so()(64bit)  
plasma_applet_fifteenPuzzle.so()(64bit)  
plasma_applet_fileWatcher.so()(64bit)  
plasma_applet_frame.so()(64bit)  
plasma_applet_fuzzy_clock.so()(64bit)  
plasma_applet_incomingmsg.so()(64bit)  
plasma_applet_kdeobservatory.so()(64bit)  
plasma_applet_knowledgebase.so()(64bit)  
plasma_applet_kolourpicker.so()(64bit)  
plasma_applet_konqprofiles.so()(64bit)  
plasma_applet_konsoleprofiles.so()(64bit)  
plasma_applet_lancelot_launcher.so()(64bit)  
plasma_applet_lancelot_part.so()(64bit)  
plasma_applet_leavenote.so()(64bit)  
plasma_applet_life.so()(64bit)  
plasma_applet_luna.so()(64bit)  
plasma_applet_magnifique.so()(64bit)  
plasma_applet_mediaplayer.so()(64bit)  
plasma_applet_microblog.so()(64bit)  
plasma_applet_news.so()(64bit)  
plasma_applet_notes.so()(64bit)  
plasma_applet_nowplaying.so()(64bit)  
plasma_applet_opendesktop.so()(64bit)  
plasma_applet_opendesktop_activities.so()(64bit)  
plasma_applet_paste.so()(64bit)  
plasma_applet_pastebin.so()(64bit)  
plasma_applet_plasmaboard.so()(64bit)  
plasma_applet_previewer.so()(64bit)  
plasma_applet_qalculate.so()(64bit)  
plasma_applet_rssnow.so()(64bit)  
plasma_applet_rtm.so()(64bit)  
plasma_applet_showdashboard.so()(64bit)  
plasma_applet_showdesktop.so()(64bit)  
plasma_applet_spellcheck.so()(64bit)  
plasma_applet_timer.so()(64bit)  
plasma_applet_unitconverter.so()(64bit)  
plasma_applet_weather.so()(64bit)  
plasma_applet_weatherstation.so()(64bit)  
plasma_applet_webslice.so()(64bit)  
plasma_comic_krossprovider.so()(64bit)  
plasma_containment_griddesktop.so()(64bit)  
plasma_containment_groupingdesktop.so()(64bit)  
plasma_containment_groupingpanel.so()(64bit)  
plasma_engine_comic.so()(64bit)  
plasma_engine_kdeobservatory.so()(64bit)  
plasma_engine_microblog.so()(64bit)  
plasma_engine_ocs.so()(64bit)  
plasma_engine_potd.so()(64bit)  
plasma_engine_rtm.so()(64bit)  
plasma_packagestructure_comic.so()(64bit)  
plasma_potd_apodprovider.so()(64bit)  
plasma_potd_epodprovider.so()(64bit)  
plasma_potd_flickrprovider.so()(64bit)  
plasma_potd_oseiprovider.so()(64bit)  
plasma_potd_wcpotdprovider.so()(64bit)  
plasma_runner_datetime.so()(64bit)  
plasma_runner_events.so()(64bit)  
plasma_wallpaper_mandelbrot.so()(64bit)  
plasma_wallpaper_pattern.so()(64bit)  
plasma_wallpaper_virus.so()(64bit)  
plasma_wallpaper_weather.so()(64bit)  
kdeplasma-addons = 4.6.3-1.fc15
kdeplasma-addons(x86-64) = 4.6.3-1.fc15

Fedora summer-coding Planet

Book Review: Otherland Volumes 1-4

isitfedoraruby updates

Fedora joins Google Code-In 2012

Google Summer of Code Mentors Summit

Reactor Pattern + Thread Pool = Win

Aeolus at the Ohio LinuxFest - Part IV Heading Out

Aeolus at the Ohio LinuxFest - Part III Conductor & CLI

Web interface

CLI

</presentation>

Aeolus at the Ohio LinuxFest - Part II Aeolus

deltacloud

imagefactory

other components

Aeolus at the Ohio LinuxFest - Part I Cloud Providers

The Art of Aikido

JSON-RPC via RJR - One API / Many Transports

is-it-fedora-ruby - from an idea to an app

First test day - Fedora Jam

GSoC Update

Getting closer - GSoC Week #x

The long drag - GSoC Week #4-5

Hitting the ground running - GSoC Week #3

Comunitising the comunity - GSoC - week #1

When in Rome...

Google Summer of Fedora/Aeolus/Ruby

JSON-RPC Presentation - Brno Ruby Users Group - 26.04.2012

Brno Trip Update

Google summer of code

Easter geekage

RubyConf India, 2012

Day 1

Day 2

Some observations

A translation editor for DTD resources

Working from Brno, CZ (04/12 - 06/12)

GTK Programming w/ Python

Updated Puppet Web Resource Module

Fudcon Blacksburg Report

Forthcoming: MRI Ruby 1.9 in Fedora

Book Review: Altered Carbon

Messing around w/ HTML5: drag-n-drop

Snap! Updates

Various Quick Tips

Plasma PackageKit integration approved as a Fedora 17 feature

libvirtd default network on a vm

Planning FUDCon Pune

GSoC is over, but my code lives

Pycon India 2011, Pune

Plasma/RPM/PackageKit GSoC work now in Rawhide

Plasma + PackageKit: The last piece of the puzzle

It works: Plasma now looks up missing components through PackageKit!

Small API change to the PackageKit support for Plasma service lookup

PackageKit support for Plasma service lookup

Automatic Plasma RPM Provides

GSoC 2011 Proposal Accepted

Submission deadline passed

Proposal submitted

Google Summer of Code 2011