rufus-lua-win 5.1.5

data/vendor/lua/lib/lua/oil/corba/services/event.lua

@@ -0,0 +1,126 @@
+--------------------------------------------------------------------------------
+------------------------------  #####      ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------ ##   ## ##  ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------  #####  ### ###### ------------------------------
+--------------------------------                --------------------------------
+----------------------- An Object Request Broker in Lua ------------------------
+--------------------------------------------------------------------------------
+-- Project: OiL - ORB in Lua: An Object Request Broker in Lua                 --
+-- Release: 0.5 alpha                                                         --
+-- Title  : Event Service                                                     --
+-- Authors: Leonardo S. A. Maciel <leonardo@maciel.org>                       --
+--------------------------------------------------------------------------------
+-- Interface:                                                                 --
+--   new() Creates a new instance of a CORBA Event Channel                    --
+--------------------------------------------------------------------------------
+-- Notes:                                                                     --
+--   This implementation currently does not support typed events.             --
+--   This implementation currently does not support pull event model.         --
+--------------------------------------------------------------------------------
+
+local oil               = require "oil"
+local oo                = require "oil.oo"
+local assert            = require "oil.assert"
+local EventQueue        = require "oil.corba.services.event.EventQueue"
+local EventFactory      = require "oil.corba.services.event.EventFactory"
+local EventDispatcher   = require "oil.corba.services.event.SingleSynchronousDispatcher"
+--local EventDispatcher   = require "oil.corba.services.event.SingleDeferredDispatcher"
+local ConsumerAdmin     = require "oil.corba.services.event.ConsumerAdmin"
+local SupplierAdmin     = require "oil.corba.services.event.SupplierAdmin"
+
+module "oil.corba.services.event"
+
+--------------------------------------------------------------------------------
+-- In this new version, ConsumerAdmin and SupplierAdmin objects were
+-- suppressed and the event channel implements their interface.
+--
+
+local EventChannel = oo.class()
+
+function EventChannel.__init(class)
+  self = oo.rawnew(class, {
+    push_consumer_count = 0,
+    push_supplier_count = 0,
+    event_queue = EventQueue(),
+    event_factory = EventFactory()
+  })
+  self.event_dispatcher = EventDispatcher(self.event_queue)
+  self.consumer_admin = ConsumerAdmin(self)
+  self.supplier_admin = SupplierAdmin(self)
+  return self
+end
+
+-- The destroy operation destroys the event channel. Destroying an event channel
+-- destroys all ConsumerAdmin and SupplierAdmin objects that were created via
+-- that channel. Destruction of a ConsumerAdmin or SupplierAdmin object causes
+-- the implementation to invoke the disconnect operation on all proxies that were
+-- created via that ConsumerAdmin or SupplierAdmin object.
+
+function EventChannel:destroy()
+  self.event_queue = nil
+  self.event_factory = nil
+  self.consumer_admin:destroy()
+  self.consumer_admin = nil
+  self.supplier_admin:destroy()
+  self.supplier_admin = nil
+  self.event_dispatcher = nil
+  self.push_consumer_count = 0
+  self.push_supplier_count = 0
+end
+
+-- returns an object reference that supports the ConsumerAdmin interface
+
+function EventChannel:for_consumers()
+  return self.consumer_admin
+end
+
+-- returns an object reference that supports the SupplierAdmin interface
+
+function EventChannel:for_suppliers()
+  return self.supplier_admin
+end
+
+-- invoked by ConsumerAdmin
+
+function EventChannel:add_push_consumer(push_consumer)
+  self.event_dispatcher:add_consumer(push_consumer)
+  self.push_consumer_count = self.push_consumer_count + 1
+end
+
+-- invoked by ConsumerAdmin
+
+function EventChannel:rem_push_consumer(push_consumer)
+  self.event_dispatcher:rem_consumer(push_consumer)
+  self.push_consumer_count = self.push_consumer_count - 1
+end
+
+-- invoked by SupplierAdmin
+
+function EventChannel:add_push_supplier(push_supplier)
+  self.push_supplier_count = self.push_supplier_count + 1
+end
+
+-- invoked by SupplierAdmin
+
+function EventChannel:rem_push_supplier(push_supplier)
+  self.push_supplier_count = self.push_supplier_count - 1
+end
+
+
+--------------------------------------------------------------------------------
+-- Creates a new instance of a CORBA Event Channel -----------------------------
+
+-- @param props table [optional] Properties instance.
+
+-- @return 1 table CORBA object which is an untyped Event Channel.
+-- @return 2 string Repository ID of interface supported by the Event Channel.
+-- @return 3 string Default Event Channel object key.
+
+function new()
+  return EventChannel(),
+         "DefaultEventChannel",
+         "IDL:omg.org/CosEventChannelAdmin/EventChannel:1.0"
+end
+

