From ac8bb2ddecac09d60760ef83319b627548d0fd77 Mon Sep 17 00:00:00 2001
From: jsdelfino <jsdelfino@13f79535-47bb-0310-9956-ffa450edef68>
Date: Thu, 1 Jul 2010 06:04:35 +0000
Subject: Minimal support for implementation.widget, using simplified (and
 generic) JSONRPC and ATOMPub Javascript proxies. Minor changes to the server
 runtime to serve reference requests from widgets. Adjust and simplified
 samples using the widget support.

git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@959521 13f79535-47bb-0310-9956-ffa450edef68
---
 sca-cpp/trunk/modules/wsgi/scdl.py | 73 ++++++++++++++++++++++++++++++++------
 1 file changed, 63 insertions(+), 10 deletions(-)

(limited to 'sca-cpp/trunk/modules/wsgi')

diff --git a/sca-cpp/trunk/modules/wsgi/scdl.py b/sca-cpp/trunk/modules/wsgi/scdl.py
index af332d0249..2a4a667173 100644
--- a/sca-cpp/trunk/modules/wsgi/scdl.py
+++ b/sca-cpp/trunk/modules/wsgi/scdl.py
@@ -18,6 +18,7 @@
 # SCDL parsing functions
 
 from xml.etree.cElementTree import iterparse
+from sys import stderr
 from util import *
 from httputil import *
 
@@ -86,8 +87,8 @@ def references(e):
     if match(car(e), "start", "reference") == False:
         return references(cdr(e))
     if "target" in att(car(e)):
-        return cons(car(tokens(att(car(e))["target"])), references(cdr(e)))
-    return cons(binding(e), references(cdr(e)))
+        return cons((att(car(e))["name"], car(tokens(att(car(e))["target"]))), references(cdr(e)))
+    return cons((att(car(e))["name"], binding(e)), references(cdr(e)))
 
 # Return the list of properties under a SCDL component element
 def properties(e):
@@ -116,7 +117,7 @@ def components(e):
     if match(car(e), "start", "component") == False:
         return components(cdr(e))
     n = name(e)
-    return cons(mkcomponent(n, implementation(e), cons(("components", n), services(e)), references(e), properties(e)), components(cdr(e)))
+    return cons(mkcomponent(n, implementation(e), services(e), references(e), properties(e)), components(cdr(e)))
 
 # Find a component with a given name
 def nameToComponent(name, comps):
@@ -136,28 +137,80 @@ def matchingURI(u, svcs):
 
 # Return the (service URI, component) pair matching a given URI
 def uriToComponent(u, comps):
+    if car(u) == "components":
+        return componentURIToComponent(u, comps)
+    if car(u) == "references":
+        return referenceURIToComponent(u, comps)
+    return serviceURIToComponent(u, comps)
+
+def serviceURIToComponent(u, comps):
     if comps == ():
         return (None, None)
     m = matchingURI(u, car(comps).svcs)
     if m != None:
         return (m, car(comps))
-    return uriToComponent(u, cdr(comps))
+    return serviceURIToComponent(u, cdr(comps))
+
+def componentURIToComponent(u, comps):
+    comp = nameToComponent(cadr(u), comps)
+    if comps == None:
+        return (None, None)
+    return (u[0:2], comp)
+
+def referenceURIToComponent(u, comps):
+    sc = nameToComponent(cadr(u), comps)
+    if sc == None:
+        return (None, None)
+    
+    def referenceToComponent(r, refs):
+        if refs == ():
+            return None
+        if r == car(car(refs)):
+            return cadr(car(refs))
+        return referenceToComponent(r, cdr(refs))
+
+    tn = referenceToComponent(caddr(u), sc.refs)
+    if tn == None:
+        return (None, None)
+    tc = nameToComponent(tn, comps)
+    if tc == None:
+        return (None, None)
+    return (u[0:3], tc)
 
 # Evaluate a reference, return a proxy to the resolved component or an
 # HTTP client configured with the reference target uri
 def evalReference(r, comps):
-    if r.startswith("http://") or r.startswith("https://"):
-        return mkclient(r)
-    return nameToComponent(r, comps)
-
-# Evaluate a component, resolve its implementation and references
+    t = cadr(r)
+    if t.startswith("http://") or t.startswith("https://"):
+        return mkclient(t)
+    return nameToComponent(t, comps)
+
+# Evaluate a property, return a lambda function returning the property
+# value. The user and email properties are configured with the values
+# from the HTTP request, if any
+def evalProperty(p):
+    if (isTaggedList(p, "user")):
+        return lambda: userProperty(cadr(p))
+    if (isTaggedList(p, "email")):
+        return lambda: emailProperty(cadr(p))
+    return lambda: p
+
+def userProperty(v):
+    return "nobody"
+
+def emailProperty(v):
+    return "nobody@nowhere.com"
+
+# Evaluate a component, resolve its implementation, references and
+# properties
 def evalComponent(comp, comps):
     comp.mod = __import__(comp.impl)
 
     # Make a list of proxy lambda functions for the component references and properties
     # A reference proxy is the callable lambda function of the component wired to the reference
     # A property proxy is a lambda function that returns the value of the property
-    comp.proxies = tuple(map(lambda r: evalReference(r, comps), comp.refs)) + tuple(map(lambda v: lambda: v, comp.props))
+    print >> stderr, "evalComponent", comp.impl, comp.svcs, comp.refs, comp.props
+    comp.proxies = tuple(map(lambda r: evalReference(r, comps), comp.refs)) + tuple(map(lambda p: evalProperty(p), comp.props))
 
     return comp
 
-- 
cgit v1.2.3