├── .buildpacks
├── .circleci
    └── config.yml
├── .dockerignore
├── .env.example
├── .gitignore
├── Dockerfile
├── Makefile
├── Procfile
├── README.md
├── bin
    ├── docker-entrypoint.sh
    ├── general-local-ssl-cert.sh
    └── wait-for-it.sh
├── docker-compose.db.yml
├── docker-compose.development.yml
├── docker-compose.test.yml
├── docker-compose.yml
├── emulation.md
├── manage.py
├── migrations
    ├── README
    ├── alembic.ini
    ├── env.py
    ├── script.py.mako
    └── versions
    │   ├── 15dd8689e7fe_print_key.py
    │   ├── 18ec55ca3e22_sender_name.py
    │   ├── 36ba0c7b9fbc_api_key.py
    │   ├── 3a2c72f262b5_add_print_key_usage.py
    │   ├── 44c4368c2db1_add_print_key_parent.py
    │   ├── 5ac2a9d2e622_sirius_models.py
    │   └── 89a031bd9657_remove_friends.py
├── notes
    ├── capture_notes.md
    ├── dokku.md
    ├── protocol.proto
    └── resetting_migration.md
├── pyproject.toml
├── requirements.txt
├── runtime.txt
├── sirius
    ├── __init__.py
    ├── coding
    │   ├── __init__.py
    │   ├── bitshuffle.py
    │   ├── claiming.py
    │   ├── crc16.py
    │   ├── decoders.py
    │   ├── default_template.html
    │   ├── encoders.py
    │   ├── image_encoding.py
    │   ├── snapshots
    │   │   ├── __init__.py
    │   │   ├── snap_test_image_coding_snapshots.py
    │   │   └── snap_test_image_coding_snapshots
    │   │   │   ├── ImageCodingSnapshotCase::test_snapshot_fixtures hello_world.png
    │   │   │   └── ImageCodingSnapshotCase::test_snapshot_template_fixtures hello_world.png
    │   ├── templating.py
    │   ├── test_claim_coding.py
    │   ├── test_encoders.py
    │   ├── test_image_coding.py
    │   └── test_image_coding_snapshots.py
    ├── config.py
    ├── database.py
    ├── emulate
    │   ├── __init__.py
    │   ├── commands.py
    │   └── protocol_fragments.py
    ├── fake
    │   ├── __init__.py
    │   └── commands.py
    ├── models
    │   ├── __init__.py
    │   ├── db.py
    │   ├── hardware.py
    │   ├── messages.py
    │   ├── print_keys.py
    │   └── user.py
    ├── protocol
    │   ├── __init__.py
    │   ├── messages.py
    │   ├── protocol_loop.py
    │   └── test_protocol_loop.py
    ├── stats.py
    ├── testing
    │   ├── __init__.py
    │   └── base.py
    └── web
    │   ├── __init__.py
    │   ├── admin.py
    │   ├── external_api.py
    │   ├── landing.py
    │   ├── login.py
    │   ├── print_key_api.py
    │   ├── printer_overview.py
    │   ├── printer_print.py
    │   ├── static
    │       ├── bootstrap-theme.min.css
    │       ├── device-key-favicon.png
    │       ├── device-key-large.svg
    │       ├── device-key-mini.svg
    │       └── site.css
    │   ├── templates
    │       ├── about.html
    │       ├── admin.html
    │       ├── base.html
    │       ├── claim.html
    │       ├── dump.html
    │       ├── landing.html
    │       ├── overview.html
    │       ├── print_key.html
    │       ├── printer_overview.html
    │       └── printer_print.html
    │   ├── test_claiming.py
    │   ├── test_oauth_flow.py
    │   ├── test_printing.py
    │   ├── twitter.py
    │   └── webapp.py
└── tests
    ├── barcode-head.png
    ├── iconrethink.png
    ├── normalface.png
    └── riley.png


/.buildpacks:
--------------------------------------------------------------------------------
1 | git://github.com/heroku/heroku-buildpack-python.git
2 | git://github.com/stomita/heroku-buildpack-phantomjs.git
3 | 


--------------------------------------------------------------------------------
/.circleci/config.yml:
--------------------------------------------------------------------------------
 1 | version: 2
 2 | jobs:
 3 |   build:
 4 |     machine:
 5 |       image: ubuntu-2204:2023.04.2
 6 |     steps:
 7 |       - checkout
 8 |       - run:
 9 |           name: Running CI
10 |           command: make ci
11 | 


--------------------------------------------------------------------------------
/.dockerignore:
--------------------------------------------------------------------------------
1 | .circleci
2 | notes
3 | docker-compose*
4 | *.md
5 | 


--------------------------------------------------------------------------------
/.env.example:
--------------------------------------------------------------------------------
1 | FLASK_CONFIG=heroku
2 | # TWITTER_CONSUMER_KEY=
3 | # TWITTER_CONSUMER_SECRET=
4 | 
5 | # default development database via Docker:
6 | # DEV_DATABASE_URL=postgresql://postgres:plop@sirius-database/sirius-dev


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Custom
 2 | venv/
 3 | .env*
 4 | !.env.example
 5 | 
 6 | certs/
 7 | 
 8 | .DS_Store
 9 | 
10 | # Byte-compiled / optimized / DLL files
11 | __pycache__/
12 | *.py[cod]
13 | 
14 | # C extensions
15 | *.so
16 | 
17 | # Distribution / packaging
18 | .Python
19 | env/
20 | build/
21 | develop-eggs/
22 | dist/
23 | downloads/
24 | eggs/
25 | lib/
26 | lib64/
27 | parts/
28 | sdist/
29 | var/
30 | *.egg-info/
31 | .installed.cfg
32 | *.egg
33 | 
34 | # PyInstaller
35 | #  Usually these files are written by a python script from a template
36 | #  before PyInstaller builds the exe, so as to inject date/other infos into it.
37 | *.manifest
38 | *.spec
39 | 
40 | # Installer logs
41 | pip-log.txt
42 | pip-delete-this-directory.txt
43 | 
44 | # Unit test / coverage reports
45 | htmlcov/
46 | .tox/
47 | .coverage
48 | .cache
49 | nosetests.xml
50 | coverage.xml
51 | 
52 | # Translations
53 | *.mo
54 | *.pot
55 | 
56 | # Django stuff:
57 | *.log
58 | 
59 | # Sphinx documentation
60 | docs/_build/
61 | 
62 | # PyBuilder
63 | target/
64 | 
65 | # local data
66 | sirius/data.sqlite
67 | 
68 | # Fake printer
69 | *.printer
70 | 


--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
 1 | FROM python:3.7.10-slim-buster
 2 | 
 3 | WORKDIR /sirius
 4 | 
 5 | RUN apt-get update -y && \
 6 |   mkdir -p /usr/share/man/man1 && \
 7 |   mkdir -p /usr/share/man/man7 && \
 8 |   apt-get install -y --no-install-recommends \
 9 |   python3 \
10 |   python3-dev \
11 |   python3-pip \
12 |   libfreetype6-dev \
13 |   libgstreamer1.0-dev \
14 |   libjpeg-dev \
15 |   libpq-dev \
16 |   zlib1g-dev \
17 |   bzip2 \
18 |   fontconfig \
19 |   gcc \
20 |   phantomjs \
21 |   wget \
22 |   postgresql-11 \
23 |   git
24 | 
25 | RUN apt-get autoremove -y
26 | 
27 | RUN wget https://bitbucket.org/ariya/phantomjs/downloads/phantomjs-2.1.1-linux-x86_64.tar.bz2
28 | RUN tar jxf phantomjs-2.1.1-linux-x86_64.tar.bz2 && \
29 |   rm phantomjs-2.1.1-linux-x86_64.tar.bz2 && \
30 |   mv phantomjs-2.1.1-linux-x86_64/bin/phantomjs /usr/local/bin/phantomjs
31 | 
32 | RUN pip install --upgrade pip setuptools wheel
33 | ADD ./pyproject.toml /sirius/pyproject.toml
34 | RUN pip install --no-cache-dir .[test]
35 | 
36 | EXPOSE 5000
37 | 
38 | ADD . .
39 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | run:
 2 | 	docker-compose -f docker-compose.yml
 3 | 
 4 | run-development:
 5 | 	docker-compose -f docker-compose.yml -f docker-compose.db.yml -f docker-compose.development.yml up
 6 | 
 7 | ci:
 8 | 	docker-compose -f docker-compose.yml -f docker-compose.test.yml run --rm --entrypoint "nosetests" sirius
 9 | 
10 | ci-snapshot-update:
11 | 	docker-compose -f docker-compose.yml -f docker-compose.test.yml run --rm --entrypoint "nosetests --snapshot-update" sirius


--------------------------------------------------------------------------------
/Procfile:
--------------------------------------------------------------------------------
1 | web: gunicorn -w 1 -k flask_sockets.worker manage:app --log-file=-
2 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # nord-sirius
  2 | 
  3 | [![CircleCI](https://circleci.com/gh/nordprojects/sirius.svg?style=svg)](https://circleci.com/gh/nordprojects/sirius)
  4 | 
  5 | ![Little Printer](https://github.com/nordprojects/sirius/assets/1244307/b4456b39-becd-4bfe-bc46-ddb14dde86b8)
  6 | 
  7 | This repository is a fork of [genmon/sirius](https://github.com/genmon/sirius), developed and maintained by [Nord Projects](https://nordprojects.co).
  8 | 
  9 | Want to try it out? We have an instance running at http://littleprinter.nordprojects.co which all are welcome to use!
 10 | 
 11 | # How to use
 12 | 
 13 | Want to get your Little Printer online?
 14 | 
 15 | - Hack the Berg Cloud bridge. Follow our [step-by-step guide](https://docs.google.com/document/d/1JT1f2ClVdAnjrnby92V9ONBnN05EFQGYpLG5ijl5KRI/edit?usp=sharing) here.
 16 | 
 17 |   - If you've already got a hacked bridge using the alpha.littleprinter.com
 18 |     backend, use the guide above but start at step 6.
 19 | 
 20 | - Once it's paired with this server, you can use Device Keys with our iOS app,
 21 |   [Little Printers](https://itunes.apple.com/us/app/little-printers/id1393105914?ls=1&mt=8),
 22 |   which is also [open source](https://github.com/nordprojects/littleprinters-ios-app)!
 23 | 
 24 | ### Using the device key API
 25 | 
 26 | Use Device Keys to print through an API. Create a device key from the web
 27 | interface, and go to that URL to view API documentation.
 28 | 
 29 | # Developing Sirius
 30 | 
 31 | ## Running on Heroku
 32 | 
 33 | We run an instance of this server on Heroku, at [littleprinter.nordprojects.co](https://littleprinter.nordprojects.co). You are welcome to use our instance!
 34 | 
 35 | If you want to run it yourself, this app will run on Heroku, but you need a
 36 | static IP address due to the way the Berg Bridge connects. We have a droplet
 37 | at Digital Ocean running nginx to forward the HTTPS connection on to Heroku.
 38 | 
 39 | It should also be possible to run in Docker, dokku, or directly with gunicorn,
 40 | but we don't use it that way :).
 41 | 
 42 | ## Running locally via Docker
 43 | 
 44 | There's a development Docker setup that adds Postgres for you, by running:
 45 | 
 46 | ```sh
 47 | docker-compose -f docker-compose.yml -f docker-compose.db.yml -f docker-compose.development.yml up
 48 | ```
 49 | 
 50 | Or if you have your own database, you can configure the `DEV_DATABASE_URL` environment variable in `.env`, and then simply run:
 51 | 
 52 | ```sh
 53 | docker-compose up
 54 | ```
 55 | 
 56 | ### Environment variables
 57 | 
 58 | The server can be configured with the following variables:
 59 | 
 60 | ```properties
 61 | TWITTER_OAUTH_CLIENT_KEY=...
 62 | TWITTER_OAUTH_CLIENT_SECRET=...
 63 | OAUTH_REDIRECT_URI=...
 64 | FLASK_CONFIG=...
 65 | DATABASE_URL=...
 66 | ```
 67 | 
 68 | These can be set in the `.env` file, and an example is available in `.env.sample` in your checkout.
 69 | 
 70 | ### Creating fake printers
 71 | 
 72 | Resetting the actual hardware all the time gets a bit tiresome so
 73 | there's a fake command that creates unclaimed fake little printers:
 74 | 
 75 | ```console
 76 | $ ./manage.py fake printer
 77 | [...]
 78 | Created printer
 79 |      address: 602d48d344b746f5
 80 |        DB id: 8
 81 |       secret: 66a596840f
 82 |   claim code: 5oop-e9dp-hh7v-fjqo
 83 | ```
 84 | 
 85 | Functionally there is no difference between resetting and creating a new printer so we don't distinguish between the two.
 86 | 
 87 | ## Sirius Architecture
 88 | 
 89 | ### Layers
 90 | 
 91 | The design is somewhat stratified: each layer only talks to the one
 92 | below and above. The ugliest bits are how database and protocol loop
 93 | interact.
 94 | 
 95 | ```
 96 | UI / database
 97 | ----------------------------
 98 | protocol_loop / send_message
 99 | ----------------------------
100 | encoders / decoders
101 | ----------------------------
102 | websockets
103 | ----------------------------
104 | ```
105 | 
106 | ### Information flow (websockets)
107 | 
108 | The entry point for the bridge is in `sirius.web.webapp`. Each new
109 | websocket connection spawns a gevent thread (specified by running the
110 | flask_sockets gunicorn worker) which runs
111 | `sirius.protocol.protocol_loop.accept` immediately. `accept` registers
112 | the websocket/bridge_address mapping in a global dictionary; it then
113 | loops forever, decoding messages as they come in.
114 | 
115 | ### Claim codes
116 | 
117 | Devices are associated with an account when a user enters a "claim
118 | code". This claim code contains a "hardware-xor" which is derived via
119 | a lossy 3-byte hash from the device address. The XOR-code for a device
120 | is always the same even though the address changes!
121 | 
122 | The claim codes are meant to be used "timely", i.e. within a short
123 | window of the printer reset. If there are multiple, conflicting claim
124 | codes we always pick the most recently created code.
125 | 
126 | We are also deriving this hardware xor when a device calls home with
127 | an "encryption_key_required". In that case we connect the device to
128 | the claim code via the hardware-xor and send back the correct
129 | encryption key.
130 | 


--------------------------------------------------------------------------------
/bin/docker-entrypoint.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | 
3 | # Apply database migrations
4 | echo "Apply database migrations"
5 | python manage.py db upgrade
6 | 
7 | # Start server
8 | echo "Starting server"
9 | honcho start


--------------------------------------------------------------------------------
/bin/general-local-ssl-cert.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | if [ -z $1 ] ; then
 4 |   echo "Usage: $0 <hostname>"
 5 |   exit
 6 | fi
 7 | 
 8 | HOSTNAME=${1}
 9 | OUTDIR="${PWD}/certs"
10 | 
11 | mkdir -p "${OUTDIR}"
12 | 
13 | openssl req \
14 |     -newkey rsa:2048 \
15 |     -x509 \
16 |     -nodes \
17 |     -keyout "${OUTDIR}/${HOSTNAME}.key" \
18 |     -new \
19 |     -out "${OUTDIR}/${HOSTNAME}.crt" \
20 |     -subj /CN=\*.${HOSTNAME} \
21 |     -reqexts SAN \
22 |     -extensions SAN \
23 |     -config <(cat /System/Library/OpenSSL/openssl.cnf \
24 |         <(printf "[SAN]\nsubjectAltName=DNS:\*.${HOSTNAME}")) \
25 |     -sha256 \
26 |     -days 3650


--------------------------------------------------------------------------------
/bin/wait-for-it.sh:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env bash
  2 | #   Use this script to test if a given TCP host/port are available
  3 | 
  4 | WAITFORIT_cmdname=${0##*/}
  5 | 
  6 | echoerr() { if [[ $WAITFORIT_QUIET -ne 1 ]]; then echo "$@" 1>&2; fi }
  7 | 
  8 | usage()
  9 | {
 10 |     cat << USAGE >&2
 11 | Usage:
 12 |     $WAITFORIT_cmdname host:port [-s] [-t timeout] [-- command args]
 13 |     -h HOST | --host=HOST       Host or IP under test
 14 |     -p PORT | --port=PORT       TCP port under test
 15 |                                 Alternatively, you specify the host and port as host:port
 16 |     -s | --strict               Only execute subcommand if the test succeeds
 17 |     -q | --quiet                Don't output any status messages
 18 |     -t TIMEOUT | --timeout=TIMEOUT
 19 |                                 Timeout in seconds, zero for no timeout
 20 |     -- COMMAND ARGS             Execute command with args after the test finishes
 21 | USAGE
 22 |     exit 1
 23 | }
 24 | 
 25 | wait_for()
 26 | {
 27 |     if [[ $WAITFORIT_TIMEOUT -gt 0 ]]; then
 28 |         echoerr "$WAITFORIT_cmdname: waiting $WAITFORIT_TIMEOUT seconds for $WAITFORIT_HOST:$WAITFORIT_PORT"
 29 |     else
 30 |         echoerr "$WAITFORIT_cmdname: waiting for $WAITFORIT_HOST:$WAITFORIT_PORT without a timeout"
 31 |     fi
 32 |     WAITFORIT_start_ts=$(date +%s)
 33 |     while :
 34 |     do
 35 |         if [[ $WAITFORIT_ISBUSY -eq 1 ]]; then
 36 |             nc -z $WAITFORIT_HOST $WAITFORIT_PORT
 37 |             WAITFORIT_result=$?
 38 |         else
 39 |             (echo > /dev/tcp/$WAITFORIT_HOST/$WAITFORIT_PORT) >/dev/null 2>&1
 40 |             WAITFORIT_result=$?
 41 |         fi
 42 |         if [[ $WAITFORIT_result -eq 0 ]]; then
 43 |             WAITFORIT_end_ts=$(date +%s)
 44 |             echoerr "$WAITFORIT_cmdname: $WAITFORIT_HOST:$WAITFORIT_PORT is available after $((WAITFORIT_end_ts - WAITFORIT_start_ts)) seconds"
 45 |             break
 46 |         fi
 47 |         sleep 1
 48 |     done
 49 |     return $WAITFORIT_result
 50 | }
 51 | 
 52 | wait_for_wrapper()
 53 | {
 54 |     # In order to support SIGINT during timeout: http://unix.stackexchange.com/a/57692
 55 |     if [[ $WAITFORIT_QUIET -eq 1 ]]; then
 56 |         timeout $WAITFORIT_BUSYTIMEFLAG $WAITFORIT_TIMEOUT $0 --quiet --child --host=$WAITFORIT_HOST --port=$WAITFORIT_PORT --timeout=$WAITFORIT_TIMEOUT &
 57 |     else
 58 |         timeout $WAITFORIT_BUSYTIMEFLAG $WAITFORIT_TIMEOUT $0 --child --host=$WAITFORIT_HOST --port=$WAITFORIT_PORT --timeout=$WAITFORIT_TIMEOUT &
 59 |     fi
 60 |     WAITFORIT_PID=$!
 61 |     trap "kill -INT -$WAITFORIT_PID" INT
 62 |     wait $WAITFORIT_PID
 63 |     WAITFORIT_RESULT=$?
 64 |     if [[ $WAITFORIT_RESULT -ne 0 ]]; then
 65 |         echoerr "$WAITFORIT_cmdname: timeout occurred after waiting $WAITFORIT_TIMEOUT seconds for $WAITFORIT_HOST:$WAITFORIT_PORT"
 66 |     fi
 67 |     return $WAITFORIT_RESULT
 68 | }
 69 | 
 70 | # process arguments
 71 | while [[ $# -gt 0 ]]
 72 | do
 73 |     case "$1" in
 74 |         *:* )
 75 |         WAITFORIT_hostport=(${1//:/ })
 76 |         WAITFORIT_HOST=${WAITFORIT_hostport[0]}
 77 |         WAITFORIT_PORT=${WAITFORIT_hostport[1]}
 78 |         shift 1
 79 |         ;;
 80 |         --child)
 81 |         WAITFORIT_CHILD=1
 82 |         shift 1
 83 |         ;;
 84 |         -q | --quiet)
 85 |         WAITFORIT_QUIET=1
 86 |         shift 1
 87 |         ;;
 88 |         -s | --strict)
 89 |         WAITFORIT_STRICT=1
 90 |         shift 1
 91 |         ;;
 92 |         -h)
 93 |         WAITFORIT_HOST="$2"
 94 |         if [[ $WAITFORIT_HOST == "" ]]; then break; fi
 95 |         shift 2
 96 |         ;;
 97 |         --host=*)
 98 |         WAITFORIT_HOST="${1#*=}"
 99 |         shift 1
100 |         ;;
101 |         -p)
102 |         WAITFORIT_PORT="$2"
103 |         if [[ $WAITFORIT_PORT == "" ]]; then break; fi
104 |         shift 2
105 |         ;;
106 |         --port=*)
107 |         WAITFORIT_PORT="${1#*=}"
108 |         shift 1
109 |         ;;
110 |         -t)
111 |         WAITFORIT_TIMEOUT="$2"
112 |         if [[ $WAITFORIT_TIMEOUT == "" ]]; then break; fi
113 |         shift 2
114 |         ;;
115 |         --timeout=*)
116 |         WAITFORIT_TIMEOUT="${1#*=}"
117 |         shift 1
118 |         ;;
119 |         --)
120 |         shift
121 |         WAITFORIT_CLI=("$@")
122 |         break
123 |         ;;
124 |         --help)
125 |         usage
126 |         ;;
127 |         *)
128 |         echoerr "Unknown argument: $1"
129 |         usage
130 |         ;;
131 |     esac
132 | done
133 | 
134 | if [[ "$WAITFORIT_HOST" == "" || "$WAITFORIT_PORT" == "" ]]; then
135 |     echoerr "Error: you need to provide a host and port to test."
136 |     usage
137 | fi
138 | 
139 | WAITFORIT_TIMEOUT=${WAITFORIT_TIMEOUT:-15}
140 | WAITFORIT_STRICT=${WAITFORIT_STRICT:-0}
141 | WAITFORIT_CHILD=${WAITFORIT_CHILD:-0}
142 | WAITFORIT_QUIET=${WAITFORIT_QUIET:-0}
143 | 
144 | # check to see if timeout is from busybox?
145 | WAITFORIT_TIMEOUT_PATH=$(type -p timeout)
146 | WAITFORIT_TIMEOUT_PATH=$(realpath $WAITFORIT_TIMEOUT_PATH 2>/dev/null || readlink -f $WAITFORIT_TIMEOUT_PATH)
147 | if [[ $WAITFORIT_TIMEOUT_PATH =~ "busybox" ]]; then
148 |         WAITFORIT_ISBUSY=1
149 |         WAITFORIT_BUSYTIMEFLAG="-t"
150 | 
151 | else
152 |         WAITFORIT_ISBUSY=0
153 |         WAITFORIT_BUSYTIMEFLAG=""
154 | fi
155 | 
156 | if [[ $WAITFORIT_CHILD -gt 0 ]]; then
157 |     wait_for
158 |     WAITFORIT_RESULT=$?
159 |     exit $WAITFORIT_RESULT
160 | else
161 |     if [[ $WAITFORIT_TIMEOUT -gt 0 ]]; then
162 |         wait_for_wrapper
163 |         WAITFORIT_RESULT=$?
164 |     else
165 |         wait_for
166 |         WAITFORIT_RESULT=$?
167 |     fi
168 | fi
169 | 
170 | if [[ $WAITFORIT_CLI != "" ]]; then
171 |     if [[ $WAITFORIT_RESULT -ne 0 && $WAITFORIT_STRICT -eq 1 ]]; then
172 |         echoerr "$WAITFORIT_cmdname: strict mode, refusing to execute subprocess"
173 |         exit $WAITFORIT_RESULT
174 |     fi
175 |     exec "${WAITFORIT_CLI[@]}"
176 | else
177 |     exit $WAITFORIT_RESULT
178 | fi
179 | 


--------------------------------------------------------------------------------
/docker-compose.db.yml:
--------------------------------------------------------------------------------
 1 | version: "3"
 2 | 
 3 | services:
 4 |   sirius:
 5 |     depends_on:
 6 |       - sirius-database
 7 |     environment:
 8 |       - DATABASE_URL=postgresql://postgres:plop@sirius-database/sirius
 9 | 
10 |   sirius-database:
11 |     image: postgres
12 |     healthcheck:
13 |       test: "exit 0"
14 |     environment:
15 |       - POSTGRES_DB=sirius
16 |       - POSTGRES_PASSWORD=plop
17 | 


--------------------------------------------------------------------------------
/docker-compose.development.yml:
--------------------------------------------------------------------------------
 1 | version: "3"
 2 | 
 3 | services:
 4 |   sirius:
 5 |     ports:
 6 |       - 5000:5000
 7 |     environment:
 8 |       - VIRTUAL_HOST=sirius.localhost
 9 |       - DATABASE_URL=postgresql://postgres:plop@sirius-database/sirius-dev
10 |       - OAUTHLIB_INSECURE_TRANSPORT=1
11 |     volumes:
12 |       - ./:/sirius
13 | 
14 |   sirius-database:
15 |     ports:
16 |       - "32770:5432"
17 |     environment:
18 |       - POSTGRES_DB=sirius-dev
19 |       - POSTGRES_PASSWORD=plop
20 | 
21 |   sirius-web:
22 |     ports:
23 |       - "8880:80"
24 |       - "8443:443"
25 | 


--------------------------------------------------------------------------------
/docker-compose.test.yml:
--------------------------------------------------------------------------------
 1 | version: "3"
 2 | 
 3 | services:
 4 |   sirius:
 5 |     depends_on:
 6 |       - sirius-database-test
 7 |     ports:
 8 |       - 5000:5000
 9 |     command: "bin/wait-for-it.sh sirius-database-test:5432 -- bin/docker-entrypoint.sh"
10 |     environment:
11 |       - DATABASE_URL=postgresql://postgres:plop@sirius-database-test/sirius-test
12 |     volumes:
13 |       - ./:/sirius
14 | 
15 |   sirius-database-test:
16 |     container_name: sirius-database-test
17 |     image: postgres
18 |     healthcheck:
19 |       test: "exit 0"
20 |     environment:
21 |       - POSTGRES_DB=sirius-test
22 |       - POSTGRES_PASSWORD=plop
23 | 
24 |   sirius-web:
25 |     ports:
26 |       - "8880:80"
27 |       - "8443:443"
28 | 


--------------------------------------------------------------------------------
/docker-compose.yml:
--------------------------------------------------------------------------------
 1 | version: "3"
 2 | 
 3 | services:
 4 |   sirius:
 5 |     build:
 6 |       context: ./
 7 |       dockerfile: ./Dockerfile
 8 |     depends_on:
 9 |       - sirius-web
10 |     command: "bin/wait-for-it.sh sirius-database:5432 -- bin/docker-entrypoint.sh"
11 |     environment:
12 |       - OPENSSL_CONF=/etc/ssl/
13 | 
14 |   sirius-web:
15 |     image: jwilder/nginx-proxy
16 |     ports:
17 |       - "80:80"
18 |       - "443:443"
19 |     volumes:
20 |       - /var/run/docker.sock:/tmp/docker.sock:ro
21 |       - ./certs:/etc/nginx/certs
22 | 


--------------------------------------------------------------------------------
/emulation.md:
--------------------------------------------------------------------------------
 1 | # Emulation
 2 | 
 3 | The project comes with a very simple emulator layer. As a first step
 4 | we have to create a fake printer:
 5 | 
 6 | ```console
 7 | $ ./manage.py fake printer
 8 | Importing environment from .env...
 9 | --------------------------------------------------------------------------------
10 | DEBUG in webapp [/home/tom/devel/wizards/sirius/sirius/web/webapp.py:65]:
11 | Creating app.
12 | --------------------------------------------------------------------------------
13 | DEBUG:sirius.web.webapp:Creating app.
14 |      address: cc18aff27ed5cf3d
15 |        DB id: 15
16 |       secret: 6b79e72280
17 |          xor: 15444370
18 |   claim code: ebqp-pyg7-4b0f-qbdk
19 | 
20 | Created printer and saved as cc18aff27ed5cf3d.printer
21 | ```
22 | 
23 | This command wrote the file `cc18aff27ed5cf3d.printer`.
24 | 
25 | ## Running a fake printer
26 | 
27 | I refer to the [README](README.md) file for running the main server
28 | and assume it is running at `127.0.0.1:5000`.
29 | 
30 | You can run:
31 | 
32 | ```console
33 | $ ./manage.py emulate printer cc18aff27ed5cf3d.printer ws://127.0.0.1:5000/api/v1/connection
34 | [...]
35 | Asked for encryption key
36 | Received encryption key, switching to heartbeat mode.
37 | Heartbeat. Pom pom.
38 | Heartbeat. Pom pom.
39 | ```
40 | 


--------------------------------------------------------------------------------
/manage.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python3
 2 | 
 3 | import os, sys
 4 | import re
 5 | 
 6 | if os.path.exists('.env'):
 7 |     print('Importing environment from .env...')
 8 |     regex = re.compile(r"#.*$") # strip comments
 9 |     for line in open('.env'):
10 |         kv = regex.sub("", line).strip()
11 |         if '=' not in kv:
12 |             continue
13 |         name, value = kv.split('=', 1)
14 |         os.environ[name] = value
15 | 
16 | from sirius.web import webapp
17 | from sirius.fake import commands as fake_commands
18 | from sirius.emulate import commands as emulate_commands
19 | from flask_script import Manager, Shell
20 | from flask_migrate import Migrate, MigrateCommand
21 | 
22 | app = webapp.create_app(os.getenv('FLASK_CONFIG', 'default'))
23 | manager = Manager(app)
24 | migrate = Migrate(app, webapp.db)
25 | 
26 | def make_shell_context():
27 |     return dict(app=app, db=webapp.db)
28 | manager.add_command("shell", Shell(make_context=make_shell_context))
29 | manager.add_command('db', MigrateCommand)
30 | manager.add_command('fake', fake_commands.fake_manager)
31 | manager.add_command('emulate', emulate_commands.manager)
32 | 
33 | 
34 | @manager.command
35 | def deploy():
36 | 	"""Run deployment tasks."""
37 | 	from flask_migrate import upgrade
38 | 
39 | 	# migrate database to latest revision
40 | 	upgrade()
41 | 
42 | 
43 | if __name__ == '__main__':
44 |     manager.run()
45 | 
46 | # run with
47 | #gunicorn -b 0.0.0.0:5000 -k flask_sockets.worker manage:app
48 | 


--------------------------------------------------------------------------------
/migrations/README:
--------------------------------------------------------------------------------
1 | Generic single-database configuration.


--------------------------------------------------------------------------------
/migrations/alembic.ini:
--------------------------------------------------------------------------------
 1 | # A generic, single database configuration.
 2 | 
 3 | [alembic]
 4 | # template used to generate migration files
 5 | # file_template = %%(rev)s_%%(slug)s
 6 | 
 7 | # set to 'true' to run the environment during
 8 | # the 'revision' command, regardless of autogenerate
 9 | # revision_environment = false
