raw
logotron_genesis.kv     1 #!/usr/bin/python
logotron_genesis.kv     2 
logotron_genesis.kv     3 import ConfigParser, sys, logging, socket, time, re, requests, urllib
logotron_genesis.kv     4 from urllib import quote
logotron_genesis.kv     5 
logotron_genesis.kv     6 # DBism
logotron_genesis.kv     7 import psycopg2, psycopg2.extras
logotron_genesis.kv     8 import psycopg2.extensions
logotron_genesis.kv     9 psycopg2.extensions.register_type(psycopg2.extensions.UNICODE)
logotron_genesis.kv    10 psycopg2.extensions.register_type(psycopg2.extensions.UNICODEARRAY)
logotron_genesis.kv    11 import time, datetime
logotron_genesis.kv    12 from datetime import datetime
logotron_genesis.kv    13 
logotron_genesis.kv    14 ##############################################################################
logotron_genesis.kv    15 
sept_fixes.kv          16 # Version. If changing this program, always set this to same # as in MANIFEST
frontend_updates.kv    17 Ver = 684804
sept_fixes.kv          18 
sept_fixes.kv          19 ##############################################################################
sept_fixes.kv          20 
logotron_genesis.kv    21 cfg = ConfigParser.ConfigParser()
logotron_genesis.kv    22 
logotron_genesis.kv    23 ##############################################################################
logotron_genesis.kv    24 
logotron_genesis.kv    25 # Single mandatory arg: config file path
logotron_genesis.kv    26 if len(sys.argv[1:]) != 1:
logotron_genesis.kv    27     # If no args, print usage and exit:
logotron_genesis.kv    28     print sys.argv[0] + " CONFIG"
logotron_genesis.kv    29     exit(0)
logotron_genesis.kv    30 
logotron_genesis.kv    31 # Read Config
logotron_genesis.kv    32 cfg.readfp(open(sys.argv[1]))
logotron_genesis.kv    33 
logotron_genesis.kv    34 # Get log path
logotron_genesis.kv    35 logpath = cfg.get("bofh", "log")
logotron_genesis.kv    36 
logotron_genesis.kv    37 # Get IRCism debug toggle
logotron_genesis.kv    38 irc_dbg = cfg.get("irc", "irc_dbg")
logotron_genesis.kv    39 if irc_dbg == 1:
logotron_genesis.kv    40     log_lvl = logging.DEBUG
logotron_genesis.kv    41 else:
logotron_genesis.kv    42     log_lvl = logging.INFO
logotron_genesis.kv    43 
logotron_genesis.kv    44 # Init logo
logotron_genesis.kv    45 logging.basicConfig(filename=logpath, filemode='a', level=log_lvl,
logotron_genesis.kv    46                     format='%(asctime)s %(levelname)s %(message)s',
logotron_genesis.kv    47                     datefmt='%d-%b-%y %H:%M:%S')
logotron_genesis.kv    48 
logotron_genesis.kv    49 # Date format used in log lines
logotron_genesis.kv    50 Date_Short_Format = "%Y-%m-%d"
logotron_genesis.kv    51 
logotron_genesis.kv    52 # Date format used in echoes
logotron_genesis.kv    53 Date_Long_Format  = "%Y-%m-%d %H:%M:%S"
logotron_genesis.kv    54 
logotron_genesis.kv    55 ##############################################################################
logotron_genesis.kv    56 # Get the remaining knob values:
logotron_genesis.kv    57 
logotron_genesis.kv    58 try:
logotron_genesis.kv    59     # IRCism:
logotron_genesis.kv    60     Buf_Size    = int(cfg.get("tcp", "bufsize"))
logotron_genesis.kv    61     Timeout     = int(cfg.get("tcp", "timeout"))
logotron_genesis.kv    62     TX_Delay    = float(cfg.get("tcp", "t_delay"))
logotron_genesis.kv    63     Servers     = [x.strip() for x in cfg.get("irc", "servers").split(',')]
logotron_genesis.kv    64     Port        = int(cfg.get("irc", "port"))
logotron_genesis.kv    65     Nick        = cfg.get("irc", "nick")
logotron_genesis.kv    66     Pass        = cfg.get("irc", "pass")
logotron_genesis.kv    67     Channels    = [x.strip() for x in cfg.get("irc", "chans").split(',')]
logotron_genesis.kv    68     Join_Delay  = int(cfg.get("irc", "join_t"))
detect_disconnect.kv   69     Discon_TO   = int(cfg.get("irc", "disc_t"))
logotron_genesis.kv    70     Prefix      = cfg.get("control", "prefix")
logotron_genesis.kv    71     # DBism:
logotron_genesis.kv    72     DB_Name     = cfg.get("db", "db_name")
logotron_genesis.kv    73     DB_User     = cfg.get("db", "db_user")
logotron_genesis.kv    74     DB_DEBUG    = cfg.get("db", "db_debug")
logotron_genesis.kv    75     # Logism:
logotron_genesis.kv    76     Base_URL    = cfg.get("logotron", "base_url")
frontend_updates.kv    77     App_Root    = cfg.get("logotron", "app_root")
logotron_genesis.kv    78     Era         = int(cfg.get("logotron", "era"))
logotron_genesis.kv    79     NewChan_Idx = int(cfg.get("logotron", "newchan_idx"))
logotron_genesis.kv    80     Src_URL     = cfg.get("logotron", "src_url")
logotron_genesis.kv    81 
logotron_genesis.kv    82 except Exception as e:
logotron_genesis.kv    83     print "Invalid config: ", e
logotron_genesis.kv    84     exit(1)
logotron_genesis.kv    85 
logotron_genesis.kv    86 ##############################################################################
logotron_genesis.kv    87 
logotron_genesis.kv    88 # Connect to the given DB
logotron_genesis.kv    89 try:
logotron_genesis.kv    90     db = psycopg2.connect("dbname=%s user=%s" % (DB_Name, DB_User))
logotron_genesis.kv    91 except Exception:
logotron_genesis.kv    92     print "Could not connect to DB!"
logotron_genesis.kv    93     logging.error("Could not connect to DB!")
logotron_genesis.kv    94     exit(1)
logotron_genesis.kv    95 else:
logotron_genesis.kv    96     logging.info("Connected to DB!")
logotron_genesis.kv    97 
logotron_genesis.kv    98 ##############################################################################
logotron_genesis.kv    99 
logotron_genesis.kv   100 def close_db():
logotron_genesis.kv   101     db.close()
logotron_genesis.kv   102 
logotron_genesis.kv   103 def exec_db(query, args=()):
logotron_genesis.kv   104     cur = db.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
logotron_genesis.kv   105     if (DB_DEBUG): logging.debug("query: '{0}'".format(query))
logotron_genesis.kv   106     if (DB_DEBUG): logging.debug("args: '{0}'".format(args))
logotron_genesis.kv   107     cur.execute(query, args)
logotron_genesis.kv   108 
logotron_genesis.kv   109 def query_db(query, args=(), one=False):
logotron_genesis.kv   110     cur = db.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
logotron_genesis.kv   111     if (DB_DEBUG): logging.debug("query: '{0}'".format(query))
logotron_genesis.kv   112     cur.execute(query, args)
logotron_genesis.kv   113     rv = cur.fetchone() if one else cur.fetchall()
logotron_genesis.kv   114     if (DB_DEBUG): logging.debug("query res: '{0}'".format(rv))
logotron_genesis.kv   115     return rv
logotron_genesis.kv   116 
logotron_genesis.kv   117 def rollback_db():
logotron_genesis.kv   118     cur = db.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
logotron_genesis.kv   119     cur.execute("ROLLBACK")
logotron_genesis.kv   120     db.commit()
logotron_genesis.kv   121 
logotron_genesis.kv   122 def commit_db():
logotron_genesis.kv   123     cur = db.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
logotron_genesis.kv   124     db.commit()
logotron_genesis.kv   125 
logotron_genesis.kv   126 
logotron_genesis.kv   127 ##############################################################################
logotron_genesis.kv   128 # IRCism
logotron_genesis.kv   129 ##############################################################################
logotron_genesis.kv   130 
logotron_genesis.kv   131 # Used to compute 'uptime'
logotron_genesis.kv   132 time_last_conn = datetime.now()
logotron_genesis.kv   133 
detect_disconnect.kv  134 # Used to monitor disconnection timeout
detect_disconnect.kv  135 time_last_recv = datetime.now()
detect_disconnect.kv  136 
active_disconnect...  137 # Socket will be here:
active_disconnect...  138 sock = None;
logotron_genesis.kv   139 
logotron_genesis.kv   140 # Initially we are not connected to anything
logotron_genesis.kv   141 connected = False
logotron_genesis.kv   142 
active_disconnect...  143 def init_socket():
active_disconnect...  144     global sock
active_disconnect...  145     sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
frontend_updates.kv   146 
active_disconnect...  147     # Disable Nagle's algorithm for transmit operations
active_disconnect...  148     sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
active_disconnect...  149     # Disable Nagle's algorithm for receive operation, Linux-only
active_disconnect...  150     try:
active_disconnect...  151         sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_QUICKACK, 1)
active_disconnect...  152     except Exception as e:
active_disconnect...  153         logging.warning(e)
frontend_updates.kv   154 
active_disconnect...  155     connected = False
active_disconnect...  156 
active_disconnect...  157 def deinit_socket():
active_disconnect...  158     global connected
active_disconnect...  159     global sock
active_disconnect...  160     sock.close()
active_disconnect...  161     connected = False
active_disconnect...  162 
logotron_genesis.kv   163 # Connect to given host:port; return whether connected
logotron_genesis.kv   164 def connect(host, port):
logotron_genesis.kv   165     logging.info("Connecting to %s:%s" % (host, port))
logotron_genesis.kv   166     sock.settimeout(Timeout)
logotron_genesis.kv   167     try:
logotron_genesis.kv   168         sock.connect((host, port))
logotron_genesis.kv   169     except (socket.timeout, socket.error) as e:
logotron_genesis.kv   170         logging.warning(e)
logotron_genesis.kv   171         return False
logotron_genesis.kv   172     except Exception as e:
logotron_genesis.kv   173         logging.exception(e)
logotron_genesis.kv   174         return False
logotron_genesis.kv   175     else:
logotron_genesis.kv   176         logging.info("Connected.")
logotron_genesis.kv   177         return True
logotron_genesis.kv   178 
logotron_genesis.kv   179 
logotron_genesis.kv   180 # Attempt connect to each of hosts, in order, on port; return whether connected
logotron_genesis.kv   181 def connect_any(hosts, port):
logotron_genesis.kv   182     for host in hosts:
logotron_genesis.kv   183         if connect(host, port):
logotron_genesis.kv   184             return True
logotron_genesis.kv   185     return False
logotron_genesis.kv   186 
logotron_genesis.kv   187 
logotron_genesis.kv   188 # Transmit IRC message
logotron_genesis.kv   189 def send(message):
logotron_genesis.kv   190     global connected
logotron_genesis.kv   191     if not connected:
logotron_genesis.kv   192         logging.warning("Tried to send while disconnected?")
logotron_genesis.kv   193         return False
logotron_genesis.kv   194     time.sleep(TX_Delay)
logotron_genesis.kv   195     logging.debug("> '%s'" % message)
logotron_genesis.kv   196     message = "%s\r\n" % message
logotron_genesis.kv   197     try:
logotron_genesis.kv   198         sock.send(message.encode("utf-8"))
logotron_genesis.kv   199     except (socket.timeout, socket.error) as e:
logotron_genesis.kv   200         logging.warning("Socket could not send! Disconnecting.")
active_disconnect...  201         deinit_socket()
logotron_genesis.kv   202         return False
logotron_genesis.kv   203     except Exception as e:
logotron_genesis.kv   204         logging.exception(e)
logotron_genesis.kv   205         return False
logotron_genesis.kv   206 
logotron_genesis.kv   207 
logotron_genesis.kv   208 # Speak given message on a selected channel
logotron_genesis.kv   209 def speak(channel, message):
logotron_genesis.kv   210     send("PRIVMSG #%s :%s" % (channel, message))
logotron_genesis.kv   211     # Now save what the bot spoke:
logotron_genesis.kv   212     save_line(datetime.now(), channel, Nick, False, message)
logotron_genesis.kv   213 
logotron_genesis.kv   214 
logotron_genesis.kv   215 # Standard incoming IRC line (excludes fleanode liquishit, etc)
logotron_genesis.kv   216 irc_line_re = re.compile("""^:([^!]+)\!\S+\s+PRIVMSG\s+\#(\S+)\s+\:(.*)""")
logotron_genesis.kv   217 
logotron_genesis.kv   218 # The '#' prevents interaction via PM, this is not a PM-able bot.
logotron_genesis.kv   219 
logotron_genesis.kv   220 # 'Actions'
logotron_genesis.kv   221 irc_act_re = re.compile(""".*ACTION\s+(.*)""")
logotron_genesis.kv   222 
logotron_genesis.kv   223 
logotron_genesis.kv   224 # A line was received from IRC
logotron_genesis.kv   225 def received_line(line):
logotron_genesis.kv   226     # Process the traditional pingpong
logotron_genesis.kv   227     if line.startswith("PING"):
logotron_genesis.kv   228         send("PONG " + line.split()[1])
logotron_genesis.kv   229     else:
logotron_genesis.kv   230         logging.debug("< '%s'" % line)
logotron_genesis.kv   231         standard_line = re.search(irc_line_re, line)
logotron_genesis.kv   232         if standard_line:
logotron_genesis.kv   233             # Break this line into the standard segments
logotron_genesis.kv   234             (user, chan, text) = [s.strip() for s in standard_line.groups()]
logotron_genesis.kv   235             # Determine whether this line is an 'action' :
logotron_genesis.kv   236             action = False
logotron_genesis.kv   237             act = re.search(irc_act_re, line)
logotron_genesis.kv   238             if act:
logotron_genesis.kv   239                 action = True
logotron_genesis.kv   240                 text = act.group(1)
sept_fixes.kv         241                 # Remove turd if present:
sept_fixes.kv         242                 if text[-1:] == '\x01':
sept_fixes.kv         243                     text = text[:-1]
logotron_genesis.kv   244             # This line is edible, process it.
logotron_genesis.kv   245             eat_logline(user, chan, text, action)
logotron_genesis.kv   246 
logotron_genesis.kv   247 
logotron_genesis.kv   248 # IRCate until we get disconnected
logotron_genesis.kv   249 def irc():
logotron_genesis.kv   250     global connected
uptimefix_bye_cac...  251     global time_last_conn
detect_disconnect.kv  252     global time_last_recv
active_disconnect...  253     global sock
frontend_updates.kv   254 
active_disconnect...  255     # Initialize a socket
active_disconnect...  256     init_socket()
frontend_updates.kv   257 
logotron_genesis.kv   258     # Connect to one among the specified servers, in given priority :
logotron_genesis.kv   259     while not connected:
logotron_genesis.kv   260         connected = connect_any(Servers, Port)
logotron_genesis.kv   261 
logotron_genesis.kv   262     # Save time of last successful connect
logotron_genesis.kv   263     time_last_conn = datetime.now()
frontend_updates.kv   264 
logotron_genesis.kv   265     # Auth to server
logotron_genesis.kv   266     send("NICK %s\r\n" % Nick)
logotron_genesis.kv   267     send("USER %s %s %s :%s\r\n" % (Nick, Nick, Nick, Nick))
frontend_updates.kv   268 
uniturds_etc.kv       269     # If this is a production bot, rather than test, there will be a PW:
uniturds_etc.kv       270     if Pass != "":
uniturds_etc.kv       271         send("NICKSERV IDENTIFY %s %s\r\n" % (Nick, Pass))
frontend_updates.kv   272 
logotron_genesis.kv   273     time.sleep(Join_Delay) # wait to join until fleanode eats auth
frontend_updates.kv   274 
logotron_genesis.kv   275     # Join selected channels
logotron_genesis.kv   276     for chan in Channels:
logotron_genesis.kv   277         logging.info("Joining channel '%s'..." % chan)
logotron_genesis.kv   278         send("JOIN #%s\r\n" % chan)
frontend_updates.kv   279 
logotron_genesis.kv   280     while connected:
logotron_genesis.kv   281         try:
logotron_genesis.kv   282             data = sock.recv(Buf_Size)
detect_disconnect.kv  283             time_last_recv = datetime.now() # Received anything -- reset timer
logotron_genesis.kv   284         except socket.timeout as e:
active_disconnect...  285             logging.debug("Receive timed out")
detect_disconnect.kv  286             # Determine whether the connection has timed out:
detect_disconnect.kv  287             since_recv = (datetime.now() - time_last_recv).seconds
detect_disconnect.kv  288             if since_recv > Discon_TO:
detect_disconnect.kv  289                 logging.info("Exceeded %d seconds of silence " % Discon_TO
detect_disconnect.kv  290                              + "from server: disconnecting!")
detect_disconnect.kv  291                 deinit_socket()
logotron_genesis.kv   292             continue
logotron_genesis.kv   293         except socket.error as e:
active_disconnect...  294             logging.warning("Receive socket error, disconnecting.")
active_disconnect...  295             deinit_socket()
logotron_genesis.kv   296             continue
logotron_genesis.kv   297         except Exception as e:
logotron_genesis.kv   298             logging.exception(e)
active_disconnect...  299             deinit_socket()
logotron_genesis.kv   300             continue
logotron_genesis.kv   301         else:
logotron_genesis.kv   302             if len(data) == 0:
active_disconnect...  303                 logging.warning("Receive socket closed, disconnecting.")
active_disconnect...  304                 deinit_socket()
logotron_genesis.kv   305                 continue
logotron_genesis.kv   306             try:
uniturds_etc.kv       307                 try:
uniturds_etc.kv       308                     data = data.strip(b'\r\n').decode("utf-8")
uniturds_etc.kv       309                 except UnicodeDecodeError:
uniturds_etc.kv       310                     data = data.strip(b'\r\n').decode('latin-1')
logotron_genesis.kv   311                 for l in data.splitlines():
logotron_genesis.kv   312                     received_line(l)
logotron_genesis.kv   313                 continue
logotron_genesis.kv   314             except Exception as e:
logotron_genesis.kv   315                 logging.exception(e)
logotron_genesis.kv   316                 continue
logotron_genesis.kv   317 
logotron_genesis.kv   318 ##############################################################################
logotron_genesis.kv   319 
logotron_genesis.kv   320 html_escape_table = {
logotron_genesis.kv   321     "&": "&amp;",
logotron_genesis.kv   322     '"': "&quot;",
logotron_genesis.kv   323     "'": "&apos;",
logotron_genesis.kv   324     ">": "&gt;",
logotron_genesis.kv   325     "<": "&lt;",
logotron_genesis.kv   326 }
logotron_genesis.kv   327 
logotron_genesis.kv   328 def html_escape(text):
logotron_genesis.kv   329     res = ("".join(html_escape_table.get(c,c) for c in text))
logotron_genesis.kv   330     return urllib.quote(res.encode('utf-8'))
logotron_genesis.kv   331 
logotron_genesis.kv   332 
logotron_genesis.kv   333 searcher_re = re.compile("""(\d+) Results""")
logotron_genesis.kv   334 
logotron_genesis.kv   335 # Retrieve a search result count using the WWWistic frontend.
logotron_genesis.kv   336 # This way it is not necessary to have query parser in two places.
logotron_genesis.kv   337 # However it is slightly wasteful of CPU (requires actually loading results.)
logotron_genesis.kv   338 def get_search_res(chan, query):
logotron_genesis.kv   339     try:
logotron_genesis.kv   340         esc_q = html_escape(query)
logotron_genesis.kv   341         url = Base_URL + "log-search?q=" + esc_q + "&chan=" + chan
logotron_genesis.kv   342         res = requests.get(url).text
logotron_genesis.kv   343         t = res[res.find('<title>') + 7 : res.find('</title>')].strip()
logotron_genesis.kv   344         found = searcher_re.match(t)
logotron_genesis.kv   345         if found:
logotron_genesis.kv   346             output = "[" + url + "]" + "[" + found.group(1)
logotron_genesis.kv   347             output += """ results for "%s" in #%s]""" % (query, chan)
logotron_genesis.kv   348             return output
logotron_genesis.kv   349         else:
logotron_genesis.kv   350             return """No results found for "%s" in #%s""" % (query, chan)
logotron_genesis.kv   351     except Exception as e:
logotron_genesis.kv   352         logging.exception(e)
logotron_genesis.kv   353         return "No results returned (is logotron WWW up ?)"
logotron_genesis.kv   354 
logotron_genesis.kv   355 ##############################################################################
logotron_genesis.kv   356 
sept_fixes.kv         357 # Get perma-URL corresponding to given log line
sept_fixes.kv         358 def line_url(l):
frontend_updates.kv   359     return "{0}{1}{2}/{3}#{4}".format(Base_URL,
frontend_updates.kv   360                                        App_Root,
sept_fixes.kv         361                                        l['chan'],
sept_fixes.kv         362                                        l['t'].strftime(Date_Short_Format),
sept_fixes.kv         363                                        l['idx'])
sept_fixes.kv         364 
sept_fixes.kv         365 ##############################################################################
sept_fixes.kv         366 
logotron_genesis.kv   367 # Commands:
logotron_genesis.kv   368 
logotron_genesis.kv   369 def cmd_help(arg, user, chan):
logotron_genesis.kv   370     # Speak the 'help' text
logotron_genesis.kv   371     speak(chan, "%s: my valid commands are: %s" %
logotron_genesis.kv   372           (user, ', '.join(Commands.keys())));
logotron_genesis.kv   373 
logotron_genesis.kv   374 def cmd_search(arg, user, chan):
logotron_genesis.kv   375     logging.debug("search: '%s'" % arg)
logotron_genesis.kv   376     speak(chan, get_search_res(chan, arg))
logotron_genesis.kv   377 
logotron_genesis.kv   378 def cmd_seen(arg, user, chan):
sept_fixes.kv         379     # Empty query is prohibited:
sept_fixes.kv         380     if arg == "":
sept_fixes.kv         381         speak(chan, "Required argument: USER")
sept_fixes.kv         382         return
frontend_updates.kv   383 
sept_fixes.kv         384     # Perform query:
sept_fixes.kv         385     seen_line = query_db(
sept_fixes.kv         386         '''select t, idx, payload, chan from loglines where
sept_fixes.kv         387         chan=%s and speaker=%s order by t desc limit 1;''',
sept_fixes.kv         388         [chan, arg], one=True)
sept_fixes.kv         389 
sept_fixes.kv         390     # Where output will go
sept_fixes.kv         391     result = ""
frontend_updates.kv   392 
sept_fixes.kv         393     # If user has been seen in THE CURRENT chan:
sept_fixes.kv         394     if seen_line != None:
sept_fixes.kv         395         time_txt = seen_line['t'].strftime(Date_Long_Format)
sept_fixes.kv         396         time_link = "[%s][%s]" % (line_url(seen_line), time_txt)
sept_fixes.kv         397         seen_line = "%s last seen here on %s: %s" % (arg,
sept_fixes.kv         398                                                      time_link,
sept_fixes.kv         399                                                      seen_line['payload'])
sept_fixes.kv         400         result = seen_line
sept_fixes.kv         401     else:
sept_fixes.kv         402         # If user has never been seen in this chan:
sept_fixes.kv         403         result = "The user %s has never been seen in #%s." % (arg, chan)
frontend_updates.kv   404 
sept_fixes.kv         405     # Speak the result into the chan where command was issued
sept_fixes.kv         406     speak(chan, result)
sept_fixes.kv         407 
sept_fixes.kv         408 def cmd_seen_anywhere(arg, user, chan):
sept_fixes.kv         409     # Empty query is prohibited:
sept_fixes.kv         410     if arg == "":
sept_fixes.kv         411         speak(chan, "Required argument: USER")
sept_fixes.kv         412         return
frontend_updates.kv   413 
sept_fixes.kv         414     # Perform query:
sept_fixes.kv         415     seen_line = query_db(
sept_fixes.kv         416         '''select t, idx, payload, chan from loglines where speaker=%s
sept_fixes.kv         417         order by t desc limit 1;''',
sept_fixes.kv         418         [arg], one=True)
sept_fixes.kv         419 
sept_fixes.kv         420     # Where output will go
sept_fixes.kv         421     result = ""
frontend_updates.kv   422 
sept_fixes.kv         423     # If user has been seen in ANY logged chan:
sept_fixes.kv         424     if seen_line != None:
sept_fixes.kv         425         time_txt = seen_line['t'].strftime(Date_Long_Format)
sept_fixes.kv         426         time_link = "[%s][%s]" % (line_url(seen_line), time_txt)
sept_fixes.kv         427         seen_line = "%s last seen in #%s on %s: %s" % (arg,
sept_fixes.kv         428                                                        seen_line['chan'],
sept_fixes.kv         429                                                        time_link,
sept_fixes.kv         430                                                        seen_line['payload'])
sept_fixes.kv         431         result = seen_line
sept_fixes.kv         432     else:
sept_fixes.kv         433         # If user has never been seen at all:
sept_fixes.kv         434         result = "The user %s has never been seen by this logger." % arg
sept_fixes.kv         435 
sept_fixes.kv         436     # Speak the result into the chan where command was issued
sept_fixes.kv         437     speak(chan, result)
sept_fixes.kv         438 
sept_fixes.kv         439 def cmd_version(arg, user, chan):
sept_fixes.kv         440     speak(chan, "I am bot version %s." % Ver);
logotron_genesis.kv   441 
logotron_genesis.kv   442 def cmd_src(arg, user, chan):
logotron_genesis.kv   443     speak(chan, "%s: my source code can be seen at: %s" % (user, Src_URL));
logotron_genesis.kv   444 
logotron_genesis.kv   445 def cmd_uptime(arg, user, chan):
logotron_genesis.kv   446     uptime_txt = ""
logotron_genesis.kv   447     uptime = (datetime.now() - time_last_conn)
logotron_genesis.kv   448     days = uptime.days
logotron_genesis.kv   449     hours = uptime.seconds/3600
logotron_genesis.kv   450     minutes = (uptime.seconds%3600)/60
logotron_genesis.kv   451     uptime_txt += '%dd ' % days
logotron_genesis.kv   452     uptime_txt += '%dh ' % hours
logotron_genesis.kv   453     uptime_txt += '%dm' % minutes
logotron_genesis.kv   454     # Speak the uptime
logotron_genesis.kv   455     speak(chan, "%s: time since my last reconnect : %s" %
logotron_genesis.kv   456           (user, uptime_txt));
logotron_genesis.kv   457 
logotron_genesis.kv   458 Commands = {
sept_fixes.kv         459     "help"          :  cmd_help,
sept_fixes.kv         460     "s"             :  cmd_search,
sept_fixes.kv         461     "seen"          :  cmd_seen,
sept_fixes.kv         462     "seen-anywhere" :  cmd_seen_anywhere,
sept_fixes.kv         463     "uptime"        :  cmd_uptime,
sept_fixes.kv         464     "src"           :  cmd_src,
sept_fixes.kv         465     "version"       :  cmd_version
logotron_genesis.kv   466 }
logotron_genesis.kv   467 
logotron_genesis.kv   468 ##############################################################################
logotron_genesis.kv   469 
logotron_genesis.kv   470 # Save given line to perma-log
logotron_genesis.kv   471 def save_line(time, chan, speaker, action, payload):
logotron_genesis.kv   472     ## Put in DB:
logotron_genesis.kv   473     try:
logotron_genesis.kv   474         # Get index of THIS new line to be saved
logotron_genesis.kv   475         last_idx = query_db(
logotron_genesis.kv   476             '''select idx from loglines where chan=%s
logotron_genesis.kv   477             and idx = (select max(idx) from loglines where chan=%s) ;''',
logotron_genesis.kv   478             [chan, chan], one=True)
frontend_updates.kv   479 
logotron_genesis.kv   480         # Was this chan unseen previously?
logotron_genesis.kv   481         if last_idx == None:
logotron_genesis.kv   482             cur_idx = NewChan_Idx # Then use the config'd start index
logotron_genesis.kv   483         else:
logotron_genesis.kv   484             cur_idx = last_idx['idx'] + 1 # Otherwise, get the next idx
frontend_updates.kv   485 
logotron_genesis.kv   486         logging.debug("Adding log line with index: %s" % cur_idx)
logotron_genesis.kv   487 
logotron_genesis.kv   488         # Set up the insert
logotron_genesis.kv   489         exec_db('''insert into loglines (idx, t, chan, era,
logotron_genesis.kv   490         speaker, self, payload) values (%s, %s, %s, %s, %s, %s, %s) ; ''',
logotron_genesis.kv   491                 [cur_idx, time, chan, Era, speaker, action, payload])
frontend_updates.kv   492 
logotron_genesis.kv   493         # Fire
logotron_genesis.kv   494         commit_db()
logotron_genesis.kv   495     except Exception as e:
logotron_genesis.kv   496         rollback_db()
logotron_genesis.kv   497         logging.warning("DB add failed, rolled back.")
logotron_genesis.kv   498         logging.exception(e)
logotron_genesis.kv   499 
logotron_genesis.kv   500 
logotron_genesis.kv   501 # RE for finding log refs
frontend_updates.kv   502 if App_Root == '/':
frontend_updates.kv   503     logref_re = re.compile(Base_URL + """([^/]+)/[^/]+#(\d+)""")
frontend_updates.kv   504 else:
frontend_updates.kv   505     logref_re = re.compile(Base_URL + App_Root.strip('/') + """\/([^/]+)/[^/]+#(\d+)""")
logotron_genesis.kv   506 
logotron_genesis.kv   507 # All valid received lines end up here
logotron_genesis.kv   508 def eat_logline(user, chan, text, action):
logotron_genesis.kv   509     # If somehow received line from channel which isn't in the set:
logotron_genesis.kv   510     if chan not in Channels:
logotron_genesis.kv   511         logging.warning(
logotron_genesis.kv   512             "Received martian : '%s' : '%s'" % (chan, text))
logotron_genesis.kv   513         return
frontend_updates.kv   514 
logotron_genesis.kv   515     # First, add the line to the log:
logotron_genesis.kv   516     save_line(datetime.now(), chan, user, action, text)
frontend_updates.kv   517 
logotron_genesis.kv   518     # Then, see if the line was a command for this bot:
logotron_genesis.kv   519     if text.startswith(Prefix):
logotron_genesis.kv   520         cmd = text.partition(Prefix)[2].strip()
logotron_genesis.kv   521         cmd = [x.strip() for x in cmd.split(' ', 1)]
logotron_genesis.kv   522         if len(cmd) == 1:
logotron_genesis.kv   523             arg = ""
logotron_genesis.kv   524         else:
logotron_genesis.kv   525             arg = cmd[1]
logotron_genesis.kv   526         # Dispatch this command...
logotron_genesis.kv   527         command = cmd[0]
logotron_genesis.kv   528         logging.debug("Dispatching command '%s' with arg '%s'.." %
logotron_genesis.kv   529                       (command, arg))
logotron_genesis.kv   530         func = Commands.get(command)
logotron_genesis.kv   531         # If this command is undefined:
logotron_genesis.kv   532         if func == None:
logotron_genesis.kv   533             logging.debug("Invalid command: %s" % command)
logotron_genesis.kv   534             # Utter the 'help' text as response to the sad command
logotron_genesis.kv   535             cmd_help("", user, chan)
logotron_genesis.kv   536         else:
logotron_genesis.kv   537             # Is defined command, dispatch it:
logotron_genesis.kv   538             func(arg, user, chan)
logotron_genesis.kv   539     else:
logotron_genesis.kv   540         # Finally, see if contains log refs:
logotron_genesis.kv   541         for ref in re.findall(logref_re, text):
sept_fixes.kv         542             ref_chan, ref_idx = ref
logotron_genesis.kv   543             # Find this line in DB:
logotron_genesis.kv   544             ref_line = query_db(
logotron_genesis.kv   545                 '''select t, speaker, payload from loglines
logotron_genesis.kv   546                 where chan=%s and idx=%s;''',
logotron_genesis.kv   547                 [ref_chan, ref_idx], one=True)
logotron_genesis.kv   548             # If retrieved line is valid, echo it:
logotron_genesis.kv   549             if ref_line != None:
sept_fixes.kv         550                 # If referred line was spoken in THIS chan:
sept_fixes.kv         551                 if ref_chan == chan:
sept_fixes.kv         552                     time_txt = ref_line['t'].strftime(Date_Long_Format)
sept_fixes.kv         553                     my_line = "Logged on %s %s: %s" % (time_txt,
sept_fixes.kv         554                                                        ref_line['speaker'],
sept_fixes.kv         555                                                        ref_line['payload'])
sept_fixes.kv         556                 else:
sept_fixes.kv         557                     # If this is a cross-chan echo:
sept_fixes.kv         558                     time_txt = ref_line['t'].strftime(Date_Short_Format)
sept_fixes.kv         559                     my_line = "(%s) %s %s: %s" % (ref_chan,
sept_fixes.kv         560                                                   time_txt,
sept_fixes.kv         561                                                   ref_line['speaker'],
sept_fixes.kv         562                                                   ref_line['payload'])
frontend_updates.kv   563 
logotron_genesis.kv   564                 # Speak the line echo into the chan where ref was seen
logotron_genesis.kv   565                 speak(chan, my_line)
logotron_genesis.kv   566 
logotron_genesis.kv   567 ##############################################################################
logotron_genesis.kv   568 
logotron_genesis.kv   569 # IRCate; if disconnected, reconnect
logotron_genesis.kv   570 def run():
logotron_genesis.kv   571     while 1:
logotron_genesis.kv   572         irc()
logotron_genesis.kv   573         logging.warning("Disconnected, will reconnect...")
logotron_genesis.kv   574 
logotron_genesis.kv   575 ##############################################################################
logotron_genesis.kv   576 
logotron_genesis.kv   577 # Run continuously.
logotron_genesis.kv   578 run()
logotron_genesis.kv   579 
logotron_genesis.kv   580 ##############################################################################