Clean up some of the gctx mess

svn path=/scripts/rpki/left_right.py; revision=1099

3 files changed, 73 insertions, 73 deletions

diff --git a/scripts/rpki/left_right.py b/scripts/rpki/left_right.py
index 2ce5f0ae..c57651e8 100644
--- a/scripts/rpki/left_right.py
+++ b/scripts/rpki/left_right.py
@@ -98,7 +98,7 @@ class data_elt(base_elt, rpki.sql.sql_persistant):
     r_msg.append(r_pdu)
 
   def serve_set(self, gctx, r_msg):
-    db_pdu = self.sql_fetch(gctx.db, gctx.cur, getattr(self, self.sql_template.index))
+    db_pdu = self.sql_fetch(gctx, getattr(self, self.sql_template.index))
     if db_pdu is not None:
       r_pdu = self.make_reply()
       for a in db_pdu.sql_template.columns[1:]:
@@ -114,7 +114,7 @@ class data_elt(base_elt, rpki.sql.sql_persistant):
       r_msg.append(make_error_report(self))
 
   def serve_get(self, gctx, r_msg):
-    r_pdu = self.sql_fetch(gctx.db, gctx.cur, getattr(self, self.sql_template.index))
+    r_pdu = self.sql_fetch(gctx, getattr(self, self.sql_template.index))
     if r_pdu is not None:
       self.make_reply(r_pdu)
       r_msg.append(r_pdu)
@@ -127,7 +127,7 @@ class data_elt(base_elt, rpki.sql.sql_persistant):
       r_msg.append(r_pdu)
 
   def serve_destroy(self, gctx, r_msg):
-    db_pdu = self.sql_fetch(gctx.db, gctx.cur, getattr(self, self.sql_template.index))
+    db_pdu = self.sql_fetch(gctx, getattr(self, self.sql_template.index))
     if db_pdu is not None:
       db_pdu.sql_delete(gctx.db, gctx.cur)
       r_msg.append(self.make_reply())
@@ -182,21 +182,21 @@ class self_elt(data_elt):
   def __init__(self):
     self.prefs = []
 
-  def sql_fetch_hook(self, db, cur):
-    cur.execute("SELECT pref_name, pref_value FROM self_pref WHERE self_id = %s", self.self_id)
-    for name, value in cur.fetchall():
+  def sql_fetch_hook(self, gctx):
+    gctx.cur.execute("SELECT pref_name, pref_value FROM self_pref WHERE self_id = %s", self.self_id)
+    for name, value in gctx.cur.fetchall():
       e = extension_preference_elt()
       e.name = name
       e.value = value
       self.prefs.append(e)
 
-  def sql_insert_hook(self, db, cur):
+  def sql_insert_hook(self, gctx):
     if self.prefs:
-      cur.executemany("INSERT self_pref (self_id, pref_name, pref_value) VALUES (%s, %s, %s)",
-                      ((e.name, e.value, self.self_id) for e in self.prefs))
+      gctx.cur.executemany("INSERT self_pref (self_id, pref_name, pref_value) VALUES (%s, %s, %s)",
+                           ((e.name, e.value, self.self_id) for e in self.prefs))
   
-  def sql_delete_hook(self, db, cur):
-    cur.execute("DELETE FROM self_pref WHERE self_id = %s", self.self_id)
+  def sql_delete_hook(self, gctx):
+    gctx.cur.execute("DELETE FROM self_pref WHERE self_id = %s", self.self_id)
 
   def serve_pre_save_hook(self, q_pdu, r_pdu):
     if self is not q_pdu:
@@ -247,16 +247,16 @@ class bsc_elt(data_elt):
   def __init__(self):
     self.signing_cert = []
 
-  def sql_fetch_hook(self, db, cur):
-    cur.execute("SELECT cert FROM bsc_cert WHERE bsc_id = %s", self.bsc_id)
-    self.signing_cert = [rpki.x509.X509(DER=x) for (x,) in cur.fetchall()]
+  def sql_fetch_hook(self, gctx):
+    gctx.cur.execute("SELECT cert FROM bsc_cert WHERE bsc_id = %s", self.bsc_id)
+    self.signing_cert = [rpki.x509.X509(DER=x) for (x,) in gctx.cur.fetchall()]
 