10 | 
11 | 
12 | # Logging configuration
13 | [loggers]
14 | keys = root,sqlalchemy,alembic
15 | 
16 | [handlers]
17 | keys = console
18 | 
19 | [formatters]
20 | keys = generic
21 | 
22 | [logger_root]
23 | level = WARN
24 | handlers = console
25 | qualname =
26 | 
27 | [logger_sqlalchemy]
28 | level = WARN
29 | handlers =
30 | qualname = sqlalchemy.engine
31 | 
32 | [logger_alembic]
33 | level = INFO
34 | handlers =
35 | qualname = alembic
36 | 
37 | [handler_console]
38 | class = StreamHandler
39 | args = (sys.stderr,)
40 | level = NOTSET
41 | formatter = generic
42 | 
43 | [formatter_generic]
44 | format = %(levelname)-5.5s [%(name)s] %(message)s
45 | datefmt = %H:%M:%S
46 | 


--------------------------------------------------------------------------------
/migrations/env.py:
--------------------------------------------------------------------------------
 1 | from __future__ import with_statement
 2 | from alembic import context
 3 | from sqlalchemy import engine_from_config, pool
 4 | from logging.config import fileConfig
 5 | 
 6 | # this is the Alembic Config object, which provides
 7 | # access to the values within the .ini file in use.
 8 | config = context.config
 9 | 
10 | # Interpret the config file for Python logging.
11 | # This line sets up loggers basically.
12 | fileConfig(config.config_file_name)
13 | 
14 | # add your model's MetaData object here
15 | # for 'autogenerate' support
16 | # from myapp import mymodel
17 | # target_metadata = mymodel.Base.metadata
18 | from flask import current_app
19 | config.set_main_option('sqlalchemy.url', current_app.config.get('SQLALCHEMY_DATABASE_URI'))
20 | target_metadata = current_app.extensions['migrate'].db.db.metadata
21 | 
22 | # other values from the config, defined by the needs of env.py,
23 | # can be acquired:
24 | # my_important_option = config.get_main_option("my_important_option")
25 | # ... etc.
26 | 
27 | def run_migrations_offline():
28 |     """Run migrations in 'offline' mode.
29 | 
30 |     This configures the context with just a URL
31 |     and not an Engine, though an Engine is acceptable
32 |     here as well.  By skipping the Engine creation
33 |     we don't even need a DBAPI to be available.
34 | 
35 |     Calls to context.execute() here emit the given string to the
36 |     script output.
37 | 
38 |     """
39 |     url = config.get_main_option("sqlalchemy.url")
40 |     context.configure(url=url)
41 | 
42 |     with context.begin_transaction():
43 |         context.run_migrations()
44 | 
45 | def run_migrations_online():
46 |     """Run migrations in 'online' mode.
47 | 
48 |     In this scenario we need to create an Engine
49 |     and associate a connection with the context.
50 | 
51 |     """
52 |     engine = engine_from_config(
53 |                 config.get_section(config.config_ini_section),
54 |                 prefix='sqlalchemy.',
55 |                 poolclass=pool.NullPool)
56 | 
57 |     connection = engine.connect()
58 |     context.configure(
59 |                 connection=connection,
60 |                 target_metadata=target_metadata
61 |                 )
62 | 
63 |     try:
64 |         with context.begin_transaction():
65 |             context.run_migrations()
66 |     finally:
67 |         connection.close()
68 | 
69 | if context.is_offline_mode():
70 |     run_migrations_offline()
71 | else:
72 |     run_migrations_online()
73 | 


--------------------------------------------------------------------------------
/migrations/script.py.mako:
--------------------------------------------------------------------------------
 1 | """${message}
 2 | 
 3 | Revision ID: ${up_revision}
 4 | Revises: ${down_revision}
 5 | Create Date: ${create_date}
 6 | 
 7 | """
 8 | 
 9 | # revision identifiers, used by Alembic.
10 | revision = ${repr(up_revision)}
11 | down_revision = ${repr(down_revision)}
12 | 
13 | from alembic import op
14 | import sqlalchemy as sa
15 | ${imports if imports else ""}
16 | 
17 | def upgrade():
18 |     ${upgrades if upgrades else "pass"}
19 | 
20 | 
21 | def downgrade():
22 |     ${downgrades if downgrades else "pass"}
23 | 


--------------------------------------------------------------------------------
/migrations/versions/15dd8689e7fe_print_key.py:
--------------------------------------------------------------------------------
 1 | """empty message
 2 | 
 3 | Revision ID: 15dd8689e7fe
 4 | Revises: 18ec55ca3e22
 5 | Create Date: 2018-01-10 17:21:00.034598
 6 | 
 7 | """
 8 | 
 9 | # revision identifiers, used by Alembic.
10 | revision = '15dd8689e7fe'
11 | down_revision = '18ec55ca3e22'
12 | 
13 | from alembic import op
14 | import sqlalchemy as sa
15 | 
16 | 
17 | def upgrade():
18 |     op.create_table('print_key',
19 |     sa.Column('id', sa.Integer(), nullable=False),
20 |     sa.Column('secret', sa.String(), nullable=True),
21 |     sa.Column('created', sa.DateTime(), nullable=True),
22 |     sa.Column('printer_id', sa.Integer(), nullable=True),
23 |     sa.ForeignKeyConstraint(['printer_id'], ['printer.id'], ),
24 |     sa.PrimaryKeyConstraint('id'),
25 |     sa.UniqueConstraint('secret')
26 |     )
27 | 
28 | 
29 | def downgrade():
30 |     op.drop_table('print_key')
31 | 


--------------------------------------------------------------------------------
/migrations/versions/18ec55ca3e22_sender_name.py:
--------------------------------------------------------------------------------
 1 | """empty message
 2 | 
 3 | Revision ID: 18ec55ca3e22
 4 | Revises: 36ba0c7b9fbc
 5 | Create Date: 2018-01-10 16:50:07.468905
 6 | 
 7 | """
 8 | 
 9 | # revision identifiers, used by Alembic.
10 | revision = '18ec55ca3e22'
11 | down_revision = '36ba0c7b9fbc'
12 | 
13 | from alembic import op
14 | import sqlalchemy as sa
15 | 
16 | 
17 | def upgrade():
18 |     op.add_column('message', sa.Column('sender_name', sa.String(), nullable=True))
19 |     op.drop_column('message', 'sender_id')
20 | 
21 | 
22 | def downgrade():
23 |     op.add_column('message', sa.Column('sender_id', sa.INTEGER(), autoincrement=False, nullable=True))
24 |     op.drop_column('message', 'sender_name')
25 | 


--------------------------------------------------------------------------------
/migrations/versions/36ba0c7b9fbc_api_key.py:
--------------------------------------------------------------------------------
 1 | """empty message
 2 | 
 3 | Revision ID: 36ba0c7b9fbc
 4 | Revises: 5ac2a9d2e622
 5 | Create Date: 2017-05-01 15:11:19.337843
 6 | 
 7 | """
 8 | 
 9 | # revision identifiers, used by Alembic.
10 | revision = '36ba0c7b9fbc'
11 | down_revision = '5ac2a9d2e622'
12 | 
13 | from alembic import op
14 | import sqlalchemy as sa
15 | 
16 | 
17 | def upgrade():
18 |     op.add_column('user',
19 |       sa.Column('api_key', sa.String())
20 |     )
21 | 
22 | 
23 | def downgrade():
24 |     op.drop_column('user', 'api_key')
25 | 


--------------------------------------------------------------------------------
/migrations/versions/3a2c72f262b5_add_print_key_usage.py:
--------------------------------------------------------------------------------
 1 | """empty message
 2 | 
 3 | Revision ID: 3a2c72f262b5
 4 | Revises: 15dd8689e7fe
 5 | Create Date: 2018-09-08 15:36:21.034476
 6 | 
 7 | """
 8 | 
 9 | # revision identifiers, used by Alembic.
10 | revision = '3a2c72f262b5'
11 | down_revision = '15dd8689e7fe'
12 | 
13 | from alembic import op
14 | import sqlalchemy as sa
15 | from sqlalchemy.dialects import postgresql
16 | 
17 | def upgrade():
18 |     ### commands auto generated by Alembic - please adjust! ###
19 |     op.add_column('print_key', sa.Column('number_of_uses', sa.Integer(), nullable=False, server_default='0'))
20 |     op.alter_column('print_key', 'number_of_uses', server_default=None)
21 |     op.add_column('print_key', sa.Column('senders', postgresql.ARRAY(sa.String()), nullable=False, server_default='{}'))
22 |     op.alter_column('print_key', 'senders', server_default=None)
23 |     ### end Alembic commands ###
24 | 
25 | 
26 | def downgrade():
27 |     ### commands auto generated by Alembic - please adjust! ###
28 |     op.drop_column('print_key', 'senders')
29 |     op.drop_column('print_key', 'number_of_uses')
30 |     ### end Alembic commands ###
31 | 


--------------------------------------------------------------------------------
/migrations/versions/44c4368c2db1_add_print_key_parent.py:
--------------------------------------------------------------------------------
 1 | """empty message
 2 | 
 3 | Revision ID: 44c4368c2db1
 4 | Revises: 3a2c72f262b5
 5 | Create Date: 2018-09-08 16:06:27.267732
 6 | 
 7 | """
 8 | 
 9 | # revision identifiers, used by Alembic.
10 | revision = '44c4368c2db1'
11 | down_revision = '3a2c72f262b5'
12 | 
13 | from alembic import op
14 | import sqlalchemy as sa
15 | 
16 | 
17 | def upgrade():
18 |     ### commands auto generated by Alembic - please adjust! ###
19 |     op.add_column('print_key', sa.Column('parent_id', sa.Integer(), nullable=True))
20 |     ### end Alembic commands ###
21 | 
22 | 
23 | def downgrade():
24 |     ### commands auto generated by Alembic - please adjust! ###
25 |     op.drop_column('print_key', 'parent_id')
26 |     ### end Alembic commands ###
27 | 


--------------------------------------------------------------------------------
/migrations/versions/5ac2a9d2e622_sirius_models.py:
--------------------------------------------------------------------------------
  1 | """Sirius models.
  2 | 
  3 | Revision ID: 5ac2a9d2e622
  4 | Revises: None
  5 | Create Date: 2015-01-26 10:34:21.975511
  6 | 
  7 | """
  8 | 
  9 | # revision identifiers, used by Alembic.
 10 | revision = '5ac2a9d2e622'
 11 | down_revision = None
 12 | 
 13 | from alembic import op
 14 | import sqlalchemy as sa
 15 | 
 16 | 
 17 | def upgrade():
 18 |     ### commands auto generated by Alembic - please adjust! ###
 19 |     op.create_table('user',
 20 |     sa.Column('id', sa.Integer(), nullable=False),
 21 |     sa.Column('created', sa.DateTime(), nullable=True),
 22 |     sa.Column('username', sa.String(), nullable=True),
 23 |     sa.PrimaryKeyConstraint('id')
 24 |     )
 25 |     op.create_table('bridge',
 26 |     sa.Column('id', sa.Integer(), nullable=False),
 27 |     sa.Column('created', sa.DateTime(), nullable=True),
 28 |     sa.Column('bridge_address', sa.String(), nullable=True),
 29 |     sa.PrimaryKeyConstraint('id')
 30 |     )
 31 |     op.create_table('device_log',
 32 |     sa.Column('id', sa.Integer(), nullable=False),
 33 |     sa.Column('created', sa.DateTime(), nullable=True),
 34 |     sa.Column('device_address', sa.String(), nullable=True),
 35 |     sa.Column('entry', sa.String(), nullable=True),
 36 |     sa.PrimaryKeyConstraint('id')
 37 |     )
 38 |     op.create_table('twitter_o_auth',
 39 |     sa.Column('id', sa.Integer(), nullable=False),
 40 |     sa.Column('created', sa.DateTime(), nullable=True),
 41 |     sa.Column('user_id', sa.Integer(), nullable=True),
 42 |     sa.Column('screen_name', sa.String(), nullable=True),
 43 |     sa.Column('token', sa.String(), nullable=True),
 44 |     sa.Column('token_secret', sa.String(), nullable=True),
 45 |     sa.Column('last_friend_refresh', sa.DateTime(), nullable=True),
 46 |     sa.Column('friends', sa.PickleType(), nullable=True),
 47 |     sa.ForeignKeyConstraint(['user_id'], [u'user.id'], ),
 48 |     sa.PrimaryKeyConstraint('id'),
 49 |     sa.UniqueConstraint('screen_name')
 50 |     )
 51 |     op.create_table('printer',
 52 |     sa.Column('id', sa.Integer(), nullable=False),
 53 |     sa.Column('created', sa.DateTime(), nullable=True),
 54 |     sa.Column('device_address', sa.String(), nullable=True),
 55 |     sa.Column('hardware_xor', sa.Integer(), nullable=True),
 56 |     sa.Column('name', sa.String(), nullable=True),
 57 |     sa.Column('owner_id', sa.Integer(), nullable=True),
 58 |     sa.Column('used_claim_code', sa.String(), nullable=True),
 59 |     sa.ForeignKeyConstraint(['owner_id'], ['user.id'], ),
 60 |     sa.PrimaryKeyConstraint('id')
 61 |     )
 62 |     op.create_table('claim_code',
 63 |     sa.Column('id', sa.Integer(), nullable=False),
 64 |     sa.Column('created', sa.DateTime(), nullable=True),
 65 |     sa.Column('by_id', sa.Integer(), nullable=True),
 66 |     sa.Column('hardware_xor', sa.Integer(), nullable=True),
 67 |     sa.Column('claim_code', sa.String(), nullable=True),
 68 |     sa.Column('name', sa.String(), nullable=True),
 69 |     sa.ForeignKeyConstraint(['by_id'], ['user.id'], ),
 70 |     sa.PrimaryKeyConstraint('id')
 71 |     )
 72 |     op.create_table('message',
 73 |     sa.Column('id', sa.Integer(), nullable=False),
 74 |     sa.Column('created', sa.DateTime(), nullable=True),
 75 |     sa.Column('pixels', sa.LargeBinary(), nullable=True),
 76 |     sa.Column('print_id', sa.Integer(), nullable=True),
 77 |     sa.Column('sender_id', sa.Integer(), nullable=True),
 78 |     sa.Column('target_printer_id', sa.Integer(), nullable=True),
 79 |     sa.Column('response_timestamp', sa.DateTime(), nullable=True),
 80 |     sa.Column('failure_message', sa.String(), nullable=True),
 81 |     sa.ForeignKeyConstraint(['sender_id'], ['user.id'], ),
 82 |     sa.ForeignKeyConstraint(['target_printer_id'], ['printer.id'], ),
 83 |     sa.PrimaryKeyConstraint('id'),
 84 |     sa.UniqueConstraint('print_id')
 85 |     )
 86 |     op.create_index(op.f('ix_message_created'), 'message', ['created'], unique=False)
 87 |     ### end Alembic commands ###
 88 | 
 89 | 
 90 | def downgrade():
 91 |     ### commands auto generated by Alembic - please adjust! ###
 92 |     op.drop_index(op.f('ix_message_created'), table_name='message')
 93 |     op.drop_table('message')
 94 |     op.drop_table('claim_code')
 95 |     op.drop_table('printer')
 96 |     op.drop_table('twitter_o_auth')
 97 |     op.drop_table('device_log')
 98 |     op.drop_table('bridge')
 99 |     op.drop_table('user')
100 |     ### end Alembic commands ###
101 | 


--------------------------------------------------------------------------------
/migrations/versions/89a031bd9657_remove_friends.py:
--------------------------------------------------------------------------------
 1 | """Remove friends
 2 | 
 3 | Revision ID: 89a031bd9657
 4 | Revises: 44c4368c2db1
 5 | Create Date: 2023-07-04 18:44:13.041005
 6 | 
 7 | """
 8 | 
 9 | # revision identifiers, used by Alembic.
10 | revision = "89a031bd9657"
11 | down_revision = "44c4368c2db1"
12 | 
13 | from alembic import op
14 | import sqlalchemy as sa
15 | from sqlalchemy.dialects import postgresql
16 | 
17 | 
18 | def upgrade():
19 |     # ### commands auto generated by Alembic - please adjust! ###
20 |     op.drop_column("twitter_o_auth", "last_friend_refresh")
21 |     op.drop_column("twitter_o_auth", "friends")
22 |     # ### end Alembic commands ###
23 | 
24 | 
25 | def downgrade():
26 |     # ### commands auto generated by Alembic - please adjust! ###
27 |     op.add_column(
28 |         "twitter_o_auth",
29 |         sa.Column("friends", postgresql.BYTEA(), autoincrement=False, nullable=True),
30 |     )
31 |     op.add_column(
32 |         "twitter_o_auth",
33 |         sa.Column(
34 |             "last_friend_refresh",
35 |             postgresql.TIMESTAMP(),
36 |             autoincrement=False,
37 |             nullable=True,
38 |         ),
39 |     )
40 |     # ### end Alembic commands ###
41 | 


--------------------------------------------------------------------------------
/notes/capture_notes.md:
--------------------------------------------------------------------------------
  1 | # Capture the connect attempt with nc
  2 | 
  3 | ```
  4 | $ nc -l -p 5002
  5 | GET /api/v1/connection HTTP/1.1
  6 | Host: 192.168.1.88
  7 | Connection: Upgrade
  8 | Upgrade: websocket
  9 | Sec-WebSocket-Key: LJUqJa44qfNRKHts7rnNsQ==
 10 | Origin: ws://192.168.1.88:5002/api/v1/connection
 11 | Sec-WebSocket-Version: 13
 12 | Sec-WebSocket-Protocol: bergcloud-bridge-v1
 13 | ```
 14 | 
 15 | Apparently `Sec-WebSocket-Protocol: bergcloud-bridge-v1` is for
 16 | protocol negotiation. CF Accept headers in HTTP.
 17 | 
 18 | # Lets provide a websocket and see what happens.
 19 | 
 20 | ```python
 21 | from eventlet import wsgi, websocket
 22 | import eventlet
 23 | 
 24 | @websocket.WebSocketWSGI
 25 | def bridge(ws):
 26 |     while True:
 27 |         print ws.wait()
 28 |         eventlet.sleep(1)
 29 | 
 30 | wsgi.server(eventlet.listen(('', 5002)), bridge)
 31 | ```
 32 | 
 33 | Output is two messages:
 34 | 
 35 | ```
 36 | {"bridge_address": "000d6f0002ff7a91", "type": "BridgeEvent", "timestamp": 1346500898.052285, "json_payload": {"uptime": "89.52 68.99", "name": "power_on", "uboot_environment": "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", "local_ip_address": "192.168.2.117", "mac_address": "40:d8:55:19:77:2e", "ncp_version": "0x46C5", "network_info": {"network_status": "EMBER_JOINED_NETWORK", "power": 8, "node_eui64": "0x000d6f0002ff7a91", "pan_id": "0xDCC9", "node_type": "EMBER_COORDINATOR", "node_id": "0x0000", "security_level": 5, "extended_pan_id": "0x42455247b439420c", "security_profile": "Custom", "channel": 25, "radio_power_mode": "EMBER_TX_POWER_MODE_BOOST"}, "firmware_version": "v2.3.1-f3c7946", "model": "B"}}
 37 | {"bridge_address": "000d6f0002ff7a91", "type": "BridgeLog", "records": [{"name": "cloud.socket", "created": 1346500877.330243, "process": 465, "levelno": 40, "processName": "MainProcess", "message": "Socket connection refused", "levelname": "ERROR"}, {"name": "cloud.socket", "created": 1346500882.4734199, "process": 465, "levelno": 40, "processName": "MainProcess", "message": "Socket connection refused", "levelname": "ERROR"}, {"name": "cloud.socket", "created": 1346500887.6230842, "process": 465, "levelno": 40, "processName": "MainProcess", "message": "Socket connection refused", "levelname": "ERROR"}, {"name": "cloud.socket", "created": 1346500892.7610618, "process": 465, "levelno": 40, "processName": "MainProcess", "message": "Socket connection refused", "levelname": "ERROR"}], "timestamp": 1346500898.143672}
 38 | ```
 39 | 
 40 | Note that the bridge also sends power_on after being disconnected from
 41 | it's websocket, e.g. by removing the cable or by killing the websocket server.
 42 | 
 43 | # What happens when I plug little printer in?
 44 | 
 45 | Getting the following on before sending the device-connect message:
 46 | 
 47 | ```
 48 | {"device_address": "000d6f000273ce0b", "timestamp": 1346504081.836229, "bridge_address": "000d6f0002ff7a91", "binary_payload": "AwAAAAAASgAAAAAAAAB2MC41LTEyLWcyNmU4MmYwAAAAAAAAAAAAAAAAAAAAAHYwLjUtMC1nMTQ4NTljYgAAAAAAAAAAAAAAAAAAAAAABAAAAAEE", "rssi_stats": [-30, -30, -30], "type": "DeviceEvent"}
 49 | ```
 50 | Decoding that:
 51 | 
 52 | >>> DeviceEventPayload.from_base64('AwAAAAAASgAAAAAAAAB2MC41LTEyLWcyNmU4MmYwAAAAAAAAAAAAAAAAAAAAAHYwLjUtMC1nMTQ4NTljYgAAAAAAAAAAAAAAAAAAAAAABAAAAAEE')
 53 | {'event_code': 3, 'event_payload_length': 74, 'reset_text': 'Power on', 'command_invocation_id': 0, 'reset_description': 1025, 'device_type': 0, 'protocol_version': 4, 'loader_build_version': 'v0.5-0-g14859cb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00', 'firmware_build_version': 'v0.5-12-g26e82f0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00', 'name': 'did_power_on'}
 54 | 
 55 | 
 56 | ## device-connect:
 57 | 
 58 | ```
 59 | {"bridge_address": "000d6f0002ff7a91", "type": "BridgeEvent", "timestamp": 1346504081.8327731, "json_payload": {"device_address": "000d6f000273ce0b", "name": "device_connect"}}
 60 | ```
 61 | 
 62 | ## This looks like heart-beat:
 63 | 
 64 | ```
 65 | {"device_address": "000d6f000273ce0b", "timestamp": 1346504091.5216279, "bridge_address": "000d6f0002ff7a91", "binary_payload": "AQAAAAAABAAAABQAAAA=", "rssi_stats": [-31, -32, -30], "type": "DeviceEvent"}
 66 | ```
 67 | 
 68 | decoding:
 69 | 
 70 | >>> p.DeviceEventPayload.from_base64('AQAAAAAABAAAABQAAAA=')
 71 | {'event_payload_length': 4, 'uptime': (20,), 'command_invocation_id': 0, 'event_code': 1, 'name': 'heartbeat'}
 72 | 
 73 | 
 74 | 
 75 | # disconnecting the device
 76 | 
 77 | ```
 78 | {"bridge_address": "000d6f0002ff7a91", "type": "BridgeEvent", "timestamp": 1346504219.3027338, "json_payload": {"device_address": "000d6f000273ce0b", "name": "device_disconnect"}}
 79 | ```
 80 | 
 81 | # intermission (bridge died)
 82 | 
 83 | 
 84 | # What happens after reset
 85 | 
 86 | ```
 87 | {"bridge_address": "000d6f0001b3719d", "type": "BridgeEvent", "timestamp": 1419107228.911871, "json_payload": {"device_address": "000d6f000273ce0b", "name": "encryption_key_required"}}
 88 | ```
 89 | 
 90 | I.e. the bridge will send encryption_key_required every ~30 seconds.
 91 | 
 92 | While in this state there will be no device_connected, device_disconnected events.
 93 | 
 94 | 
 95 | # Notes
 96 | 
 97 | The bridge itself doesn't send any health pings. The only way we know
 98 | the bridge is online is by websocket-connect. That's TCP which doesn't
 99 | send any health pings so we don't really know whether a bridge by
100 | itself is online.
101 | 
102 | # What to model on the high level layer
103 | 
104 | - bridges
105 |     - address
106 |     - devices
107 | - devices
108 |     - claim code (entered by user)
109 |     - address
110 | - users
111 | 
112 | 
113 | # What is this?
114 | 
115 | {u'device_address': u'000d6f000273ce0b',
116 | u'timestamp': 1421336620.588616,
117 | u'transfer_time': 3.43,
118 | u'bridge_address': u'000d6f0001b3719d',
119 | u'return_code': 144,
120 | u'rssi_stats': [-19,-19,-19],
121 | u'type': u'DeviceCommandResponse',
122 | u'command_id': 0}
123 | 
124 | Note the `return_code` of 144 (0x90). Looks like it is this:
125 | 
126 |     COMMAND_NAME_ID_MAP = { :set_delivery_and_print => 0x0001,
127 |                             :set_delivery => 0x0002,
128 |                             :set_delivery_and_print_no_face => 0x0011,
129 |                             :set_delivery_no_face => 0x0012,
130 |                             :set_personality => 0x0102,
131 |                             :set_personality_with_message => 0x0101,
132 |                             :set_quip => 0x0202,
133 |                             :firmware_update => 0xf000 }
134 | 
135 |     RESPONSE_CODE_MAP = { :success => 0,
136 |                           :eui64_not_found => 0x01,
137 |                           :failed_network => 0x02,
138 |                           :invalid_sequence => 0x20,
139 |                           :busy => 0x30,
140 |                           :invalid_size => 0x80,
141 |                           :invalid_devicetype => 0x81,
142 |                           :filesystem_error => 0x82,
143 |                           :filesystem_invalid_id => 0x90,
144 |                           :filesystem_no_free_filehandles => 0x91,
145 |                           :filesystem_write_error => 0x92,
146 |                           :bridge_error => 0xff }
147 | 
148 | 
149 | # What happens when the binary payload has an extra 'x' at the end
150 |   before encoding:
151 | 
152 | {u'device_address': u'000d6f000273ce0b',
153 | u'timestamp': 1421339025.755868,
154 | u'transfer_time': 3.44,
155 | u'bridge_address': u'000d6f0001b3719d',
156 | u'return_code': 128,
157 | u'rssi_stats': [-19,-19,-19],
158 | u'type': u'DeviceCommandResponse',
159 | u'command_id': 0}
160 | 


