wip fixes

[hippotat.git] / server

diff --git a/server b/server
index 8a16c34a390d6d195430f5b7f3e06163283b65ff..52d83b50a95953f9204bbb1890726fa913126c24 100755 (executable)
--- a/server
+++ b/server
@@ -24,7 +24,7 @@ def route(packet, iface, saddr, daddr):
   if dclient is not None:
     lt('client')
     dclient.queue_outbound(packet)
-  elif daddr == c.server or daddr not in c.network:
+  elif daddr == c.vaddr or daddr not in c.vnetwork:
     lt('inbound')
     queue_inbound(packet)
   elif daddr == relay:
@@ -37,28 +37,20 @@ def route(packet, iface, saddr, daddr):
 #---------- client ----------
 
 class Client():
-  def __init__(self, ip, cs, pw):
+  def __init__(self, ip, cc):
     # instance data members
     self._ip = ip
-    self._cs = cs
-    self.pw = pw
+    self.cc = cc
     self._rq = collections.deque() # requests
     # self._pq = PacketQueue(...)
     # plus from config:
     #  .max_batch_down
     #  .max_queue_time
-    #  .max_request_time
     #  .target_requests_outstanding
 
-    if ip not in c.network:
+    if ip not in c.vnetwork:
       raise ValueError('client %s not in network' % ip)
 
-    for k in ('max_batch_down','max_queue_time','max_request_time',
-              'target_requests_outstanding'):
-      req = cfg.getint(cs, k)
-      limit = cfg.getint('limits',k)
-      self.__dict__[k] = min(req, limit)
-
     self._pq = PacketQueue(str(ip), self.max_queue_time)
 
     if ip in clients:
@@ -91,10 +83,17 @@ class Client():
     self._pq.append(packet)
     self._check_outbound()
 
+  def _req_fin(self, dummy, request, cl):
+    self._log(DBG.HTTP_CTRL, '_req_fin ' + repr(dummy), idof=request)
+    try: cl.cancel()
+    except twisted.internet.error.AlreadyCalled: pass
+
   def new_request(self, request):
     request.setHeader('Content-Type','application/octet-stream')
-    reactor.callLater(self.max_request_time, self._req_cancel, request)
-    request.notifyFinish().addErrback(self._req_error, request)
+    cl = reactor.callLater(self.http_timeout, self._req_cancel, request)
+    nf = request.notifyFinish()
+    nf.addErrback(self._req_error, request)
+    nf.addCallback(self._req_fin, request, cl)
     self._rq.append(request)
     self._check_outbound()
 
@@ -143,11 +142,11 @@ def process_request(request, desca):
   # find client, update config, etc.
   metadata = request.args[b'm'][0]
   metadata = metadata.split(b'\r\n')
-  (ci_s, pw, tro) = metadata[0:3]
-  desca['m[0,2]'] = [ci_s, tro]
+  (ci_s, pw, tro, cto) = metadata[0:4]
+  desca['m[0,2:3]'] = [ci_s, tro, cto]
   ci_s = ci_s.decode('utf-8')
-  tro = int(tro)
-  desca['tro']= tro
+  tro = int(tro); desca['tro']= tro
+  cto = int(cto); desca['cto']= cto
   ci = ipaddr(ci_s)
   desca['ci'] = ci
   cl = clients[ci]
@@ -157,6 +156,9 @@ def process_request(request, desca):
   if tro != cl.target_requests_outstanding:
     raise ValueError('tro must be %d' % cl.target_requests_outstanding)
 
+  if cto < cl.http_timeout:
+    raise ValueError('cto must be >= %d' % cl.http_timeout)
+
   try:
     d = request.args[b'd'][0]
     desca['d'] = d
@@ -211,29 +213,39 @@ def start_http():
 
 #---------- config and setup ----------
         
-def process_cfg():
-  process_cfg_common_always()
-  process_cfg_server()
-  process_cfg_network()
+def process_cfg(putative_servers, putative_clients):
+  global c
+  c = ConfigResults()
+  c.server = cfg.get('SERVER','server')
+
+  cfg_process_common(c, c.server)
+  cfg_process_saddrs(c, c.server)
+  cfg_process_vnetwork(c, c.server)
+  cfg_process_vaddr(c, c.server)
+
+  for (ci,cs) in putative_clients.items():
+    cc = ConfigResults()
+    sections = cfg_process_client_common(cc,c.server,cs,ci):
+    if not sections: continue
+    cfg_process_client_limited(cc,c.server,sections, 'max_batch_down')
+    cfg_process_client_limited(cc,c.server,sections, 'max_queue_time')
+    Client(ci)
 
   try:
-    c.relay = cfg.get('virtual','relay')
+    c.relay = cfg.get(c.server, 'relay')
   except NoOptionError:
-    for search in c.network.hosts():
-      if search == c.server: continue
+    for search in c.vnetwork.hosts():
+      if search == c.vaddr: continue
       c.relay = search
       break
 
-  process_cfg_saddrs()
-  process_cfg_clients(Client)
-
-  process_cfg_ipif('server',
-                   (('local','server'),
-                    ('peer', 'relay'),
-                    ('rnets','network')))
+  cfg_process_ipif(c,
+                   [c.server, 'DEFAULT'],
+                   (('local','vaddr'),
+                    ('peer', 'vrelay'),
+                    ('rnets','vnetwork')))
 
-common_startup()
-process_cfg()
+common_startup(process_cfg)
 start_ipif(c.ipif_command, (lambda p,s,d: route(p,"[ipif]",s,d)))
 start_http()
 common_run()