Remove: pgqadm and related code, its unmaintained

Although it was nice to have Python code that shows
how PgQ ticker and maintenance operations should work,
if it's unmaintaned, it's pointless.

4 files changed, 0 insertions, 406 deletions

diff --git a/python/pgq/__init__.py b/python/pgq/__init__.py
index dc6ece29..d8473da5 100644
--- a/python/pgq/__init__.py
+++ b/python/pgq/__init__.py
@@ -7,8 +7,6 @@ import pgq.consumer
 import pgq.remoteconsumer
 import pgq.producer
 
-import pgq.ticker
-import pgq.maint
 import pgq.status
 
 import pgq.cascade
@@ -24,8 +22,6 @@ from pgq.remoteconsumer import *
 from pgq.localconsumer import *
 from pgq.producer import *
 
-from pgq.ticker import *
-from pgq.maint import *
 from pgq.status import *
 
 from pgq.cascade.nodeinfo import *
@@ -44,8 +40,6 @@ __all__ = (
     pgq.cascade.consumer.__all__ +
     pgq.cascade.worker.__all__ +
     pgq.producer.__all__ +
-    pgq.ticker.__all__ +
-    pgq.maint.__all__ +
     pgq.status.__all__ )
 
 
diff --git a/python/pgq/maint.py b/python/pgq/maint.py
deleted file mode 100644
index 89014dd4..00000000
--- a/python/pgq/maint.py
+++ /dev/null
@@ -1,104 +0,0 @@
-"""PgQ maintenance functions."""
-
-import skytools, time
-
-__all__ = ['MaintenanceJob']
-
-def get_pgq_api_version(curs):
-    q = "select count(1) from pg_proc p, pg_namespace n"\
-        " where n.oid = p.pronamespace and n.nspname='pgq'"\
-        "   and p.proname='version';"
-    curs.execute(q)
-    if not curs.fetchone()[0]:
-        return '1.0.0'
-
-    curs.execute("select pgq.version()")
-    return curs.fetchone()[0]
-
-def version_ge(curs, want_ver):
-    """Check is db version of pgq is greater than want_ver."""
-    db_ver = get_pgq_api_version(curs)
-    want_tuple = map(int, want_ver.split('.'))
-    db_tuple = map(int, db_ver.split('.'))
-    if db_tuple[0] != want_tuple[0]:
-        raise Exception('Wrong major version')
-    if db_tuple[1] >= want_tuple[1]:
-        return 1
-    return 0
-
-class MaintenanceJob(skytools.DBScript):
-    """Periodic maintenance."""
-    def __init__(self, ticker, args):
-        skytools.DBScript.__init__(self, 'pgqadm', args)
-        self.ticker = ticker
-        self.last_time = 0 # start immidiately
-        self.last_ticks = 0
-        self.clean_ticks = 1
-        self.maint_delay = 5*60
-
-    def startup(self):
-        # disable regular DBScript startup()
-        pass
-
-    def reload(self):
-        skytools.DBScript.reload(self)
-
-        # force loop_delay
-        self.loop_delay = 5
-
-        # compat var
-        self.maint_delay = 60 * self.cf.getfloat('maint_delay_min', -1)
-        if self.maint_delay < 0:
-            self.maint_delay = self.cf.getfloat('maint_delay', 5*60)
-        self.maint_delay = self.cf.getfloat('maint_delay', self.maint_delay)
-
-    def work(self):
-        t = time.time()
-        if self.last_time + self.maint_delay > t:
-            return
-
-        self.do_maintenance()
-
-        self.last_time = t
-        duration = time.time() - t
-        self.stat_put('maint_duration', duration)
-
-    def do_maintenance(self):
-        """Helper function for running maintenance."""
-
-        db = self.get_database('db', autocommit=1)
-        cx = db.cursor()
-
-        if skytools.exists_function(cx, "pgq.maint_rotate_tables_step1", 1):
-            # rotate each queue in own TX
-            q = "select queue_name from pgq.get_queue_info()"
-            cx.execute(q)
-            for row in cx.fetchall():
-                cx.execute("select pgq.maint_rotate_tables_step1(%s)", [row[0]])
-                res = cx.fetchone()[0]
-                if res:
-                    self.log.info('Rotating %s' % row[0])
-        else:
-            cx.execute("select pgq.maint_rotate_tables_step1();")
-
-        # finish rotation
-        cx.execute("select pgq.maint_rotate_tables_step2();")
-
-        # move retry events to main queue in small blocks
-        rcount = 0
-        while 1:
-            cx.execute('select pgq.maint_retry_events();')
-            res = cx.fetchone()[0]
-            rcount += res
-            if res == 0:
-                break
-        if rcount:
-            self.log.info('Got %d events for retry' % rcount)
-
-        # vacuum tables that are needed
-        cx.execute('set maintenance_work_mem = 32768')
-        cx.execute('select * from pgq.maint_tables_to_vacuum()')
-        for row in cx.fetchall():
-            cx.execute('vacuum %s;' % row[0])
-
-
diff --git a/python/pgq/ticker.py b/python/pgq/ticker.py
deleted file mode 100644
index e623b9cb..00000000
--- a/python/pgq/ticker.py
+++ /dev/null
@@ -1,52 +0,0 @@
-"""PgQ ticker.
-
-It will also launch maintenance job.
-"""
-
-import time, threading
-import skytools
-
-from pgq.maint import MaintenanceJob
-
-__all__ = ['SmallTicker']
-
-class SmallTicker(skytools.DBScript):
-    """Ticker that periodically calls pgq.ticker()."""
-    tick_count = 0
-    maint_thread = None
-
-    def __init__(self, args):
-        skytools.DBScript.__init__(self, 'pgqadm', args)
-
-        self.ticker_log_time = 0
-        self.ticker_log_delay = 5*60
-
-    def reload(self):
-        skytools.DBScript.reload(self)
-        self.ticker_log_delay = self.cf.getfloat("ticker_log_delay", 5*60)
-
-    def startup(self):
-        if self.maint_thread:
-            return
-
-        # launch maint thread
-        self.maint_thread = MaintenanceJob(self, [self.cf.filename])
-        t = threading.Thread(name = 'maint_thread',
-                             target = self.maint_thread.run)
-        t.setDaemon(1)
-        t.start()
-
-    def work(self):
-        db = self.get_database("db", autocommit = 1)
-        cx = db.cursor()
-
-        # run ticker
-        cx.execute("select pgq.ticker()")
-        self.tick_count += cx.fetchone()[0]
-
-        cur_time = time.time()
-        if cur_time > self.ticker_log_time + self.ticker_log_delay:
-            self.ticker_log_time = cur_time
-            self.stat_increase('ticks', self.tick_count)
-            self.tick_count = 0
-
diff --git a/python/pgqadm.py b/python/pgqadm.py
deleted file mode 100755
index 32591250..00000000
--- a/python/pgqadm.py
+++ /dev/null
@@ -1,244 +0,0 @@
-#! /usr/bin/env python
-
-"""PgQ ticker and maintenance.
-
-
-Config template::
-
-    [pgqadm]
-
-    # should be globally unique
-    job_name = pgqadm_somedb
-
-    db = dbname=provider port=6000 host=127.0.0.1
-
-    # how often to run maintenance [minutes]
-    maint_delay_min = 5
-
-    # how often to check for activity [secs]
-    loop_delay = 0.5
-
-    logfile = ~/log/%(job_name)s.log
-    pidfile = ~/pid/%(job_name)s.pid
-
-    use_skylog = 0
-
-"""
-
-import sys
-
-import pkgloader
-pkgloader.require('skytools', '3.0')
-
-import skytools, pgq
-from pgq.cascade.admin import CascadeAdmin
-
-"""TODO:
-pgqadm ini check
-"""
-
-command_usage = """
-%prog [options] INI CMD [subcmd args]
-
-local queue commands:
-  ticker                   start ticking & maintenance process
-
-  status                   show overview of queue health
-
-  install                  install code into db
-  create QNAME             create queue
-  drop QNAME               drop queue
-  register QNAME CONS      install code into db
-  unregister QNAME CONS    install code into db
-  config QNAME [VAR=VAL]   show or change queue config
-
-cascaded queue commands:
-  create-node
-  rename-node
-  pause-node
-  resume-node
-  change-provider
-  tag-alive
-  tag-dead
-  switchover
-  failover
-"""
-
-config_allowed_list = {
-    'queue_ticker_max_count': 'int',
-    'queue_ticker_max_lag': 'interval',
-    'queue_ticker_idle_period': 'interval',
-    'queue_rotation_period': 'interval',
-}
-
-class PGQAdmin(skytools.DBScript):
-    __doc__ = __doc__
-    def __init__(self, args):
-        """Initialize pgqadm."""
-        skytools.DBScript.__init__(self, 'pgqadm', args)
-        self.set_single_loop(1)
-
-
-        if len(self.args) < 2:
-            print("need command")
-            sys.exit(1)
-
-        int_cmds = {
-            'create': self.create_queue,
-            'drop': self.drop_queue,
-            'register': self.register,
-            'unregister': self.unregister,
-            'install': self.installer,
-            'config': self.change_config,
-        }
-
-        cascade_cmds = ['create-node']
-
-        cmd = self.args[1]
-        if cmd == "ticker":
-            script = pgq.SmallTicker(args)
-        elif cmd == "status":
-            script = pgq.PGQStatus(args)
-        elif cmd in cascade_cmds:
-            script = CascadeAdmin(self.service_name, 'db', args)
-        elif cmd in int_cmds:
-            script = None
-            self.work = int_cmds[cmd]
-        else:
-            print("unknown command")
-            sys.exit(1)
-
-        if self.pidfile:
-            self.pidfile += ".admin"
-        self.run_script = script
-
-    def start(self):
-        if self.run_script:
-            self.run_script.start()
-        else:
-            skytools.DBScript.start(self)
-
-    def reload(self):
-        skytools.DBScript.reload(self)
-        self.set_single_loop(1)
-
-    def init_optparse(self, parser=None):
-        p = skytools.DBScript.init_optparse(self, parser)
-        p.set_usage(command_usage.strip())
-        p.add_option("--queue", help = 'cascading: specify queue name')
-        return p
-
-    def installer(self):
-        objs = [
-            skytools.DBLanguage("plpgsql"),
-            #skytools.DBFunction("txid_current_snapshot", 0, sql_file="txid.sql"),
-            skytools.DBSchema("pgq", sql_file="pgq.sql"),
-        ]
-
-        db = self.get_database('db')
-        curs = db.cursor()
-        skytools.db_install(curs, objs, self.log)
-        db.commit()
-
-    def create_queue(self):
-        qname = self.args[2]
-        self.log.info('Creating queue: %s' % qname)
-        self.exec_sql("select pgq.create_queue(%s)", [qname])
-
-    def drop_queue(self):
-        qname = self.args[2]
-        self.log.info('Dropping queue: %s' % qname)
-        self.exec_sql("select pgq.drop_queue(%s)", [qname])
-
-    def register(self):
-        qname = self.args[2]
-        cons = self.args[3]
-        self.log.info('Registering consumer %s on queue %s' % (cons, qname))
-        self.exec_sql("select pgq.register_consumer(%s, %s)", [qname, cons])
-
-    def unregister(self):
-        qname = self.args[2]
-        cons = self.args[3]
-        self.log.info('Unregistering consumer %s from queue %s' % (cons, qname))
-        self.exec_sql("select pgq.unregister_consumer(%s, %s)", [qname, cons])
-
-    def change_config(self):
-        if len(self.args) < 3:
-            qlist = self.get_queue_list()
-            for qname in qlist:
-                self.show_config(qname)
-            return
-
-        qname = self.args[2]
-        if len(self.args) == 3:
-            self.show_config(qname)
-            return
-
-        alist = []
-        for el in self.args[3:]:
-            k, v = el.split('=')
-            if k not in config_allowed_list:
-                qk = "queue_" + k
-                if qk not in config_allowed_list:
-                    raise Exception('unknown config var: '+k)
-                k = qk
-            expr = "%s=%s" % (k, skytools.quote_literal(v))
-            alist.append(expr)
-        self.log.info('Change queue %s config to: %s' % (qname, ", ".join(alist)))
-        sql = "update pgq.queue set %s where queue_name = %s" % (
-                        ", ".join(alist), skytools.quote_literal(qname))
-        self.exec_sql(sql, [])
-
-    def exec_sql(self, q, args):
-        self.log.debug(q)
-        db = self.get_database('db')
-        curs = db.cursor()
-        curs.execute(q, args)
-        db.commit()
-
-    def show_config(self, qname):
-        fields = []
-        for f, kind in config_allowed_list.items():
-            if kind == 'interval':
-                sql = "extract('epoch' from %s)::text as %s" % (f, f)
-                fields.append(sql)
-            else:
-                fields.append(f)
-        klist = ", ".join(fields)
-        q = "select " + klist + " from pgq.queue where queue_name = %s"
-
-        db = self.get_database('db')
-        curs = db.cursor()
-        curs.execute(q, [qname])
-        res = curs.dictfetchone()
-        db.commit()
-
-        if res is None:
-            print("no such queue: " + qname)
-            return
-
-        print(qname)
-        for k in config_allowed_list:
-            n = k
-            if k[:6] == "queue_":
-                n = k[6:]
-            print("    %s\t=%7s" % (n, res[k]))
-
-    def get_queue_list(self):
-        db = self.get_database('db')
-        curs = db.cursor()
-        curs.execute("select queue_name from pgq.queue order by 1")
-        rows = curs.fetchall()
-        db.commit()
-        
-        qlist = []
-        for r in rows:
-            qlist.append(r[0])
-        return qlist
-
-if __name__ == '__main__':
-    script = PGQAdmin(sys.argv[1:])
-    script.start()
-
-
-