--------------------------------------------------------------------------------
/notes/dokku.md:
--------------------------------------------------------------------------------
 1 | # Dokku setup
 2 | 
 3 | We set up a Digital Ocean instance with Ubuntu 14.04 and dokku
 4 | 0.2.3. Note that a 512M memory instance works but you'll have to
 5 | restart docker a lot because it doesn't free memory very often.
 6 | 
 7 | Let's assume the Digital Ocean instance's IP is `104.236.81.129`:
 8 | 
 9 | ```
10 | export DO=104.236.81.129
11 | ssh root@${DO} dokku version
12 | v0.3.14
13 | ```
14 | 
15 | Add your ssh key:
16 | 
17 | ```
18 | cat  ~/.ssh/id_rsa.pub | ssh root@${DO} "sshcommand acl-add dokku username"
19 | ```
20 | 
21 | # Swap
22 | 
23 | On a small DO instance you will have to add swap. On the server run:
24 | 
25 | ```
26 | fallocate -l 4G /swapfile
27 | chmod 600 /swapfile
28 | mkswap /swapfile
29 | swapon /swapfile
30 | ```
31 | 
32 | # Postgres
33 | 
34 | We won't be able to run on sqlite in a docker container so we'll use
35 | postgres via
36 | [this dokku plugin](https://github.com/ohardy/dokku-psql psql).
37 | 
38 | ```
39 | ssh root@${DO}
40 | cd /var/lib/dokku/plugins
41 | git clone https://github.com/ohardy/dokku-psql psql
42 | dokku plugins-install
43 | ```
44 | 
45 | Still on the server, create the postgres database
46 | 
47 | ```
48 | dokku psql:start
49 | dokku psql:create sirius
50 | ```
51 | 
52 | 
53 | # Push your sirius app
54 | 
55 | Back on the local laptop, we set our Digital Ocean instance as the
56 | remote with the dokku user as our account:
57 | 
58 | ```
59 | git remote add dokku dokku@${DO}:sirius
60 | git push --set-upstream dokku master
61 | ```
62 | 
63 | After deploying you'll need to pick the right database by setting the
64 | FLASK_CONFIG, then migrate the database:
65 | 
66 | ```
67 | ssh root@${DO} dokku config:set sirius FLASK_CONFIG=heroku
68 | ssh root@${DO} dokku run sirius python ./manage.py db upgrade
69 | ```
70 | 
71 | # NGinx
72 | 
73 | We'll have to enable vhost support explicitly in dokku 0.3.x.
74 | 
75 | ```
76 | ssh root@${DO}
77 | echo alpha.littleprinter.com > /home/dokku/sirius/VHOST
78 | echo alpha.littleprinter.com > /home/dokku/HOSTNAME
79 | dokku nginx:build-config sirius
80 | ```
81 | 


--------------------------------------------------------------------------------
/notes/protocol.proto:
--------------------------------------------------------------------------------
  1 | // Write down protocol buffer definitions of the protocol as observed
  2 | // in the wild. We are not actually using these, I added them for reference.
  3 | //
  4 | // Note that the protocol is slightly weird in that the json-message
  5 | // is polymorphic based on one of its member's values. So the decode
  6 | // process is:
  7 | // 1) read message.type
  8 | // 2) look up decoder based on message.type
  9 | // 3) run specific decoder
 10 | //
 11 | // The same is true for the sub-messages in json_payload and
 12 | // binary_payload.
 13 | 
 14 | message BridgeEvent {
 15 |   // e.g. "000d6f0002ff7a91"
 16 |   required string bridge_address = 1;
 17 |   // e.g. "BridgeEvent"
 18 |   required string type = 2;
 19 |   // e.g. 1346501618.506583
 20 |   required float timestamp = 3;
 21 |   // json_payload dispatches on type
 22 |   required Payload json_payload = 4;
 23 | }
 24 | 
 25 | message BridgeLog {
 26 |   // e.g. "000d6f0002ff7a91"
 27 |   required string bridge_address = 1;
 28 |   // "BridgeLog"
 29 |   required string type = 2;
 30 |   // e.g. 1346501618.506583
 31 |   required float timestamp =  3;
 32 |   // standard python logging stuff
 33 |   repeated LogRecord records = 4;
 34 | }
 35 | 
 36 | message DeviceEvent {
 37 |   required string bridge_address = 1;
 38 |   // "DeviceEvent"
 39 |   required string type = 2;
 40 |   // e.g. 1346501618.506583
 41 |   required float timestamp =  3;
 42 |   // e.g. 000d6f000273ce0b
 43 |   required string device_address = 4;
 44 |   // e.g. "AQAAAAAABAAAABQAAAA="
 45 |   required bytes binary_payload = 5;
 46 |   // [-31, -32, -30]
 47 |   repeated int rssi_stats = 6;
 48 | }
 49 | 
 50 | message LogRecord {
 51 |   // {"name": "ws4py", "created": 1346503015.4821309, "process": 495,
 52 |   // "levelno": 40, "processName": "MainProcess", "message": "Failed
 53 |   // to receive data", "levelname": "ERROR"}
 54 |   required string name = 1;
 55 |   // e.g. 1346501618.506583
 56 |   required float created = 2;
 57 |   required int process = 3;
 58 |   required int levelno = 4;
 59 |   required string processName = 5;
 60 |   required string message = 6;
 61 |   required string levelname = 7;
 62 | }
 63 | 
 64 | // poweron is the json_payload for a BridgeEvent
 65 | message PowerOn {
 66 |   // power_on:
 67 |   required string name = 1;
 68 |   required string model = 2; // e.g. B
 69 |   // "v2.3.1-f3c7946",
 70 |   required string firmware_version = 3;
 71 |   // "0x46C5"
 72 |   required string ncp_version = 4;
 73 |   // "local_ip_address" : "192.168.2.117",
 74 |   required string local_ip_address = 5;
 75 |   // "mac_address" : "40:d8:55:19:77:2e",
 76 |   required string mac_address = 6;
 77 |   // "uptime" : "830.55 798.31",
 78 |   required string uptime = 7;
 79 |   // "uboot_environment" :
 80 |   required bytes uboot_environment = 8;
 81 |   required NetworkInfo network_info = 9;
 82 | }
 83 | 
 84 | message NetworkInfo {
 85 |   // "node_type" : "EMBER_COORDINATOR",
 86 |   required string node_type  = 1;
 87 |   // "security_level" : 5,
 88 |   required int security_level = 2;
 89 |   // "security_profile" : "Custom",
 90 |   required string security_profile = 3;
 91 |   // "network_status" : "EMBER_JOINED_NETWORK",
 92 |   required string network_status = 4;
 93 |   // "pan_id" : "0xDCC9",
 94 |   required string pan_id = 5;
 95 |   // "node_eui64" : "0x000d6f0002ff7a91",
 96 |   required string node_eui64 = 6;
 97 |   // "power" : 8,
 98 |   required int power = 7;
 99 |   // "node_id" : "0x0000",
100 |   required string node_id = 8;
101 |   // "channel" : 16,
102 |   required int channel = 9;
103 |   // "radio_power_mode" : "EMBER_TX_POWER_MODE_BOOST",
104 |   required string radio_power_mode = 10;
105 |   // "extended_pan_id" : "0x42455247b439420c"
106 |   required string extended_pan_id = 11;
107 | }
108 | 
109 | enum EmberNetworkStatus {
110 |   EMBER_NO_NETWORK = 0;
111 |   EMBER_JOINING_NETWORK = 1;
112 |   EMBER_JOINED_NETWORK = 2;
113 |   EMBER_JOINED_NETWORK_NO_PARENT = 3;
114 |   EMBER_LEAVING_NETWORK = 4;
115 | }
116 | enum EmberSecurityProfile {
117 |   NONE_SECURITY_PROFILE = 0;
118 |   HA_SECURITY_PROFILE = 1;
119 |   SE_SECURITY_PROFILE_TEST = 2;
120 |   SE_SECURITY_PROFILE_FULL = 3;
121 | }
122 | 
123 | enum EmberNodeType {
124 |   EMBER_UNKNOWN_DEVICE = 0;
125 |   EMBER_COORDINATOR = 1;
126 |   EMBER_ROUTER = 2;
127 |   EMBER_END_DEVICE = 3;
128 |   EMBER_SLEEPY_END_DEVICE = 4;
129 |   EMBER_MOBILE_END_DEVICE = 5;
130 | }
131 | 
132 | enum EmberPowerMode {
133 |   EMBER_TX_POWER_MODE_DEFAULT = 0;
134 |   EMBER_TX_POWER_MODE_BOOST = 1;
135 |   EMBER_TX_POWER_MODE_ALTERNATE = 2;
136 |   EMBER_TX_POWER_MODE_BOOST_AND_ALTERNATE = 3; // 1 | 2
137 | }
138 | 
139 | message BridgeCommand {
140 |   // type ==  "BridgeCommand"
141 |   required string type = 1;
142 | 
143 |   // AFAICT command_id is a unique id that's used to match requests
144 |   // and responses.
145 |   required int command_id = 2;
146 |   required string bridge_address = 3;
147 |   required AddDeviceEncryptionKey json_payload = 4;
148 |   required float timestamp = 5;
149 | }
150 | 
151 | 
152 | // Possible bridge commands = ['add_device_encryption_key', 'leave',
153 | // 'form', 'reboot', 'restart', 'set_cloud_log_level']
154 | message AddDeviceEncryptionKey {
155 |   // 'add_device_encryption_key',
156 |   required string name = 1;
157 |   message Params {
158 |     // 'device_address': device.device_address,
159 |     required bytes device_address = 1;
160 |     // 'encryption_key': pending_claims[device.hardware_xor]
161 |     required bytes encryption_key = 2;
162 |   };
163 |   required Params params = 2;
164 | }
165 | 
166 | 
167 | // The little printer (barringer) device type is 0x01.
168 | enum LittlePrinterCommand {
169 |   set_delivery_and_print = 0x0001;
170 |   set_delivery = 0x0002;
171 |   set_delivery_and_print_no_face = 0x0011;
172 |   set_delivery_no_face = 0x0012;
173 |   set_personality = 0x0102;
174 |   set_personality_with_message = 0x0101;
175 |   set_quip = 0x0202;
176 |   firmware_update = 0xf000;
177 | }
178 | 
179 | enum LittlePrinterCommandResponse {
180 |   success = 0;
181 |   eui64_not_found = 0x01;
182 |   failed_network = 0x02;
183 |   invalid_sequence = 0x20;
184 |   busy = 0x30;
185 |   invalid_size = 0x80;
186 |   invalid_devicetype = 0x81;
187 |   filesystem_error = 0x82;
188 |   filesystem_invalid_id = 0x90;
189 |   filesystem_no_free_filehandles = 0x91;
190 |   filesystem_write_error = 0x92;
191 |   bridge_error = 0xff;
192 | }
193 | 


--------------------------------------------------------------------------------
/notes/resetting_migration.md:
--------------------------------------------------------------------------------
 1 | Migrations are meant for production systems. In order to start with a
 2 | clean migration layout run the following after a model change:
 3 | 
 4 | ```sh
 5 | rm -f sirius/data.sqlite
 6 | -git rm -f migrations/versions/*py
 7 | rm -f migrations/versions/*pyc
 8 | rm -f migrations/versions/*py
 9 | ./manage.py db revision --autogenerate -m "Sirius models."
10 | ./manage.py db upgrade
11 | git add migrations/versions/*py
12 | ```
13 | 


--------------------------------------------------------------------------------
/pyproject.toml:
--------------------------------------------------------------------------------
 1 | [build-system]
 2 | requires = ["setuptools", "wheel"]
 3 | 
 4 | [project]
 5 | name = "sirius"
 6 | readme = "README.md"
 7 | requires-python = ">=3.7,<3.8"
 8 | version = "0.0.0"
 9 | dependencies = [
10 |     "Flask==1.1.1",
11 |     "Flask-Bootstrap==3.3.7.1",
12 |     "Flask-Cors==3.0.8",
13 |     "Flask-Login==0.4.1",
14 |     "Flask-Migrate==2.5.2",
15 |     "Flask-SQLAlchemy==2.4.0",
16 |     "Flask-Script==2.0.6",
17 |     "Flask-Sockets==0.2.1",
18 |     "Flask-WTF==0.14.2",
19 |     "Jinja2==2.10.1",
20 |     "Mako==1.1.0",
21 |     "MarkupSafe==1.1.1",
22 |     "Pillow==6.1.0",
23 |     "SQLAlchemy==1.3.8",
24 |     "WTForms==2.2.1",
25 |     "Werkzeug==0.15.6",
26 |     "alembic==1.1.0",
27 |     "argparse==1.2.1",
28 |     "backports.ssl-match-hostname==3.7.0.1",
29 |     "blinker==1.4",
30 |     "gevent==1.4.0",
31 |     "gevent-websocket==0.10.1",
32 |     "greenlet==0.4.15",
33 |     "gunicorn==19.9.0",
34 |     "httplib2==0.13.1",
35 |     "itsdangerous==1.1.0",
36 |     "nose==1.3.7",
37 |     "oauthlib==3.2.2",
38 |     "psycopg2-binary==2.8.3",
39 |     "pycrypto==2.6.1",
40 |     "redis==3.3.8",
41 |     "requests==2.22.0",
42 |     "requests-oauthlib==1.3.1",
43 |     "selenium==3.141.0",
44 |     "six==1.12.0",
45 |     "twitter==1.18.0",
46 |     "websocket-client==0.56.0",
47 |     "honcho",
48 | ]
49 | 
50 | [project.optional-dependencies]
51 | test = [
52 |     "snapshottest @ git+https://github.com/syrusakbary/snapshottest.git@1.0.0a0",
53 |     "Flask-Testing==0.7.1",
54 | ]
55 | 
56 | [tool.setuptools.packages.find]
57 | include = ["sirius*"]
58 | 


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
1 | # needed for heroku deploy
2 | # see https://github.com/heroku/heroku-buildpack-python/pull/834#issuecomment-1242217467
3 | -e .
4 | 


--------------------------------------------------------------------------------
/runtime.txt:
--------------------------------------------------------------------------------
1 | python-3.7.10
2 | 


--------------------------------------------------------------------------------
/sirius/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nordprojects/sirius/9d88c63a0fc17d4acc5ae12194b93f8591e35a55/sirius/__init__.py


--------------------------------------------------------------------------------
/sirius/coding/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nordprojects/sirius/9d88c63a0fc17d4acc5ae12194b93f8591e35a55/sirius/coding/__init__.py


--------------------------------------------------------------------------------
/sirius/coding/bitshuffle.py:
--------------------------------------------------------------------------------
 1 | """This module contains encoder/decoder functions that are needed but
 2 | don't fit neatly into any category.
 3 | """
 4 | 
 5 | def hardware_xor_from_device_address(device_address):
 6 |     """The "hardware xor" is a 3-byte representation of the device_address.
 7 | 
 8 |     :param device_address: A str containing the hex-encoded device address.
 9 |     """
10 |     b = bytearray.fromhex(device_address)
11 | 
12 |     # little endian
13 |     b.reverse()
14 | 
15 |     claim_address = bytearray(3)
16 |     claim_address[0] = b[0] ^ b[5]
17 |     claim_address[1] = b[1] ^ b[3] ^ b[6]
18 |     claim_address[2] = b[2] ^ b[4] ^ b[7]
19 | 
20 |     result = claim_address[2] << 16 | claim_address[1] << 8 | claim_address[0]
21 | 
22 |     return result
23 | 


--------------------------------------------------------------------------------
/sirius/coding/claiming.py:
--------------------------------------------------------------------------------
  1 | from .crc16 import crc16
  2 | from Crypto.Cipher import AES
  3 | 
  4 | import struct
  5 | import base64
  6 | 
  7 | ZBEE_SEC_CONST_BLOCKSIZE = 16
  8 | 
  9 | CLAIM_CODE_SALT = [ 0x38, 0x96, 0x10, 0xd9,
 10 |                     0xb6, 0xb1, 0x0d, 0x16,
 11 |                     0x9e, 0xe9, 0xbf, 0x87,
 12 |                     0x95, 0x32, 0x62, 0x5b ]
 13 | 
 14 | # This dictionary maps base32 digits to five-bit values.
 15 | #
 16 | # Letter 'A' is omitted and not valid in a claim code.
 17 | # Letter 'I' is mapped to number '1' (i.e. claim code is '1', user enters 'I' by mistake).
 18 | # Letter 'L' is mapped to number '1' (i.e. claim code is '1', user enters 'L' by mistake).
 19 | # Letter 'U' is mapped to letter 'v' (i.e. claim code is 'V', user enters 'U' by mistake).
 20 | CLAIMCODE_BASE32_DICT = {
 21 |   '0': 0x00,
 22 |   '1': 0x01,
 23 |   '2': 0x02,
 24 |   '3': 0x03,
 25 |   '4': 0x04,
 26 |   '5': 0x05,
 27 |   '6': 0x06,
 28 |   '7': 0x07,
 29 |   '8': 0x08,
 30 |   '9': 0x09,
 31 | # 'A': omitted
 32 |   'B': 0x0A,
 33 |   'C': 0x0B,
 34 |   'D': 0x0C,
 35 |   'E': 0x0D,
 36 |   'F': 0x0E,
 37 |   'G': 0x0F,
 38 |   'H': 0x10,
 39 |   'I': 0x01,   # mapped to '1'
 40 |   'J': 0x11,
 41 |   'K': 0x12,
 42 |   'L': 0x01,   # mapped to '1'
 43 |   'M': 0x13,
 44 |   'N': 0x14,
 45 |   'O': 0x15,
 46 |   'P': 0x16,
 47 |   'Q': 0x17,
 48 |   'R': 0x18,
 49 |   'S': 0x19,
 50 |   'T': 0x1A,
 51 |   'U': 0x1B,   # mapped to 'V'
 52 |   'V': 0x1B,
 53 |   'W': 0x1C,
 54 |   'X': 0x1D,
 55 |   'Y': 0x1E,
 56 |   'Z': 0x1F
 57 | }
 58 | 
 59 | CC_ENCODE_LIST = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
 60 |                   'j', 'k', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'v', 'w', 'x', 'y', 'z']
 61 | 
 62 | 
 63 | def canonicalize(claim_code):
 64 |     return claim_code.upper().replace('L', '1').replace('I', '1').replace('U', 'V')
 65 | 
 66 | 
 67 | class InvalidClaimCode(Exception):
 68 |     pass
 69 | 
 70 | def unpack_claim_code(claim_code):
 71 |     clean = claim_code.replace("-", "").upper()
 72 | 
 73 |     if len(clean) != 16:
 74 |         raise InvalidClaimCode("claim codes should be 16 characters")
 75 | 
 76 |     value = 0
 77 | 
 78 |     for i, c in enumerate(clean):
 79 |         if c in CLAIMCODE_BASE32_DICT.keys():
 80 |             value += CLAIMCODE_BASE32_DICT[c] * (32 ** (15 - i))
 81 |         else:
 82 |             raise InvalidClaimCode("%s is not a valid character" % c)
 83 | 
 84 |     device = value & 0xffffff             # 24 bit hardware address xor
 85 |     secret = (value >> 24) & 0xffffffffff # 40 bit secret
 86 |     crc = value >> 64                     # 16 bit crc
 87 | 
 88 |     # Return the components, and the raw 80 bit value
 89 |     return (device, secret, crc, value)
 90 | 
 91 | # This method is inspired by dissectors/packet-zbee-security.c from Wireshark
 92 | # input should be a binary string of 5 bytes in length
 93 | def generate_link_key(input):
 94 |     input_length = len(input) + len(CLAIM_CODE_SALT)
 95 | 
 96 |     if len(input) <= 5:
 97 |         # Padding begins with 1000000
 98 |         # Then pad with zeroes until we're at 14 bytes
 99 |         input = input + b'\x80' + b'\x00' * (ZBEE_SEC_CONST_BLOCKSIZE - 2 - len(input) - 1)
100 | 
101 |         # Pad with the original length encoded as a 16bit int
102 |         # Python3
103 |         input = input + bytes( [((input_length * 8) >> 8 & 0xff)] )
104 |         input = input + bytes( [((input_length * 8) >> 0 & 0xff)] )
105 |         # Python2
106 |         # input = input + chr((input_length * 8) >> 8 & 0xff)
107 |         # input = input + chr((input_length * 8) >> 0 & 0xff)
108 | 
109 |     elif input_length != ZBEE_SEC_CONST_BLOCKSIZE:
110 |         raise InvalidClaimCode("cannot handle input size %d" % input_length)
111 | 
112 |     # We encrypt the salt and the input bytes
113 |     blocks = [bytes(CLAIM_CODE_SALT), input] # Python3
114 |     # blocks = [str(bytearray(CLAIM_CODE_SALT)), input] # Python2
115 | 
116 |     output = bytes(16) # Works in Python3
117 |     # output = bytearray(16) # Works in Python2
118 | 
119 |     for block in blocks:
120 |         aes_encoder = AES.new(output, AES.MODE_ECB) # Python3
121 |         # aes_encoder = AES.new(str(output), AES.MODE_ECB) # Python2
122 |         h = aes_encoder.encrypt(block)
123 |         output = bytearray(16)
124 |         for i in range(len(output)):
125 |             output[i] = h[i] ^ block[i] # Python3
126 |             # output[i] = ord(h[i]) ^ ord(block[i]) # Python2
127 |         output = bytes(output)
128 | 
129 |     return output
130 | 
131 | 
132 | # Codes go through the following process:
133 | #
134 | # 1. Cleaning
135 | # 2. Convert from 5-bit to 8-bit (16 chars down to 10 chars)
136 | # 3. Checksum is checked
137 | # 4. XOR EUI64 + Base64 security hash + CRC are returned
138 | #
139 | # Return the link key in Base64, and the XORed hardware_address
140 | def process_claim_code(claim_code):
141 |     hardware_xor, secret, crc, raw_value = unpack_claim_code(claim_code)
142 | 
143 |     # Generate our own CRC from the raw_value, and confirm it matches the extracted crc
144 |     data_for_crc = struct.pack("<Q", raw_value & 0xffffffffffffffff)
145 |     server_crc = crc16(data_for_crc) # this works in Python3
146 |     # server_crc = crc16( bytearray(data_for_crc) ) # this works in Python2
147 | 
148 |     if server_crc != crc:
149 |         raise InvalidClaimCode("CRC problem")
150 | 
151 |     # Pack the 40-bit number as a LE long long, and then truncate back to 5 bytes
152 |     packed_secret = struct.pack("<Q", secret)[0:5]
153 |     link_key = generate_link_key(packed_secret)
154 |     link_key_b64 = base64.b64encode(link_key)
155 | 
156 |     return (hardware_xor, link_key_b64)
157 | 
158 | 
159 | def key_from_claim_code(claim_code):
160 |     _, key = process_claim_code(claim_code)
161 |     return key
162 | 
163 | 
164 | def encode(device, secret):
165 |     device = device & 0xffffff
166 |     secret = secret & 0xffffffffff
167 | 
168 |     value = device | (secret << 24)
169 |     data = bytearray(struct.pack("<Q", value))
170 |     crc = crc16(data, 0xffff)
171 |     cc = value | (crc << 64)
172 | 
173 |     text = ''
174 | 
175 |     i = 16
176 |     while i> 0:
177 |         text = CC_ENCODE_LIST[cc & 0x1f] + text
178 |         cc = cc >> 5
179 |         if (i==5) or (i==9) or (i==13):
180 |             text = '-' + text
181 |         i -= 1
182 | 
183 |     return text
184 | 


--------------------------------------------------------------------------------
/sirius/coding/crc16.py:
--------------------------------------------------------------------------------
 1 | def crc16(buf, crc = 0xffff):
 2 |     for b in buf:
 3 |         crc = ((crc<<8) ^ CCITT_16[(crc>>8) ^ b]) & 0xffff
 4 |     return crc
 5 | 
 6 | CCITT_16 = [
 7 |     0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
 8 |     0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
 9 |     0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
10 |     0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
11 |     0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
12 |     0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
13 |     0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
14 |     0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
15 |     0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
16 |     0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
17 |     0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
18 |     0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
19 |     0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
20 |     0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
21 |     0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
22 |     0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
23 |     0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
24 |     0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
25 |     0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
26 |     0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
27 |     0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
28 |     0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
29 |     0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
30 |     0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
31 |     0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
32 |     0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
33 |     0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
34 |     0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
35 |     0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
36 |     0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
37 |     0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
38 |     0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
39 |     ]
40 | 


--------------------------------------------------------------------------------
/sirius/coding/decoders.py:
--------------------------------------------------------------------------------
  1 | """This module decodes incoming the incoming dictionaries into
  2 | "messages". Each message is its own type for easier dispatching.
  3 | """
  4 | import base64
  5 | import struct
  6 | 
  7 | from sirius.protocol import messages
  8 | from sirius.coding import bitshuffle
  9 | 
 10 | 
 11 | class BERGCloudConst(object):
 12 |     BC_EVENT_PRODUCT_ANNOUNCE   = 0xA000
 13 |     BC_COMMAND_SET_BERGCLOUD_ID = 0xB000
 14 | 
 15 |     BC_COMMAND_START_BINARY     = 0xC000
 16 |     BC_COMMAND_START_PACKED     = 0xC100
 17 |     BC_COMMAND_ID_MASK          = 0x00FF
 18 |     BC_COMMAND_FORMAT_MASK      = 0xFF00
 19 | 
 20 |     BC_COMMAND_DISPLAY_IMAGE    = 0xD000
 21 |     BC_COMMAND_DISPLAY_TEXT     = 0xD001
 22 | 
 23 |     BC_EVENT_START_BINARY       = 0xE000
 24 |     BC_EVENT_START_PACKED       = 0xE100
 25 |     BC_EVENT_ID_MASK            = 0x00FF
 26 |     BC_EVENT_FORMAT_MASK        = 0xFF00
 27 | 
 28 |     BC_COMMAND_FIRMWARE_ARDUINO = 0xF010
 29 |     BC_COMMAND_FIRMWARE_MBED    = 0xF020
 30 | 
 31 | 
 32 | class DeviceEventConst(object):
 33 |     EVENT_HEADER_SIZE = 10
 34 | 
 35 |     EVENT_HEARTBEAT = 1
 36 |     EVENT_DID_PRINT = 2
 37 |     EVENT_DID_POWER_ON = 3
 38 | 
 39 |     EVENT_HEARTBEAT_SIZE = 4
 40 |     EVENT_DID_PRINT_SIZE = 5
 41 |     EVENT_DID_POWER_ON_SIZE_LONG = 74  # Using fragmentation
 42 |     EVENT_DID_POWER_ON_SIZE_SHORT = 58 # No fragmentation
 43 | 
 44 |     RESET_DICT = {
 45 |         0x0000: "Undeterminable cause",
 46 |         0x0100: "FIB bootloader",
 47 |         0x0200: "Ember bootloader",
 48 |         0x0300: "External reset",
 49 |         0x0400: "Power on",
 50 |         0x0500: "Watchdog",
 51 |         0x0600: "Software triggered",
 52 |         0x0700: "Software crash",
 53 |         0x0800: "Flash failure",
 54 |         0x0900: "Fatal error",
 55 |         0x0a00: "Access fault",
 56 |     }
 57 | 
 58 | 
 59 | def decode_message(data):
 60 |     """Decodes a single incoming message from data.
 61 | 
 62 |     :param data: A python dictionary, as decoded from json.
 63 |     """
 64 |     if data['type'] == 'BridgeEvent':
 65 |         return _decode_bridge_event(data)
 66 | 
 67 |     elif data['type'] == 'BridgeLog':
 68 |         return _decode_bridge_log(data)
 69 | 
 70 |     elif data['type'] == 'BridgeCommandResponse':
 71 |         return _decode_bridge_command_response(data)
 72 | 
 73 |     elif data['type'] == 'DeviceCommandResponse':
 74 |         return _decode_device_command_response(data)
 75 | 
 76 |     elif data['type'] == 'DeviceEvent':
 77 |         return _decode_device_event(data)
 78 | 
 79 |     else:
 80 |         return messages.UnknownEvent(data)
 81 | 
 82 |     assert False, "never reached"
 83 | 
 84 | 
 85 | def _decode_bridge_event(data):
 86 |     """Decodes a single bridge event from data.
 87 | 
 88 |     :param data: A python dictionary, as decoded from json.
 89 |     """
 90 |     try:
 91 |         name = data['json_payload']['name']
 92 |         payload = data['json_payload']
 93 |     except KeyError as e:
 94 |         return messages.MalformedEvent(data, 'Missing field {}'.format(e))
 95 | 
 96 |     if name == 'power_on':
 97 |         return messages.PowerOn(
 98 |             bridge_address=data['bridge_address'],
 99 |             model=payload['model'],
100 |             firmware_version=payload['firmware_version'],
101 |             ncp_version=payload['ncp_version'],
102 |             local_ip_address=payload['local_ip_address'],
103 |             mac_address=payload['mac_address'],
104 |             uptime=payload['uptime'],
105 |             uboot_environment=payload['uboot_environment'],
106 |             network_info=payload['network_info'],
107 |         )
108 |     elif name == 'device_connect':
109 |         return messages.DeviceConnect(
110 |             bridge_address=data['bridge_address'],
111 |             device_address=payload['device_address'],
112 |         )
113 |     elif name == 'device_disconnect':
114 |         return messages.DeviceDisconnect(
115 |             bridge_address=data['bridge_address'],
116 |             device_address=payload['device_address'],
117 |         )
118 |     elif name == 'encryption_key_required':
119 |         return messages.EncryptionKeyRequired(
120 |             bridge_address=data['bridge_address'],
121 |             device_address=payload['device_address'],
122 |             hardware_xor=bitshuffle.hardware_xor_from_device_address(
123 |                 payload['device_address']),
124 |         )
125 |     else:
126 |         return messages.UnknownEvent(data)
127 | 
128 |     assert False, "never reached"
129 | 
130 | 
131 | def _decode_bridge_log(data):
132 |     """Decodes the bridge log from data.
133 | 
134 |     :param data: A python dictionary, as decoded from json.
135 |     """
136 |     return messages.BridgeLog(
137 |         bridge_address=data['bridge_address'],
138 |         records=data['records'],
139 |     )
140 | 
141 | 
142 | def _decode_device_event(data):
143 |     """Decodes a device event from data.
144 | 
145 |     :param data: A python dictionary, as decoded from json.
146 |     """
147 |     try:
148 |         payload = data['binary_payload']
149 |         device_address = data['device_address']
150 |         binary = base64.b64decode(payload)
151 |     except KeyError as e:
152 |         return messages.MalformedEvent(data, 'Missing field {}'.format(e))
153 |     except TypeError as e:
154 |         return messages.MalformedEvent(data, 'Invalid base64 {}'.format(e))
155 | 
156 |     offset = 0
157 |     code, command_id, payload_length = \
158 |         struct.unpack_from("<HII", binary, offset)
159 | 
160 |     expected_length = DeviceEventConst.EVENT_HEADER_SIZE + payload_length
161 |     if len(binary) != expected_length:
162 |         return messages.MalformedEvent(data, 'Is: {}, should be: {}'.format(
163 |             len(binary), expected_length))
164 | 
165 |     if code & BERGCloudConst.BC_EVENT_FORMAT_MASK == BERGCloudConst.BC_EVENT_START_BINARY:
166 |         return messages.BergCloudStartBinary(
167 |             device_address=device_address,
168 |             event_id=code & BERGCloudConst.BC_EVENT_ID_MASK,
169 |             data=binary[offset:],
170 |         )
171 | 
172 |     elif code & BERGCloudConst.BC_EVENT_FORMAT_MASK == BERGCloudConst.BC_EVENT_START_PACKED:
173 |         return messages.BergCloudStartPacked(
174 |             device_address=device_address,
175 |             event_id=code & BERGCloudConst.BC_EVENT_ID_MASK,
176 |             data=binary[offset:],
177 |         )
178 | 
179 |     elif code == DeviceEventConst.EVENT_DID_POWER_ON:
180 |         if payload_length == DeviceEventConst.EVENT_DID_POWER_ON_SIZE_LONG:
181 |             power_on_fields = struct.unpack_from("<I32s32sIH", binary, offset)
182 | 
183 |         elif payload_length == DeviceEventConst.EVENT_DID_POWER_ON_SIZE_SHORT:
184 |             power_on_fields = struct.unpack_from("<I24s24sIH", binary, offset)
185 | 
186 |         else:
187 |             return messages.MalformedEvent(
188 |                 data, 'power_on payload wrong size. Is {}. Expected: {}'.format(
189 |                     len(payload_length),
190 |             ))
191 | 
192 |         deviceType, firmwareBuildVersion, loaderBuildVersion, protocolVersion, resetDescription = power_on_fields
193 | 
194 |         # High byte of resetDescription is the reset 'base type', low byte gives
195 |         # extended information about the reset cause.
196 |         reset_description = DeviceEventConst.RESET_DICT.get(resetDescription & 0xff00)
197 |         if reset_description is None:
198 |             return messages.MalformedEvent(
199 |                 data, 'Invalid reset description. {}'.format(resetDescription))
200 | 
201 |         return messages.DeviceDidPowerOn(
202 |             device_address=device_address,
203 |             device_type=deviceType,
204 |             firmware_build_version=firmwareBuildVersion,
205 |             loader_build_version=loaderBuildVersion,
206 |             protocol_version=protocolVersion,
207 |             reset_description=resetDescription,
208 |         )
209 | 
210 |     elif code == BERGCloudConst.BC_EVENT_PRODUCT_ANNOUNCE:
211 |         if payload_length != 20:
212 |             return messages.MalformedEvent(
213 |                 data, 'Invalid BC_EVENT_PRODUCT_ANNOUNCE. Is {}. Expected 20.'.format(payload_length))
214 | 
215 |         id0, id1, id2, id3, version =  struct.unpack_from(">LLLLL", binary, offset)
216 |         return messages.BergCloudProductAnnounce(
217 |             device_address=device_address,
218 |             product_id='%08x%08x%08x%08x' % (id0, id1, id2, id3),
219 |             product_version=version,
220 |         )
221 | 
222 |     elif code == DeviceEventConst.EVENT_HEARTBEAT:
223 |         if payload_length != DeviceEventConst.EVENT_HEARTBEAT_SIZE:
224 |             return messages.MalformedEvent(
225 |                 data, 'Invalid EVENT_HEARTBEAT length. Is: {}. Expected: {}'.format(
226 |                     payload_length, DeviceEventConst.EVENT_HEARTBEAT_SIZE))
227 | 
228 |         uptime =  struct.unpack_from("<I", binary, offset)
229 |         return messages.DeviceHeartbeat(
230 |             bridge_address=data['bridge_address'],
231 |             device_address=device_address,
232 |             uptime=uptime,
233 |         )
234 | 
235 |     elif code == DeviceEventConst.EVENT_DID_PRINT:
236 |         if payload_length != DeviceEventConst.EVENT_DID_PRINT_SIZE:
237 |             return messages.MalformedEvent(
238 |                 data, 'Invalid EVENT_DID_PRINT length. Is: {}. Expected: {}'.format(
239 |                     payload_length, DeviceEventConst.EVENT_DID_PRINT_SIZE))
240 | 
241 |         print_type, print_id = struct.unpack_from("<BI", binary, offset)
242 | 
243 |         # 0x01 => :delivery,
244 |         # 0x10 => :nothing_to_print,
245 |         # 0x11 => :quip,
246 | 
247 |         return messages.DeviceDidPrint(
248 |             device_address=device_address,
249 |             type=print_type,
250 |             id=print_id,
251 |         )
252 | 
253 |     else:
254 |         return messages.UnknownEvent(data)
255 | 
256 |     assert False, "never reached"
257 | 
258 | def _decode_bridge_command_response(data):
259 |     """Decodes a BridgeCommandResponse.
260 | 
261 |     :param data: A python dictionary, as decoded from json.
262 |     """
263 |     return messages.BridgeCommandResponse(
264 |         bridge_address=data['bridge_address'],
265 |         command_id=data['command_id'],
266 |         timestamp=data['timestamp'],
267 |         return_code=data['return_code'],
268 |     )
269 | 
270 | def _decode_device_command_response(data):
271 |     """Decodes a DeviceCommandResponse.
272 | 
273 |     :param data: A python dictionary, as decoded from json.
274 |     """
275 |     return messages.DeviceCommandResponse(
276 |         bridge_address=data['bridge_address'],
277 |         command_id=data['command_id'],
278 |         timestamp=data['timestamp'],
279 |         return_code=data['return_code'],
280 |     )
281 | 


--------------------------------------------------------------------------------
/sirius/coding/default_template.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 |   <head>
 4 |     <meta charset="utf-8">
 5 |     <style>
 6 |       html, body {
 7 |         margin: 0;
 8 |         padding: 0;
 9 |         background-color: white;
10 |         overflow-x: hidden;
11 |         word-wrap: break-word;
12 |       }
13 | 
14 |       body {
15 |         /*
16 |            first line must be white because of a bug in the image encoder,
17 |            that inverts the image if the first pixel is black
18 |         */
19 |         margin-top: 1px;
20 |         margin-bottom: 80px;
21 |         border: 1px;
22 |         font-family: Helvetica, Arial, sans-serif;
23 |         font-size: 30px;
24 |       }
25 |       h1, h2, h3, h4, h5, h6 {
26 |         margin-bottom: 20px;
27 |       }
28 | 
29 |       li {
30 |         margin-bottom: 0.5em;
31 |       }
32 | 
33 |       .header {
34 |         font-weight: 800;
35 |         text-transform: uppercase;
36 |         font-size: 18px;
37 |         margin-bottom: 18px;
38 |         text-align: center;
39 |       }
40 | 
41 |       img {
42 |         max-width: 100%;
43 |       }
44 |     </style>
45 |   </head>
46 |   <body>
47 |     <div class="header">
48 |       {{ date.strftime('%H:%M | %d-%b-%Y') }}{% if from_name %} | {{ from_name }}{% endif %}
49 |     </div>
50 |     {{ raw_html|safe }}
51 |   </body>
52 | </html>
53 | 