-  def sql_insert_hook(self, db, cur):
+  def sql_insert_hook(self, gctx):
     if self.signing_cert:
-      cur.executemany("INSERT bsc_cert (cert, bsc_id) VALUES (%s, %s)", ((x.get_DER(), self.bsc_id) for x in self.signing_cert))
+      gctx.cur.executemany("INSERT bsc_cert (cert, bsc_id) VALUES (%s, %s)", ((x.get_DER(), self.bsc_id) for x in self.signing_cert))
 
-  def sql_delete_hook(self, db, cur):
-    cur.execute("DELETE FROM bsc_cert WHERE bsc_id = %s", self.bsc_id)
+  def sql_delete_hook(self, gctx):
+    gctx.cur.execute("DELETE FROM bsc_cert WHERE bsc_id = %s", self.bsc_id)
 
   def serve_pre_save_hook(self, q_pdu, r_pdu):
     if self is not q_pdu:
@@ -357,7 +357,7 @@ class parent_elt(data_elt):
 
     For now, keep this dead simple lock step, rewrite it later.
     """
-    bsc = bsc_elt.sql_fetch(gctx.db, gctx.cur, self.bsc_id)
+    bsc = bsc_elt.sql_fetch(gctx, self.bsc_id)
     if bsc is None:
       raise rpki.exceptions.NotFound, "Could not find BSC %s" % self.bsc_id
     q_msg = rpki.up_down.message_pdu.make_query(q_pdu)
@@ -408,7 +408,7 @@ class child_elt(data_elt):
 
   def serve_up_down(self, gctx, query):
     """Outer layer of server handling for one up-down PDU from this child."""
-    bsc = bsc_elt.sql_fetch(gctx.db, gctx.cur, self.bsc_id)
+    bsc = bsc_elt.sql_fetch(gctx, self.bsc_id)
     if bsc is None:
       raise rpki.exceptions.NotFound, "Could not find BSC %s" % self.bsc_id
     q_elt = rpki.cms.xml_decode(query, self.cms_ta)
@@ -470,21 +470,21 @@ class route_origin_elt(data_elt):
   ca_detail_id = None
   roa = None
 
-  def sql_fetch_hook(self, db, cur):
-    self.ipv4 = rpki.resource_set.resource_set_ipv4.from_sql(cur,
+  def sql_fetch_hook(self, gctx):
+    self.ipv4 = rpki.resource_set.resource_set_ipv4.from_sql(gctx.cur,
                                                              "SELECT start_ip, end_ip FROM route_origin_range WHERE route_origin_id = %s AND start_ip NOT LIKE '%:%'",
                                                              self.route_origin_id)
-    self.ipv6 = rpki.resource_set.resource_set_ipv6.from_sql(cur,
+    self.ipv6 = rpki.resource_set.resource_set_ipv6.from_sql(gctx.cur,
                                                              "SELECT start_ip, end_ip FROM route_origin_range WHERE route_origin_id = %s AND start_ip LIKE '%:%'",
                                                              self.route_origin_id)
 
-  def sql_insert_hook(self, db, cur):
+  def sql_insert_hook(self, gctx):
     if self.ipv4 + self.ipv6:
-      cur.executemany("INSERT route_origin_range (route_origin_id, start_ip, end_ip) VALUES (%s, %s, %s)",
-                      ((self.route_origin_id, x.min, x.max) for x in self.ipv4 + self.ipv6))
+      gctx.cur.executemany("INSERT route_origin_range (route_origin_id, start_ip, end_ip) VALUES (%s, %s, %s)",
+                           ((self.route_origin_id, x.min, x.max) for x in self.ipv4 + self.ipv6))
   
-  def sql_delete_hook(self, db, cur):
-    cur.execute("DELETE FROM route_origin_range WHERE route_origin_id = %s", self.route_origin_id)
+  def sql_delete_hook(self, gctx):
+    gctx.cur.execute("DELETE FROM route_origin_range WHERE route_origin_id = %s", self.route_origin_id)
 
   def serve_post_save_hook(self, q_pdu, r_pdu):
     if self.suppress_publication:
diff --git a/scripts/rpki/sql.py b/scripts/rpki/sql.py
index b9eb2f7d..186df9af 100644
--- a/scripts/rpki/sql.py
+++ b/scripts/rpki/sql.py
@@ -46,10 +46,10 @@ def sql_sweep(db, cur):
   for s in sql_dirty:
     s.sql_store(db, cur)
 
-def fetch_column(cur, *query):
+def fetch_column(gctx, *query):
   """Pull a single column from SQL, return it as a list."""
-  cur.execute(*query)
-  return [x[0] for x in cur.fetchall()]
+  gctx.cur.execute(*query)
+  return [x[0] for x in gctx.cur.fetchall()]
 
 class sql_persistant(object):
   """Mixin for persistant class that needs to be stored in SQL.
