wip new config

[hippotat.git] / client

diff --git a/client b/client
index b5a4db5bf5bb639be691feaa04b65fa100d0ed58..e5d4e0005092b3e7ebf842788c17d44145bfa7c4 100755 (executable)
--- a/client
+++ b/client
@@ -37,15 +37,19 @@ def process_cfg():
   c.routes = cfg.get('virtual','routes')
   c.max_queue_time = cfg.getint(client_cs, 'max_queue_time')
   c.max_batch_up   = cfg.getint(client_cs, 'max_batch_up')
   c.routes = cfg.get('virtual','routes')
   c.max_queue_time = cfg.getint(client_cs, 'max_queue_time')
   c.max_batch_up   = cfg.getint(client_cs, 'max_batch_up')

-  c.http_timeout   = cfg.getint(client_cs, 'http_timeout')

   c.http_retry     = cfg.getint(client_cs, 'http_retry')
   c.http_retry     = cfg.getint(client_cs, 'http_retry')

+  c.http_timeout = (cfg.getint(client_cs, 'http_timeout') +
+                    cfg.getint(client_cs, 'http_timeout_grace'))

 
   process_cfg_ipif(client_cs,
                    (('local', 'client'),
                     ('peer',  'server'),
                     ('rnets', 'routes')))
 
 
   process_cfg_ipif(client_cs,
                    (('local', 'client'),
                     ('peer',  'server'),
                     ('rnets', 'routes')))
 

-outstanding = 0
+outstanding = { }
+
+def log_outstanding():
+  log_debug(DBG.CTRL_DUMP, 'OS %s' % outstanding)

 
 def start_client():
   global queue
 
 def start_client():
   global queue


@@ -58,62 +62,61 @@ def outbound(packet, saddr, daddr):
   queue.append(packet)
   check_outbound()
 
   queue.append(packet)
   check_outbound()
 

-def crashy(): assert(False)
-
-class ResponseConsumer(twisted.internet.protocol.Protocol):
-  def __init__(self, req):
+class GeneralResponseConsumer(twisted.internet.protocol.Protocol):
+  def __init__(self, req, desc):

     self._req = req
     self._req = req

-    self._ssd = SlipStreamDecoder(crashy)
-    self._log(DBG.HTTP_CTRL, '__init__')
+    self._desc = desc

 
   def _log(self, dflag, msg, **kwargs):
 
   def _log(self, dflag, msg, **kwargs):

-    log_debug(dflag, 'RC ' + msg, idof=self._req, **kwargs)
+    log_debug(dflag, '%s: %s' % (self._desc, msg), idof=self._req, **kwargs)
+
+  def connectionMade(self):
+    self._log(DBG.HTTP_CTRL, 'connectionMade')
+
+class ResponseConsumer(GeneralResponseConsumer):
+  def __init__(self, req):
+    super().__init__(req, 'RC')
+    ssddesc = '[%s] %s' % (id(req), self._desc)
+    self._ssd = SlipStreamDecoder(ssddesc, queue_inbound)
+    self._log(DBG.HTTP_CTRL, '__init__')

 
   def dataReceived(self, data):
 
   def dataReceived(self, data):

-    self._log(DBG.HTTP_CTRL, 'dataReceived', d=data)
+    self._log(DBG.HTTP, 'dataReceived', d=data)

     try:
     try:

-      self._ssd.inputdata(mime_translate(data))
+      self._ssd.inputdata(data)

     except Exception as e:
       self._handleexception()
 
     except Exception as e:
       self._handleexception()
 

-  def connectionMade(self):
-    self._log(DBG.HTTP_CTRL, 'connectionMade')
-

   def connectionLost(self, reason):
     self._log(DBG.HTTP_CTRL, 'connectionLost ' + str(reason))
     if not reason.check(twisted.web.client.ResponseDone):
   def connectionLost(self, reason):
     self._log(DBG.HTTP_CTRL, 'connectionLost ' + str(reason))
     if not reason.check(twisted.web.client.ResponseDone):

-      self._asyncfailure(reason)
+      self.latefailure()

       return
     try:
       return
     try:

+      self._log(DBG.HTTP, 'ResponseDone')

       self._ssd.flush()
       self._ssd.flush()

+      req_fin(self._req)

     except Exception as e:
       self._handleexception()
 
   def _handleexception(self):
     except Exception as e:
       self._handleexception()
 
   def _handleexception(self):

-    self._asyncfailure(traceback.format_exc())
+    self._latefailure(traceback.format_exc())

 
 

-  def _asyncfailure(self, reason):
-    self._log(DBG.HTTP_CTRL, '_asyncFailure ' + str(reason))
+  def _latefailure(self, reason):
+    self._log(DBG.HTTP_CTRL, '_latefailure ' + str(reason))

     req_err(self._req, reason)
 
 class ErrorResponseConsumer(twisted.internet.protocol.Protocol):
   def __init__(self, req, resp):
     req_err(self._req, reason)
 
 class ErrorResponseConsumer(twisted.internet.protocol.Protocol):
   def __init__(self, req, resp):

-    self._req = req
+    super().__init__(req, 'ERROR-RC')

     self._resp = resp
     self._resp = resp