--------------------------------------------------------------------------------
/sirius/coding/encoders.py:
--------------------------------------------------------------------------------
  1 | """Encoders for various commands. All encoders return python
  2 | dictionaries that can be encoded directly as json.
  3 | """
  4 | import struct
  5 | import base64
  6 | 
  7 | from sirius.coding import image_encoding
  8 | from sirius.coding import claiming
  9 | from sirius.protocol import messages
 10 | 
 11 | __all__ = [
 12 |     'encode_bridge_command',
 13 | ]
 14 | 
 15 | 
 16 | def _encode_pixels(pixel_count, rle_image):
 17 |     """
 18 |     :param pixel_count: total number of pixels
 19 |     :param rle_image: Run-length encoded black and white image.
 20 |     :returns: The binary payload
 21 |     """
 22 |     printer_control = struct.pack("<13B",
 23 |         0x1d, 0x73, 0x03, 0xe8, # max printer speed
 24 |         0x1d, 0x61, 0xd0, # printer acceleration
 25 |         0x1d, 0x2f, 0x0f, # peak current
 26 |         0x1d, 0x44, 0x80, # max intensity
 27 |     )
 28 |     printer_byte_count = pixel_count // 8
 29 |     n3, n3_remainder = divmod(printer_byte_count, 65536)
 30 |     n2, n1 = divmod(n3_remainder, 256)
 31 |     printer_data = struct.pack("<8B", 0x1b, 0x2a, n1, n2, n3, 0, 0, 48)
 32 |     header_region = struct.pack("<BI", 0, len(printer_control) + len(printer_data))
 33 |     header_region += printer_control + printer_data
 34 | 
 35 |     # payload including the header
 36 |     payload = struct.pack("<IB", len(header_region) + len(rle_image) + 1, 0)
 37 |     payload += header_region + rle_image
 38 | 
 39 |     return payload
 40 | 
 41 | 
 42 | def _encode_printer_message(command, payload, print_id):
 43 |     """
 44 |     :param command: See LittlePrinterCommand in protocol.proto.
 45 |     :param pixel_count: total number of pixels
 46 |     :param rle_image: Run-length encoded black and white image.
 47 |     :print_id: unique 32-bit number for ack-ing the print (sent back in didprint event)
 48 |     :returns: The binary payload
 49 |     """
 50 |     LITTLE_PRINTER_DEVICE_ID = 1
 51 | 
 52 |     # device type c, reserved byte c,
 53 |     # command_name <H (short), file_id <L (long),
 54 |     # unimplemented CRC (long is zero)
 55 |     command_header = struct.pack(
 56 |         "<BBHII",
 57 |         LITTLE_PRINTER_DEVICE_ID, 0,
 58 |         command,
 59 |         print_id, 0,
 60 |     )
 61 |     entire_payload = command_header + struct.pack("<I", len(payload)) + payload
 62 | 
 63 |     return entire_payload
 64 | 
 65 | 
 66 | def _payload_from_pixels(pixels):
 67 |     """
 68 |     :returns: binary payload to be embedded in full message.
 69 |     """
 70 |     pixel_count, rle_pixels = image_encoding.rle_from_bw(pixels)
 71 |     return _encode_pixels(pixel_count, rle_pixels)
 72 | 
 73 | 
 74 | def encode_bridge_command(bridge_address, command, command_id, timestamp):
 75 |     """Encodes a BridgeCommand into a dict that can be serialized as json.
 76 | 
 77 |     :param bridge_address: The hex bridge address.
 78 |     :param command: A command from messages.py
 79 |     :param command_id: A unique id that is used to ack the command.
 80 |     :param timestamp: unix timestamp. Unclear why this is necessary.
 81 |     """
 82 |     def make(extra):
 83 |         base = {
 84 |             'type': 'BridgeCommand',
 85 |             'bridge_address': bridge_address,
 86 |             'command_id': command_id,
 87 |             # Apparently in ISO format?
 88 |             'timestamp': timestamp,
 89 |         }
 90 |         base.update(extra)
 91 |         return base
 92 | 
 93 |     if type(command) == messages.AddDeviceEncryptionKey:
 94 |         return make({
 95 |             'json_payload': {
 96 |                 'name': 'add_device_encryption_key',
 97 |                 'params': {
 98 |                     'device_address': command.device_address,
 99 |                     'encryption_key': claiming.key_from_claim_code(command.claim_code).decode('utf-8'),
100 |                 },
101 |             },
102 |         })
103 | 
104 |     elif type(command) == messages.SetDeliveryAndPrint:
105 |         return make({
106 |             'binary_payload': base64.b64encode(_encode_printer_message(
107 |                 0x1, _payload_from_pixels(command.pixels), command_id)).decode('utf-8'),
108 |             'device_address': command.device_address,
109 |             'type': 'DeviceCommand',
110 |         })
111 | 
112 |     elif type(command) == messages.SetDelivery:
113 |         return make({
114 |             'binary_payload': base64.b64encode(_encode_printer_message(
115 |                 0x2, _payload_from_pixels(command.pixels), command_id)).decode('utf-8'),
116 |             'device_address': command.device_address,
117 |             'type': 'DeviceCommand',
118 |         })
119 | 
120 |     elif type(command) == messages.SetDeliveryAndPrintNoFace:
121 |         return make({
122 |             'binary_payload': base64.b64encode(_encode_printer_message(
123 |                 0x11, _payload_from_pixels(command.pixels), command_id)).decode('utf-8'),
124 |             'device_address': command.device_address,
125 |             'type': 'DeviceCommand',
126 |         })
127 | 
128 |     elif type(command) == messages.SetDeliveryNoFace:
129 |         return make({
130 |             'binary_payload': base64.b64encode(_encode_printer_message(
131 |                 0x12, _payload_from_pixels(command.pixels), command_id)).decode('utf-8'),
132 |             'device_address': command.device_address,
133 |             'type': 'DeviceCommand',
134 |         })
135 | 
136 |     elif type(command) == messages.SetPersonality:
137 |         payload = (
138 |             _payload_from_pixels(command.face_pixels)
139 |             + _payload_from_pixels(command.nothing_to_print_pixels)
140 |             + _payload_from_pixels(command.cannot_see_bridge_pixels)
141 |             + _payload_from_pixels(command.cannot_see_internet_pixels))
142 | 
143 |         return make({
144 |             'binary_payload': base64.b64encode(_encode_printer_message(
145 |                 0x0102, payload, command_id)).decode('utf-8'),
146 |             'device_address': command.device_address,
147 |             'type': 'DeviceCommand',
148 |         })
149 | 
150 |     elif type(command) == messages.SetPersonalityWithMessage:
151 |         payload = (
152 |             _payload_from_pixels(command.face_pixels)
153 |             + _payload_from_pixels(command.nothing_to_print_pixels)
154 |             + _payload_from_pixels(command.cannot_see_bridge_pixels)
155 |             + _payload_from_pixels(command.cannot_see_internet_pixels)
156 |             + _payload_from_pixels(command.message_pixels))
157 | 
158 |         return make({
159 |             'binary_payload': base64.b64encode(_encode_printer_message(
160 |                 0x0101, payload, command_id)).decode('utf-8'),
161 |             'device_address': command.device_address,
162 |             'type': 'DeviceCommand',
163 |         })
164 | 
165 |     elif type(command) == messages.SetQuip:
166 |         payload = (
167 |             _payload_from_pixels(command.quip_pixels_1)
168 |             + _payload_from_pixels(command.quip_pixels_2)
169 |             + _payload_from_pixels(command.quip_pixels_3))
170 | 
171 |         return make({
172 |             'binary_payload': base64.b64encode(_encode_printer_message(
173 |                 0x202, payload, command_id)).decode('utf-8'),
174 |             'device_address': command.device_address,
175 |             'type': 'DeviceCommand',
176 |         })
177 | 
178 |     assert False, "unknown command type: {}".format(command)
179 | 


--------------------------------------------------------------------------------
/sirius/coding/image_encoding.py:
--------------------------------------------------------------------------------
  1 | from PIL import Image
  2 | from itertools import groupby
  3 | import struct
  4 | import io
  5 | import tempfile
  6 | 
  7 | WHITE = '\xff'
  8 | BLACK = '\x00'
  9 | THRESHOLD = 127
 10 | TRANSLATE = [(1536, 255), (1152, 254), (768, 253), (384, 252), (251, 251)]
 11 | 
 12 | 
 13 | def pixel_to_bw(p):
 14 |     if p == (0, 0, 0, 0): # 0 alpha means white.
 15 |         return WHITE
 16 |     elif p[0] > THRESHOLD or p[1] > THRESHOLD or p[2] > THRESHOLD:
 17 |         return WHITE
 18 |     else:
 19 |         return BLACK
 20 | 
 21 | 
 22 | def ilen(i):
 23 |     "Returns length of an iterator in constant space."
 24 |     return sum(1 for _ in i)
 25 | 
 26 | 
 27 | # so what we have is a list of runs, alternating white and black,
 28 | # starting with white.
 29 | # the scheme for our little printer RLE is:
 30 | # - runs of 0..251 inclusive are stored as a byte
 31 | # - if larger, pull off chunks of 1536, 1152, 768, 384, 251 (encoded as
 32 | # 255, 254, 253, 252, 251) until small enough
 33 | # when a large number is broken into chunks, each chunk needs
 34 | # to be suffixed by a zero so it snaps back to swap it back to the
 35 | # correct colour
 36 | def rle(lengths):
 37 |     for length in lengths:
 38 |         if length == 0:
 39 |             yield length
 40 |         elif length <= 251:
 41 |             yield length
 42 |         elif length > 251:
 43 |             remainder = length
 44 |             done_first = False
 45 |             while remainder > 251:
 46 |                 chunk, code = [t for t in TRANSLATE if remainder >= t[0]][0]
 47 |                 remainder -= chunk
 48 |                 if done_first:
 49 |                     yield 0
 50 |                 else:
 51 |                     done_first = True
 52 |                 yield code
 53 |             else:
 54 |                 if remainder > 0:
 55 |                     yield 0
 56 |                     yield remainder
 57 | 
 58 | 
 59 | def crop_384(im):
 60 |     w, h = im.size
 61 |     return im.crop((0, 0, 384, min(h, 10000)))
 62 | 
 63 | 
 64 | def convert_to_1bit(im):
 65 |     return im.convert('1')
 66 | 
 67 | 
 68 | def rle_from_bw(bw_image):
 69 |     """
 70 |     :param bw_image: A mode "1" PIL image.
 71 |     :returns: A 2-tuple of (number of pixels, RLE-encoded pixel data)
 72 |     """
 73 |     bw_image = bw_image.transpose(Image.ROTATE_180)
 74 |     pixels = list(bw_image.getdata())
 75 | 
 76 |     # Group each run length into lists each list is (result of
 77 |     # identity function, [actual pixels])
 78 |     grouped = groupby(pixels)
 79 | 
 80 |     # create list of tuples (WHITE|BLACK, run_length)
 81 |     groups = []
 82 |     for k, g in grouped:
 83 |         groups.append((k, ilen(g)))
 84 | 
 85 |     # the decoder assumes that the first run is white, so if the
 86 |     # first pixel is black, add a zero run of white
 87 |     if groups[0][0] == BLACK:
 88 |         groups.insert(0, (WHITE, 0))
 89 | 
 90 |     # encode using our custom encoding
 91 |     lengths = [g[1] for g in groups]
 92 |     x = bytearray(rle(lengths))
 93 |     compressed_data = struct.pack("<%dB" % len(x), *x)
 94 | 
 95 |     # package up with length as header
 96 |     # first byte is compressed type, always 1
 97 |     output = struct.pack("<BL", 0x01, len(compressed_data)) + compressed_data
 98 | 
 99 |     # return (number of pixels, output)
100 |     return len(pixels), output
101 | 
102 | 
103 | def html_to_png(html):
104 |     """ This works:
105 |     <html><body style="width: 384px; margin: 0;">
106 |     <img src="https://dl.dropboxusercontent.com/u/165957/Escher.gif">
107 |     </body></html>
108 |     """
109 |     from selenium import webdriver
110 |     driver = None
111 |     try:
112 |         caps = {'acceptSslCerts': True}
113 |         driver = webdriver.PhantomJS(
114 |             'phantomjs', desired_capabilities=caps,
115 |             service_args=['--ignore-ssl-errors=true', '--ssl-protocol=any'])
116 |         driver.set_window_size(384, 5)
117 | 
118 |         # note that the .html suffix is required to make phantomjs
119 |         # pick up the mime-type and render correctly.
120 |         with tempfile.NamedTemporaryFile(suffix='.html') as f:
121 |             if isinstance(html, str):
122 |                 f.write(html.encode('utf8'))
123 |             else:
124 |                 f.write(html)
125 |             f.flush()
126 |             driver.get('file://' + f.name)
127 |             data = io.BytesIO(driver.get_screenshot_as_png())
128 | 
129 |         return data
130 |     finally:
131 |         if driver:
132 |             driver.quit()
133 | 
134 | 
135 | def default_pipeline(html):
136 |     """Encode HTML into an RLE image."""
137 |     data = html_to_png(html)
138 |     return png_pipeline(data)
139 | 
140 | 
141 | def png_pipeline(png_data):
142 |     image = Image.open(png_data)
143 |     image = crop_384(image)
144 |     return convert_to_1bit(image)
145 | 


--------------------------------------------------------------------------------
/sirius/coding/snapshots/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nordprojects/sirius/9d88c63a0fc17d4acc5ae12194b93f8591e35a55/sirius/coding/snapshots/__init__.py


--------------------------------------------------------------------------------
/sirius/coding/snapshots/snap_test_image_coding_snapshots.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | # snapshottest: v1 - https://goo.gl/zC4yUc
 3 | from __future__ import unicode_literals
 4 | 
 5 | from snapshottest import Snapshot
 6 | from snapshottest.file import FileSnapshot
 7 | 
 8 | 
 9 | snapshots = Snapshot()
10 | 
11 | snapshots['ImageCodingSnapshotCase::test_snapshot_fixtures hello_world'] = FileSnapshot('snap_test_image_coding_snapshots/ImageCodingSnapshotCase::test_snapshot_fixtures hello_world.png')
12 | 
13 | snapshots['ImageCodingSnapshotCase::test_snapshot_template_fixtures hello_world'] = FileSnapshot('snap_test_image_coding_snapshots/ImageCodingSnapshotCase::test_snapshot_template_fixtures hello_world.png')
14 | 


--------------------------------------------------------------------------------
/sirius/coding/snapshots/snap_test_image_coding_snapshots/ImageCodingSnapshotCase::test_snapshot_fixtures hello_world.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nordprojects/sirius/9d88c63a0fc17d4acc5ae12194b93f8591e35a55/sirius/coding/snapshots/snap_test_image_coding_snapshots/ImageCodingSnapshotCase::test_snapshot_fixtures hello_world.png


--------------------------------------------------------------------------------
/sirius/coding/snapshots/snap_test_image_coding_snapshots/ImageCodingSnapshotCase::test_snapshot_template_fixtures hello_world.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nordprojects/sirius/9d88c63a0fc17d4acc5ae12194b93f8591e35a55/sirius/coding/snapshots/snap_test_image_coding_snapshots/ImageCodingSnapshotCase::test_snapshot_template_fixtures hello_world.png


--------------------------------------------------------------------------------
/sirius/coding/templating.py:
--------------------------------------------------------------------------------
 1 | import os, datetime
 2 | import jinja2
 3 | 
 4 | DEFAULT_TEMPLATE_FILE = os.path.join(os.path.dirname(__file__), 'default_template.html')
 5 | 
 6 | ENV = jinja2.Environment()
 7 | 
 8 | # TODO apply scrubber library if wanted.
 9 | # https://pypi.python.org/pypi/scrubber
10 | 
11 | def default_template(raw_html, from_name, date=None):
12 |     if date is None:
13 |         date = datetime.datetime.now()
14 | 
15 |     with open(DEFAULT_TEMPLATE_FILE) as f:
16 |         template = f.read()
17 | 
18 |     t = ENV.from_string(template)
19 |     return t.render(
20 |         raw_html=raw_html,
21 |         date=date,
22 |         from_name=from_name
23 |     )
24 | 


--------------------------------------------------------------------------------
/sirius/coding/test_claim_coding.py:
--------------------------------------------------------------------------------
 1 | import unittest
 2 | 
 3 | from sirius.coding import claiming
 4 | 
 5 | 
 6 | CC_TEST_VECTORS = [
 7 |     ("64z0-0000-0000-0000", 0x000000, 0x0000000000),
 8 |     ("kzgz-zzzz-zzzz-zzzz", 0xffffff, 0xffffffffff),
 9 |     ("c1zp-g2ec-sqqh-28t5", 0x012345, 0x6789abcdef),
10 |     ("d2y7-dv9z-4rz9-7bk3", 0x93aa43, 0x766d3f263e),
11 | ]
12 | 
13 | 
14 | class CodingCase(unittest.TestCase):
15 | 
16 |     def test_decoding(self):
17 |         claim_code = '6xwh-441j-8115-zyrh'
18 |         expected_encryption_key = b'F7D9bmztHV32+WJScGZR0g=='
19 |         _, calculated_encryption_key = claiming.process_claim_code(claim_code)
20 | 
21 |         self.assertEqual(expected_encryption_key, calculated_encryption_key)
22 | 
23 |     def test_encoding(self):
24 |         for cc, device, secret in CC_TEST_VECTORS:
25 |             self.assertEqual(claiming.encode(device, secret), cc)
26 |             dec_device, dec_secret, _, _ = claiming.unpack_claim_code(cc)
27 |             self.assertEqual(dec_device, device)
28 |             self.assertEqual(dec_secret, secret)
29 | 
30 |     def test_coding_from_real_world(self):
31 |         device_address = '000d6f000273c164'
32 |         # only the last 24 bits of the device address are used
33 |         device_address_int = int(device_address, 16) & 0xffffff
34 |         # secret only known to printer and claim code
35 |         secret = 0xeb1ba696a0
36 | 
37 |         self.assertEqual(
38 |             claiming.encode(device_address_int, secret),
39 |             'n5ry-p6x6-kth7-7hc4',
40 |         )
41 | 


--------------------------------------------------------------------------------
/sirius/coding/test_encoders.py:
--------------------------------------------------------------------------------
  1 | import unittest
  2 | 
  3 | from PIL import Image, ImageDraw
  4 | 
  5 | from sirius.coding import encoders
  6 | from sirius.protocol import messages
  7 | 
  8 | class EncodersCase(unittest.TestCase):
  9 |     # AddDeviceEncryptionKey
 10 |     def test_add_device_encryption_key(self):
 11 |         claim_code = '6xwh-441j-8115-zyrh'
 12 |         expected_encryption_key = 'F7D9bmztHV32+WJScGZR0g=='
 13 | 
 14 |         command = messages.AddDeviceEncryptionKey(
 15 |             'some-bridge-address',
 16 |             'some-device-address',
 17 |             claim_code
 18 |         )
 19 | 
 20 |         json = encoders.encode_bridge_command('some-bridge-address', command, 1, '0')
 21 | 
 22 |         expected_json = {
 23 |             'type': 'BridgeCommand',
 24 |             'bridge_address': 'some-bridge-address',
 25 |             'command_id': 1,
 26 |             'timestamp': '0',
 27 |             'json_payload': {
 28 |                 'name': 'add_device_encryption_key',
 29 |                 'params': {
 30 |                     'device_address': 'some-device-address',
 31 |                     'encryption_key': expected_encryption_key,
 32 |                 }
 33 |             }
 34 |         }
 35 | 
 36 |         self.assertDictEqual(expected_json, json)
 37 | 
 38 |     # SetDeliveryAndPrint
 39 |     def test_set_delivery_and_print(self):
 40 |         command = messages.SetDeliveryAndPrint('some-device-address', self.bw_2x2())
 41 | 
 42 |         json = encoders.encode_bridge_command('some-bridge-address', command, 1, '0')
 43 | 
 44 |         expected_json = {
 45 |             'type': 'DeviceCommand',
 46 |             'bridge_address': 'some-bridge-address',
 47 |             'device_address': 'some-device-address',
 48 |             'command_id': 1,
 49 |             'timestamp': '0',
 50 |             'binary_payload': 'AQABAAEAAAAAAAAAJwAAACMAAAAAABUAAAAdcwPoHWHQHS8PHUSAGyoAAAAAADABAwAAAAECAQ=='
 51 |         }
 52 | 
 53 |         self.assertDictEqual(expected_json, json)
 54 | 
 55 |     # SetDelivery
 56 |     def test_set_delivery(self):
 57 |         command = messages.SetDelivery('some-device-address', self.bw_2x2())
 58 | 
 59 |         json = encoders.encode_bridge_command('some-bridge-address', command, 1, '0')
 60 | 
 61 |         expected_json = {
 62 |             'type': 'DeviceCommand',
 63 |             'bridge_address': 'some-bridge-address',
 64 |             'device_address': 'some-device-address',
 65 |             'command_id': 1,
 66 |             'timestamp': '0',
 67 |             'binary_payload': 'AQACAAEAAAAAAAAAJwAAACMAAAAAABUAAAAdcwPoHWHQHS8PHUSAGyoAAAAAADABAwAAAAECAQ=='
 68 |         }
 69 | 
 70 |         self.assertDictEqual(expected_json, json)
 71 | 
 72 |     # SetDeliveryAndPrintNoFace
 73 |     def test_set_delivery_and_print_no_face(self):
 74 |         command = messages.SetDeliveryAndPrintNoFace('some-device-address', self.bw_2x2())
 75 | 
 76 |         json = encoders.encode_bridge_command('some-bridge-address', command, 1, '0')
 77 | 
 78 |         expected_json = {
 79 |             'type': 'DeviceCommand',
 80 |             'bridge_address': 'some-bridge-address',
 81 |             'device_address': 'some-device-address',
 82 |             'command_id': 1,
 83 |             'timestamp': '0',
 84 |             'binary_payload': 'AQARAAEAAAAAAAAAJwAAACMAAAAAABUAAAAdcwPoHWHQHS8PHUSAGyoAAAAAADABAwAAAAECAQ=='
 85 |         }
 86 | 
 87 |         self.assertDictEqual(expected_json, json)
 88 | 
 89 |     # SetDeliveryNoFace
 90 |     def test_set_delivery_no_face(self):
 91 |         command = messages.SetDeliveryNoFace('some-device-address', self.bw_2x2())
 92 | 
 93 |         json = encoders.encode_bridge_command('some-bridge-address', command, 1, '0')
 94 | 
 95 |         expected_json = {
 96 |             'type': 'DeviceCommand',
 97 |             'bridge_address': 'some-bridge-address',
 98 |             'device_address': 'some-device-address',
 99 |             'command_id': 1,
100 |             'timestamp': '0',
101 |             'binary_payload': 'AQASAAEAAAAAAAAAJwAAACMAAAAAABUAAAAdcwPoHWHQHS8PHUSAGyoAAAAAADABAwAAAAECAQ=='
102 |         }
103 | 
104 |         self.assertDictEqual(expected_json, json)
105 | 
106 |     # SetPersonality
107 |     def test_set_personality(self):
108 |         command = messages.SetPersonality('some-device-address', self.bw_2x2(), self.bw_2x2(), self.bw_2x2(), self.bw_2x2())
109 | 
110 |         json = encoders.encode_bridge_command('some-bridge-address', command, 1, '0')
111 | 
112 |         expected_json = {
113 |             'type': 'DeviceCommand',
114 |             'bridge_address': 'some-bridge-address',
115 |             'device_address': 'some-device-address',
116 |             'command_id': 1,
117 |             'timestamp': '0',
118 |             'binary_payload': 'AQACAQEAAAAAAAAAnAAAACMAAAAAABUAAAAdcwPoHWHQHS8PHUSAGyoAAAAAADABAwAAAAECASMAAAAAABUAAAAdcwPoHWHQHS8PHUSAGyoAAAAAADABAwAAAAECASMAAAAAABUAAAAdcwPoHWHQHS8PHUSAGyoAAAAAADABAwAAAAECASMAAAAAABUAAAAdcwPoHWHQHS8PHUSAGyoAAAAAADABAwAAAAECAQ=='
119 |         }
120 | 
121 |         self.assertDictEqual(expected_json, json)
122 | 
123 |     # SetPersonalityWithMessage
124 |     def test_set_personality_with_message(self):
125 |         command = messages.SetPersonalityWithMessage('some-device-address', self.bw_2x2(), self.bw_2x2(), self.bw_2x2(), self.bw_2x2(), self.bw_2x2())
126 | 
127 |         json = encoders.encode_bridge_command('some-bridge-address', command, 1, '0')
128 | 
129 |         expected_json = {
130 |             'type': 'DeviceCommand',
131 |             'bridge_address': 'some-bridge-address',
132 |             'device_address': 'some-device-address',
133 |             'command_id': 1,
134 |             'timestamp': '0',
135 |             'binary_payload': 'AQABAQEAAAAAAAAAwwAAACMAAAAAABUAAAAdcwPoHWHQHS8PHUSAGyoAAAAAADABAwAAAAECASMAAAAAABUAAAAdcwPoHWHQHS8PHUSAGyoAAAAAADABAwAAAAECASMAAAAAABUAAAAdcwPoHWHQHS8PHUSAGyoAAAAAADABAwAAAAECASMAAAAAABUAAAAdcwPoHWHQHS8PHUSAGyoAAAAAADABAwAAAAECASMAAAAAABUAAAAdcwPoHWHQHS8PHUSAGyoAAAAAADABAwAAAAECAQ=='
136 |         }
137 | 
138 |         self.assertDictEqual(expected_json, json)
139 | 
140 |     # SetQuip
141 |     def test_set_quip(self):
142 |         command = messages.SetQuip('some-device-address', self.bw_2x2(), self.bw_2x2(), self.bw_2x2())
143 | 
144 |         json = encoders.encode_bridge_command('some-bridge-address', command, 1, '0')
145 | 
146 |         expected_json = {
147 |             'type': 'DeviceCommand',
148 |             'bridge_address': 'some-bridge-address',
149 |             'device_address': 'some-device-address',
150 |             'command_id': 1,
151 |             'timestamp': '0',
152 |             'binary_payload': 'AQACAgEAAAAAAAAAdQAAACMAAAAAABUAAAAdcwPoHWHQHS8PHUSAGyoAAAAAADABAwAAAAECASMAAAAAABUAAAAdcwPoHWHQHS8PHUSAGyoAAAAAADABAwAAAAECASMAAAAAABUAAAAdcwPoHWHQHS8PHUSAGyoAAAAAADABAwAAAAECAQ=='
153 |         }
154 | 
155 |         self.assertDictEqual(expected_json, json)
156 | 
157 |     # Create 2x2 with white/black checkerboard:
158 |     #
159 |     #    01
160 |     # 0  WB
161 |     # 1  BW
162 |     def bw_2x2(self):
163 |         im = Image.new("1", (2, 2), 0)
164 | 
165 |         draw = ImageDraw.Draw(im)
166 |         draw.point((0, 0), 1)
167 |         draw.point((1, 1), 1)
168 | 
169 |         return im
170 | 


--------------------------------------------------------------------------------
/sirius/coding/test_image_coding.py:
--------------------------------------------------------------------------------
 1 | from PIL import Image, ImageDraw
 2 | import unittest
 3 | 
 4 | from sirius.coding import image_encoding
 5 | 
 6 | class ImageCase(unittest.TestCase):
 7 |     def test_normal_text(self):
 8 |         data = image_encoding.html_to_png(
 9 |             '<html><body style="margin: 0px; height: 10px;"></body></html>'
10 |             )
11 |         image = Image.open(data)
12 |         self.assertEquals(image.size[0], 384)
13 |         self.assertEquals(image.size[1], 10)
14 | 
15 |     def test_normal_height(self):
16 |         data = image_encoding.html_to_png(
17 |             '<html><body style="margin: 0px; height: 100px;"></body></html>'
18 |             )
19 |         image = Image.open(data)
20 |         self.assertEquals(image.size[0], 384)
21 |         self.assertEquals(image.size[1], 100)
22 | 
23 | 
24 | class PipeTestCase(unittest.TestCase):
25 |     def test_specific_image_rle(self):
26 |         image = Image.new('1', (3, 3), 0)
27 | 
28 |         # 3x3 checkerboard
29 |         draw = ImageDraw.Draw(image)
30 |         draw.point((0, 0), 1)
31 |         draw.point((2, 0), 1)
32 |         draw.point((1, 1), 1)
33 |         draw.point((0, 2), 1)
34 |         draw.point((2, 2), 1)
35 | 
36 |         n_bytes, rle = image_encoding.rle_from_bw(image)
37 |         self.assertEqual(rle, b'\x01\x09\x00\x00\x00\x01\x01\x01\x01\x01\x01\x01\x01\x01')
38 |         self.assertEquals(n_bytes, 9)
39 | 
40 |     def test_full(self):
41 |         data = image_encoding.html_to_png(
42 |             '<html><body style="margin: 0px; height: 10px;"></body></html>'
43 |             )
44 | 
45 |         image = Image.open(data)
46 |         image = image_encoding.crop_384(image)
47 |         image = image_encoding.convert_to_1bit(image)
48 | 
49 |         n_bytes, _ = image_encoding.rle_from_bw(image)
50 |         self.assertEquals(n_bytes, 3840)
51 | 
52 |     def test_default_pipeline(self):
53 |         n_bytes, _ = image_encoding.rle_from_bw(
54 |             image_encoding.default_pipeline(
55 |             '<html><body style="margin: 0px; height: 10px;"></body></html>'
56 |             )
57 |         )
58 |         self.assertEquals(n_bytes, 3840)
59 | 


--------------------------------------------------------------------------------
/sirius/coding/test_image_coding_snapshots.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | import datetime
 3 | from tempfile import TemporaryDirectory
 4 | from PIL import Image
 5 | 
 6 | import snapshottest
 7 | from snapshottest.file import FileSnapshot
 8 | 
 9 | from sirius.coding import image_encoding
10 | from sirius.coding import templating
11 | 
12 | 
13 | class ImageCodingSnapshotCase(snapshottest.TestCase):
14 |     def _check_html(self, name, html):
15 |         print('Cheking fixture named: %s' % name)
16 | 
17 |         with TemporaryDirectory() as tmpdir:
18 |             data = image_encoding.html_to_png(html)
19 |             image = Image.open(data)
20 | 
21 |             temp_file_name = os.path.join(tmpdir, '%s.png' % name)
22 |             image.save(temp_file_name, format='PNG')
23 |             self.assertMatchSnapshot(FileSnapshot(temp_file_name), name)
24 | 
25 |     def test_snapshot_fixtures(self):
26 |         fixtures = {
27 |             'hello_world': '<html><body>Hello, world!</body></html>',
28 |         }
29 | 
30 |         for name, html in fixtures.items():
31 |             self._check_html(name, html)
32 | 
33 |     def test_snapshot_template_fixtures(self):
34 |         fixtures = {
35 |             'hello_world': '<p>Hello, world!</p>',
36 |         }
37 | 
38 |         fixture_username = 'somebody'
39 |         fixture_date = datetime.datetime(2012, 2, 3, 15, 46, 12)
40 | 
41 |         for name, snippet in fixtures.items():
42 |             self._check_html(
43 |                 name, templating.default_template(
44 |                     snippet,
45 |                     fixture_username,
46 |                     fixture_date
47 |                 )
48 |             )