@@ -60,8 +60,8 @@ class sql_persistant(object):
   sql_in_db = False
 
   @classmethod
-  def sql_fetch(cls, db, cur, id):
-    results = cls.sql_fetch_where(db, cur, "%s = %s" % (cls.sql_template.index, id))
+  def sql_fetch(cls, gctx, id):
+    results = cls.sql_fetch_where(gctx, "%s = %s" % (cls.sql_template.index, id))
     assert len(results) <= 1
     if len(results) == 0:
       return None
@@ -71,31 +71,31 @@ class sql_persistant(object):
       raise rpki.exceptions.DBConsistancyError, "Database contained multiple matches for %s.%s" % (cls.__name__, id)
 
   @classmethod
-  def sql_fetch_all(cls, db, cur):
-    return cls.sql_fetch_where(db, cur, None)
+  def sql_fetch_all(gctx, cur):
+    return cls.sql_fetch_where(gctx, None)
 
   @classmethod
-  def sql_fetch_where(cls, db, cur, where):
+  def sql_fetch_where(cls, gctx, where):
     if where is None:
-      cur.execute(cls.sql_template.select)
+      gctx.cur.execute(cls.sql_template.select)
     else:
-      cur.execute(cls.sql_template.select + " WHERE " + where)
+      gctx.cur.execute(cls.sql_template.select + " WHERE " + where)
     results = []
-    for row in cur.fetchall():
+    for row in gctx.cur.fetchall():
       key = (cls, row[0])
       if key in sql_cache:
         results.append(sql_cache[key])
       else:
-        results.append(cls.sql_init(db, cur, row, key))
+        results.append(cls.sql_init(gctx, row, key))
     return results
 
   @classmethod
-  def sql_init(cls, db, cur, row, key):
+  def sql_init(cls, gctx, row, key):
     self = cls()
     self.sql_decode(dict(zip(cls.sql_template.columns, row)))
     sql_cache[key] = self
     self.sql_in_db = True
-    self.sql_fetch_hook(db, cur)
+    self.sql_fetch_hook(gctx)
     return self
 
   def sql_mark_dirty(self):
@@ -107,25 +107,25 @@ class sql_persistant(object):
   def sql_is_dirty(self):
     return self in sql_dirty
 
-  def sql_store(self, db, cur):
+  def sql_store(self, gctx):
     if not self.sql_in_db:
-      cur.execute(self.sql_template.insert, self.sql_encode())
-      setattr(self, self.sql_template.index, cur.lastrowid)
-      sql_cache[(self.__class__, cur.lastrowid)] = self
-      self.sql_insert_hook(db, cur)
+      gctx.cur.execute(self.sql_template.insert, self.sql_encode())
+      setattr(self, self.sql_template.index, gctx.cur.lastrowid)
+      sql_cache[(self.__class__, gctx.cur.lastrowid)] = self
+      self.sql_insert_hook(gctx)
     elif self in sql_dirty:
-      cur.execute(self.sql_template.update, self.sql_encode())
-      self.sql_update_hook(db, cur)
+      gctx.cur.execute(self.sql_template.update, self.sql_encode())
+      self.sql_update_hook(gctx)
     key = (self.__class__, getattr(self, self.sql_template.index))
     assert key in sql_cache and sql_cache[key] == self
     self.sql_mark_clean()
     self.sql_in_db = True
 
-  def sql_delete(self, db, cur):
+  def sql_delete(self, gctx):
     if self.sql_in_db:
       id = getattr(self, self.sql_template.index)
-      cur.execute(self.sql_template.delete, id)
-      self.sql_delete_hook(db, cur)
+      gctx.cur.execute(self.sql_template.delete, id)
+      self.sql_delete_hook(gctx)
       key = (self.__class__, id)
       if sql_cache.get(key) == self:
         del sql_cache[key]