data/vendor/lua/lib/lua/oil/corba/services/event/ConsumerAdmin.lua

@@ -0,0 +1,50 @@
+local oil               = require "oil"
+local oo                = require "oil.oo"
+local assert            = require "oil.assert"
+local UnorderedArraySet = require "loop.collection.UnorderedArraySet"
+local ProxyPushSupplier = require "oil.corba.services.event.ProxyPushSupplier"
+
+module("oil.corba.services.event.ConsumerAdmin", oo.class)
+
+function __init(class, channel)
+  return oo.rawnew(class, {
+    channel = channel,
+    proxypushsuppliers = UnorderedArraySet()
+  })
+end
+
+-- The obtain_push_supplier operation returns a ProxyPushSupplier object. The
+-- ProxyPushSupplier object is then used to connect a push-style consumer.
+
+function obtain_push_supplier(self)
+  return ProxyPushSupplier(self)
+end
+
+-- invoked by ProxyPushSupplier to signal it's connected
+
+function add_push_consumer(self, proxy, push_consumer)
+  self.proxypushsuppliers:add(proxy)
+  self.channel:add_push_consumer(push_consumer)
+end
+
+-- invoked by ProxyPushSupplier to signal it's disconnected
+
+function rem_push_consumer(self, proxy, push_consumer)
+  assert.results(self.proxypushsuppliers:contains(proxy))
+  self.proxypushsuppliers:remove(proxy)
+  self.channel:rem_push_consumer(push_consumer)
+end
+
+-- invoked by the channel to disconnect all proxies of the admin.
+-- must reverse iterate over proxypushsuppliers because the disconnection
+-- removes the consumer from the array.
+
+function destroy(self)
+  for i=#self.proxypushsuppliers,1,-1 do
+    local proxy = self.proxypushsuppliers[i]
+    oil.pcall(proxy.disconnect_push_supplier, proxy) 
+  end
+  self.proxypushsuppliers = nil
+  self.channel = nil
+end
+

data/vendor/lua/lib/lua/oil/corba/services/event/EventFactory.lua

@@ -0,0 +1,15 @@
+local oil               = require "oil"
+local oo                = require "oil.oo"
+local assert            = require "oil.assert"
+local os                = require "os"
+
+module("oil.corba.services.event.EventFactory", oo.class)
+
+function create(self, data)
+  assert.type(data, "table")
+  return {
+    created = os.time(),
+    data = data
+  }
+end
+

data/vendor/lua/lib/lua/oil/corba/services/event/EventQueue.lua

@@ -0,0 +1,37 @@
+local oil               = require "oil"
+local oo                = require "oil.oo"
+local assert            = require "oil.assert"
+
+module("oil.corba.services.event.EventQueue", oo.class)
+
+-- filo por enquanto
+
+function __init(class, scheduler)
+  return oo.rawnew(class, {
+    count = 0,
+    scheduler = scheduler or oil.tasks
+  })
+end
+
+function enqueue(self, event)
+  self.count = self.count + 1
+  self[self.count] = event
+  if self.count > 0 and self.waiting_thread then
+    local t = self.waiting_thread
+    self.waiting_thread = nil
+    self.scheduler:resume(t)
+  end
+end
+
+function dequeue(self)
+  if self.count == 0 then
+    assert.results(self.waiting_thread == nil)
+    self.waiting_thread = self.scheduler.current
+    self.scheduler:suspend()
+  end
+  local e = self[self.count]
+  self[self.count] = nil
+  self.count = self.count - 1
+  return e
+end
+

data/vendor/lua/lib/lua/oil/corba/services/event/ProxyPushConsumer.lua