--------------------------------------------------------------------------------
/sirius/config.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | 
 3 | basedir = os.path.abspath(os.path.dirname(__file__))
 4 | 
 5 | 
 6 | class Config:
 7 |     SECRET_KEY = os.environ.get("SECRET_KEY") or "this is the lp2 secret"
 8 |     SQLALCHEMY_COMMIT_ON_TEARDOWN = True
 9 |     SQLALCHEMY_TRACK_MODIFICATIONS = False
10 |     # printer not seen for 60 seconds: Mark offline.
11 |     PRINTER_OFFLINE_CUTOFF_SECONDS = 60
12 |     TWITTER_OAUTH_CLIENT_KEY = os.getenv("TWITTER_OAUTH_CLIENT_KEY")
13 |     TWITTER_OAUTH_CLIENT_SECRET = os.getenv("TWITTER_OAUTH_CLIENT_SECRET")
14 |     OAUTH_REDIRECT_URI = os.getenv("OAUTH_REDIRECT_URI")
15 | 
16 |     @staticmethod
17 |     def init_app(app):
18 |         pass
19 | 
20 | 
21 | class TestConfig(Config):
22 |     DEBUG = False
23 |     SQLALCHEMY_DATABASE_URI = os.environ.get(
24 |         "DATABASE_URL"
25 |     ) or "sqlite:///" + os.path.join(basedir, "data-dev.sqlite")
26 |     TESTING = True
27 |     WTF_CSRF_ENABLED = False
28 |     LOGIN_DISABLED = False
29 | 
30 | 
31 | class DevelopmentConfig(Config):
32 |     DEBUG = True
33 |     SQLALCHEMY_DATABASE_URI = os.environ.get(
34 |         "DATABASE_URL"
35 |     ) or "sqlite:///" + os.path.join(basedir, "data-dev.sqlite")
36 | 
37 | 
38 | class ProductionConfig(Config):
39 |     SQLALCHEMY_DATABASE_URI = os.environ.get(
40 |         "DATABASE_URL"
41 |     ) or "sqlite:///" + os.path.join(basedir, "data.sqlite")
42 | 
43 |     @classmethod
44 |     def init_app(cls, app):
45 |         Config.init_app(app)
46 | 
47 | 
48 | class HerokuConfig(ProductionConfig):
49 |     SSL_DISABLE = bool(os.environ.get("SSL_DISABLE"))
50 |     DEBUG = True
51 | 
52 |     @classmethod
53 |     def init_app(cls, app):
54 |         ProductionConfig.init_app(app)
55 | 
56 |         # handle proxy server headers
57 |         from werkzeug.contrib.fixers import ProxyFix
58 | 
59 |         app.wsgi_app = ProxyFix(app.wsgi_app)
60 | 
61 |         # log to stderr
62 |         import logging
63 |         from logging import StreamHandler
64 | 
65 |         file_handler = StreamHandler()
66 |         file_handler.setLevel(logging.WARNING)
67 |         app.logger.addHandler(file_handler)
68 | 
69 | 
70 | config = {
71 |     "development": DevelopmentConfig,
72 |     "production": ProductionConfig,
73 |     "heroku": HerokuConfig,
74 |     "test": TestConfig,
75 |     "default": DevelopmentConfig,
76 | }
77 | 


--------------------------------------------------------------------------------
/sirius/database.py:
--------------------------------------------------------------------------------
 1 | """Fake database to be connected to a real database at some point.
 2 | 
 3 | """
 4 | import collections
 5 | 
 6 | 
 7 | ClaimedDevice = collections.namedtuple('ClaimedDevice', 'address hardware_xor claim_code')
 8 | claimed_devices = {
 9 |     0x73c164: ClaimedDevice(
10 |         '000d6f000273c164',
11 |         0x73c164,
12 |         'n5ry-p6x6-kth7-7hc4',
13 |     ),
14 |     0xaacafe: ClaimedDevice(
15 |         '000d6f000273ce0b',
16 |         0xaacafe,
17 |         'n5ry-p6x6-kth7-7hc4',
18 |     ),
19 | }
20 | 
21 | def get_claim_code(hardware_xor):
22 |     return claimed_devices.get(hardware_xor)
23 | 


--------------------------------------------------------------------------------
/sirius/emulate/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nordprojects/sirius/9d88c63a0fc17d4acc5ae12194b93f8591e35a55/sirius/emulate/__init__.py


--------------------------------------------------------------------------------
/sirius/emulate/commands.py:
--------------------------------------------------------------------------------
  1 | """Fake a few printer interactions for testing.
  2 | """
  3 | from __future__ import print_function
  4 | 
  5 | import os
  6 | import gevent
  7 | import gevent.monkey
  8 | gevent.monkey.patch_all()
  9 | import websocket
 10 | import json
 11 | import re
 12 | import random
 13 | import time
 14 | import struct
 15 | import base64
 16 | 
 17 | import flask_script as script
 18 | 
 19 | from sirius.emulate import protocol_fragments as pf
 20 | 
 21 | def sub_opts(app, **kwargs):
 22 |     pass
 23 | 
 24 | manager = script.Manager(
 25 |     sub_opts, usage="Emulate a real printer, websockets and all.")
 26 | 
 27 | 
 28 | class State:
 29 |     """Keep track of printer state. Only one per process so global state
 30 |     is OK."""
 31 |     online = True
 32 |     needs_key = True
 33 |     device_address = None
 34 |     bridge_address = None
 35 | 
 36 | def heartbeat(ws):
 37 |     while True:
 38 |         if (State.online, State.needs_key) == (True, True):
 39 |             ws.send(pf.ENCRYPTION_KEY_REQUIRED %
 40 |                     dict(bridge_address=State.bridge_address,
 41 |                          device_address=State.device_address))
 42 |             print("Asked for encryption key")
 43 |             gevent.sleep(30.0) # key request is sent every 30s
 44 |         elif (State.online, State.needs_key) == (True, False):
 45 |             ws.send(pf.HEARTBEAT %
 46 |                     dict(bridge_address=State.bridge_address,
 47 |                          device_address=State.device_address))
 48 |             print("Heartbeat. Pom pom.")
 49 |             gevent.sleep(10.0) # heartbeate is sent every 10s
 50 |         elif State.online == False:
 51 |             gevent.sleep(10.0) # sleep for a while to burn cycles
 52 | 
 53 |         else:
 54 |             assert False # unreachable
 55 | 
 56 | 
 57 | def _decode_binary(base64_data):
 58 |     bdata = base64.b64decode(base64_data)
 59 |     _, _, command, print_id, _, length = struct.unpack("<BBHIII", bdata[:16])
 60 | 
 61 |     print("command", command, print_id, length)
 62 | 
 63 | 
 64 | def _decode(data):
 65 |     try:
 66 |         data = json.loads(data)
 67 |     except ValueError as e:
 68 |         print("Server sent invalid JSON!", e)
 69 |         return
 70 | 
 71 |     if data['type'] == 'BridgeCommand':
 72 |         key = data['json_payload'].get('params', {}).get('encryption_key')
 73 |         print("Received encryption key, switching to heartbeat mode.")
 74 |         State.needs_key = False
 75 | 
 76 |     if data['type'] == 'DeviceCommand':
 77 |         payload = data['binary_payload']
 78 |         command_id = data['command_id']
 79 | 
 80 |         _decode_binary(payload)
 81 | 
 82 |         # TODO(tom): Decode binary payload for debugging.
 83 | 
 84 |         return {u'device_address': State.device_address,
 85 |                 u'timestamp': time.time(),
 86 |                 u'transfer_time': 3.44,
 87 |                 u'bridge_address': State.bridge_address,
 88 |                 u'return_code': 0,
 89 |                 u'rssi_stats': [-19,-19,-19],
 90 |                 u'type': u'DeviceCommandResponse',
 91 |                 u'command_id': command_id}
 92 | 
 93 | 
 94 | @manager.command
 95 | def printer(printer_data_path, websocket_url):
 96 | 
 97 |     with open(printer_data_path) as f:
 98 |         printer_data = f.read()
 99 | 
100 |     print("Contacting", websocket_url)
101 |     print(printer_data)
102 |     print("-----------------------------")
103 | 
104 |     # Parse data from printer file
105 |     State.device_address = re.search('address: ([a-f0-9]{16})', printer_data).group(1)
106 |     State.bridge_address = '{:016x}'.format(random.randrange(0, 2**64))
107 | 
108 |     # Sanity check websocket connection URL:
109 |     if not websocket_url.endswith('/api/v1/connection'):
110 |         print("Websocket URL must end with '/api/v1/connection'")
111 |         print("Maybe you meant {}/api/v1/connection ?".format(websocket_url))
112 |         return 1
113 | 
114 |     # Connect and initialize
115 |     ws = websocket.create_connection(websocket_url)
116 |     ws.send(pf.CONNECT % dict(bridge_address=State.bridge_address))
117 | 
118 |     gevent.spawn(heartbeat, ws)
119 | 
120 |     try:
121 |         while True:
122 |             data = ws.recv()
123 |             response = _decode(data)
124 |             if response is not None:
125 |                 ws.send(json.dumps(response))
126 | 
127 |     finally:
128 |         ws.close()
129 | 


--------------------------------------------------------------------------------
/sirius/emulate/protocol_fragments.py:
--------------------------------------------------------------------------------
 1 | CONNECT = """\
 2 | {
 3 |    "type" : "BridgeEvent",
 4 |    "json_payload" : {
 5 |       "ncp_version" : "0x46C5",
 6 |       "uptime" : "45.71 23.94",
 7 |       "firmware_version" : "v2.3.1-f3c7946",
 8 |       "network_info" : {
 9 |          "extended_pan_id" : "0x42455247fbbbbd7f",
10 |          "node_type" : "EMBER_COORDINATOR",
11 |          "radio_power_mode" : "EMBER_TX_POWER_MODE_BOOST",
12 |          "security_level" : 5,
13 |          "network_status" : "EMBER_JOINED_NETWORK",
14 |          "channel" : 11,
15 |          "security_profile" : "Custom",
16 |          "power" : 8,
17 |          "node_eui64" : "0x000d6f0001b3719d",
18 |          "pan_id" : "0xDF3A",
19 |          "node_id" : "0x0000"
20 |       },
21 |       "name" : "power_on",
22 |       "local_ip_address" : "192.168.1.98",
23 |       "uboot_environment" : "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",
24 |       "mac_address" : "40:d8:55:01:c1:b3",
25 |       "model" : "A"
26 |    },
27 |    "bridge_address" : "%(bridge_address)s",
28 |    "timestamp" : 1426256447.70695
29 | }
30 | """
31 | 
32 | DEVICE_CONNECT = """\
33 | {
34 |    "timestamp" : 1426256449.81701,
35 |    "json_payload" : {
36 |       "device_address" : "%(device_address)s",
37 |       "name" : "device_connect"
38 |    },
39 |    "bridge_address" : "%(bridge_address)s",
40 |    "type" : "BridgeEvent"
41 | }
42 | """
43 | 
44 | HEARTBEAT = """\
45 | {
46 |    "rssi_stats" : [
47 |       -20,
48 |       -20,
49 |       -19
50 |    ],
51 |    "device_address" : "%(device_address)s",
52 |    "binary_payload" : "AQAAAAAABAAAAG4AAAA=",
53 |    "type" : "DeviceEvent",
54 |    "bridge_address" : "%(bridge_address)s",
55 |    "timestamp" : 1426256547.52687
56 | }
57 | """
58 | 
59 | ENCRYPTION_KEY_REQUIRED = """\
60 | {
61 |    "timestamp" : 1419107228.91187,
62 |    "type" : "BridgeEvent",
63 |    "json_payload" : {
64 |       "name" : "encryption_key_required",
65 |       "device_address" : "%(device_address)s"
66 |    },
67 |    "bridge_address" : "%(bridge_address)s"
68 | }
69 | """
70 | 


--------------------------------------------------------------------------------
/sirius/fake/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nordprojects/sirius/9d88c63a0fc17d4acc5ae12194b93f8591e35a55/sirius/fake/__init__.py


--------------------------------------------------------------------------------
/sirius/fake/commands.py:
--------------------------------------------------------------------------------
 1 | """Fake a few printer interactions for testing.
 2 | """
 3 | from __future__ import print_function
 4 | 
 5 | import os
 6 | import sys
 7 | 
 8 | import flask_script as script
 9 | from sirius.models import hardware
10 | from sirius.models import user as user_model
11 | from sirius.models.db import db
12 | from sirius.coding import bitshuffle
13 | from sirius.coding import claiming
14 | 
15 | 
16 | def sub_opts(app, **kwargs):
17 |     pass
18 | 
19 | 
20 | fake_manager = script.Manager(sub_opts, usage="Fake printer interactions.")
21 | 
22 | 
23 | @fake_manager.command
24 | def printer():
25 |     device_address = os.urandom(8).hex()
26 |     xor = bitshuffle.hardware_xor_from_device_address(device_address)
27 |     secret = os.urandom(5).hex()
28 | 
29 |     cc = claiming.encode(xor, int(secret, 16))
30 |     printer = hardware.Printer(
31 |         device_address=device_address,
32 |         hardware_xor=xor,
33 |     )
34 |     db.session.add(printer)
35 |     db.session.commit()
36 | 
37 |     def out(x):
38 |         x.write('     address: {}\n'.format(device_address))
39 |         x.write('       DB id: {}\n'.format(printer.id))
40 |         x.write('      secret: {}\n'.format(secret))
41 |         x.write('         xor: {}\n'.format(xor))
42 |         x.write('  claim code: {}\n'.format(cc))
43 | 
44 |     path = device_address + '.printer'
45 |     with open(path, 'w') as f:
46 |         out(f)
47 | 
48 |     out(sys.stdout)
49 |     print('\nCreated printer and saved as {}'.format(path))
50 | 
51 | 
52 | @fake_manager.command
53 | def claim(device_address, owner, code, name):
54 |     user = user_model.User.query.filter_by(username=owner).first()
55 |     if user is None:
56 |         print("User not found: {}".format(owner))
57 |         return
58 | 
59 |     hardware.Printer.phone_home(device_address)
60 |     user.claim_printer(code, name)
61 | 
62 | 
63 | @fake_manager.command
64 | def user(screen_name):
65 |     new_user = user_model.User(
66 |         username=screen_name,
67 |     )
68 |     oauth = user_model.TwitterOAuth(
69 |         user=new_user,
70 |         screen_name=screen_name,
71 |         token='token',
72 |         token_secret='secret',
73 |     )
74 |     db.session.add(new_user)
75 |     db.session.add(oauth)
76 |     db.session.commit()
77 | 


--------------------------------------------------------------------------------
/sirius/models/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nordprojects/sirius/9d88c63a0fc17d4acc5ae12194b93f8591e35a55/sirius/models/__init__.py


--------------------------------------------------------------------------------
/sirius/models/db.py:
--------------------------------------------------------------------------------
1 | import flask_sqlalchemy as sqlalchemy
2 | 
3 | db = sqlalchemy.SQLAlchemy()
4 | 


--------------------------------------------------------------------------------
/sirius/models/hardware.py:
--------------------------------------------------------------------------------
  1 | import datetime, io
  2 | from sqlalchemy import desc
  3 | 
  4 | from sirius.coding import bitshuffle
  5 | from sirius.models.db import db
  6 | 
  7 | class Bridge(db.Model):
  8 |     """Bridges are not really interesting for users other than that they
  9 |     are connected so we don't store ownership for them.
 10 |     """
 11 |     id = db.Column(db.Integer, primary_key=True)
 12 |     created = db.Column(db.DateTime, default=datetime.datetime.utcnow)
 13 |     bridge_address = db.Column(db.String)
 14 | 
 15 | 
 16 | class Printer(db.Model):
 17 |     """On reset printers generate a new, unique device address, so every
 18 |     reset will result in a new Printer row.
 19 | 
 20 |     Note that this model is only ever created by a printer calling
 21 |     home. Users create a ClaimCode row.
 22 |     """
 23 |     id = db.Column(db.Integer, primary_key=True)
 24 |     created = db.Column(db.DateTime, default=datetime.datetime.utcnow)
 25 |     device_address = db.Column(db.String)
 26 |     hardware_xor = db.Column(db.Integer)
 27 | 
 28 |     # Name of printer; used for display purposes.
 29 |     name = db.Column(db.String)
 30 | 
 31 |     # Update the following fields after we connected (i.e. joined over
 32 |     # hardware xor) a claim to a printer. The fields start out as
 33 |     # NULL.
 34 |     owner_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=True)
 35 |     owner = db.relationship('User', backref=db.backref('printers', lazy='dynamic'))
 36 | 
 37 |     used_claim_code = db.Column(db.String, nullable=True, unique=True)
 38 | 
 39 |     def __repr__(self):
 40 |         return 'Printer {}, xor: {}, owner: {}'.format(
 41 |             self.device_address, self.hardware_xor, self.owner_id)
 42 | 
 43 |     @classmethod
 44 |     def phone_home(cls, device_address):
 45 |         """This gets called every time the in-memory machinery thinks it has
 46 |         seen a printer for the first time round, e.g. after a
 47 |         re-connect of the websocket.
 48 |         """
 49 |         printer = cls.query.filter_by(device_address=device_address).first()
 50 |         hardware_xor = bitshuffle.hardware_xor_from_device_address(device_address)
 51 | 
 52 |         if printer is not None:
 53 |             return
 54 | 
 55 |         printer = cls(
 56 |             device_address=device_address,
 57 |             hardware_xor=hardware_xor,
 58 |             owner_id=None,
 59 |             used_claim_code=None,
 60 |         )
 61 |         db.session.add(printer)
 62 |         db.session.commit()
 63 | 
 64 |         # Connect hardware xor and printer if there is a claim code
 65 |         # waiting.
 66 |         #
 67 |         # Printers always generate the same XOR. I.e. we can have more
 68 |         # than one claim code with the same XOR. We always pick the
 69 |         # newest claim code.
 70 |         claim_code_query = ClaimCode.query.filter_by(
 71 |             hardware_xor=hardware_xor).order_by(desc('created'), desc('id'))
 72 |         claim_code = claim_code_query.first()
 73 |         if claim_code is None:
 74 |             return
 75 | 
 76 |         printer.owner_id = claim_code.by_id
 77 |         printer.name = claim_code.name
 78 |         printer.used_claim_code = claim_code.claim_code
 79 |         db.session.add(printer)
 80 |         db.session.commit()
 81 | 
 82 |     @classmethod
 83 |     def get_claim_code(cls, device_address):
 84 |         """Find and return a claim code."""
 85 |         printer = cls.query.filter_by(device_address=device_address).first()
 86 |         if printer is None:
 87 |             return None
 88 |         db.session.commit()
 89 | 
 90 |         return printer.used_claim_code
 91 | 
 92 |     @property
 93 |     def is_online(self):
 94 |         from sirius.protocol import protocol_loop
 95 |         return protocol_loop.device_is_online(self.device_address)
 96 | 
 97 |     class OfflineError(Exception):
 98 |         pass
 99 | 
100 |     def print_html(self, html, from_name, face='default'):
101 |         from sirius.coding import image_encoding
102 |         from sirius.coding import templating
103 | 
104 |         pixels = image_encoding.default_pipeline(
105 |             templating.default_template(html, from_name=from_name)
106 |         )
107 | 
108 |         self.print_pixels(pixels, from_name=from_name, face=face)
109 | 
110 |     def print_pixels(self, pixels, from_name, face='default'):
111 |         from sirius.protocol import messages
112 |         from sirius.protocol import protocol_loop
113 |         from sirius import stats
114 |         from sirius.models import messages as model_messages
115 | 
116 |         hardware_message = None
117 |         if face == "noface":
118 |             hardware_message = messages.SetDeliveryAndPrintNoFace(
119 |                 device_address=self.device_address,
120 |                 pixels=pixels,
121 |             )
122 |         else:
123 |             hardware_message = messages.SetDeliveryAndPrint(
124 |                 device_address=self.device_address,
125 |                 pixels=pixels,
126 |             )
127 | 
128 |         # If a printer is "offline" then we won't find the printer
129 |         # connected and success will be false.
130 |         success, next_print_id = protocol_loop.send_message(
131 |             self.device_address,
132 |             hardware_message
133 |         )
134 | 
135 |         if success:
136 |             stats.inc('printer.print.ok')
137 |         else:
138 |             stats.inc('printer.print.offline')
139 | 
140 |         # Store the same message in the database.
141 |         png = io.BytesIO()
142 |         pixels.save(png, "PNG")
143 |         model_message = model_messages.Message(
144 |             print_id=next_print_id,
145 |             pixels=bytearray(png.getvalue()),
146 |             sender_name=from_name,
147 |             target_printer=self,
148 |         )
149 | 
150 |         # We know immediately if the printer wasn't online.
151 |         if not success:
152 |             model_message.failure_message = 'Printer offline'
153 |             model_message.response_timestamp = datetime.datetime.utcnow()
154 |         db.session.add(model_message)
155 | 
156 |         self.trim_old_messages()
157 | 
158 |         if not success:
159 |             raise Printer.OfflineError()
160 |     
161 |     def trim_old_messages(self):
162 |         '''
163 |         Keep up to 10 messages per printer to stop them building up forever.
164 | 
165 |         Should be called after a message is added.
166 |         '''
167 |         from sirius.models import messages as model_messages
168 | 
169 |         old_messages = self.messages.order_by(desc('created')).offset(10).all()
170 |         for old_message in old_messages:
171 |             db.session.delete(old_message)
172 | 
173 | 
174 | class ClaimCode(db.Model):
175 |     """Printer and claim codes are joined over the hardware xor. Claim
176 |     codes are meant to have a temporary life time though we're not
177 |     treating them like this for now.
178 |     """
179 |     id = db.Column(db.Integer, primary_key=True)
180 |     created = db.Column(db.DateTime, default=datetime.datetime.utcnow)
181 |     by_id = db.Column(db.ForeignKey('user.id'))
182 |     by = db.relationship('User', backref=db.backref('claim_codes', lazy='dynamic'))
183 |     hardware_xor = db.Column(db.Integer)
184 |     claim_code = db.Column(db.String, unique=True)
185 | 
186 |     # Intended name of printer; used for display purposes.
187 |     name = db.Column(db.String)
188 | 
189 |     def __repr__(self):
190 |         return '<ClaimCode xor: {} code: {}>'.format(self.hardware_xor, self.claim_code)
191 | 
192 | 
193 | class DeviceLog(db.Model):
194 |     """The device log Recorde state changes in the bridge and connected
195 |     devices. We may selectively expose some of these to the user.
196 |     """
197 |     id = db.Column(db.Integer, primary_key=True)
198 |     created = db.Column(db.DateTime, default=datetime.datetime.utcnow)
199 |     device_address = db.Column(db.String)
200 | 
201 |     # json dict of events dispatched on VALID_STATES. E.g.
202 |     # {"type": "grant_access", "payload": {...}}
203 |     entry = db.Column(db.String)
204 | 
205 |     VALID_STATES = [
206 |         'power_on',
207 |         'connect',
208 |         'disconnect',
209 |         'claim',
210 |         'print',
211 |         'grant_access',
212 |         'revoke_access',
213 |     ]
214 | 
215 |     # Expose an explicit API to force people to provide the correct
216 |     # arguments.
217 |     @classmethod
218 |     def log_power_on(cls, bridge_address):
219 |         pass
220 | 
221 |     @classmethod
222 |     def log_connect(cls, device_address):
223 |         pass
224 | 
225 |     @classmethod
226 |     def log_disconnect(cls, device_address):
227 |         pass
228 | 
229 |     # TODO log all the things
230 | 


--------------------------------------------------------------------------------
/sirius/models/messages.py:
--------------------------------------------------------------------------------
  1 | import base64
  2 | import datetime
  3 | import logging
  4 | from sqlalchemy import desc
  5 | 
  6 | from sirius.models.db import db
  7 | 
  8 | 
  9 | logger = logging.getLogger(__name__)
 10 | 
 11 | 
 12 | TIMEOUT_SECONDS = 60
 13 | 
 14 | class Message(db.Model):
 15 |     """Messages are printed by someone on ("sender") to a "target
 16 |     printer".
 17 |     """
 18 |     id = db.Column(db.Integer, primary_key=True)
 19 |     created = db.Column(db.DateTime, default=datetime.datetime.utcnow, index=True)
 20 |     pixels = db.Column(db.LargeBinary)
 21 | 
 22 |     print_id = db.Column(db.Integer, unique=True)
 23 | 
 24 |     sender_name = db.Column(db.String)
 25 | 
 26 |     target_printer_id = db.Column(db.Integer, db.ForeignKey('printer.id'))
 27 |     target_printer = db.relationship('Printer', backref=db.backref('messages', lazy='dynamic'))
 28 | 
 29 |     # The response is received by the protocol_loop. It's also
 30 |     # possible to not receive a response (e.g. printer got
 31 |     # disconnected) in which case we "time out" after TIMEOUT_SECONDS.
 32 |     response_timestamp = db.Column(db.DateTime, nullable=True)
 33 |     failure_message = db.Column(db.String, nullable=True)
 34 | 
 35 | 
 36 |     @classmethod
 37 |     def timeout_updates(cls, utcnow=None):
 38 |         """Update all messages that are timed-out with an error message. This
 39 |         is a destructive update. It should also be fairly cheap
 40 |         because of the index on created.
 41 | 
 42 |         We're doing these updates "eagerly" on every printer overview
 43 |         page load instead of through a cron job, but there's no reason
 44 |         why we couldn't do that.
 45 |         """
 46 | 
 47 |         if utcnow is None:
 48 |             utcnow = datetime.datetime.utcnow()
 49 |         cutoff = utcnow - datetime.timedelta(seconds=TIMEOUT_SECONDS)
 50 | 
 51 |         cls.query.filter(
 52 |             cls.created <= cutoff,
 53 |             cls.response_timestamp == None
 54 |         ).update(dict(
 55 |             response_timestamp=utcnow,
 56 |             failure_message="Timed out",
 57 |         ))
 58 |         db.session.commit()
 59 | 
 60 | 
 61 |     def base64_pixels(self):
 62 |         return base64.b64encode(self.pixels)
 63 | 
 64 | 
 65 |     @classmethod
 66 |     def ack(cls, return_code, command_id, utcnow=None):
 67 |         if return_code != 0:
 68 |             # TODO map codes to error messages
 69 |             failure_message = 'Problem printing: {}'.format(return_code)
 70 |         else:
 71 |             failure_message = None
 72 | 
 73 |         if utcnow is None:
 74 |             utcnow = datetime.datetime.utcnow()
 75 | 
 76 |         message = cls.query.filter_by(print_id=command_id).first()
 77 | 
 78 |         if message is None:
 79 |             logger.error("Ack'ed unknown message %s.", command_id)
 80 |             return
 81 | 
 82 |         message.response_timestamp = utcnow
 83 |         message.failure_message = failure_message
 84 | 
 85 |         db.session.add(message)
 86 |         db.session.commit()
 87 | 
 88 |     @classmethod
 89 |     def get_next_command_id(cls):
 90 |         """Return the next command id to be used by the bridge. Command ids
 91 |         are used to ack messages so we need to make sure we don't have
 92 |         any collisions. The best way to do so is to pick the
 93 |         next-highest number after the ones we already used up.
 94 |         """
 95 |         last = cls.query.order_by(desc('print_id')).first()
 96 |         if last is None:
 97 |             next_print_id = 1
 98 |         else:
 99 |             next_print_id = last.print_id + 1
100 | 
101 |         db.session.commit()
102 |         return next_print_id
103 | 


--------------------------------------------------------------------------------
/sirius/models/print_keys.py:
--------------------------------------------------------------------------------
 1 | import datetime, random, string, os
 2 | from flask import request
 3 | from sirius.models.db import db
 4 | from sqlalchemy.dialects import postgresql
 5 | from sqlalchemy.orm.attributes import flag_modified
 6 | 
 7 | def generate_secret():
 8 |     return ''.join(random.choice(string.ascii_lowercase + string.digits) for _ in range(20))
 9 | 
10 | 
11 | class PrintKey(db.Model):
12 |     """
13 |     Keys uniquely identify a printer and include a secret so you can print to a
14 |     little printer by just embedding a secret in an URL.
15 |     """
16 |     id = db.Column(db.Integer, primary_key=True)
17 |     secret = db.Column(db.String, default=generate_secret, unique=True)
18 |     created = db.Column(db.DateTime, default=datetime.datetime.utcnow)
19 | 
20 |     printer_id = db.Column(db.Integer, db.ForeignKey('printer.id'))
21 |     printer = db.relationship('Printer', backref=db.backref('print_keys', lazy='dynamic'))
22 | 
23 |     number_of_uses = db.Column(db.Integer, default=0, nullable=False)
24 |     senders = db.Column(postgresql.ARRAY(db.String), default=list, nullable=False)
25 | 
26 |     def record_usage(self, by_name):
27 |         self.number_of_uses += 1
28 |         if by_name not in self.senders:
29 |             self.senders.append(by_name)
30 |             flag_modified(self, 'senders')
31 | 
32 |     parent_id = db.Column(db.Integer, db.ForeignKey('print_key.id'))
33 |     parent = db.relationship(
34 |         'PrintKey', 
35 |         backref=db.backref('children', lazy='dynamic'), 
36 |         remote_side=[id])
37 | 
38 |     def senders_formatted(self):
39 |         return ', '.join((s or 'Anonymous') for s in self.senders)
40 |     
41 |     @property
42 |     def url(self):
43 |         if 'DEVICE_KEY_DOMAIN' in os.environ:
44 |             return 'https://%s/%s' % (os.environ['DEVICE_KEY_DOMAIN'], self.secret)
45 |         else:
46 |             # if a DEVICE_KEY_DOMAIN is not defined, we need a request object
47 |             # to get the full URL.
48 |             return '%sprintkey/%s' % (request.url_root, self.secret)
49 |         