-
+    self._m = b''

     try:
       self._phrase = resp.phrase.decode('utf-8')
     except Exception:
       self._phrase = repr(resp.phrase)
     try:
       self._phrase = resp.phrase.decode('utf-8')
     except Exception:
       self._phrase = repr(resp.phrase)

-

     self._log(DBG.HTTP_CTRL, '__init__ %d %s' % (resp.code, self._phrase))
 
     self._log(DBG.HTTP_CTRL, '__init__ %d %s' % (resp.code, self._phrase))
 

-  def _log(self, dflag, msg, **kwargs):
-    log_debug(dflag,'ERROR-RC '+msg, idof=self._req, **kwargs)
-
-  def connectionMade(self):
-    self._m = b''
-

   def dataReceived(self, data):
     self._log(DBG.HTTP_CTRL, 'dataReceived ' + repr(data))
     self._m += data
   def dataReceived(self, data):
     self._log(DBG.HTTP_CTRL, 'dataReceived ' + repr(data))
     self._m += data


@@ -139,26 +142,41 @@ def req_ok(req, resp):
     rc = ErrorResponseConsumer(req, resp)
 
   resp.deliverBody(rc)
     rc = ErrorResponseConsumer(req, resp)
 
   resp.deliverBody(rc)

+  # now rc is responsible for calling req_fin

 
 def req_err(req, err):
 
 def req_err(req, err):

-  log_debug(DBG.HTTP_CTRL, 'req_err ' + str(err), idof=req)
-  if isinstance(err, twisted.python.failure.Failure):
-    err = err.getTraceback()
-  print(err, file=sys.stderr)
-  reactor.callLater(c.http_retry, (lambda: req_fin(req)))
+  # called when the Deferred fails, or (if it completes),
+  # later, by ResponsConsumer or ErrorResponsConsumer
+  try:
+    log_debug(DBG.HTTP_CTRL, 'req_err ' + str(err), idof=req)
+    if isinstance(err, twisted.python.failure.Failure):
+      err = err.getTraceback()
+    print('[%#x] %s' % (id(req), err), file=sys.stderr)
+    if not isinstance(outstanding[req], int):
+      raise RuntimeError('[%#x] previously %s' % (id(req), outstanding[req]))
+    outstanding[req] = err
+    log_outstanding()
+    reactor.callLater(c.http_retry, partial(req_fin, req))
+  except Exception as e:
+    crash(traceback.format_exc() + '\n----- handling -----\n' + err)

 
 def req_fin(req):
 
 def req_fin(req):

-  global outstanding
-  outstanding -= 1
-  log_debug(DBG.HTTP_CTRL, 'req_fin OS=%d' % outstanding, idof=req)
+  del outstanding[req]
+  log_debug(DBG.HTTP_CTRL, 'req_fin OS=%d' % len(outstanding), idof=req)

   check_outbound()
 
   check_outbound()
 

+class Errb:
+  def __init__(self, req):
+    self._req = req
+  def call(self, err):
+    req_err(self._req, err)
+

 def check_outbound():
   global outstanding
 
   while True:
 def check_outbound():
   global outstanding
 
   while True:

-    if                          outstanding >= c.max_outstanding   : break
-    if not queue.nonempty() and outstanding >= c.target_outstanding: break
+    if                          len(outstanding) >= c.max_outstanding   : break
+    if not queue.nonempty() and len(outstanding) >= c.target_outstanding: break

 
     d = b''
     def moredata(s): nonlocal d; d += s
 
     d = b''
     def moredata(s): nonlocal d; d += s


@@ -176,6 +194,7 @@ def check_outbound():
             str(c.client)             .encode('ascii')    + crlf +
             password                                      + crlf +
             str(c.target_outstanding) .encode('ascii')    + crlf +
             str(c.client)             .encode('ascii')    + crlf +
             password                                      + crlf +
             str(c.target_outstanding) .encode('ascii')    + crlf +

+            str(c.http_timeout)       .encode('ascii')    + crlf +

           ((
             b'--b'                                        + crlf +
             b'Content-Type: application/octet-stream'     + crlf +
           ((
             b'--b'                                        + crlf +
             b'Content-Type: application/octet-stream'     + crlf +


@@ -203,14 +222,15 @@ def check_outbound():
                         twisted.web.client.Headers(hh),
                         producer)
 
                         twisted.web.client.Headers(hh),
                         producer)
 

-    outstanding += 1
-    log_debug(DBG.HTTP_CTRL, 'request OS=%d' % outstanding, idof=req, d=d)
+    outstanding[req] = len(d)
+    log_debug(DBG.HTTP_CTRL, 'request OS=%d' % len(outstanding), idof=req, d=d)

     req.addTimeout(c.http_timeout, reactor)
     req.addTimeout(c.http_timeout, reactor)

-    req.addCallback((lambda resp: req_ok(req, resp)))
-    req.addErrback((lambda err: req_err(req, err)))
+    req.addCallback(partial(req_ok, req))
+    req.addErrback(partial(req_err, req))
+
+  log_outstanding()

 
 

-common_startup()
-process_cfg()
+common_startup(process_cfg)

 start_client()
 start_ipif(c.ipif_command, outbound)
 check_outbound()
 start_client()
 start_ipif(c.ipif_command, outbound)
 check_outbound()