@@ -150,20 +150,20 @@ class sql_persistant(object):
     for a in self.sql_template.columns:
       setattr(self, a, vals[a])
 
-  def sql_fetch_hook(self, db, cur):
+  def sql_fetch_hook(self, gctx):
     """Customization hook."""
     pass
 
-  def sql_insert_hook(self, db, cur):
+  def sql_insert_hook(self, gctx):
     """Customization hook."""
     pass
   
-  def sql_update_hook(self, db, cur):
+  def sql_update_hook(self, gctx):
     """Customization hook."""
-    self.sql_delete_hook(db, cur)
-    self.sql_insert_hook(db, cur)
+    self.sql_delete_hook(gctx)
+    self.sql_insert_hook(gctx)
 
-  def sql_delete_hook(self, db, cur):
+  def sql_delete_hook(self, gctx):
     """Customization hook."""
     pass
 
@@ -205,8 +205,8 @@ class ca_detail_obj(sql_persistant):
     return d
 
   @classmethod
-  def sql_fetch_active(cls, db, cur, ca_id):
-    hits = cls.sql_fetch_where(db, cur, "ca_id = %s AND state = 'active'" % ca_id)
+  def sql_fetch_active(cls, gctx, ca_id):
+    hits = cls.sql_fetch_where(gctx, "ca_id = %s AND state = 'active'" % ca_id)
     assert len(hits) < 2, "Found more than one 'active' ca_detail record, this should not happen!"
     if hits:
       return hits[0]
diff --git a/scripts/rpki/up_down.py b/scripts/rpki/up_down.py
index 149de9c8..90c6f63e 100644
--- a/scripts/rpki/up_down.py
+++ b/scripts/rpki/up_down.py
@@ -157,8 +157,8 @@ class list_pdu(base_elt):
     """Serve one "list" PDU."""
     r_msg.payload = list_response_pdu()
     irdb_as, irdb_v4, irdb_v6 = rpki.left_right.irdb_query(gctx, child.self_id, child.child_id)
-    for ca_id in rpki.sql.fetch_column(gctx.cur, "SELECT ca_id FROM ca WHERE ca.parent_id = parent.parent_id AND parent.self_id = %s" % child.self_id):
-      ca_detail = rpki.sql.ca_detail_obj.sql_fetch_active(gctx.db, gctx.cur, ca_id)
+    for ca_id in rpki.sql.fetch_column(gctx, "SELECT ca_id FROM ca WHERE ca.parent_id = parent.parent_id AND parent.self_id = %s" % child.self_id):
+      ca_detail = rpki.sql.ca_detail_obj.sql_fetch_active(gctx, ca_id)
       if not ca_detail:
         continue
       rc_as, rc_v4, rc_v6 = ca_detail.latest_ca_cert.get_3779resources(irdb_as, irdb_v4, irdb_v6)
@@ -168,7 +168,7 @@ class list_pdu(base_elt):
       rc.class_name = str(ca_id)
       rc.cert_url = multi_uri(ca_detail.ca_cert_uri)
       rc.resource_set_as, rc.resource_set_ipv4, rc.resource_set_ipv6 = rc_as, rc_v4, rc_v6
-      for child_cert in rpki.sql.child_cert_obj.sql_fetch_where(gctx.db, gctx.cur, "child_id = %s AND ca_detail_id = %s" % (child.child_id, ca_detail.ca_detail_id)):
+      for child_cert in rpki.sql.child_cert_obj.sql_fetch_where(gctx, "child_id = %s AND ca_detail_id = %s" % (child.child_id, ca_detail.ca_detail_id)):
         c = certificate_elt()
         c.cert_url = multi_uri(ca.sia_uri + child_cert.cert.gSKI() + ".cer")
         c.cert = child_cert.cert
@@ -234,8 +234,8 @@ class issue_pdu(base_elt):
     if not self.class_name.isdigit():
       raise rpki.exceptions.BadClassNameSyntax, "Bad class name %s" % self.class_name
     ca_id = long(self.class_name)