--------------------------------------------------------------------------------
/sirius/models/user.py:
--------------------------------------------------------------------------------
  1 | """User models. Login only via twitter for now to avoid the whole
  2 | forgot-password/reset-password dance.
  3 | """
  4 | import collections
  5 | import datetime
  6 | import random
  7 | import string
  8 | 
  9 | from sirius.coding import claiming
 10 | 
 11 | from sirius.models.db import db
 12 | from sirius.models import hardware
 13 | 
 14 | 
 15 | class CannotChangeOwner(Exception):
 16 |     pass
 17 | 
 18 | 
 19 | class ClaimCodeInUse(Exception):
 20 |     pass
 21 | 
 22 | 
 23 | class User(db.Model):
 24 |     id = db.Column(db.Integer, primary_key=True)
 25 |     created = db.Column(db.DateTime, default=datetime.datetime.utcnow)
 26 |     api_key = db.Column(db.String)
 27 | 
 28 |     # username can't be unique because we may have multiple identity
 29 |     # providers. For now we just copy the  twitter handle.
 30 |     username = db.Column(db.String)
 31 |     twitter_oauth = db.relationship(
 32 |         "TwitterOAuth", uselist=False, backref=db.backref("user")
 33 |     )
 34 | 
 35 |     def __repr__(self):
 36 |         return "User {}".format(self.username)
 37 | 
 38 |     # Flask-login interface:
 39 |     @property
 40 |     def is_active(self):
 41 |         return True
 42 | 
 43 |     @property
 44 |     def is_authenticated(self):
 45 |         return True
 46 | 
 47 |     def get_id(self):
 48 |         return self.id
 49 | 
 50 |     def generate_api_key(self):
 51 |         self.api_key = "".join(
 52 |             random.choice(string.ascii_letters + string.digits) for _ in range(32)
 53 |         )
 54 | 
 55 |     def claim_printer(self, claim_code, name):
 56 |         """Claiming can happen before the printer "calls home" for the first
 57 |         time so we need to be able to deal with that."""
 58 | 
 59 |         # TODO(tom): This method probably belongs to printer, not
 60 |         # user. Move at some point.
 61 | 
 62 |         claim_code = claiming.canonicalize(claim_code)
 63 | 
 64 |         hcc = hardware.ClaimCode.query.filter_by(claim_code=claim_code).first()
 65 |         hardware_xor, _ = claiming.process_claim_code(claim_code)
 66 | 
 67 |         if hcc is not None and hcc.by != self:
 68 |             raise ClaimCodeInUse(
 69 |                 "Claim code {} already claimed by {}".format(claim_code, hcc.by)
 70 |             )
 71 | 
 72 |         if hcc is None:
 73 |             hcc = hardware.ClaimCode(
 74 |                 by_id=self.id,
 75 |                 hardware_xor=hardware_xor,
 76 |                 claim_code=claim_code,
 77 |                 name=name,
 78 |             )
 79 |             db.session.add(hcc)
 80 |         else:
 81 |             # we already have a claim code, don't do anything.
 82 |             pass
 83 | 
 84 |         # Check whether we've seen this printer and if so: connect it
 85 |         # to claim code and make it "owned" but *only* if it does not
 86 |         # have an owner yet.
 87 |         printer_query = hardware.Printer.query.filter_by(hardware_xor=hardware_xor)
 88 |         printer = printer_query.first()
 89 |         if printer is None:
 90 |             return
 91 | 
 92 |         if printer.owner is not None and printer.owner != self:
 93 |             raise CannotChangeOwner(
 94 |                 "Printer {} already owned by {}. Cannot claim for {}.".format(
 95 |                     printer, printer.owner, self
 96 |                 )
 97 |             )
 98 | 
 99 |         assert printer_query.count() == 1, "hardware xor collision: {}".format(
100 |             hardware_xor
101 |         )
102 | 
103 |         printer.used_claim_code = claim_code
104 |         printer.hardware_xor = hardware_xor
105 |         printer.owner_id = hcc.by_id
106 |         printer.name = name
107 |         db.session.add(printer)
108 |         return printer
109 | 
110 | 
111 | class TwitterOAuth(db.Model):
112 |     id = db.Column(db.Integer, primary_key=True)
113 |     created = db.Column(db.DateTime, default=datetime.datetime.utcnow)
114 |     user_id = db.Column(db.Integer, db.ForeignKey(User.id))
115 |     screen_name = db.Column(db.String, unique=True)
116 | 
117 |     token = db.Column(db.String)
118 |     token_secret = db.Column(db.String)
119 | 


--------------------------------------------------------------------------------
/sirius/protocol/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nordprojects/sirius/9d88c63a0fc17d4acc5ae12194b93f8591e35a55/sirius/protocol/__init__.py


--------------------------------------------------------------------------------
/sirius/protocol/messages.py:
--------------------------------------------------------------------------------
  1 | """Data structures for device events.
  2 | 
  3 | This is a mix of BridgeEvent, DeviceEvent, BridgeCommand, etc.
  4 | 
  5 | TODO: The messages are messy because I added them as I encountered
  6 | them. I will group and sort them at some point.
  7 | """
  8 | from collections import namedtuple
  9 | 
 10 | 
 11 | PowerOn = namedtuple('PowerOn', [
 12 |     'bridge_address',
 13 |     'model',
 14 |     'firmware_version',
 15 |     'ncp_version',
 16 |     'local_ip_address',
 17 |     'mac_address',
 18 |     'uptime',
 19 |     'uboot_environment',
 20 |     'network_info',
 21 | ])
 22 | 
 23 | BridgeLog = namedtuple('BridgeLog', [
 24 |     'bridge_address',
 25 |     'records',
 26 | ])
 27 | 
 28 | EncryptionKeyRequired = namedtuple('EncryptionKeyRequired', [
 29 |     'bridge_address',
 30 |     'device_address',
 31 |     'hardware_xor',
 32 | ])
 33 | 
 34 | DeviceConnect = namedtuple('DeviceConnect', [
 35 |     'bridge_address',
 36 |     'device_address',
 37 | ])
 38 | 
 39 | DeviceDisconnect = namedtuple('DeviceDisconnect', [
 40 |     'bridge_address',
 41 |     'device_address',
 42 | ])
 43 | 
 44 | # BridgeCommands
 45 | AddDeviceEncryptionKey = namedtuple('AddDeviceEncryptionKey', [
 46 |     'bridge_address',
 47 |     'device_address',
 48 |     'claim_code',
 49 | ])
 50 | 
 51 | BridgeCommandResponse = namedtuple('BridgeCommandResponse', [
 52 |     'bridge_address',
 53 |     'command_id',
 54 |     'return_code',
 55 |     'timestamp',
 56 | ])
 57 | 
 58 | DeviceCommandResponse = namedtuple('DeviceCommandResponse', [
 59 |     'bridge_address',
 60 |     'command_id',
 61 |     'return_code',
 62 |     'timestamp',
 63 | ])
 64 | 
 65 | SetDeliveryAndPrint = namedtuple('SetDeliveryAndPrint', [
 66 |     'device_address',
 67 |     'pixels',  # 384 pixels wide
 68 | ])
 69 | 
 70 | SetDelivery = namedtuple('SetDelivery', [
 71 |     'device_address',
 72 |     'pixels',
 73 | ])
 74 | 
 75 | SetDeliveryAndPrintNoFace = namedtuple('SetDeliveryAndPrintNoFace', [
 76 |     'device_address',
 77 |     'pixels',
 78 | ])
 79 | 
 80 | SetDeliveryNoFace = namedtuple('SetDeliveryNoFace', [
 81 |     'device_address',
 82 |     'pixels',
 83 | ])
 84 | 
 85 | SetPersonality = namedtuple('SetPersonality', [
 86 |     'device_address',
 87 |     'face_pixels',
 88 |     'nothing_to_print_pixels',
 89 |     'cannot_see_bridge_pixels',
 90 |     'cannot_see_internet_pixels',
 91 | ])
 92 | 
 93 | SetPersonalityWithMessage = namedtuple('SetPersonalityWithMessage', [
 94 |     'device_address',
 95 |     'face_pixels',
 96 |     'nothing_to_print_pixels',
 97 |     'cannot_see_bridge_pixels',
 98 |     'cannot_see_internet_pixels',
 99 |     'message_pixels',
100 | ])
101 | 
102 | SetQuip = namedtuple('SetQuip', [
103 |     'device_address',
104 |     'quip_pixels_1',
105 |     'quip_pixels_2',
106 |     'quip_pixels_3', # Don't know what these are yet.
107 | ])
108 | 
109 | SetLogLevel = namedtuple('SetLogLevel', [
110 |     'level',  # lower-case string, e.g. 'critical'
111 | ])
112 | 
113 | EnableCloudLogging = namedtuple('EnableCloudLogging', [])
114 | 
115 | DisableCloudLogging = namedtuple('DisableCloudLogging', [])
116 | 
117 | Leave = namedtuple('Leave', [])
118 | 
119 | Form = namedtuple('Form', [
120 |     'channels',  # list of numbers
121 | ])
122 | 
123 | Pjoin = namedtuple('Pjoin', [
124 |     'duration',  # int
125 | ])
126 | 
127 | Restart = namedtuple('Restart', [])
128 | 
129 | Reboot = namedtuple('Reboot', [])
130 | 
131 | SetCommandPollFrequency = namedtuple('SetCommandPollFrequency', [
132 |     'frequency',  # int in seconds, clamped to [10, 30]
133 | ])
134 | 
135 | SetBridgeLogFrequency = namedtuple('SetBridgeLogFrequency', [
136 |     'frequency',  # int in seconds, clamped to [10, 30]
137 | ])
138 | 
139 | EnableSlowEvents = namedtuple('EnableSlowEvents', [])
140 | 
141 | DisableSlowEvents = namedtuple('DisableSlowEvents', [])
142 | 
143 | DeviceHeartbeat = namedtuple('DeviceHeartbeat', [
144 |     'bridge_address',
145 |     'device_address',
146 |     'uptime',
147 | ])
148 | 
149 | DeviceDidPrint = namedtuple('DeviceDidPrint', [
150 |     'device_address',
151 |     'type',
152 |     'id',
153 | ])
154 | 
155 | DeviceDidPowerOn = namedtuple('DeviceDidPowerOn', [
156 |     'device_address',
157 |     'device_type',
158 |     'firmware_build_version',
159 |     'loader_build_version',
160 |     'protocol_version',
161 |     'reset_description',
162 | ])
163 | 
164 | BergCloudProductAnnounce = namedtuple('BergCloudProductAnnounce', [
165 |     'device_address',
166 |     'product_id',
167 |     'product_version',
168 | ])
169 | 
170 | BergCloudStartBinary = namedtuple('BergCloudStartBinary', [
171 |     'device_address',
172 |     'event_id',
173 |     'data',
174 | ])
175 | 
176 | BergCloudStartPacked = namedtuple('BergCloudStartPacked', [
177 |     'device_address',
178 |     'event_id',
179 |     'data',
180 | ])
181 | 
182 | UnknownEvent = namedtuple('UnknownEvent', [
183 |     'raw_dict',
184 | ])
185 | 
186 | MalformedEvent = namedtuple('MalformedEvent', [
187 |     'raw_data',
188 |     'error',
189 | ])
190 | 


--------------------------------------------------------------------------------
/sirius/protocol/test_protocol_loop.py:
--------------------------------------------------------------------------------
  1 | """Simple protocol_loop steps.
  2 | 
  3 | Run like:
  4 | 
  5 | $ bin/nosetests sirius/
  6 | """
  7 | import flask_testing as testing
  8 | 
  9 | # TODO: It's a bit ugly that the protocol loop depends on the flask setup
 10 | # for database access but it's the easiest solution for now.
 11 | from sirius.web import webapp
 12 | from sirius.models.db import db
 13 | from sirius.models import hardware
 14 | 
 15 | from sirius.protocol import messages
 16 | from sirius.protocol import protocol_loop
 17 | 
 18 | # The messages are taken from a real network dump so slightly ugly.
 19 | m_power_on = messages.PowerOn(
 20 |     bridge_address=u'000d6f0001b3719d',
 21 |     model=u'A',
 22 |     firmware_version=u'v2.3.1-f3c7946',
 23 |     ncp_version=u'0x46C5',
 24 |     local_ip_address=u'192.168.1.98',
 25 |     mac_address=u'40:d8:55:01:c1:b3',
 26 |     uptime=u'4135.25 4083.53',
 27 |     uboot_environment=u'truncated',
 28 |     network_info={
 29 |         u'network_status': u'EMBER_JOINED_NETWORK',
 30 |         u'power': 8,
 31 |         u'node_eui64': u'0x000d6f0001b3719d',
 32 |         u'pan_id': u'0xDF3A',
 33 |         u'node_type': u'EMBER_COORDINATOR',
 34 |         u'node_id': u'0x0000',
 35 |         u'security_level': 5,
 36 |         u'extended_pan_id': u'0x42455247fbbbbd7f',
 37 |         u'security_profile': u'Custom',
 38 |         u'channel': 25,
 39 |         u'radio_power_mode': u'EMBER_TX_POWER_MODE_BOOST',
 40 |     }
 41 | )
 42 | 
 43 | m_hearbeat = messages.DeviceHeartbeat(
 44 |     bridge_address=u'000d6f0001b3719d',
 45 |     device_address=u'000d6f000273ce0b',
 46 |     uptime=(1,))
 47 | 
 48 | m_hearbeat_2 = messages.DeviceHeartbeat(
 49 |     bridge_address=u'000d6f0001b3719d',
 50 |     device_address=u'000d6f00cafecccc',
 51 |     uptime=(1,))
 52 | 
 53 | m_bridge_log = messages.BridgeLog(
 54 |     bridge_address=u'000d6f0001b3719d',
 55 |     records=[
 56 |         {u'name': u'cloud.socketclient', u'created': 1419267045.369878,
 57 |          u'process': 490, u'levelno': 30, u'processName': u'MainProcess',
 58 |          u'message': u'Closed down websocket, code: 1006, reason: Going away',
 59 |          u'levelname': u'WARNING'},
 60 |         {u'name': u'cloud.socket', u'created': 1419267045.569464,
 61 |          u'process': 490, u'levelno': 40, u'processName': u'MainProcess',
 62 |          u'message': u'Socket connection refused', u'levelname': u'ERROR'}
 63 |     ]
 64 | )
 65 | 
 66 | m_device_connect = messages.DeviceConnect(
 67 |     bridge_address=u'000d6f0001b3719d',
 68 |     device_address=u'000d6f000273ce0b')
 69 | 
 70 | m_device_disconnect = messages.DeviceDisconnect(
 71 |     bridge_address=u'000d6f0001b3719d',
 72 |     device_address=u'000d6f000273ce0b')
 73 | 
 74 | m_encryption_key_required = messages.EncryptionKeyRequired(
 75 |     bridge_address=u'000d6f0001b3719d',
 76 |     device_address=u'000d6f000273ce0b',
 77 |     hardware_xor=0xaacafe,
 78 | )
 79 | 
 80 | m_command_response = messages.BridgeCommandResponse(
 81 |     bridge_address=u'000d6f0001b3719d',
 82 |     command_id=10,
 83 |     return_code=0,
 84 |     timestamp=0,
 85 | )
 86 | 
 87 | class BaseTest(testing.TestCase):
 88 | 
 89 |     def create_app(self):
 90 |         app = webapp.create_app('test')
 91 |         return app
 92 | 
 93 |     def setUp(self):
 94 |         testing.TestCase.setUp(self)
 95 |         db.create_all()
 96 | 
 97 |     def tearDown(self):
 98 |         db.session.remove()
 99 |         db.drop_all()
100 | 
101 | 
102 | class FakeWebsocket:
103 |     "Use to create an in-memory a BridgeState."
104 |     def __init__(self):
105 |         self.messages = []
106 |     def send(self, message):
107 |         self.messages.append(message)
108 | 
109 | 
110 | # pylint: disable=no-member
111 | class TestNormalFlow(BaseTest):
112 |     "A bunch of smoke tests that exercise the _accept_step."
113 |     def setUp(self):
114 |         BaseTest.setUp(self)
115 |         self.bridge_state = protocol_loop.BridgeState(
116 |             FakeWebsocket(), m_power_on.bridge_address)
117 | 
118 |     def test_bridge_log(self):
119 |         protocol_loop._accept_step(m_bridge_log, self.bridge_state)
120 | 
121 |     def test_heartbeat(self):
122 |         self.assertNotIn(m_hearbeat.device_address, self.bridge_state.connected_devices)
123 | 
124 |         protocol_loop._accept_step(m_hearbeat, self.bridge_state)
125 | 
126 |         self.assertIn(m_hearbeat.device_address, self.bridge_state.connected_devices)
127 | 
128 |     def test_device_connect(self):
129 |         self.assertNotIn(m_device_connect.device_address, self.bridge_state.connected_devices)
130 | 
131 |         protocol_loop._accept_step(m_device_connect, self.bridge_state)
132 | 
133 |         self.assertIn(m_device_connect.device_address, self.bridge_state.connected_devices)
134 | 
135 |     def test_device_disconnect(self):
136 |         self.assertNotIn(m_hearbeat.device_address, self.bridge_state.connected_devices)
137 | 
138 |         protocol_loop._accept_step(m_device_connect, self.bridge_state)
139 |         protocol_loop._accept_step(m_device_disconnect, self.bridge_state)
140 | 
141 |         self.assertNotIn(m_hearbeat.device_address, self.bridge_state.connected_devices)
142 | 
143 |     def test_encryption_key_required(self):
144 |         # Pretend this printer is claimed:
145 |         hardware.Printer.phone_home('000d6f000273ce0b')
146 |         p = hardware.Printer.query.first()
147 |         p.used_claim_code = 'n5ry-p6x6-kth7-7hc4'
148 |         db.session.add(p)
149 |         db.session.commit()
150 | 
151 |         protocol_loop.bridge_by_address = {
152 |             self.bridge_state.address: self.bridge_state
153 |         }
154 |         protocol_loop._accept_step(m_encryption_key_required, self.bridge_state)
155 | 
156 |         self.assertEquals(len(self.bridge_state.websocket.messages), 1)
157 | 
158 | 
159 | class TestBrokenFlow(BaseTest):
160 |     "Check unexpected interactions."
161 |     def setUp(self):
162 |         BaseTest.setUp(self)
163 |         self.bridge_state = protocol_loop.BridgeState(
164 |             None, m_power_on.bridge_address)
165 | 
166 |     def test_device_double_disconnect(self):
167 |         self.assertNotIn(m_hearbeat.device_address, self.bridge_state.connected_devices)
168 | 
169 |         protocol_loop._accept_step(m_device_connect, self.bridge_state)
170 |         protocol_loop._accept_step(m_device_disconnect, self.bridge_state)
171 |         protocol_loop._accept_step(m_device_disconnect, self.bridge_state)
172 | 
173 |         self.assertNotIn(m_hearbeat.device_address, self.bridge_state.connected_devices)
174 | 
175 |     def test_device_double_power_on(self):
176 |         protocol_loop._accept_step(m_power_on, self.bridge_state)
177 |         protocol_loop._accept_step(m_power_on, self.bridge_state)
178 | 
179 |     def test_command_response_unseed_command_id(self):
180 |         protocol_loop._accept_step(m_command_response, self.bridge_state)
181 | 
182 | 
183 | class TestMultiDevice(BaseTest):
184 |     "What happens when we have more than one device."
185 |     def setUp(self):
186 |         BaseTest.setUp(self)
187 |         self.bridge_state = protocol_loop.BridgeState(
188 |             FakeWebsocket(), m_power_on.bridge_address)
189 | 
190 |     def test_two_heartbeats(self):
191 |         protocol_loop._accept_step(m_hearbeat, self.bridge_state)
192 |         protocol_loop._accept_step(m_hearbeat_2, self.bridge_state)
193 | 
194 |         self.assertEquals(len(self.bridge_state.connected_devices), 2)
195 | 


--------------------------------------------------------------------------------
/sirius/stats.py:
--------------------------------------------------------------------------------
 1 | import flask
 2 | import collections
 3 | 
 4 | STATS = collections.defaultdict(int)
 5 | blueprint = flask.Blueprint('stats', __name__)
 6 | 
 7 | 
 8 | def inc(key):
 9 |     STATS[key] += 1
10 | 
11 | 
12 | @blueprint.route('/_/stats')
13 | def showstats():
14 |     "Render some trivial stats"
15 |     return '<pre>' + '\n'.join('{} {}'.format(k, v) for k, v in STATS.items())
16 | 


--------------------------------------------------------------------------------
/sirius/testing/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nordprojects/sirius/9d88c63a0fc17d4acc5ae12194b93f8591e35a55/sirius/testing/__init__.py


--------------------------------------------------------------------------------
/sirius/testing/base.py:
--------------------------------------------------------------------------------
 1 | import flask_testing as testing
 2 | import flask_login as login
 3 | 
 4 | from sirius.models import user
 5 | from sirius.models.db import db
 6 | from sirius.web import webapp
 7 | 
 8 | 
 9 | # pylint: disable=no-member
10 | class Base(testing.TestCase):
11 |     """Common base class for tests that require database interactions."""
12 | 
13 |     def create_app(self):
14 |         app = webapp.create_app("test")
15 |         return app
16 | 
17 |     def setUp(self):
18 |         testing.TestCase.setUp(self)
19 |         db.create_all()
20 |         db.session.begin_nested()
21 |         self.testuser = user.User(
22 |             username="testuser",
23 |             twitter_oauth=user.TwitterOAuth(
24 |                 screen_name="testuser",
25 |                 token="token",
26 |                 token_secret="token_secret",
27 |             ),
28 |         )
29 |         db.session.add(self.testuser)
30 |         db.session.flush()
31 |         db.session.refresh(self.testuser)
32 | 
33 |     def tearDown(self):
34 |         db.session.rollback()
35 |         db.session.remove()
36 |         db.drop_all()
37 | 
38 |     def autologin(self):
39 |         # Most disgusting hack but I see no other way to log in users:
40 |         # Flask session doesn't pick up the cookies if I call just
41 |         # login_user. The login_user call needs to be embedded in a
42 |         # request.
43 |         @self.app.route("/autologin")
44 |         def autologin():
45 |             login.login_user(self.testuser)
46 |             return ""
47 | 
48 |         self.client.get("/autologin")
49 | 


--------------------------------------------------------------------------------
/sirius/web/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nordprojects/sirius/9d88c63a0fc17d4acc5ae12194b93f8591e35a55/sirius/web/__init__.py


--------------------------------------------------------------------------------
/sirius/web/admin.py:
--------------------------------------------------------------------------------
 1 | import io
 2 | from PIL import Image
 3 | import flask
 4 | import flask_login as login
 5 | 
 6 | from sirius.protocol import protocol_loop
 7 | from sirius.protocol import messages
 8 | from sirius.coding import image_encoding
 9 | 
10 | 
11 | blueprint = flask.Blueprint('admin', __name__)
12 | 
13 | 
14 | 
15 | @blueprint.route('/admin', methods=['GET'])
16 | def admin_landing():
17 |     return flask.render_template(
18 |         'admin.html',
19 |     )
20 | 
21 | @blueprint.route('/admin/randomly-change-personality', methods=['POST'])
22 | def randomly_change_personality():
23 |     # Restrict to debug for now until we have a proper user management
24 |     # system.
25 |     assert flask.current_app.config['DEBUG'], "Debug not enabled"
26 | 
27 |     im = image_encoding.convert_to_1bit(Image.open('./tests/normalface.png'))
28 | 
29 |     msg = messages.SetPersonality(
30 |         device_address='000d6f000273ce0b',
31 |         face_pixels=im,
32 |         nothing_to_print_pixels=image_encoding.default_pipeline('Nothing to print'),
33 |         cannot_see_bridge_pixels=image_encoding.default_pipeline('Cannot see bridge'),
34 |         cannot_see_internet_pixels=image_encoding.default_pipeline('Cannot see internet'),
35 |     )
36 |     success, next_print_id = protocol_loop.send_message(
37 |         '000d6f000273ce0b', msg)
38 | 
39 |     if success:
40 |         flask.flash('Sent your message to the printer!')
41 |     else:
42 |         flask.flash(("Could not send message because the "
43 |                      "printer {} is offline.").format('000d6f000273ce0b'),
44 |                     'error')
45 | 
46 |     return flask.redirect('/admin')
47 | 


--------------------------------------------------------------------------------
/sirius/web/external_api.py:
--------------------------------------------------------------------------------
 1 | import io
 2 | import datetime
 3 | import json
 4 | 
 5 | import flask
 6 | import flask_login as login
 7 | from flask import request
 8 | 
 9 | from sirius.models.db import db
10 | from sirius.models import hardware
11 | from sirius.models import messages as model_messages
12 | from sirius.protocol import protocol_loop
13 | from sirius.protocol import messages
14 | from sirius.coding import image_encoding
15 | from sirius.coding import templating
16 | 
17 | blueprint = flask.Blueprint("external_api", __name__)
18 | 
19 | 
20 | # TODO : need a refactor as this is code duplication from printer_print
21 | @blueprint.route("/ext_api/v1/printer/<int:printer_id>/print_html", methods=["POST"])
22 | @login.login_required
23 | def print_html(printer_id):
24 |     printer = hardware.Printer.query.get(printer_id)
25 |     if printer is None:
26 |         flask.abort(404)
27 | 
28 |     # PERMISSIONS
29 |     # the printer must either belong to this user
30 |     if printer.owner.id == login.current_user.id:
31 |         # fine
32 |         pass
33 |     else:
34 |         flask.abort(404)
35 | 
36 |     request.get_data()
37 |     task = json.loads(request.data)
38 |     if not task["message"] or not task["face"]:
39 |         flask.abort(500)
40 | 
41 |     pixels = image_encoding.default_pipeline(
42 |         templating.default_template(
43 |             task["message"], from_name=login.current_user.username
44 |         )
45 |     )
46 | 
47 |     hardware_message = None
48 |     if task["face"] == "noface":
49 |         hardware_message = messages.SetDeliveryAndPrintNoFace(
50 |             device_address=printer.device_address,
51 |             pixels=pixels,
52 |         )
53 |     else:
54 |         hardware_message = messages.SetDeliveryAndPrint(
55 |             device_address=printer.device_address,
56 |             pixels=pixels,
57 |         )
58 | 
59 |     # If a printer is "offline" then we won't find the printer
60 |     # connected and success will be false.
61 |     success, next_print_id = protocol_loop.send_message(
62 |         printer.device_address, hardware_message
63 |     )
64 | 
65 |     # Store the same message in the database.
66 |     png = io.BytesIO()
67 |     pixels.save(png, "PNG")
68 |     model_message = model_messages.Message(
69 |         print_id=next_print_id,
70 |         pixels=bytearray(png.getvalue()),
71 |         sender_id=login.current_user.id,
72 |         target_printer=printer,
73 |     )
74 | 
75 |     # We know immediately if the printer wasn't online.
76 |     if not success:
77 |         model_message.failure_message = "Printer offline"
78 |         model_message.response_timestamp = datetime.datetime.utcnow()
79 |     db.session.add(model_message)
80 | 
81 |     response = {}
82 |     if success:
83 |         response["status"] = "Sent your message to the printer!"
84 |     else:
85 |         response["status"] = (
86 |             "Could not send message because the " "printer {} is offline."
87 |         ).format(printer.name)
88 | 
89 |     return json.dumps(response)
90 | 


--------------------------------------------------------------------------------
/sirius/web/landing.py:
--------------------------------------------------------------------------------
 1 | import flask
 2 | import flask_wtf
 3 | import wtforms
 4 | import flask_login as login
 5 | 
 6 | from sirius.coding import claiming
 7 | 
 8 | 
 9 | blueprint = flask.Blueprint("landing", __name__)
10 | 
11 | 
12 | class ClaimForm(flask_wtf.FlaskForm):
13 |     claim_code = wtforms.StringField(
14 |         "Claim code",
15 |         validators=[wtforms.validators.DataRequired()],
16 |     )
17 |     printer_name = wtforms.StringField(
18 |         "Name your printer",
19 |         validators=[wtforms.validators.DataRequired()],
20 |     )
21 | 
22 |     def validate_claim_code(self, field):
23 |         try:
24 |             claiming.unpack_claim_code(field.data)
25 |         except claiming.InvalidClaimCode:
26 |             raise wtforms.validators.ValidationError(
27 |                 "`{}` doesn't look like a valid claim code :(".format(field.data)
28 |             )
29 | 
30 | 
31 | @blueprint.route("/about")
32 | def about():
33 |     return flask.render_template("about.html")
34 | 
35 | 
36 | @blueprint.route("/")
37 | def landing():
38 |     if not login.current_user.is_authenticated:
39 |         return flask.render_template("landing.html")
40 | 
41 |     return overview()
42 | 
43 | 
44 | @login.login_required
45 | def overview():
46 |     user = login.current_user
47 |     my_printers = user.printers.all()
48 | 
49 |     return flask.render_template("overview.html", my_printers=my_printers)
50 | 
51 | 
52 | @blueprint.route("/<int:user_id>/<username>/claim", methods=["GET", "POST"])
53 | @login.login_required
54 | def claim(user_id, username):
55 |     user = login.current_user
56 |     assert user_id == user.get_id()
57 |     assert username == user.username
58 | 
59 |     form = ClaimForm()
60 |     if form.validate_on_submit():
61 |         user.claim_printer(form.claim_code.data, form.printer_name.data)
62 |         return flask.redirect(flask.url_for(".landing"))
63 | 
64 |     return flask.render_template("claim.html", form=form)
65 | 
66 | 
67 | @blueprint.route("/<int:user_id>/<username>/generate_api_key", methods=["POST"])
68 | @login.login_required
69 | def generate_api_key(user_id, username):
70 |     user = login.current_user
71 |     assert user_id == user.get_id()
72 |     assert username == user.username
73 | 
74 |     user.generate_api_key()
75 |     return flask.redirect(flask.url_for(".landing"))
76 | 


--------------------------------------------------------------------------------
/sirius/web/login.py:
--------------------------------------------------------------------------------
 1 | import flask_login as login
 2 | 
 3 | from sirius.models import user
 4 | 
 5 | manager = login.LoginManager()
 6 | 
 7 | 
 8 | @manager.user_loader
 9 | def load_user(user_id):
10 |     return user.User.query.get(user_id)
11 | 
12 | @manager.request_loader
13 | def load_user_from_request(request):
14 |     api_key = request.args.get('api_key')
15 |     if api_key:
16 |         selected_user = user.User.query.filter_by(api_key=api_key).first()
17 |         if selected_user and selected_user.api_key != None:
18 |             return selected_user
19 |     return None
20 | 


--------------------------------------------------------------------------------
/sirius/web/print_key_api.py:
--------------------------------------------------------------------------------
 1 | import io
 2 | import datetime
 3 | import flask
 4 | import flask_login as login
 5 | from flask import request, jsonify
 6 | import flask_wtf
 7 | import wtforms
 8 | import base64
 9 | import json
