Fedora

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

Feeds

Links

People

Add your blog

December 26, 2012

December 19, 2012

November 19, 2012

October 22, 2012

October 03, 2012

September 27, 2012

September 26, 2012

Web interface

CLI

</presentation>

September 25, 2012

deltacloud

imagefactory

other components

September 24, 2012

September 19, 2012

August 30, 2012

August 20, 2012

July 19, 2012

July 16, 2012

July 05, 2012

June 28, 2012

June 13, 2012

May 26, 2012

May 08, 2012

May 06, 2012

April 30, 2012

April 26, 2012

April 07, 2012

March 27, 2012

Day 1

Day 2

Some observations

March 19, 2012

March 18, 2012

March 03, 2012

February 29, 2012

January 16, 2012

January 03, 2012

January 01, 2012

December 23, 2011

December 20, 2011

December 19, 2011

December 10, 2011

December 05, 2011

October 18, 2011

September 28, 2011

September 20, 2011

August 20, 2011

August 17, 2011

August 10, 2011

June 26, 2011

June 20, 2011

June 05, 2011

April 25, 2011

April 08, 2011

April 06, 2011

April 04, 2011