CHANGELOG.md: Move unreleased changes to v0.5.0

We only need Solr in the indexing component, not for the API itself.

.travis.yml

@@ -0,0 +1,11 @@
+language: python
+python:
+  - "3.5"
+  - "3.6"
+  - "3.7-dev"
+script: pip install -r requirements.txt
+branches:
+  only:
+    - master
+
+# vim: ts=2 sw=2 et

CHANGELOG.md

@@ -4,6 +4,89 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+### [0.5.0] - 2018-10-24
+## Added
+- Example nginx configuration to README.md
+
+## Changed
+- Don't initialize Solr connection in API
+
+### [0.4.3] - 2018-10-17
+## Changed
+- Use pip install as script for Travis CI
+
+## Improved
+- Documentation for deployment and testing
+
+## [0.4.2] - 2018-10-04
+### Changed
+- README.md introduction and requirements
+- Use ujson instead of json
+- Iterate directly on SQL cursor in `/items` route
+
+### Fixed
+- Logic error in SQL for item views
+
+## [0.4.1] - 2018-09-26
+### Changed
+- Use execute_values() to batch insert records to PostgreSQL
+
+## [0.4.0] - 2018-09-25
+### Fixed
+- Invalid OnCalendar syntax in dspace-statistics-indexer.timer
+- Major logic error in indexer.py
+
+## [0.3.2] - 2018-09-25
+## Changed
+- /item/id route now returns HTTP 404 if an item is not found
+
+## [0.3.1] - 2018-09-25
+### Changed
+- Force SolrClient's kazoo dependency to version 2.5.0 to work with Python 3.7
+- Add Python 3.7 to Travis CI configuration
+
+## [0.3.0] - 2018-09-25
+### Added
+- requirements.txt for pip
+- Travis CI build configuration for Python 3.5 and 3.6
+- Documentation on using the API
+
+### Changed
+- The "all items" route from / to /items
+
+## [0.2.1] - 2018-09-24
+### Changed
+- Environment settings in example systemd unit files
+- Use psycopg2.extras.DictCursor for PostgreSQL connection
+
+## [0.2.0] - 2018-09-24
+### Changed
+- Use PostgreSQL instead of SQLite because UPSERT support needs a very new libsqlite3 whereas it's already in PostgreSQL 9.5+
+
+## [0.1.0] - 2018-09-24
+### Changed
+- Rename project to "DSpace Statistics API"
+- Use read-only database connection in API
+- Update systemd units for CGSpace→DSpace rename
+- Use UPSERT to simplify database schema and Python logic
+
+### Added
+- Example systemd service and timer unit for indexer service
+- Add top-level route to expose all item statistics
+
+### Removed
+- Ability to customize SOLR_CORE variable
+
+## [0.0.4] - 2018-09-23
+### Added
+- Added example systemd unit file for API
+- Added indexer.py to ingest views and downloads from Solr to a SQLite database
+
+### Changed
+- Refactor Solr configuration and connection
+- /item route now expects id as part of the URI instead of a query parameter: /item/id
+- View and download stats are now fetched from a SQLite database
+
 ## [0.0.3] - 2018-09-20
 ### Changed
 - Refactor environment variables into config module

README.md

@@ -1,19 +1,79 @@
-# CGSpace Statistics API
-A quick and dirty REST API to expose Solr view and download statistics for items in a DSpace repository.
+# DSpace Statistics API [![Build Status](https://travis-ci.org/alanorth/dspace-statistics-api.svg?branch=master)](https://travis-ci.org/alanorth/dspace-statistics-api)
+A simple REST API to expose Solr view and download statistics for items in a DSpace repository. This project contains a standalone indexing component and a WSGI application.
 
-Written and tested in Python 3.6. SolrClient (0.2.1) does not currently run in Python 3.7.0.
+## Requirements
 