10 | import cgi
11 | 
12 | from sirius.models.db import db
13 | from sirius.models import hardware
14 | from sirius.models.print_keys import PrintKey
15 | from sirius.models import messages as model_messages
16 | from sirius.protocol import protocol_loop
17 | from sirius.protocol import messages
18 | from sirius.coding import image_encoding
19 | from sirius.coding import templating
20 | from sirius import stats
21 | 
22 | blueprint = flask.Blueprint('print_key_api', __name__)
23 | 
24 | 
25 | @blueprint.route('/printkey/<print_key_secret>', methods=['GET', 'POST'])
26 | def print_key(print_key_secret):
27 |     print_key = PrintKey.query.filter(PrintKey.secret == print_key_secret).first()
28 |     if print_key is None:
29 |         flask.abort(404)
30 | 
31 |     printer = print_key.printer
32 |     if printer is None:
33 |         flask.abort(404)
34 | 
35 |     if request.method == 'GET':
36 |         printer_info = {
37 |             "name": printer.name,
38 |             "owner": printer.owner.username,
39 |             "status": 'online' if printer.is_online else 'offline'
40 |         }
41 | 
42 |         html_preference_score = request.accept_mimetypes.quality('text/html')
43 |         json_preference_score = request.accept_mimetypes.quality('application/json')
44 | 
45 |         if html_preference_score > json_preference_score:
46 |             return flask.render_template(
47 |                 'print_key.html',
48 |                 printer=printer,
49 |                 printer_info_json=json.dumps(printer_info, indent=2),
50 |                 print_key=print_key,
51 |             )
52 |         else:
53 |             return json.dumps(printer_info), 200, {'content-type': 'application/json'}
54 |     else:
55 |         from_name = request.args.get('from')
56 | 
57 |         print_key.record_usage(from_name)
58 |         db.session.add(print_key)
59 |         db.session.commit()
60 | 
61 |         if request.mimetype == 'text/html':
62 |             html = request.get_data(as_text=True)
63 |         elif request.mimetype.startswith('image/'):
64 |             html = html_for_image_data(request.get_data())
65 |         elif request.mimetype.startswith('text/'):
66 |             # fallback for sending any text format
67 |             html = html_for_plain_text(request.get_data(as_text=True))
68 |         elif request.mimetype == 'application/json':
69 |             json_object = request.get_json()
70 |             if 'html' in json_object:
71 |                 html = json_object['html']
72 |             elif 'text' in json_object:
73 |                 html = html_for_plain_text(json_object['text'])
74 |             else:
75 |                 flask.abort(jsonify(message='json requests must have "html" or "text"'))
76 |         else:
77 |             flask.abort(415)
78 | 
79 |         try:
80 |             printer.print_html(html, from_name=from_name or 'Key ' + print_key_secret[0:4])
81 |         except hardware.Printer.OfflineError:
82 |             return json.dumps({'status': 'failed-offline'}), 504, {'content-type': 'application/json'}
83 |         
84 |         return json.dumps({'status': 'sent'}), 200, {'content-type': 'application/json'}
85 | 
86 | def html_for_plain_text(text):
87 |     return '<div style="white-space: pre-wrap">{text}</div>'.format(
88 |         text=cgi.escape(text)
89 |     )
90 | 
91 | def html_for_image_data(image_data):
92 |     data_uri = 'data:{type};base64,{data}'.format(
93 |         type=request.content_type,
94 |         data=base64.b64encode(image_data).decode('utf-8')
95 |     )
96 | 
97 |     return '<img src="{uri}" style="width: 100%">'.format(uri=data_uri)


--------------------------------------------------------------------------------
/sirius/web/printer_overview.py:
--------------------------------------------------------------------------------
 1 | import flask, io
 2 | import flask_login as login
 3 | from sqlalchemy import desc
 4 | from PIL import Image
 5 | 
 6 | from sirius.models import hardware
 7 | from sirius.models import messages
 8 | from sirius.models.print_keys import PrintKey
 9 | from sirius.models.db import db
10 | 
11 | blueprint = flask.Blueprint('printer_overview', __name__)
12 | 
13 | 
14 | @login.login_required
15 | @blueprint.route('/printer/<int:printer_id>')
16 | def printer_overview(printer_id):
17 | 	printer = hardware.Printer.query.get(printer_id)
18 | 	if printer is None:
19 | 		flask.abort(404)
20 | 	
21 | 	# only show messages history to printer owner
22 | 	if printer.owner.id == login.current_user.id:
23 | 		messages.Message.timeout_updates()
24 | 		message_list = printer.messages.order_by(desc('created'))
25 | 	else:
26 | 		message_list = []
27 | 
28 | 	# TODO - pagination?
29 | 	return flask.render_template(
30 | 		'printer_overview.html',
31 | 		printer=printer,
32 | 		messages=message_list[:10],
33 | 	)
34 | 
35 | @login.login_required
36 | @blueprint.route('/printer/<int:printer_id>/message/<int:message_id>/reprint', methods=['POST'])
37 | def reprint(printer_id, message_id):
38 | 	printer = hardware.Printer.query.get(printer_id)
39 | 	if printer is None:
40 | 		flask.abort(404)
41 | 	
42 | 	if printer.owner.id != login.current_user.id:
43 | 		flask.abort(403)
44 | 
45 | 	message = printer.messages.filter(messages.Message.id==message_id).first()
46 | 
47 | 	if message is None:
48 | 		flask.abort(404)
49 | 
50 | 	pixels = Image.open(io.BytesIO(message.pixels))
51 | 
52 | 	printer.print_pixels(pixels, from_name=message.sender_name)
53 | 
54 | 	return flask.redirect(flask.url_for('.printer_overview', printer_id=printer.id))
55 | 
56 | @login.login_required
57 | @blueprint.route('/printer/<int:printer_id>/printkey/<int:print_key_id>/delete', methods=['POST'])
58 | def print_key_delete(printer_id, print_key_id):
59 | 	printer = hardware.Printer.query.get(printer_id)
60 | 	if printer is None:
61 | 		flask.abort(404)
62 | 	
63 | 	if printer.owner.id != login.current_user.id:
64 | 		flask.abort(403)
65 | 
66 | 	print_key = printer.print_keys.filter(PrintKey.id==print_key_id).first()
67 | 
68 | 	if print_key is None:
69 | 		flask.abort(404)
70 | 
71 | 	db.session.delete(print_key)
72 | 	db.session.commit()
73 | 
74 | 	return flask.redirect(flask.url_for('.printer_overview', printer_id=printer.id))
75 | 
76 | @login.login_required
77 | @blueprint.route('/printer/<int:printer_id>/printkey/add', methods=['POST'])
78 | def print_key_add(printer_id):
79 | 	printer = hardware.Printer.query.get(printer_id)
80 | 	if printer is None:
81 | 		flask.abort(404)
82 | 	
83 | 	if printer.owner.id != login.current_user.id:
84 | 		flask.abort(403)
85 | 
86 | 	print_key = PrintKey(printer_id=printer.id)
87 | 
88 | 	db.session.add(print_key)
89 | 	db.session.commit()
90 | 
91 | 	return flask.redirect(flask.url_for('.printer_overview', printer_id=printer.id))
92 | 


--------------------------------------------------------------------------------
/sirius/web/printer_print.py:
--------------------------------------------------------------------------------
  1 | import io
  2 | import base64
  3 | 
  4 | import flask
  5 | import flask_login as login
  6 | import flask_wtf
  7 | import wtforms
  8 | 
  9 | from sirius.models import hardware
 10 | from sirius.coding import image_encoding
 11 | from sirius.coding import templating
 12 | from sirius import stats
 13 | 
 14 | 
 15 | blueprint = flask.Blueprint("printer_print", __name__)
 16 | 
 17 | 
 18 | class PrintForm(flask_wtf.FlaskForm):
 19 |     target_printer = wtforms.SelectField(
 20 |         "Printer",
 21 |         coerce=int,
 22 |         validators=[wtforms.validators.DataRequired()],
 23 |     )
 24 |     face = wtforms.SelectField(
 25 |         "Face",
 26 |         coerce=str,
 27 |         validators=[wtforms.validators.DataRequired()],
 28 |     )
 29 |     message = wtforms.TextAreaField(
 30 |         "Message",
 31 |         validators=[wtforms.validators.DataRequired()],
 32 |     )
 33 | 
 34 | 
 35 | @login.login_required
 36 | @blueprint.route("/printer/<int:printer_id>/print", methods=["GET", "POST"])
 37 | def printer_print(printer_id):
 38 |     printer = hardware.Printer.query.get(printer_id)
 39 |     if printer is None:
 40 |         flask.abort(404)
 41 | 
 42 |     # PERMISSIONS
 43 |     # the printer must either belong to this user
 44 |     if printer.owner.id == login.current_user.id:
 45 |         # fine
 46 |         pass
 47 |     else:
 48 |         flask.abort(404)
 49 | 
 50 |     form = PrintForm()
 51 |     # Note that the form enforces access permissions: People can't
 52 |     # submit a valid printer-id that's not owned by the user.
 53 |     choices = [(x.id, x.name) for x in login.current_user.printers]
 54 |     form.target_printer.choices = choices
 55 |     form.face.choices = [("default", "Default face"), ("noface", "No face")]
 56 | 
 57 |     # Set default printer on get
 58 |     if flask.request.method != "POST":
 59 |         form.target_printer.data = printer.id
 60 |         form.face.data = "default"
 61 | 
 62 |     if form.validate_on_submit():
 63 |         try:
 64 |             printer.print_html(
 65 |                 html=form.message.data,
 66 |                 from_name="@" + login.current_user.username,
 67 |             )
 68 |             flask.flash("Sent your message to the printer!")
 69 |         except hardware.Printer.OfflineError:
 70 |             flask.flash(
 71 |                 "Could not send message because the printer {} is offline.".format(
 72 |                     printer.name
 73 |                 ),
 74 |                 "error",
 75 |             )
 76 | 
 77 |         return flask.redirect(
 78 |             flask.url_for("printer_overview.printer_overview", printer_id=printer.id)
 79 |         )
 80 | 
 81 |     return flask.render_template(
 82 |         "printer_print.html",
 83 |         printer=printer,
 84 |         form=form,
 85 |     )
 86 | 
 87 | 
 88 | @blueprint.route(
 89 |     "/<int:user_id>/<username>/printer/<int:printer_id>/preview", methods=["POST"]
 90 | )
 91 | @login.login_required
 92 | def preview(user_id, username, printer_id):
 93 |     assert user_id == login.current_user.id
 94 |     assert username == login.current_user.username
 95 | 
 96 |     message = flask.request.data.decode("utf-8")
 97 |     pixels = image_encoding.default_pipeline(
 98 |         templating.default_template(message, from_name=login.current_user.username)
 99 |     )
100 |     png = io.BytesIO()
101 |     pixels.save(png, "PNG")
102 | 
103 |     stats.inc("printer.preview")
104 | 
105 |     return '<img style="width: 100%;" src="data:image/png;base64,{}">'.format(
106 |         base64.b64encode(png.getvalue()).decode("utf-8")
107 |     )
108 | 


--------------------------------------------------------------------------------
/sirius/web/static/device-key-favicon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nordprojects/sirius/9d88c63a0fc17d4acc5ae12194b93f8591e35a55/sirius/web/static/device-key-favicon.png


--------------------------------------------------------------------------------
/sirius/web/static/device-key-large.svg:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <svg width="188px" height="207px" viewBox="0 0 188 207" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
 3 |     <!-- Generator: Sketch 54 (76480) - https://sketchapp.com -->
 4 |     <title>Group 2</title>
 5 |     <desc>Created with Sketch.</desc>
 6 |     <defs>
 7 |         <filter x="-21.7%" y="-19.1%" width="143.5%" height="138.2%" filterUnits="objectBoundingBox" id="filter-1">
 8 |             <feGaussianBlur stdDeviation="10" in="SourceGraphic"></feGaussianBlur>
 9 |         </filter>
10 |     </defs>
11 |     <g id="5.-Website" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
12 |         <g id="Artboard-Copy-2" transform="translate(-612.000000, -161.000000)">
13 |             <g id="Group-2" transform="translate(622.000000, 172.000000)">
14 |                 <rect id="Rectangle-2-Copy-3" fill="#000000" opacity="0.235770089" filter="url(#filter-1)" x="15" y="14" width="138" height="157" rx="23"></rect>
15 |                 <path d="M37,0 L132,0 C152.434536,-3.75376332e-15 169,16.5654643 169,37 L169,132 C169,152.434536 152.434536,169 132,169 L37,169 C16.5654643,169 2.50250888e-15,152.434536 0,132 L0,37 C-2.50250888e-15,16.5654643 16.5654643,3.75376332e-15 37,0 Z" id="Rectangle-2-Copy-4" fill="#FFFFFF"></path>
16 |                 <g id="Group-2-Copy-2" transform="translate(6.000000, 28.000000)" fill="#49528D">
17 |                     <g id="Group" transform="translate(67.000000, 0.000000)">
18 |                         <path d="M60.4099657,21.9996233 C59.778359,22.2120418 59.5456863,22.2503695 59.354811,22.3607348 C51.2669947,27.023322 43.1633882,31.6591259 35.1354816,36.4205338 C34.4309616,36.8379825 33.8536916,38.0815545 33.8434745,38.9487763 C33.7473402,47.2548034 33.7858868,55.5626775 33.7858868,63.8700899 L33.7858868,67.1279439 C34.1281619,67.238771 34.2261538,67.3052672 34.2707378,67.2798693 C42.6385974,62.4870604 51.0185318,57.7145697 59.3348411,52.8344845 C59.9316165,52.4844557 60.3375167,51.3567902 60.3616663,50.5759212 C60.4717331,47.1181166 60.4099657,43.6547707 60.4099657,40.193272 L60.4099657,21.9996233 Z M30.2187024,67.6331306 C30.2187024,57.48368 30.2442453,47.7987796 30.1569349,38.1143409 C30.1518264,37.5020213 29.3878609,36.6911366 28.7664714,36.321713 C23.9258565,33.4439035 19.0360133,30.6478289 14.1563874,27.8346685 C10.7703254,25.8827267 7.37683284,23.9437148 3.59880322,21.7770456 L3.59880322,24.4133445 C3.59880322,32.1052048 3.81707906,39.805839 3.50313339,47.4852313 C3.35452005,51.1111236 4.49001881,53.0672213 7.72746742,54.7758053 C15.2143286,58.7290992 22.4504047,63.1524846 30.2187024,67.6331306 L30.2187024,67.6331306 Z M58.6149952,18.7459253 C49.8612054,13.6995994 41.4696606,8.81997593 33.0065956,4.06595646 C32.3708092,3.70900094 31.0839106,3.98883929 30.3440949,4.40351724 C24.4947669,7.67984246 18.7020978,11.0577592 12.8968894,14.4116633 C10.4814583,15.8071608 8.07670876,17.2215913 5.41978099,18.7717849 C14.1489567,23.8079516 22.5474678,28.6709511 30.9794169,33.4753045 C31.4791292,33.7597606 32.399603,33.8382631 32.8695927,33.5708928 C41.3688822,28.7309824 49.8286963,23.8231904 58.6149952,18.7459253 L58.6149952,18.7459253 Z M0.0357985277,35.5607005 C0.0357985277,30.1735814 0.0655211946,24.7869241 0.0121132775,19.4002668 C0.000502860722,18.2273469 0.210419196,17.4991207 1.36867437,16.8461646 C10.781007,11.5366244 20.1506134,6.15089069 29.5044295,0.7388355 C31.2320595,-0.261378795 32.7479155,-0.239213381 34.4801897,0.76377159 C43.6979318,6.10101851 52.9416812,11.393011 62.2170109,16.6309754 C63.5536021,17.3859848 64.000371,18.3053877 63.9952624,19.7701521 C63.9534649,30.4663496 63.944641,41.1634706 63.9999065,51.8601298 C64.0091949,53.6273598 63.3265024,54.6598987 61.801358,55.5220409 C52.5961552,60.7258336 43.4197462,65.9822691 34.2763108,71.2927328 C32.6805751,72.2190624 31.3746354,72.2453838 29.7682182,71.3130511 C20.5565135,65.965645 11.3109065,60.6754996 2.03836321,55.4324557 C0.584739032,54.6104883 -0.0278265562,53.6412132 0.000967277392,51.9511004 C0.0947794448,46.489173 0.0357985277,41.024475 0.0357985277,35.5607005 L0.0357985277,35.5607005 Z" id="Fill-1"></path>
19 |                         <path d="M33.9591837,15.2814529 C32.9039627,16.1501798 32.2795217,17.0612162 31.7183687,17.0166071 C31.1276812,16.9701585 30.5973283,16.0103741 30.0408163,15.4497716 C30.5542925,14.8463997 31.0129191,13.8489045 31.5968558,13.7523282 C32.1529459,13.6603508 32.839831,14.5083827 33.9591837,15.2814529" id="Fill-4"></path>
20 |                         <path d="M33.9591837,29.056527 C32.8142394,29.9173659 32.1912997,30.7378747 31.5415016,30.7633707 C31.0233959,30.7828404 29.9720226,29.7268409 30.0443668,29.3365198 C30.177792,28.6128959 30.8873715,27.6282854 31.4942829,27.5012688 C32.0461781,27.3853777 32.7800167,28.2633685 33.9591837,29.056527" id="Fill-6"></path>
21 |                         <path d="M31.6396776,19.6363636 C32.4882514,20.7898055 33.3823584,21.4777386 33.3009505,22.0368766 C33.2126437,22.6478842 32.2440277,23.5305486 31.6180609,23.563077 C31.0868399,23.5903306 30.1163842,22.6153558 30.0446349,22.0078647 C29.976565,21.4372978 30.830658,20.7665081 31.6396776,19.6363636" id="Fill-8"></path>
22 |                         <path d="M33.9591837,8.92784148 C32.7677528,9.70673442 32.018516,10.5795758 31.45298,10.4620246 C30.8550776,10.3375313 30.1513286,9.31751935 30.043295,8.59601365 C29.9824988,8.19106337 31.055399,7.17012586 31.5767593,7.20067068 C32.2328336,7.23908311 32.8473565,8.06888408 33.9591837,8.92784148" id="Fill-10"></path>
23 |                         <path d="M8.18140861,53.0181818 C7.33811673,51.7112401 6.45106485,50.9352284 6.5363057,50.308207 C6.63020739,49.6127567 7.61207263,49.0541641 8.20739111,48.4363636 C8.77216875,49.0779444 9.70753898,49.6695381 9.79141233,50.3756651 C9.86616902,51.0036572 8.99735047,51.7583153 8.18140861,53.0181818" id="Fill-12"></path>
24 |                         <path d="M20.1225064,45.1636364 C19.1856777,44.0970832 18.2456671,43.491923 18.2870312,42.9498699 C18.3329409,42.348471 19.2747696,41.8047462 19.826594,41.2363636 C20.4338736,41.741639 21.4066118,42.1787921 21.5393406,42.773922 C21.6579783,43.3063628 20.8506965,44.0134975 20.1225064,45.1636364" id="Fill-14"></path>
25 |                         <path d="M13.2466367,44.5090909 C14.1563788,45.6356989 15.0583726,46.267007 15.0191753,46.8367349 C14.9776991,47.4396895 14.0547393,48.4183278 13.4904804,48.4360487 C12.8947725,48.4550987 11.8879487,47.6058232 11.7653432,47.0010965 C11.6532207,46.4482035 12.4822892,45.7150001 13.2466367,44.5090909" id="Fill-16"></path>
26 |                         <path d="M29.3877551,39.4881423 C28.0941835,40.3868872 27.3660945,41.2861082 26.7180952,41.2342209 C26.0438847,41.1799535 25.4468517,40.2059957 24.8163265,39.6342835 C25.4216112,39.042102 25.970105,38.0676683 26.648684,37.9705581 C27.291344,37.8791603 28.0703993,38.7093569 29.3877551,39.4881423" id="Fill-18"></path>
27 |                         <path d="M58.122449,50.1699015 C56.9720625,50.9442982 56.2808891,51.7778787 55.688577,51.7045819 C55.1026844,51.6321956 54.1547283,50.5919272 54.2060848,50.0701996 C54.2689966,49.4360228 55.1780074,48.4940905 55.7823026,48.4385488 C56.3596357,48.3857387 57.0157155,49.2994449 58.122449,50.1699015" id="Fill-20"></path>
28 |                         <path d="M44.2611628,40.5818182 C44.9905159,41.759341 45.8112643,42.4957836 45.704938,43.0747287 C45.5954446,43.6719976 44.562496,44.5380157 43.9761179,44.5083486 C43.401051,44.4791177 42.4608552,43.4791613 42.4490914,42.890618 C42.4373276,42.2872412 43.3558058,41.6668494 44.2611628,40.5818182" id="Fill-22"></path>
29 |                         <path d="M41.1428571,39.6019866 C39.8272149,40.4453553 39.0870471,41.2957953 38.4354138,41.2330966 C37.7680728,41.1689836 37.1887904,40.2105886 36.5714286,39.6434715 C37.1749866,39.0471264 37.7276135,38.0547893 38.3973344,37.968991 C39.0370679,37.8874355 39.7996073,38.7515467 41.1428571,39.6019866" id="Fill-24"></path>
30 |                         <path d="M52.8979592,46.7368979 C51.6070796,47.613954 50.8916179,48.482527 50.2457018,48.4344562 C49.5712053,48.384029 48.9633963,47.451833 48.3265306,46.9046744 C48.912428,46.2891799 49.4340196,45.2768659 50.1018473,45.1717699 C50.737284,45.0713869 51.5251492,45.9178096 52.8979592,46.7368979" id="Fill-26"></path>
31 |                     </g>
32 |                     <g id="Group-9" transform="translate(46.000000, 90.500000) rotate(-45.000000) translate(-46.000000, -90.500000) translate(14.000000, 58.000000)">
33 |                         <g id="Group-8" transform="translate(32.029091, 32.516283) rotate(45.000000) translate(-32.029091, -32.516283) translate(9.529091, 10.016283)">
34 |                             <g id="Group-4" fill-rule="nonzero">
35 |                                 <path d="M34.8187898,4.45237236 L19.3998407,20.0154519 L18.223861,19.6143752 C14.4775301,18.3366608 10.3160388,19.3041305 7.47123872,22.221987 C3.35475286,26.4441871 3.35475286,33.2979191 7.47123872,37.5201191 C11.5768463,41.7311616 18.2250205,41.7311616 22.3306281,37.5201191 C25.187989,34.5893793 26.1336215,30.2886821 24.8711409,26.4226421 L24.4795548,25.2235049 L40.0128969,9.54482275 L40.3913192,4.45237236 L34.8187898,4.45237236 Z M29.0334812,26.3807277 C30.2018113,31.3508827 28.814725,36.6696904 25.1859649,40.3916396 C19.5079693,46.21545 10.2938975,46.21545 4.61590197,40.3916396 C-1.05121531,34.5789868 -1.05121531,25.1631193 4.61590197,19.3504666 C8.24206127,15.631185 13.4295855,14.2014186 18.2830256,15.3889734 L33.1616434,0.371275952 L44.7243254,0.371275952 L43.907163,11.3678781 L29.0334812,26.3807277 Z" id="Combined-Shape"></path>
36 |                             </g>
37 |                             <path d="M15.5561792,29.835368 C16.733014,31.0305908 16.733014,32.96877 15.5561792,34.1641783 C14.3793444,35.3594012 12.4709833,35.3594012 11.2939659,34.1641783 C10.1171311,32.96877 10.1171311,31.0305908 11.2939659,29.835368 C12.4709833,28.6401451 14.3793444,28.6401451 15.5561792,29.835368" id="Fill-5"></path>
38 |                         </g>
39 |                         <polygon id="Rectangle-3-Copy-2" points="35.5141475 32.4265935 39.5324578 32.4265935 39.5324578 36.5076899 35.5141475 36.5076899"></polygon>
40 |                         <polygon id="Rectangle-3-Copy-3" points="41.541613 32.4265935 45.5599233 32.4265935 45.5599233 36.5076899 41.541613 36.5076899"></polygon>
41 |                         <polygon id="Rectangle-3-Copy-4" points="47.5690785 32.4265935 51.5873888 32.4265935 51.5873888 36.5076899 47.5690785 36.5076899"></polygon>
42 |                     </g>
43 |                 </g>
44 |             </g>
45 |         </g>
46 |     </g>
47 | </svg>


--------------------------------------------------------------------------------
/sirius/web/static/device-key-mini.svg:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <svg width="29px" height="29px" viewBox="0 0 29 29" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
 3 |     <!-- Generator: Sketch 54 (76480) - https://sketchapp.com -->
 4 |     <title>Group 10</title>
 5 |     <desc>Created with Sketch.</desc>
 6 |     <g id="5.-Website" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
 7 |         <g id="Artboard-Copy-2" transform="translate(-48.000000, -36.000000)" fill="#1500FF">
 8 |             <g id="Group-10" transform="translate(32.000000, 21.000000)">
 9 |                 <g id="Group-9" transform="translate(30.000000, 30.000000) rotate(-45.000000) translate(-30.000000, -30.000000) translate(9.000000, 9.000000)">
10 |                     <g id="Group-8" transform="translate(21.468612, 20.951190) rotate(45.000000) translate(-21.468612, -20.951190) translate(6.968612, 6.451190)">
11 |                         <g id="Group-4" fill-rule="nonzero">
12 |                             <path d="M22.2514057,2.84534714 L12.3977234,12.7911379 L11.6461982,12.5348245 C9.25205608,11.7182843 6.59260036,12.3365586 4.77459341,14.2012532 C2.14389896,16.8995057 2.14389896,21.2794733 4.77459341,23.9777258 C7.39833598,26.6688479 11.6469391,26.6688479 14.2706817,23.9777258 C16.0967158,22.1047979 16.7010347,19.3563808 15.8942298,16.8857371 L15.6439816,16.1194127 L25.5707682,6.09974456 L25.812604,2.84534714 L22.2514057,2.84534714 Z M18.5542282,16.8589512 C19.3008649,20.0351941 18.4144292,23.4342481 16.0954222,25.8128088 C12.4668245,29.5345914 6.57845063,29.5345914 2.94985289,25.8128088 C-0.671792972,22.0981565 -0.671792972,16.0808225 2.94985289,12.3661703 C5.2671977,9.98931443 8.58235332,9.0756034 11.6840081,9.83452593 L21.1923846,0.237268782 L28.5816686,0.237268782 L28.0594502,7.2647921 L18.5542282,16.8589512 Z" id="Combined-Shape"></path>
13 |                         </g>
14 |                         <path d="M9.94138097,19.0666845 C10.6934527,19.8305073 10.6934527,21.0691262 9.94138097,21.8330677 C9.18930921,22.5968906 7.969746,22.5968906 7.21755751,21.8330677 C6.46548574,21.0691262 6.46548574,19.8305073 7.21755751,19.0666845 C7.969746,18.3028616 9.18930921,18.3028616 9.94138097,19.0666845" id="Fill-5"></path>
15 |                     </g>
16 |                     <polygon id="Rectangle-3-Copy-2" points="23.6957833 20.7226412 26.2637373 20.7226412 26.2637373 23.3307196 23.6957833 23.3307196"></polygon>
17 |                     <polygon id="Rectangle-3-Copy-3" points="27.5477144 20.7226412 30.1156685 20.7226412 30.1156685 23.3307196 27.5477144 23.3307196"></polygon>
18 |                     <polygon id="Rectangle-3-Copy-4" points="31.3996455 20.7226412 33.9675996 20.7226412 33.9675996 23.3307196 31.3996455 23.3307196"></polygon>
19 |                 </g>
20 |             </g>
21 |         </g>
22 |     </g>
23 | </svg>


--------------------------------------------------------------------------------
/sirius/web/static/site.css:
--------------------------------------------------------------------------------
 1 | body {
 2 |     font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;
 3 |     -webkit-font-smoothing: antialiased;
 4 | }
 5 | 
 6 | .navbar-inverse {
 7 |     background: #49528d;
 8 |     background-image: none;
 9 |     border: none;
10 |     color: white;
11 | }
12 | 
13 | .navbar-brand {
14 |     font-weight: 500;
15 |     letter-spacing: 0.5px;
16 | }
17 | .navbar-inverse .navbar-nav>li>a {
18 |     color: inherit;
19 | }
20 | .navbar-inverse .navbar-brand {
21 |     color: inherit;
22 |     text-shadow: none;
23 | }
24 | .navbar-inverse .navbar-nav>.active>a, .navbar-inverse .navbar-nav>.open>a {
25 |     background-image: none;
26 |     background: rgba(0, 0, 0, 0.1);
27 |     box-shadow: none;
28 | }
29 | .navbar-inverse .navbar-nav>.active>a, .navbar-inverse .navbar-nav>.active>a:hover, .navbar-inverse .navbar-nav>.active>a:focus {
30 |     background: rgba(0, 0, 0, 0.1);
31 | }
32 | 
33 | .jumbotron p {
34 |     font-weight: 300;
35 |     letter-spacing: 0;
36 |     font-size: 16px;
37 | }
38 | 


--------------------------------------------------------------------------------
/sirius/web/templates/about.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | 
 3 | {% block title %}About | Little Printer{% endblock %}
 4 | 
 5 | {% block page_content %}
 6 | 
 7 | <div class="row">
 8 | 	<div class="col-md-8">
 9 | 		<h1>About</h1>
10 | 		
11 | 		<p>This is an alternate Little Printer backend, maintained by <a href="http://nordprojects.co">Nord Projects</a>.</p>
12 | 		<p>You can:</p>
13 | 		<ul>
14 | 			<li>Claim your printer</li>
15 | 			<li>Send test messages</li>
16 | 			<li>Use it with our <a href="https://itunes.apple.com/us/app/little-printers/id1393105914?ls=1&mt=8">Little Printers</a> app to send messages from your iPhone!</li>
17 | 			<li>Send messages via our Print Key API</li>
18 | 		</ul>
19 | 
20 | 		<p>To use your Little Printer with this backend, you'll need to root your bridge, and install a software update. Check out <a href="http://joerick.me/posts/2017/03/09/little-printer/">information about the process</a> or check out a <a href="https://docs.google.com/document/d/1JT1f2ClVdAnjrnby92V9ONBnN05EFQGYpLG5ijl5KRI/edit?usp=sharing">step-by-step guide here</a>.</p>
21 | 
22 | 		<p>All the code is open source, check it on <a href="https://github.com/nordprojects/sirius">GitHub</a>. This backend is forked from the <a href="http://github.com/genmon/sirius">sirius project</a>, and most of the code originated there. Thanks to Matt Webb, Tom Hunger, Quentin Dufour, who did the lion's share of the work to get this thing working!</p>
23 | 
24 | 		<p>Finally, thanks to the good people of BERG, whose product captured our imaginations.</p>
25 | 	</div>
26 | </div>
27 | 
28 | 
29 | {% endblock %}
30 | 


--------------------------------------------------------------------------------
/sirius/web/templates/admin.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | 
 3 | {% block title %}Sirius - Admin{% endblock %}
 4 | 
 5 | {% block page_content %}
 6 | <h1>Admin!</h1>
 7 | 
 8 | <form method="post" action="/admin/randomly-change-personality">
 9 | 	<button>change personality randomly</button>
10 | </form>
11 | 
12 | {% endblock %}
13 | 


--------------------------------------------------------------------------------
/sirius/web/templates/base.html:
--------------------------------------------------------------------------------
 1 | {% extends "bootstrap/base.html" %}
 2 | 
 3 | {% block styles %}
 4 | {{super()}}
 5 | <link rel="stylesheet" href="{{url_for('static', filename='bootstrap-theme.min.css')}}">
 6 | <link rel="stylesheet" href="{{url_for('static', filename='site.css')}}">
 7 | {% endblock %}
 8 | 
 9 | {% block title %}Little Printer{% endblock %}
10 | 
11 | {% block navbar %}
12 | <nav class="navbar navbar-inverse navbar-static-top">
13 | 	<div class="container">
14 | 		<div class="navbar-header">
15 | 			<button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#navbar" aria-expanded="false" aria-controls="navbar">
16 | 				<span class="sr-only">Toggle navigation</span>
17 | 				<span class="icon-bar"></span>
18 | 				<span class="icon-bar"></span>
19 | 				<span class="icon-bar"></span>
20 | 			</button>
21 | 			<a class="navbar-brand" href="{{ url_for('landing.landing') }}">nord-sirius</a>
22 | 		</div>
23 | 		<div id="navbar" class="navbar-collapse collapse">
24 | 			<ul class="nav navbar-nav">
25 | 				<li{% if request.url_rule.endpoint == "landing.landing" %} class="active"{% endif %}><a href="{{ url_for('landing.landing') }}">Home</a></li>
26 | 				<li{% if request.url_rule.endpoint == "landing.about" %} class="active"{% endif %}><a href="{{ url_for('landing.about') }}">About</a></li>
27 | 			</ul>
28 | 			{% if current_user.is_authenticated %}
29 | 			<ul class="nav navbar-nav navbar-right">
30 | 				<li><a href="/login/twitter/logout">Sign out</a></li>
31 | 			</ul>
32 | 			{% endif %}
33 | 		</div><!--/.nav-collapse -->
34 | 	</div>
35 | </nav>
36 | {% endblock %}
37 | 
38 | {% block content %}
39 | <div class="container" role="main">
40 | 	{% for message in get_flashed_messages() %}
41 | 	<div class="alert alert-warning">
42 | 		<button type="button" class="close" data-dismiss="alert">&times;</button>
43 | 		{{ message }}
44 | 	</div>
45 | 	{% endfor %}
46 | 
47 | 	{% block page_content %}{% endblock %}
48 | </div>
49 | {% endblock %}
50 | 


