Changeset 256 for trunk

Timestamp:

04/01/09 11:40:06 (3 years ago)

Author:

ocjhb

Message:

getting the first cdd passed, with httpserver in doctest

Location:

trunk/sandbox/jhb/oc2

Files:

• documentation.py (modified) (2 diffs)
• issuer.py (modified) (1 diff)
• messages.py (added)
• protocols.py (modified) (2 diffs)
• testmobile.py (added)
• testserver.py (modified) (1 diff)
• transports.py (modified) (1 diff)
• wallet.py (added)

trunk/sandbox/jhb/oc2/documentation.py

@@ -217 +217 @@
 
 ###############################################################################
-
+>>> port = 9090
 >>> cdd = issuer.makeCDD('OpenCentA',
 ...                      'oca',
 ...                      [str(d) for d in [0,1,2,5,10,20]],
-...                      'http://localhost:8000',
+...                      'http://localhost:%s/' % port,
 ...                      '')
 >>> issuer.getMasterPubKey().verifyContainerSignature(cdd)
@@ -270 +270 @@
 
 * fetch "currency description document" from issuer
+
+###############################################################################
+
+>>> #faked request
+>>> from wallet import Wallet
+>>> wallet = Wallet(Item())
+>>> import protocols
+>>> serverside = protocols.GiveLatestCDD(issuer)
+>>> clientside = protocols.AskLatestCDD(wallet,serverside.run)
+>>> cdd == clientside.run()
+True
+
+>>> #using http
+>>> import transports
+>>> import testserver
+>>> transport = transports.HTTPTransport('http://localhost:%s/' % port)
+>>> clientside = protocols.AskLatestCDD(wallet,transport)
+>>> testserver.run_once(port,issuer)
+>>> cdd2 =  clientside.run()
+>>> cdd2.toString(True) == cdd.toString(True)
+True
+
+###############################################################################
 
 

trunk/sandbox/jhb/oc2/issuer.py

@@ -25 +25 @@
         cdd.issuer = self.storage.masterPubKey.hash()
         if not hasattr(self.storage,'cdds'):
-            self.storage.cdds = Item()
-        cddlist = getattr(self.storage.cdds,shortCurrencyId,[])
-        setattr(self.storage.cdds,shortCurrencyId,cddlist)
-        cdd.version = len(cddlist)   
+            self.storage.cdds = []
+        cdds = self.get('cdds')
+        cdd.version = len(cdds)   
         self.storage.masterPrivKey.signContainer(cdd)
-        cddlist.append(cdd)
+        cdds.append(cdd)
         return cdd
 
-    def getCDD(self,shortCurrencyId,version=None):
-        cddlist = getattr(self.storage.cdds,shortCurrencyId,None)
+    def getCDD(self,version=None):
+        cdds = self.get('cdds')
         if version:
-            return cddlist[version]
+            return cdds[version]
         else:
-            return cddlist[-1]
+            return cdds[-1]
 
     def getMasterPubKey(self):

trunk/sandbox/jhb/oc2/protocols.py

@@ +1 @@
+import messages
+
 class Protocol(object):
 
-    def __init__(self):
-        self.digest = self.dummy
+    def __init__(self,transport):
+        self.transport = transport
 
-    def dummy(self,message):
-        
-        return ''
+    def getResponse(self):
+        return self.transport.readMessage()
 
+class AskLatestCDD(Protocol):
 
+    def __init__(self,wallet,transport):
+        self.transport = transport
+        self.wallet = wallet
+    
+    def run(self,message=None):
+        message = messages.AskLatestCDD()  
+        response = self.transport(message)
+        return response.cdd 
+
+class GiveLatestCDD(Protocol):
+    
+    def __init__(self,issuer):
+        self.issuer = issuer
+    
+    def run(self,message=None):
+        if message:
+            answer = messages.GiveLatestCDD()
+            answer.cdd = self.issuer.getCDD()
+            return answer
+        else:
+            pass
 
 class CoinsSpendSender(Protocol):
@@ -64 +87 @@
 
     def giveKeys(self,message):
-    
-
-class requestCDD(Protocol):
-    
-    def __init__(self,cdd_version):
-        self.cdd_version = cdd_version
+        pass    
 
 
-    def getCDD(self,message):
-        return ''
-
-class giveCDD(Protocol):
-
-    def giveCDD(self,message):
-        return ''

trunk/sandbox/jhb/oc2/testserver.py

@@ -1 +1 @@
 import BaseHTTPServer, threading
+import protocols, issuer, mint, transports, urllib
+
 
 class Handler(BaseHTTPServer.BaseHTTPRequestHandler):
 
-    def do_GET(self):
-        self.send_response(200)
+    def do_POST(self):
+        #print self.server
         if self.path == '/stop':
             raise 'foobar'
+        length = self.headers.get('Content-Length')
+        data = self.rfile.read(int(length))
+        data = urllib.unquote(data)
+        message = transports.createMessage(data)
+        if message.header == 'AskLatestCDD':
+            protocol = protocols.GiveLatestCDD(self.issuer)
+        answer = protocol.run(message)
+        self.send_response(200)
         self.send_header("Content-type", "text/plain")
-        self.end_headers()
-        self.wfile.write('foo')
-        
-PORT = 8000
+        self.wfile.write('\r\n')
+        self.wfile.write(answer.toString(True))
 
-httpd = BaseHTTPServer.HTTPServer(("", PORT), Handler)
-import threading
-def run_once():
+
+def run_once(port,issuer=None):
+    Handler.issuer = issuer
+    httpd = BaseHTTPServer.HTTPServer(("", port), Handler)
+    import threading
     t = threading.Thread(target=httpd.handle_request)     
     t.start()
 
-
-#print "serving at port", PORT
-#t = threading.Thread(target=httpd.handle_request)
-#t.start()
-#import time
-#for i in range(10):
-#    time.sleep(3)
-#print 'foobar'
-
-#httpd.serve_forever()
-

trunk/sandbox/jhb/oc2/transports.py

@@ +1 @@
+import messages,  simplejson
+
+def createMessage(data):
+    data = dict(simplejson.loads(str(data)))
+    header = data['header']
+    klass = getattr(messages,header)
+    message = klass(data)
+    return message
+
 class Transport(object):
 
-    def write(self,message):
-        return ''        
+    def __call__(self,message):
+        return ''
 
-    def handleResponse(self,message):
-        pass
+class HTTPTransport(object):
+    
+    def __init__(self,url):
+        self.url = url
+     
+    def __call__(self,message):
+        import urllib2, urllib
+        response = urllib2.urlopen(self.url,message.toString(True))
+        return createMessage(response.read())
+        
+