@@ -0,0 +1,75 @@
+local oil               = require "oil"
+local oo                = require "oil.oo"
+local assert            = require "oil.assert"
+
+module("oil.corba.services.event.ProxyPushConsumer", oo.class)
+
+-- Proxies are in one of three states: disconnected, connected, or destroyed.  
+-- Push/pull operations are only valid in the connected state.
+
+function __init(class, admin)                                        
+  assert.results(admin)
+  return oo.rawnew(class, {
+    admin = admin,
+    connected = false,
+    push_supplier = nil
+  })
+end
+
+-- A supplier communicates event data to the consumer by invoking the push 
+-- operation and passing the event data as a parameter.
+
+function push(self, data)                                           
+  if not self.connected then
+    assert.exception{"IDL:omg.org/CosEventComm/Disconnected:1.0"}
+  end
+  local channel = self.admin.channel
+  local event = channel.event_factory:create(data)
+  channel.event_queue:enqueue(event)
+end
+
+-- A nil object reference may be passed to the connect_push_supplier operation. 
+-- If so a channel cannot invoke the disconnect_push_supplier operation on the
+-- supplier. The supplier may be disconnected from the channel without being 
+-- informed. If a nonnil reference is passed to connect_push_supplier, the
+-- implementation calls disconnect_push_supplier via that reference when the 
+-- ProxyPushConsumer is destroyed.
+-- 
+-- If the ProxyPushConsumer is already connected to a PushSupplier, then the
+-- AlreadyConnected exception is raised.
+
+function connect_push_supplier(self, push_supplier)                 
+  if self.connected then
+    assert.exception{"IDL:omg.org/CosEventChannelAdmin/AlreadyConnected:1.0"}
+  end
+  self.push_supplier = push_supplier
+  self.admin:add_push_supplier(self, push_supplier)
+  self.connected = true
+end
+
+-- The disconnect_push_consumer operation terminates the event communication.
+-- It releases resources used at the consumer to support the event
+-- communication.  The PushConsumer object reference is disposed.  Calling 
+-- disconnect_push_consumer causes the implementation to call the
+-- disconnect_push_supplier operation on the corresponding PushSupplier 
+-- interface (if that interface is known).
+-- 
+-- Calling a disconnect operation on a consumer or supplier interface may cause
+-- a call to the corresponding disconnect operation on the connected supplier
+-- or consumer.  Implementations must take care to avoid infinite recursive
+-- calls to these disconnect operations.  If a consumer or supplier has received
+-- a disconnect call and subsequently receives another disconnect call, it shall
+-- raise a CORBA::OBJECT_NOT_EXIST exception.
+
+function disconnect_push_consumer(self)
+  if not self.connected then
+    assert.exception{"IDL:omg.org/CORBA/OBJECT_NOT_EXIST:1.0"}
+  end
+  self.connected = false
+  if self.push_supplier then -- supplier may be nil
+    self.admin:rem_push_supplier(self, push_supplier)
+    oil.pcall(self.push_supplier.disconnect_push_supplier, self.push_supplier)
+    self.push_supplier = nil
+  end
+end
+

data/vendor/lua/lib/lua/oil/corba/services/event/ProxyPushSupplier.lua