--------------------------------------------------------------------------------
/sirius/web/templates/claim.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | 
 3 | {% block title %}Overview{% endblock %}
 4 | 
 5 | {% block page_content %}
 6 | <div class="row">
 7 | 	<div class="col-md-8">
 8 | 
 9 | <h1>Claim a printer</h1>
10 | 
11 | 		<p>
12 | 		<strong>Important:</strong> Your Berg Cloud Bridge must be configured to connect to <em>alpha.littleprinter.com</em> otherwise claiming won't work. Bridge software that allows configuration is currently in testing with a small group, and is not yet generally available.
13 | 		</p>
14 | 
15 | <form method="POST">
16 | 	{{ form.csrf_token }}
17 | 
18 | 	<div class="form-group {% if form.claim_code.errors %}has-error{% endif%}">
19 | 		<label>{{ form.claim_code.label }}</label>
20 | 		{% if form.claim_code.errors %}
21 | 		<ul>
22 | 			{% for error in form.claim_code.errors %}
23 | 			<li>{{ error }}</li>
24 | 			{% endfor %}
25 | 		</ul>
26 | 		{% endif %}
27 | 		{{ form.claim_code(class="form-control") }}
28 | 	</div>
29 | 
30 | 	<div class="form-group {% if form.printer_name.errors %}has-error{% endif%}">
31 | 		<label>{{ form.printer_name.label }}</label>
32 | 		{% if form.printer_name.errors %}
33 | 		<ul>
34 | 			{% for error in form.printer_name.errors %}
35 | 			<li>{{ error }}</li>
36 | 			{% endfor %}
37 | 		</ul>
38 | 		{% endif %}
39 | 		{{ form.printer_name(class="form-control") }}
40 | 	</div>
41 | 	<button class="btn btn-primary" type="submit">Claim printer</button>
42 | </form>
43 | 
44 | </div>
45 | </div>
46 | {% endblock %}
47 | 


--------------------------------------------------------------------------------
/sirius/web/templates/dump.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | {% import "bootstrap/wtf.html" as wtf %}
 3 | 
 4 | {% block title %}Sirius - Device{% endblock %}
 5 | 
 6 | {% block page_content %}
 7 | <h1>Send a message</h1>
 8 | 
 9 | <pre>
10 | {{ dump }}
11 | </pre>
12 | 
13 | {{ wtf.quick_form(form) }}
14 | 
15 | {% endblock %}


--------------------------------------------------------------------------------
/sirius/web/templates/landing.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %} {% block title %}Little Printer{% endblock %} {% block
 2 | page_content %}
 3 | <div class="jumbotron">
 4 |   <h1>Little Printer</h1>
 5 |   <p>Lets get your Little Printer printing again!</p>
 6 |   <p>
 7 |     Send messages to your printer, using our
 8 |     <a
 9 |       href="https://itunes.apple.com/us/app/little-printers/id1393105914?ls=1&mt=8"
10 |       >Little Printers</a
11 |     >
12 |     app, or via the Print Key API.
13 |   </p>
14 |   <p>
15 |     <a role="button" class="btn btn-primary" href="/login/twitter"
16 |       >Sign in with Twitter</a
17 |     >
18 |   </p>
19 | </div>
20 | {% endblock %}
21 | 


--------------------------------------------------------------------------------
/sirius/web/templates/overview.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | 
 3 | {% block title %}Home | Little Printer{% endblock %}
 4 | 
 5 | {% block page_content %}
 6 | <div class="row">
 7 | 	<div class="col-md-8">
 8 | 
 9 | 		<h1>My Printers</h1>
10 | 		
11 | 		{% if not my_printers %}
12 | 		<p><em class="bg-warning">None available</em></p>
13 | 		{% endif %}
14 | 		
15 | 		<ul>
16 | 			{% for p in my_printers %}
17 | 			<li>
18 | 				{% if p.is_online %}
19 | 					<span class="label label-success">Online</span>
20 | 				{% else %}
21 | 					<span class="label label-default">Offline</span>
22 | 				{% endif %}
23 | 				<a class="btn btn-link" href="{{
24 | 								url_for('printer_overview.printer_overview',
25 | 										printer_id=p.id) }}">{{ p.name }}</a>
26 | 			</li>
27 | 			{% endfor %}
28 | 		</ul>
29 | 
30 | 		<p>
31 | 		<a class="btn btn-default" href="{{ url_for('landing.claim',
32 | 										user_id=current_user.id,
33 | 										username=current_user.username) }}">
34 | 			Claim a printer
35 | 		</a>
36 | 		</p>
37 | 		
38 | 	</div>
39 | </div>
40 | {% endblock %}
41 | 


--------------------------------------------------------------------------------
/sirius/web/templates/printer_overview.html:
--------------------------------------------------------------------------------
  1 | {% extends "base.html" %}
  2 | 
  3 | {% block title %}{{ printer.name }} | Little Printer{% endblock %}
  4 | 
  5 | {% block page_content %}
  6 | <div class="row">
  7 | 	<div class="col-md-8">
  8 | 
  9 | 		<h1>
 10 | 			{{ printer.name }}
 11 | 		</h1>
 12 | 
 13 | 		<p>
 14 | 			{% if printer.is_online %}
 15 | 				<span class="label label-success">Online</span>
 16 | 			{% else %}
 17 | 				<span class="label label-default">Offline</span>
 18 | 			{% endif %}
 19 | 		</p>
 20 | 
 21 | 		<p>
 22 | 			<a class="btn btn-default" href="{{
 23 | 							url_for('printer_print.printer_print',
 24 | 									printer_id=printer.id) }}">Send test message</a>
 25 | 		</p>
 26 | 
 27 | 		<div class="spacer" style="height: 1em"></div>
 28 | 
 29 | 		{% if current_user.id == printer.owner.id %}
 30 | 		<h2>🔑 Print Keys</h2>
 31 | 
 32 | 		<p>
 33 | 			Print Keys let you print using the <a href="https://itunes.apple.com/us/app/little-printers/id1393105914?ls=1&mt=8">Little Printers</a> app, or using our
 34 | 			simple API.
 35 | 		</p>
 36 | 		
 37 | 		{% if printer.print_keys.count() > 0 %}
 38 | 		<table class="table print-keys-table">
 39 | 			<thead>
 40 | 				<tr>
 41 | 					<th>Key</th>
 42 | 					<th>Creation date</th>
 43 | 					<th>Uses</th>
 44 | 					<th>Senders</th>
 45 | 					<th></th>
 46 | 				</tr>
 47 | 			</thead>
 48 | 			<tbody>
 49 | 				{% for print_key in printer.print_keys %}
 50 | 				<tr>
 51 | 					<td>
 52 | 						<a href="{{ print_key.url }}">
 53 | 							{{ print_key.url }}
 54 | 						</a>
 55 | 					</td>
 56 | 					<td>{{ print_key.created.strftime('%H:%M %d/%m/%Y') }}</td>
 57 | 					<td>{{ print_key.number_of_uses }}</td>
 58 | 					<td>{{ print_key.senders_formatted() }}</td>
 59 | 					<td>
 60 | 						<button class="btn btn-link print-key-delete">
 61 | 							<span class="glyphicon glyphicon-remove"></span>
 62 | 						</button>
 63 | 						<form id="delete_form_{{ print_key.id }}"
 64 | 						      class="delete-form"
 65 | 						      method="POST"
 66 | 						      style="display: inline;
 67 | 						             visibility: hidden"
 68 | 						      action="{{ url_for('printer_overview.print_key_delete',
 69 | 						                         printer_id=printer.id,
 70 | 						                         print_key_id=print_key.id) }}">
 71 | 							Are you sure?
 72 | 							<button class="btn btn-link text-danger" 
 73 | 							        style="vertical-align: baseline;"
 74 | 							        type="submit">
 75 | 								Delete
 76 | 							</button>
 77 | 						</form>
 78 | 					</td>
 79 | 				</tr>
 80 | 				{% endfor %}
 81 | 			</tbody>
 82 | 		</table>
 83 | 		<style>
 84 | 			.table.print-keys-table>tbody>tr>td {
 85 | 				vertical-align: middle;
 86 | 			}
 87 | 		</style>
 88 | 		{% endif %}
 89 | 
 90 | 		<form method="POST" action="{{ url_for('printer_overview.print_key_add',
 91 | 		                                       printer_id=printer.id) }}">
 92 | 			<button class="btn btn-default" type="submit">
 93 | 				<span class="glyphicon glyphicon-plus"></span> Cut a new Print Key
 94 | 			</button>
 95 | 		</form>
 96 | 
 97 | 		<div class="spacer" style="height: 1em"></div>
 98 | 
 99 | 		<h2>Recent messages</h2>
100 | 
101 | 		{% for m in messages %}
102 | 		<div class="thumbnail" style="width: 300px;">
103 | 			<img src="data:image/png;base64,{{ m.base64_pixels().decode('utf-8') }}" style="border: 1px solid #ccc; width: 100%;">
104 | 			<div class="caption">
105 | 				<p>
106 | 					{% if m.response_timestamp == None %}
107 | 					<span class="bg-info">(still sending)</span>
108 | 					{% else %}
109 | 					Sent {{ m.response_timestamp.strftime('%H:%M, %d/%m/%Y') }}
110 | 					{% endif %}
111 | 					{% if m.failure_message %}
112 | 					<br>
113 | 					Message failed: <span class="bg-danger">{{ m.failure_message }}</span>
114 | 					{% endif %}
115 | 					<form method="POST" action="{{ url_for('printer_overview.reprint',
116 | 		                                                   printer_id=printer.id,
117 | 														   message_id=m.id) }}">
118 | 						<button class="btn btn-link" type="submit" style="padding: 0;">
119 | 							<span class="glyphicon glyphicon-repeat"></span> Reprint
120 | 						</button>
121 | 					</form>
122 | 				</p>
123 | 			</div>
124 | 		</div>
125 | 		{% endfor %}
126 | 		
127 | 		{% endif %}
128 | 
129 | 	</div>
130 | </div>
131 | {% endblock %}
132 | 
133 | {% block scripts %}
134 | {{ super() }}
135 | 
136 | <script>
137 | 	$(".print-key-delete").click(function () {
138 | 		$(this).parent().find('.delete-form').css({visibility: 'visible'});
139 | 	});
140 | </script>
141 | {% endblock scripts %}
142 | 


--------------------------------------------------------------------------------
/sirius/web/templates/printer_print.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | 
 3 | {% block title %}Print | {{ printer.name }} | Little Printer{% endblock %}
 4 | 
 5 | {% block page_content %}
 6 | <div class="row">
 7 | 	<div class="col-md-8">
 8 | 
 9 | 		<h1>Send message</h1>
10 | 
11 | 		<form method="POST">
12 | 			{{ form.csrf_token }}
13 | 			<div class="form-group {% if form.target_printer.errors %}has-error{% endif%}">
14 | 				<label>{{ form.target_printer.label }}</label>
15 | 			{% if form.target_printer.errors %}
16 | 			<ul>
17 | 			{% for error in form.target_printer.errors %}
18 | 			<li>{{ error }}</li>
19 | 			{% endfor %}
20 | 			</ul>
21 | 			{% endif %}
22 | 			{{ form.target_printer(class="form-control") }}
23 |     </div>
24 |     <div class="form-group {% if form.face.errors %}has-error{% endif%}">
25 | 				<label>{{ form.face.label }}</label>
26 | 			{% if form.face.errors %}
27 | 			<ul>
28 | 			{% for error in form.face.errors %}
29 | 			<li>{{ error }}</li>
30 | 			{% endfor %}
31 | 			</ul>
32 | 			{% endif %}
33 | 			{{ form.face(class="form-control") }}
34 | 		</div>
35 | 
36 | 		<div class="form-group {% if form.message.errors %}has-error{% endif%}">
37 | 			<label>{{ form.message.label }}</label>
38 | 			{% if form.message.errors %}
39 | 			<ul>
40 | 			{% for error in form.message.errors %}
41 | 			<li>{{ error }}</li>
42 | 			{% endfor %}
43 | 			</ul>
44 | 			{% endif %}
45 | 			{{ form.message(class="form-control") }}
46 | 		</div>
47 | 		<button type="submit" class="btn btn-primary">Print now</button>
48 | 		<button class="btn" type="button" id="preview">Preview</button>
49 | 	</form>
50 | 		
51 | 		<p>&nbsp;</p>
52 | 		<p>
53 | 			<strong>Preview</strong>
54 | 		</p>
55 | 		<div class="thumbnail" style="width: 300px;">
56 | 			<div id="preview_pane" style="width: 100%; border: 1px solid #ccc; overflow: hidden;"></div>
57 | 		</div>
58 | 
59 | 	</div>
60 | </div>
61 | {% endblock %}
62 | 
63 | {% block scripts %}
64 | {{ super() }}
65 | 
66 | <script>
67 |         $("#preview").on('click', function() {
68 |         $.ajax({
69 |           url: "{{ url_for('printer_print.preview',
70 |                           user_id=current_user.id,
71 |                           username=current_user.username,
72 |                           printer_id=printer.id) }}",
73 |           data: $("#message").val(),
74 | 	  method: "POST",
75 | 	  contentType: "text/plain",
76 |           success: function(response) {
77 |           $("#preview_pane").html(response);
78 |             console.log(response);
79 |           }
80 | 	})
81 | 	})
82 | </script>
83 | {% endblock scripts%}
84 | 


--------------------------------------------------------------------------------
/sirius/web/test_claiming.py:
--------------------------------------------------------------------------------
 1 | import flask
 2 | 
 3 | from sirius.models import user
 4 | from sirius.models import hardware
 5 | from sirius.models.db import db
 6 | from sirius.testing import base
 7 | 
 8 | 
 9 | # pylint: disable=no-member
10 | class TestClaiming(base.Base):
11 | 
12 |     def setUp(self):
13 |         base.Base.setUp(self)
14 |         self.testuser2 = user.User(username="testuser 2")
15 |         db.session.add(self.testuser2)
16 |         db.session.commit()
17 | 
18 |     def test_claim_first(self):
19 |         self.testuser.claim_printer('n5ry-p6x6-kth7-7hc4', 'my test printer')
20 |         hardware.Printer.phone_home('000d6f000273ce0b')
21 |         db.session.commit()
22 |         printer = hardware.Printer.query.first()
23 | 
24 |         self.assertEqual(printer.owner, self.testuser)
25 | 
26 |     def test_printer_phone_home_first(self):
27 |         hardware.Printer.phone_home('000d6f000273ce0b')
28 |         self.testuser.claim_printer('n5ry-p6x6-kth7-7hc4', 'my test printer')
29 |         db.session.commit()
30 |         printer = hardware.Printer.query.first()
31 | 
32 |         self.assertEqual(printer.owner, self.testuser)
33 | 
34 |     def test_two_claims_different_users(self):
35 |         "We expect this to fail because printers can't change users without reset."
36 |         self.testuser.claim_printer('n5ry-p6x6-kth7-7hc4', 'my test printer')
37 |         with self.assertRaises(user.ClaimCodeInUse):
38 |             # printer can't change user without reset
39 |             self.testuser2.claim_printer('n5ry-p6x6-kth7-7hc4', 'my test printer 2')
40 | 
41 |     def test_two_claims_different_users_same_xor_different_code(self):
42 |         "printer changes user after reset."
43 |         self.testuser.claim_printer('n5ry-p6x6-kth7-7hc4', 'my test printer')
44 |         self.testuser2.claim_printer('0cx6-nk3t-49zq-7hc4', 'my test printer 2')
45 | 
46 |         hardware.Printer.phone_home('000d6f000273ce0b')
47 |         db.session.commit()
48 |         printer = hardware.Printer.query.filter_by(owner=self.testuser2)
49 | 
50 |         # One printer in system owner by testuser2
51 |         self.assertIsNot(printer, None)
52 | 
53 |     def test_user_tries_to_reclaim_with_old_code(self):
54 |         """What happens if we enter the same code twice and it'd change owners."""
55 |         self.testuser.claim_printer('n5ry-p6x6-kth7-7hc4', 'my test printer')
56 |         self.testuser2.claim_printer('0cx6-nk3t-49zq-7hc4', 'my test printer 2')
57 |         hardware.Printer.phone_home('000d6f000273ce0b')
58 |         db.session.commit()
59 | 
60 |         # try to re-claim printer.
61 |         with self.assertRaises(user.CannotChangeOwner):
62 |             self.testuser.claim_printer('n5ry-p6x6-kth7-7hc4', 'my test printer')
63 |             db.session.commit()
64 | 
65 |         printer = hardware.Printer.query.filter_by(owner=self.testuser2)
66 |         # printer must still belong to user 2
67 |         self.assertIsNot(printer, None)
68 | 
69 | 
70 | class TestClaimingWeb(base.Base):
71 | 
72 |     def get_claim_url(self):
73 |         return flask.url_for(
74 |             'landing.claim',
75 |             user_id=self.testuser.id,
76 |             username=self.testuser.username)
77 | 
78 |     def test_invalid_claim_code(self):
79 |         self.autologin()
80 |         r = self.client.post(self.get_claim_url(), data=dict(
81 |             claim_code='invalid', printer_name='lp'))
82 |         # invalid keeps us on claiming page and doesn't redirect
83 |         self.assert200(r)
84 | 
85 |     def test_valid_claim_code(self):
86 |         self.autologin()
87 |         r = self.client.post(self.get_claim_url(), data=dict(
88 |             claim_code='n5ry-p6x6-kth7-7hc4', printer_name='lp'))
89 | 
90 |         # valid code: redirect to overview.
91 |         self.assertRedirects(r, '/')
92 | 


--------------------------------------------------------------------------------
/sirius/web/test_oauth_flow.py:
--------------------------------------------------------------------------------
 1 | from unittest import mock
 2 | 
 3 | import flask_testing as testing
 4 | import flask_login as login
 5 | 
 6 | from sirius.models.db import db
 7 | from sirius.web import webapp
 8 | from sirius.web import twitter
 9 | 
10 | 
11 | # pylint: disable=no-member
12 | class TestOAuthFlow(testing.TestCase):
13 |     def setUp(self):
14 |         testing.TestCase.setUp(self)
15 |         db.create_all()
16 | 
17 |     def tearDown(self):
18 |         db.session.remove()
19 |         db.drop_all()
20 | 
21 |     def create_app(self):
22 |         app = webapp.create_app("test")
23 |         return app
24 | 
25 |     @mock.patch("sirius.web.twitter.get_self")
26 |     def test_oauth_authorized(self, get_self_mock):
27 |         get_self_mock.return_value = {"username": "test_screen_name"}
28 |         self.assertEqual(login.current_user.is_authenticated, False)
29 |         twitter.process_authorization(
30 |             {"access_token": "token"},
31 |             "/next_url",
32 |         )
33 |         self.assertEqual(login.current_user.username, "test_screen_name")
34 |         self.assertEqual(login.current_user.is_authenticated, True)
35 | 


--------------------------------------------------------------------------------
/sirius/web/test_printing.py:
--------------------------------------------------------------------------------
 1 | import flask
 2 | 
 3 | from sirius.models import hardware
 4 | from sirius.models.db import db
 5 | from sirius.testing import base
 6 | 
 7 | # pylint: disable=no-member
 8 | class TestPrinting(base.Base):
 9 | 
10 |     def setUp(self):
11 |         base.Base.setUp(self)
12 |         self.autologin()
13 |         hardware.Printer.phone_home('000d6f000273ce0b')
14 |         self.testuser.claim_printer('n5ry-p6x6-kth7-7hc4', 'my test printer')
15 |         db.session.commit()
16 |         self.printer = hardware.Printer.query.first()
17 | 
18 |     def get_print_url(self):
19 |         return flask.url_for(
20 |             'printer_print.printer_print',
21 |             user_id=self.testuser.id,
22 |             username=self.testuser.username,
23 |             printer_id=self.printer.id,
24 |         )
25 | 
26 |     def test_print_ok(self):
27 |         r = self.client.post(self.get_print_url(), data=dict(
28 |             target_printer=self.printer.id, 
29 |             face='default',
30 |             message='hello'
31 |         ))
32 |         self.assertRedirects(r, '/printer/1')
33 | 
34 |     def test_print_wrong_printer(self):
35 |         r = self.client.post(self.get_print_url(), data=dict(
36 |             target_printer='10',
37 |             face='default',
38 |             message='hello2'
39 |         ))
40 |         self.assertIn('Not a valid choice', r.data.decode('utf-8'))
41 |         self.assert200(r)
42 |     
43 |     def test_that_message_is_added_to_db(self):
44 |         self.assertTrue(self.printer.messages.count() == 0)
45 | 
46 |         r = self.client.post(self.get_print_url(), data=dict(
47 |             target_printer=self.printer.id, 
48 |             face='default',
49 |             message='hello'
50 |         ))
51 | 
52 |         self.assertTrue(self.printer.messages.count() == 1)
53 |     
54 |     def test_that_stored_messages_are_trimmed(self):
55 |         from sirius.models.messages import Message
56 |         from sirius.protocol.protocol_loop import _get_next_command_id
57 | 
58 |         # put 10 dummy messages in the database
59 |         dummy_messages = [
60 |             Message(
61 |                 print_id=_get_next_command_id(),
62 |                 pixels=bytearray(b''),
63 |                 sender_name='[dummy test data]',
64 |                 target_printer=self.printer,
65 |             ) 
66 |             for _ in range(10)
67 |         ]
68 |         
69 |         for dummy_message in dummy_messages:
70 |             db.session.add(dummy_message)
71 |         
72 |         db.session.commit()
73 |         self.assertEqual(self.printer.messages.count(), 10)
74 | 
75 |         # add one more
76 |         r = self.client.post(self.get_print_url(), data=dict(
77 |             target_printer=self.printer.id, 
78 |             face='default',
79 |             message='hello'
80 |         ))
81 | 
82 |         # check there are still 10
83 |         self.assertEqual(self.printer.messages.count(), 10)
84 | 
85 |         # check that the oldest message was deleted
86 |         self.assertNotIn(dummy_messages[0], self.printer.messages)
87 |         # and the second-oldest was not deleted
88 |         self.assertIn(dummy_messages[1], self.printer.messages)
89 | 


--------------------------------------------------------------------------------
/sirius/web/twitter.py:
--------------------------------------------------------------------------------
  1 | import logging
  2 | 
  3 | from requests_oauthlib import OAuth2Session
  4 | import requests
  5 | import flask
  6 | import flask_login as login
  7 | 
  8 | from sirius.models import user as user_model
  9 | from sirius.models.db import db
 10 | 
 11 | logger = logging.getLogger(__name__)
 12 | 
 13 | blueprint = flask.Blueprint("twitter", __name__)
 14 | 
 15 | auth_url = "https://twitter.com/i/oauth2/authorize"
 16 | token_url = "https://api.twitter.com/2/oauth2/token"
 17 | 
 18 | scopes = ["tweet.read", "users.read", "offline.access"]
 19 | 
 20 | oauth_session: OAuth2Session
 21 | code_challenge: str
 22 | code_verifier: str
 23 | 
 24 | 
 25 | def make_token():
 26 |     global oauth_session
 27 |     global code_verifier
 28 |     global code_challenge
 29 | 
 30 |     client_id = flask.current_app.config.get("TWITTER_OAUTH_CLIENT_KEY")
 31 |     redirect_uri = flask.current_app.config.get("OAUTH_REDIRECT_URI")
 32 | 
 33 |     oauth_session = OAuth2Session(client_id, redirect_uri=redirect_uri, scope=scopes)
 34 |     code_verifier = oauth_session._client.create_code_verifier(43)
 35 |     code_challenge = oauth_session._client.create_code_challenge(
 36 |         code_verifier, code_challenge_method="S256"
 37 |     )
 38 | 
 39 | 
 40 | def get_self():
 41 |     access_token = flask.session.get("twitter_token").get("access_token")
 42 |     resp = requests.get(
 43 |         url="https://api.twitter.com/2/users/me",
 44 |         headers={
 45 |             "Authorization": f"Bearer {access_token}",
 46 |             "Content-Type": "application/json",
 47 |         },
 48 |     )
 49 |     if not resp.ok:
 50 |         rule = flask.request.url_rule
 51 |         msg = f"Error from {rule.endpoint}!"
 52 |         logger.debug(msg)
 53 |         flask.flash(msg, category="error")
 54 |         return flask.redirect("/")
 55 | 
 56 |     return resp.json().get("data")
 57 | 
 58 | 
 59 | @blueprint.route("/twitter/logout")
 60 | def twitter_logout():
 61 |     flask.session.pop("user_id", None)
 62 |     flask.flash("You were signed out")
 63 |     return flask.redirect("/")
 64 | 
 65 | 
 66 | def process_authorization(token, next_url):
 67 |     """Process the incoming twitter oauth data. Validation has already
 68 |     succeeded at this point and we're just doing the book-keeping."""
 69 | 
 70 |     flask.session["twitter_token"] = token
 71 |     screen_name = get_self().get("username")
 72 |     flask.session["twitter_screen_name"] = screen_name
 73 |     oauth = user_model.TwitterOAuth.query.filter_by(
 74 |         screen_name=screen_name,
 75 |     ).first()
 76 | 
 77 |     # Create local user model for keying resources (e.g. claim codes)
 78 |     # if we haven't seen this twitter user before.
 79 |     if oauth is None:
 80 |         new_user = user_model.User(
 81 |             username=screen_name,
 82 |         )
 83 | 
 84 |         oauth = user_model.TwitterOAuth(
 85 |             user=new_user,
 86 |             screen_name=screen_name,
 87 |             token=token.get("access_token"),
 88 |             token_secret=token.get("access_token"),
 89 |         )
 90 | 
 91 |         db.session.add(new_user)
 92 |         db.session.add(oauth)
 93 |         db.session.commit()
 94 | 
 95 |     login.login_user(oauth.user)
 96 | 
 97 |     flask.flash("Successfully signed in! Hi, @%s." % screen_name)
 98 | 
 99 |     return flask.redirect(next_url)
100 | 
101 | 
102 | @blueprint.route("/twitter")
103 | def twitter_logged_in():
104 |     make_token()
105 | 
106 |     authorization_url, state = oauth_session.authorization_url(
107 |         auth_url, code_challenge=code_challenge, code_challenge_method="S256"
108 |     )
109 |     flask.session["oauth_state"] = state
110 |     return flask.redirect(authorization_url)
111 | 
112 | 
113 | @blueprint.route("/twitter/authorized", methods=["GET"])
114 | def twitter_callback():
115 |     client_secret = flask.current_app.config.get("TWITTER_OAUTH_CLIENT_SECRET")
116 |     next_url = "/"
117 |     code = flask.request.args.get("code")
118 |     error = flask.request.args.get("error")
119 |     if error is not None:
120 |         logger.debug("twitter_callback: we got a problem")
121 |         rule = flask.request.url_rule
122 |         msg = f"OAuth error from {rule.endpoint}! message={error}"
123 |         logger.debug(msg)
124 |         flask.flash(msg, category="error")
125 |         return flask.redirect(next_url)
126 | 
127 |     token = oauth_session.fetch_token(
128 |         token_url=token_url,
129 |         client_secret=client_secret,
130 |         code_verifier=code_verifier,
131 |         code=code,
132 |     )
133 | 
134 |     if token is None:
135 |         flask.flash("Twitter didn't authorize our sign-in request.", category="error")
136 |         return flask.redirect(next_url)
137 | 
138 |     return process_authorization(token, next_url)
139 | 


--------------------------------------------------------------------------------
/sirius/web/webapp.py:
--------------------------------------------------------------------------------
 1 | """Main server entry. Run like:
 2 | 
 3 | $ bin/gunicorn -k flask_sockets.worker sirius.server:app -b 0.0.0.0:5002 -w 1
 4 | """
 5 | import gevent
 6 | import logging
 7 | import flask
 8 | import flask_sockets
 9 | from flask_cors import CORS
10 | import flask_bootstrap as bootstrap
11 | 
12 | from sirius.protocol import protocol_loop
13 | from sirius import stats
14 | from sirius import config
15 | 
16 | # Import models so they get picked up for migrations. Do not remove.
17 | from sirius.models import db
18 | from sirius.models import user
19 | from sirius.models import hardware
20 | from sirius.models import messages
21 | 
22 | from sirius.web import landing
23 | from sirius.web import twitter
24 | from sirius.web import login
25 | from sirius.web import admin
26 | from sirius.web import printer_print
27 | from sirius.web import printer_overview
28 | from sirius.web import external_api
29 | from sirius.web import print_key_api
30 | 
31 | 
32 | logger = logging.getLogger(__name__)
33 | bootstrap = bootstrap.Bootstrap()
34 | sockets = flask_sockets.Sockets()
35 | 
36 | 
37 | def create_app(config_name):
38 |     app = flask.Flask(__name__)
39 |     app.config.from_object(config.config[config_name])
40 |     config.config[config_name].init_app(app)
41 | 
42 |     # Allow the printkey API to be browser accessible
43 |     CORS(app, resources={r"/printkey/*": {"origins": "*"}})
44 | 
45 |     # Configure various plugins and logging
46 |     bootstrap.init_app(app)
47 |     db.db.init_app(app)
48 |     sockets.init_app(app)
49 |     login.manager.init_app(app)
50 |     logging.basicConfig(level=logging.DEBUG if app.debug else logging.INFO)
51 | 
52 |     # Register blueprints
53 |     app.register_blueprint(stats.blueprint)
54 |     app.register_blueprint(landing.blueprint)
55 |     app.register_blueprint(twitter.blueprint, url_prefix="/login")
56 |     app.register_blueprint(printer_overview.blueprint)
57 |     app.register_blueprint(printer_print.blueprint)
58 |     app.register_blueprint(external_api.blueprint)
59 |     app.register_blueprint(admin.blueprint)
60 |     app.register_blueprint(print_key_api.blueprint)
61 | 
62 |     # Live interactions.
63 |     gevent.spawn(protocol_loop.mark_dead_loop)
64 |     @sockets.route('/api/v1/connection')
65 |     def api_v1_connection(ws):
66 |         with app.app_context():
67 |             protocol_loop.accept(ws)
68 | 
69 |     logger.debug('Creating app.')
70 |     return app
71 | 


--------------------------------------------------------------------------------
/tests/barcode-head.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nordprojects/sirius/9d88c63a0fc17d4acc5ae12194b93f8591e35a55/tests/barcode-head.png


--------------------------------------------------------------------------------
/tests/iconrethink.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nordprojects/sirius/9d88c63a0fc17d4acc5ae12194b93f8591e35a55/tests/iconrethink.png


--------------------------------------------------------------------------------
/tests/normalface.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nordprojects/sirius/9d88c63a0fc17d4acc5ae12194b93f8591e35a55/tests/normalface.png


--------------------------------------------------------------------------------
/tests/riley.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nordprojects/sirius/9d88c63a0fc17d4acc5ae12194b93f8591e35a55/tests/riley.png


--------------------------------------------------------------------------------