Implement a fairly naive sqlite listener and test

Author: hardbyte

can/CAN.py

@@ -11,6 +11,7 @@
 from datetime import datetime
 import time
 import base64
+import sqlite3
 
 try:
     import queue
@@ -161,17 +162,68 @@ def stop(self):
 
 
 class SqliteWriter(Listener):
-    """TODO"""
+    """Logs received CAN data to a simple SQL database.
+
+    The sqlite database may already exist, otherwise it will
+    be created when the first message arrives.
+    """
+
+    insert_msg_template = '''
+        INSERT INTO messages VALUES
+        (?, ?, ?, ?, ?, ?, ?)
+        '''
 
     def __init__(self, filename):
-        self.db_file = open(filename, 'wt')
+        self.db_fn = filename
+        self.db_setup = False
+
+    def _create_db(self):
+        # Note you can't share sqlite3 connections between threads
+        # hence we setup the db here.
+        log.info("Creating sqlite db")
+        self.conn = sqlite3.connect(self.db_fn)
+        c = self.conn.cursor()
 
         # create table structure
-        raise NotImplementedError("TODO")
+        c.execute('''
+        CREATE TABLE IF NOT EXISTS messages
+        (
+          ts REAL,
+          arbitration_id INTEGER,
+          extended INTEGER,
+          remote INTEGER,
+          error INTEGER,
+          dlc INTEGER,
+          data BLOB
+        )
+        ''')
+        self.conn.commit()
+
+        self.db_setup = True
 
     def on_message_received(self, msg):
-        # add row
-        raise NotImplementedError("TODO")
+        if not self.db_setup:
+            self._create_db()
+
+        # add row to db
+        row_data = (
+            msg.timestamp,
+            msg.arbitration_id,
+            msg.id_type,
+            msg.is_remote_frame,
+            msg.is_error_frame,
+            msg.dlc,
+            msg.data
+        )
+        c = self.conn.cursor()
+        c.execute(SqliteWriter.insert_msg_template, row_data)
+
+        self.conn.commit()
+
+    def stop(self):
+        if self.db_setup:
+            self.conn.commit()
+            self.conn.close()
 
 
 class ASCWriter(Listener):

can/interfaces/interface.py

@@ -10,6 +10,9 @@ class Bus(object):
     """
     Instantiates a CAN Bus of the given `bustype`, falls back to reading a
     configuration file from default locations.
+
+    :raises: NotImplementedError if the bustype isn't recognized
+
     """
 
     @classmethod

test/listener_test.py

@@ -1,11 +1,12 @@
 from time import sleep
 import unittest
 import random
-
+import logging
+import tempfile
 
 import can
 
-import logging
+
 logging.getLogger("").setLevel(logging.DEBUG)
 
 
@@ -50,6 +51,19 @@ def testBufferedListenerReceives(self):
         m = a_listener.get_message(0.2)
         self.assertIsNotNone(m)
 
+    def testSQLWriterReceives(self):
+        f = tempfile.NamedTemporaryFile('w')
+        a_listener = can.SqliteWriter(f.name)
+        a_listener(generate_message(0xDADADA))
+        a_listener.stop()
+
+        import sqlite3
+        con = sqlite3.connect(f.name)
+        c = con.cursor()
+        c.execute("select * from messages")
+        msg = c.fetchone()
+        assert msg[1] == 0xDADADA
+
     def testAscListener(self):
         a_listener = can.ASCWriter("test.asc")
         notifier = can.Notifier(self.bus, [a_listener], 0.1)