-## Installation
-Create a virtual environment and run it:
+- Python 3.5+
+- PostgreSQL version 9.5+ (due to [`UPSERT` support](https://wiki.postgresql.org/wiki/UPSERT))
+- DSpace 4+ with [Solr usage statistics enabled](https://wiki.duraspace.org/display/DSDOC5x/SOLR+Statistics)
 
-    $ virtualenv -p /usr/bin/python3.6 venv
+## Installation and Testing
+Create a Python virtual environment and install the dependencies:
+
+    $ python -m venv venv
     $ . venv/bin/activate
-    $ pip install falcon gunicorn SolrClient
+    $ pip install -r requirements.txt
+
+Set up the environment variables for Solr and PostgreSQL:
+
+    $ export SOLR_SERVER=http://localhost:8080/solr
+    $ export DATABASE_NAME=dspacestatistics
+    $ export DATABASE_USER=dspacestatistics
+    $ export DATABASE_PASS=dspacestatistics
+    $ export DATABASE_HOST=localhost
+
+Index the Solr statistics core to populate the PostgreSQL database:
+
+    $ ./indexer.py
+
+Run the REST API:
+
     $ gunicorn app:api
 
+Test to see if there are any statistics:
+
+    $ curl 'http://localhost:8000/items?limit=1'
+
+## Deployment
+There are example systemd service and timer units in the `contrib` directory. The API service listens on localhost by default so you will need to expose it publicly using a web server like nginx.
+
+An example nginx configuration is:
+
+```
+server {
+    #...
+
+    location ~ /rest/statistics/?(.*) {
+        access_log /var/log/nginx/statistics.log;
+        proxy_pass http://statistics_api/$1$is_args$args;
+    }
+}
+
+upstream statistics_api {
+    server 127.0.0.1:5000;
+}
+```
+
+This would expose the API at `/rest/statistics`.
+
+## Using the API
+The API exposes the following endpoints:
+
+  - GET `/items` — return views and downloads for all items that Solr knows about¹. Accepts `limit` and `page` query parameters for pagination of results.
+  - GET `/item/id` — return views and downloads for a single item (*id* must be a positive integer). Returns HTTP 404 if an item id is not found.
+
+¹ We are querying the Solr statistics core, which technically only knows about items that have either views or downloads.
+
 ## Todo
 
-- Ability to return a paginated list of items (on a different route?)
+- Add API documentation
+- Close DB connection when gunicorn shuts down gracefully
+- Better logging
+- Tests
+- Check if database exists (try/except)
+- Version API
+- Use JSON in PostgreSQL
+- Switch to [Python 3.6+ f-string syntax](https://realpython.com/python-f-strings/)
 
 ## License
 This work is licensed under the [GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html).

app.py

@@ -1,44 +1,73 @@
-# Tested with Python 3.6
-# See DSpace Solr docs for tips about parameters
-# https://wiki.duraspace.org/display/DSPACE/Solr
-
-from config import SOLR_SERVER
-from config import SOLR_CORE
+from database import database_connection
 import falcon
-from SolrClient import SolrClient
 
+db = database_connection()
+db.set_session(readonly=True)
 
-class ItemResource:
+class AllItemsResource:
     def on_get(self, req, resp):
         """Handles GET requests"""
         # Return HTTPBadRequest if id parameter is not present and valid
-        item_id = req.get_param_as_int("id", required=True, min=0)
+        limit = req.get_param_as_int("limit", min=0, max=100) or 100
+        page = req.get_param_as_int("page", min=0) or 0
+        offset = limit * page
 
-        solr = SolrClient(SOLR_SERVER)
+        cursor = db.cursor()
 
-        # Get views
-        res = solr.query(SOLR_CORE, {
-            'q':'type:2 AND id:{0}'.format(item_id),
-            'fq':'isBot:false AND statistics_type:view'
-        }, rows=0)
+        # get total number of items so we can estimate the pages
+        cursor.execute('SELECT COUNT(id) FROM items')
+        pages = round(cursor.fetchone()[0] / limit)
 
-        views = res.get_num_found()
+        # get statistics, ordered by id, and use limit and offset to page through results
+        cursor.execute('SELECT id, views, downloads FROM items ORDER BY id ASC LIMIT {} OFFSET {}'.format(limit, offset))
 
-        # Get downloads
-        res = solr.query(SOLR_CORE, {
-            'q':'type:0 AND owningItem:{0}'.format(item_id),
-            'fq':'isBot:false AND statistics_type:view AND bundleName:ORIGINAL'
-        }, rows=0)
+        # create a list to hold dicts of item stats
+        statistics = list()
 
-        downloads = res.get_num_found() 
+        # iterate over results and build statistics object
+        for item in cursor:
+            statistics.append({ 'id': item['id'], 'views': item['views'], 'downloads': item['downloads'] })
 
-        statistics = {
-            'id': item_id,
-            'views': views,
-            'downloads': downloads
+        cursor.close()
+
+        message = {
+                'currentPage': page,
+                'totalPages': pages,
+                'limit': limit,
+                'statistics': statistics
         }
 
-        resp.media = statistics
+        resp.media = message
+
+class ItemResource:
+    def on_get(self, req, resp, item_id):
+        """Handles GET requests"""
+
+        cursor = db.cursor()
+        cursor.execute('SELECT views, downloads FROM items WHERE id={}'.format(item_id))
+        if cursor.rowcount == 0:
+            raise falcon.HTTPNotFound(
+                    title='Item not found',
+                    description='The item with id "{}" was not found.'.format(item_id)
+            )
+        else:
+            results = cursor.fetchone()
+
+            statistics = {
+                'id': item_id,
+                'views': results['views'],
+                'downloads': results['downloads']
+            }
+
+            resp.media = statistics
+
+        cursor.close()
+
+def on_exit(api):
+    print("Shutting down DB")
 
 api = falcon.API()
-api.add_route('/item', ItemResource())
+api.add_route('/items', AllItemsResource())
+api.add_route('/item/{item_id:int}', ItemResource())
+
+# vim: set sw=4 ts=4 expandtab:

config.py

@@ -2,4 +2,10 @@ import os
 
 # Check if Solr connection information was provided in the environment
 SOLR_SERVER = os.environ.get('SOLR_SERVER', 'http://localhost:8080/solr')
-SOLR_CORE = os.environ.get('SOLR_CORE', 'statistics')
+
+DATABASE_NAME = os.environ.get('DATABASE_NAME', 'dspacestatistics')
+DATABASE_USER = os.environ.get('DATABASE_USER', 'dspacestatistics')
+DATABASE_PASS = os.environ.get('DATABASE_PASS', 'dspacestatistics')
+DATABASE_HOST = os.environ.get('DATABASE_HOST', 'localhost')
+
+# vim: set sw=4 ts=4 expandtab:

contrib/dspace-statistics-api.service

@@ -0,0 +1,20 @@
+[Unit]
+Description=DSpace Statistics API
+After=network.target
+
+[Service]
+Environment=DATABASE_NAME=dspacestatistics
+Environment=DATABASE_USER=dspacestatistics
+Environment=DATABASE_PASS=dspacestatistics
+Environment=DATABASE_HOST=localhost
+User=nobody
+Group=nogroup
+WorkingDirectory=/var/lib/dspace-statistics-api
+ExecStart=/var/lib/dspace-statistics-api/venv/bin/gunicorn \
+          --bind 127.0.0.1:5000                             \
+          app:api
+ExecReload=/bin/kill -s HUP $MAINPID
+ExecStop=/bin/kill -s TERM $MAINPID
+
+[Install]
+WantedBy=multi-user.target

contrib/dspace-statistics-indexer.service

@@ -0,0 +1,17 @@
+[Unit]
+Description=DSpace Statistics Indexer
+After=tomcat7.target
+
+[Service]
+Environment=SOLR_SERVER=http://localhost:8081/solr
+Environment=DATABASE_NAME=dspacestatistics
+Environment=DATABASE_USER=dspacestatistics
+Environment=DATABASE_PASS=dspacestatistics
+Environment=DATABASE_HOST=localhost
+User=nobody
+Group=nogroup
+WorkingDirectory=/var/lib/dspace-statistics-api
+ExecStart=/var/lib/dspace-statistics-api/venv/bin/python indexer.py
+
+[Install]
+WantedBy=multi-user.target

contrib/dspace-statistics-indexer.timer

@@ -0,0 +1,12 @@
+[Unit]
+Description=DSpace Statistics Indexer
+
+[Timer]
+# twice a day, at 6AM and 6PM
+OnCalendar=*-*-* 06,18:00:00
+# Add a random delay of 0–3600 seconds
+RandomizedDelaySec=3600
+Persistent=true
+
+[Install]
+WantedBy=timers.target

database.py

@@ -0,0 +1,12 @@
+from config import DATABASE_NAME
+from config import DATABASE_USER
+from config import DATABASE_PASS
+from config import DATABASE_HOST
+import psycopg2, psycopg2.extras
+
+def database_connection():
+    connection = psycopg2.connect("dbname={} user={} password={} host='{}'".format(DATABASE_NAME, DATABASE_USER, DATABASE_PASS, DATABASE_HOST), cursor_factory=psycopg2.extras.DictCursor)
+
+    return connection
+
+# vim: set sw=4 ts=4 expandtab:

indexer.py

@@ -0,0 +1,173 @@
+#!/usr/bin/env python
+#
+# indexer.py
+#
+# Copyright 2018 Alan Orth.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# ---
+#
+# Connects to a DSpace Solr statistics core and ingests item views and downloads
+# into a PostgreSQL database for use by other applications (like an API).
+#
+# This script is written for Python 3.5+ and requires several modules that you
+# can install with pip (I recommend using a Python virtual environment):
+#
+#   $ pip install SolrClient psycopg2-binary
+#
+# See: https://solrclient.readthedocs.io/en/latest/SolrClient.html
+# See: https://wiki.duraspace.org/display/DSPACE/Solr
+
+from database import database_connection
+import ujson
+import psycopg2.extras
+from solr import solr_connection
+
+def index_views():
+    # get total number of distinct facets for items with a minimum of 1 view,
+    # otherwise Solr returns all kinds of weird ids that are actually not in
+    # the database. Also, stats are expensive, but we need stats.calcdistinct
+    # so we can get the countDistinct summary.
+    #
+    # see: https://lucene.apache.org/solr/guide/6_6/the-stats-component.html
+    res = solr.query('statistics', {
+        'q':'type:2',
+        'fq':'isBot:false AND statistics_type:view',
+        'facet':True,
+        'facet.field':'id',
+        'facet.mincount':1,
+        'facet.limit':1,
+        'facet.offset':0,
+        'stats':True,
+        'stats.field':'id',
+        'stats.calcdistinct':True
+    }, rows=0)
+
+    # get total number of distinct facets (countDistinct)
+    results_totalNumFacets = ujson.loads(res.get_json())['stats']['stats_fields']['id']['countDistinct']
+
+    # divide results into "pages" (cast to int to effectively round down)
+    results_per_page = 100
+    results_num_pages = int(results_totalNumFacets / results_per_page)
+    results_current_page = 0
+
+    cursor = db.cursor()
+
+    # create an empty list to store values for batch insertion
+    data = []
+
+    while results_current_page <= results_num_pages:
+        print('Indexing item views (page {} of {})'.format(results_current_page, results_num_pages))
+
+        res = solr.query('statistics', {
+            'q':'type:2',
+            'fq':'isBot:false AND statistics_type:view',
+            'facet':True,
+            'facet.field':'id',
+            'facet.mincount':1,
+            'facet.limit':results_per_page,
+            'facet.offset':results_current_page * results_per_page
+        }, rows=0)
+
+        # SolrClient's get_facets() returns a dict of dicts
+        views = res.get_facets()
+        # in this case iterate over the 'id' dict and get the item ids and views
+        for item_id, item_views in views['id'].items():
+            data.append((item_id, item_views))
+
+        # do a batch insert of values from the current "page" of results
+        sql = 'INSERT INTO items(id, views) VALUES %s ON CONFLICT(id) DO UPDATE SET views=excluded.views'
+        psycopg2.extras.execute_values(cursor, sql, data, template='(%s, %s)')
+        db.commit()
+
+        # clear all items from the list so we can populate it with the next batch
+        data.clear()
+
+        results_current_page += 1
+
+    cursor.close()
+
+def index_downloads():
+    # get the total number of distinct facets for items with at least 1 download
+    res = solr.query('statistics', {
+        'q':'type:0',
+        'fq':'isBot:false AND statistics_type:view AND bundleName:ORIGINAL',
+        'facet':True,
+        'facet.field':'owningItem',
+        'facet.mincount':1,
+        'facet.limit':1,
+        'facet.offset':0,
+        'stats':True,
+        'stats.field':'owningItem',
+        'stats.calcdistinct':True
+    }, rows=0)
+
+    # get total number of distinct facets (countDistinct)
+    results_totalNumFacets = ujson.loads(res.get_json())['stats']['stats_fields']['owningItem']['countDistinct']
+
+    # divide results into "pages" (cast to int to effectively round down)
+    results_per_page = 100
+    results_num_pages = int(results_totalNumFacets / results_per_page)
+    results_current_page = 0
+
+    cursor = db.cursor()
+
+    # create an empty list to store values for batch insertion
+    data = []
+
+    while results_current_page <= results_num_pages:
+        print('Indexing item downloads (page {} of {})'.format(results_current_page, results_num_pages))
+
+        res = solr.query('statistics', {
+            'q':'type:0',
+            'fq':'isBot:false AND statistics_type:view AND bundleName:ORIGINAL',
+            'facet':True,
+            'facet.field':'owningItem',
+            'facet.mincount':1,
+            'facet.limit':results_per_page,
+            'facet.offset':results_current_page * results_per_page
+        }, rows=0)
+
+        # SolrClient's get_facets() returns a dict of dicts
+        downloads = res.get_facets()
+        # in this case iterate over the 'owningItem' dict and get the item ids and downloads
+        for item_id, item_downloads in downloads['owningItem'].items():
+            data.append((item_id, item_downloads))
+
+        # do a batch insert of values from the current "page" of results
+        sql = 'INSERT INTO items(id, downloads) VALUES %s ON CONFLICT(id) DO UPDATE SET downloads=excluded.downloads'
+        psycopg2.extras.execute_values(cursor, sql, data, template='(%s, %s)')
+        db.commit()
+
+        # clear all items from the list so we can populate it with the next batch
+        data.clear()
+
+        results_current_page += 1
+
+    cursor.close()
+
+db = database_connection()
+solr = solr_connection()
+
+# create table to store item views and downloads
+cursor = db.cursor()
+cursor.execute('''CREATE TABLE IF NOT EXISTS items
+                  (id INT PRIMARY KEY, views INT DEFAULT 0, downloads INT DEFAULT 0)''')
+index_views()
+index_downloads()
+
+db.close()
+
+# vim: set sw=4 ts=4 expandtab:

requirements.txt

@@ -0,0 +1,13 @@
+certifi==2018.8.24
+chardet==3.0.4
+falcon==1.4.1
+gunicorn==19.9.0
+idna==2.7
+kazoo==2.5.0
+psycopg2-binary==2.7.5
+python-mimeparse==1.6.0
+requests==2.19.1
+six==1.11.0
+SolrClient==0.2.1
+ujson==1.35
+urllib3==1.23

solr.py

@@ -0,0 +1,9 @@
+from config import SOLR_SERVER
+from SolrClient import SolrClient
+
+def solr_connection():
+    connection = SolrClient(SOLR_SERVER)
+
+    return connection
+
+# vim: set sw=4 ts=4 expandtab: