make transporter running with dummy XML-RPC API

git-svn-id: svn://svn.cy55.de/Zope3/src/cybertools/trunk@2721 fd906abe-77d9-0310-91a1-e0d9ade77398

agent/core/agent.py

@@ -72,6 +72,7 @@ class QueueableAgent(Agent):
 
     def error(self, result):
         print '*** error', result
+        job = self.currentJob
         job.state = states.aborted
         self.log(self.currentJob, result='Error')
         self.master.notify(job, result)

agent/main.py

@@ -59,6 +59,8 @@ def setupEnvironment(config):
     from cybertools.agent.transport import remote, loops
     from cybertools.agent.system.windows import api
     api.setup(config)
+    from cybertools.agent.system import rpcapi
+    rpcapi.setup(config)
     from cybertools.agent.crawl import base, filesystem, outlook
 
 

agent/testing/rpcserver.py

@@ -24,6 +24,7 @@ $Id$
 
 from twisted.internet.defer import succeed
 
+
 class RPCServer(object):
 
     serverURL = ''
@@ -48,14 +49,14 @@ class RPCServer(object):
             # this is done AFTER the resource (like e.g. file or mail)
             # is handed over
             pass
-        deferred = defer.succeed('Metadata accepted by server')
+        deferred = succeed('Metadata accepted by server')
         return deferred
 
     def xmlrpc_shutdownRPCServer():
         return "xmlrRPC server shutdown completed!"
 
 
-class xmlrpc(object):
+class XmlRpc(object):
 
      Proxy = None
      XMLRPC = None
@@ -65,16 +66,17 @@ class xmlrpc(object):
      _QueryFactory = None
 
      def __init__(self):
-         self.Proxy = Proxy()
+         self.Proxy = Proxy
-         self.XMLRPC = XMLRPC()
+         #self.XMLRPC = XMLRPC()
-         self.Handler = Handler()
+         #self.Handler = Handler()
-         self.XMLRPCIntrospection = XMLRPCIntrospection()
+         #self.XMLRPCIntrospection = XMLRPCIntrospection()
-         self.QueryProtocol = QueryProtocol()
+         #self.QueryProtocol = QueryProtocol()
-         self._QueryFactory = _QueryFactory()
+         #self._QueryFactory = _QueryFactory()
 
      def addIntrospection(self, xmlrpc):
          pass
 
+
 class Proxy(object):
 
      url = ''
@@ -100,6 +102,9 @@ class Proxy(object):
         return method(*params)
 
 
+xmlrpc = XmlRpc()
+
+
 class XMLRPC(object):
 
     def __init__(self):

agent/tests.py

@@ -45,6 +45,7 @@ def test_suite():
             DocFileSuite('crawl/README.txt', optionflags=flags),
             DocFileSuite('crawl/filesystem.txt', optionflags=flags),
             DocFileSuite('crawl/outlook.txt', optionflags=flags),
+            DocFileSuite('transport/transporter.txt', optionflags=flags),
     ))
     return testSuite
 

agent/transport/remote.py

@@ -24,9 +24,10 @@ and sending requests to a corresponding remote controller.
 $Id$
 """
 
+from twisted.internet import defer
 from zope.interface import implements
-from cybertools.agent.system import rpcapi
 
+from cybertools.agent.system import rpcapi
 from cybertools.agent.base.agent import Master
 from cybertools.agent.core.agent import QueueableAgent
 from cybertools.agent.interfaces import ITransporter
@@ -49,27 +50,29 @@ class Transporter(QueueableAgent):
     password = ''
     resource = None
 
-    def __init__(self, master, params):
+    def __init__(self, master):
         super(Transporter, self).__init__(master)
-##        if isinstance(configuration, Configurator):
+        config = master.config
-##            self.config = configuration
+        #self.serverURL = params[serverURL]
-##        else:   # configuration is path to config file
-##            self.config = Configurator()
-##            self.config.load(configuration)
-        self.serverURL = params[serverURL]
         self.server = rpcapi.xmlrpc.Proxy(self.serverURL)
-        self.method = params[method]
+        #self.method = params[method]
-        self.machineName = params[machineName]
+        #self.machineName = params[machineName]
-        self.userName = params[userName]
+        #self.userName = params[userName]
-        self.password = params[password]
+        #self.password = params[password]
+
+    def process(self):
+        return self.transfer(self.params['resource'])
 
     def transfer(self, resource):
         """ Transfer the resource (an object providing IResource)
             to the server and return a Deferred.
         """
-        deferred = self.server.callRemote('getMetadata', resource.metadata)
+        #return self.server.callRemote('getMetadata', resource.metadata)
-        deferred.addCallback(self.transferDone)
+        self.deferred = defer.Deferred()
-        deferred.addErrback(self.errorHandler)
+        d = self.server.callRemote('getMetadata', resource.metadata)
+        d.addCallback(self.transferDone)
+        d.addErrback(self.errorHandler)
+        return self.deferred
 
     def errorHandler(self, errorInfo):
         """
@@ -77,16 +80,16 @@ class Transporter(QueueableAgent):
         Error handler.
         """
         print errorInfo
-        self.server.close()
+        #self.server.close()
 
-    def transferDone(self, successMessage=''):
+    def transferDone(self, result):
         """
         Invoked as a callback from self.transfer
         This callback method is called when resource and metadata
         have been transferred successfully.
         """
-        print successMessage
+        #print 'transferDone:', successMessage
-        pass
+        self.deferred.callback(result)
 
 #    def process(self):
 #        return self.collect()

agent/transport/transporter.txt

@@ -35,11 +35,15 @@ This Testcase is using subsidiary methods to simulate a real xmlrpc server.
 
 In the next step we request the start of a job, again via the controller.
 
-  >>> controller.enterJob('sample', 'sample03', params=dict(serverURL="", machineName="", method="", userName="", password=""))
+  >>> from cybertools.agent.crawl.base import Metadata, Resource
+  >>> md01 = Metadata(dict(filename='dummy.txt'))
+  >>> r01 = Resource()
+  >>> r01.metadata = md01
+  >>> controller.enterJob('sample', 'sample03', params=dict(resource=r01))
 
 The job is not executed immediately - we have to hand over control to
 the twisted reactor first.
 
   >>> from cybertools.agent.tests import tester
   >>> tester.iterate()
-  Job 00001 completed; result: Metadata received!;
+  Job 00001 completed; result: Metadata accepted by server;