-    ca = rpki.sql.ca_obj.sql_fetch(gctx.db, gctx.cur, ca_id)
-    ca_detail = rpki.sql.ca_detail_obj.sql_fetch_active(gctx.db, gctx.cur, ca_id)
+    ca = rpki.sql.ca_obj.sql_fetch(gctx, ca_id)
+    ca_detail = rpki.sql.ca_detail_obj.sql_fetch_active(gctx, ca_id)
     if ca is None or ca_detail is None:
       raise rpki.exceptions.NotInDatabase
     self.pkcs10.check_valid_rpki()
@@ -246,7 +246,7 @@ class issue_pdu(base_elt):
     req_sia = self.pkcs10.get_POWpkix().getExtension(name2oid["subjectInfoAccess"])
     #
     # This next search loop might be an argument for a child_cert.ski column
-    for child_cert in rpki.sql.child_cert_obj.sql_fetch_where(gctx.db, gctx.cur, "child_id = %s AND ca_detail_id = %s" % (child.child_id, ca_detail.ca_detail_id)):
+    for child_cert in rpki.sql.child_cert_obj.sql_fetch_where(gctx, "child_id = %s AND ca_detail_id = %s" % (child.child_id, ca_detail.ca_detail_id)):
       if child_cert.cert.get_POWpkix().tbs.subjectPublicKeyInfo.get() == pubkey:
         break
     else:
@@ -296,11 +296,11 @@ class issue_pdu(base_elt):
   @classmethod
   def query(cls, gctx, ca, sia):
     """Send an "issue" request to parent associated with ca."""
-    parent = rpki.left_right.parent_elt.sql_fetch(gctx.db, gctx.cur, ca.parent_id)
+    parent = rpki.left_right.parent_elt.sql_fetch(gctx, ca.parent_id)
     #
     # Do we always want the active ca_detail here?  Assume yes for
     # now, may need to revisit
-    ca_detail = rpki.sql.ca_detail_obj.sql_fetch_active(gctx.db, gctx.cur, ca.ca_id)
+    ca_detail = rpki.sql.ca_detail_obj.sql_fetch_active(gctx, ca.ca_id)
     if ca_detail is None:
       ca_detail = rpki.sql.ca_detail_obj.create(gctx, ca)
     self = cls()
@@ -332,13 +332,13 @@ class revoke_pdu(revoke_syntax):
     if not self.class_name.isdigit():
       raise rpki.exceptions.BadClassNameSyntax, "Bad class name %s" % self.class_name
     ca_id = long(self.class_name)
-    ca = rpki.sql.ca_obj.sql_fetch(gctx.db, gctx.cur, ca_id)
-    ca_detail = rpki.sql.ca_detail_obj.sql_fetch_active(gctx.db, gctx.cur, ca_id)
+    ca = rpki.sql.ca_obj.sql_fetch(gctx, ca_id)
+    ca_detail = rpki.sql.ca_detail_obj.sql_fetch_active(gctx, ca_id)
     if ca is None or ca_detail is None:
       raise rpki.exceptions.NotInDatabase
     ski = base64.b64decode(self.ski.replace("_", "/").replace("-", "+"))
     # This next search loop might be an argument for a child_cert.ski column
-    for c in rpki.sql.child_cert_obj.sql_fetch_where(gctx.db, gctx.cur, "child_id = %s AND ca_detail_id = %s" % (child.child_id, ca_detail.ca_detail_id)):
+    for c in rpki.sql.child_cert_obj.sql_fetch_where(gctx, "child_id = %s AND ca_detail_id = %s" % (child.child_id, ca_detail.ca_detail_id)):
       if c.cert.get_SKI() == ski:
         c.sql_delete()
     r_msg.payload = revoke_response_pdu()
@@ -348,8 +348,8 @@ class revoke_pdu(revoke_syntax):
   @classmethod
   def query(cls, gctx, ca_detail):
     """Send a "revoke" request to parent associated with ca_detail."""
-    ca = rpki.sql.ca_obj.sql_fetch(gctx.db, gctx.cur, ca_detail.ca_id)
-    parent = rpki.left_right.parent_elt.sql_fetch(gctx.db, gctx.cur, ca.parent_id)
+    ca = rpki.sql.ca_obj.sql_fetch(gctx, ca_detail.ca_id)
+    parent = rpki.left_right.parent_elt.sql_fetch(gctx, ca.parent_id)
     self = cls()
     self.class_name = ca.parent_resource_class
     self.ski = ca_detail.latest_ca_cert.gSKI()