@@ -0,0 +1,62 @@
+local oil               = require "oil"
+local oo                = require "oil.oo"
+local assert            = require "oil.assert"
+
+module("oil.corba.services.event.ProxyPushSupplier", oo.class)
+
+function __init(class, admin)
+  return oo.rawnew(class, {
+    admin = admin,
+    connected = false,
+    push_consumer = nil
+  })
+end
+
+-- Implementations shall raise the CORBA standard BAD_PARAM exception if a nil
+-- object reference is passed to the connect_push_consumer operation.  If the
+-- ProxyPushSupplier is already connected to a PushConsumer, then the
+-- AlreadyConnected exception is raised.
+--
+-- An implementation of a ProxyPushSupplier may put additional requirements on
+-- the interface supported by the push consumer.  If the push consumer does not
+-- meet those requirements, the ProxyPushSupplier raises the TypeError
+-- exception.
+
+function connect_push_consumer(self, push_consumer)                
+  if self.connected then
+    assert.exception{"IDL:omg.org/CosEventChannelAdmin/AlreadyConnected:1.0"}
+  elseif not push_consumer then
+    assert.exception{"IDL:omg.org/CORBA/BAD_PARAM:1.0"}
+  end
+  self.push_consumer = push_consumer
+  self.connected = true
+  self.admin:add_push_consumer(self, self.push_consumer)
+end
+
+-- The disconnect_push_supplier operation terminates the event communication; it
+-- releases resources used at the supplier to support the event communication.
+-- The PushSupplier object reference is disposed.  Calling
+-- disconnect_push_supplier causes the implementation to call the
+-- disconnect_push_consumer operation on the corresponding PushConsumer
+-- interface (if that interface is known).
+-- 
+-- Calling a disconnect operation on a consumer or supplier interface may cause
+-- a call to the corresponding disconnect operation on the connected supplier or
+-- consumer.
+--
+-- Implementations must take care to avoid infinite recursive calls to these
+-- disconnect operations. If a consumer or supplier has received a disconnect
+-- call and subsequently receives another disconnect call, it shall raise a
+-- CORBA::OBJECT_NOT_EXIST exception.
+
+function disconnect_push_supplier(self)
+  if not self.connected then
+    assert.exception{"IDL:omg.org/CORBA/OBJECT_NOT_EXIST:1.0"}
+  end
+  self.connected = false
+  assert.results(self.push_consumer)
+  self.admin:rem_push_consumer(self, self.push_consumer)
+  oil.pcall(self.push_consumer.disconnect_push_consumer, self.push_consumer)
+  self.push_consumer = nil
+end
+

data/vendor/lua/lib/lua/oil/corba/services/event/SingleDeferredDispatcher.lua

@@ -0,0 +1,60 @@
+local oil             = require "oil"
+local oo              = require "oil.oo"
+local assert          = require "oil.assert"
+local pairs           = pairs
+local next            = next
+local io              = io
+local coroutine       = coroutine
+
+module("oil.corba.services.event.SingleDeferredDispatcher", oo.class)
+
+local calls = {} -- futures
+
+local function dispatch(consumer, event)
+  calls[consumer.__deferred:push(event.data)] = consumer
+end
+
+local function waitforresults()
+  repeat
+    for call, id in pairs(calls) do
+      if call:ready() then
+        --io.write("ready, ")
+        if call:results()
+          then --io.write("success\n"); io.flush()
+          else io.write("failure\n"); io.flush() -- TODO retry
+        end
+        calls[call] = nil
+      end
+    end
+    coroutine.yield()
+  until next(calls) == nil
+end
+
+function __init(class, event_queue, consumers)
+  assert.type(event_queue, "table")
+  local self = oo.rawnew(class, {
+    event_queue = event_queue,
+    consumers = consumers or {},
+  })
+  oil.tasks:start(self.run, self)
+  return self
+end
+
+function add_consumer(self, push_consumer)
+  self.consumers[push_consumer] = true
+end
+
+function rem_consumer(self, push_consumer)
+  self.consumers[push_consumer] = nil
+end
+
+function run(self)
+  while true do
+    local e = self.event_queue:dequeue()
+    for c in pairs(self.consumers) do
+      dispatch(c, e)
+    end
+    waitforresults()
+  end
+end
+

data/vendor/lua/lib/lua/oil/corba/services/event/SingleSynchronousDispatcher.lua

@@ -0,0 +1,39 @@
+local oil             = require "oil"
+local oo              = require "oil.oo"
+local assert          = require "oil.assert"
+local pairs           = pairs
+
+module("oil.corba.services.event.SingleSynchronousDispatcher", oo.class)
+
+local function dispatch(consumer, event)
+  local b,e = oil.pcall(consumer.push, consumer, event.data)
+  assert.results(b)
+end
+
+function __init(class, event_queue, consumers)
+  assert.type(event_queue, "table")
+  local self = oo.rawnew(class, {
+    event_queue = event_queue,
+    consumers = consumers or {},
+  })
+  oil.tasks:start(self.run, self)
+  return self
+end
+
+function add_consumer(self, push_consumer)
+  self.consumers[push_consumer] = true
+end
+
+function rem_consumer(self, push_consumer)
+  self.consumers[push_consumer] = nil
+end
+
+function run(self)
+  while true do
+    local e = self.event_queue:dequeue()
+    for c in pairs(self.consumers) do
+      dispatch(c, e)
+    end
+  end
+end
+