├── packet_queue
    ├── __init__.py
    ├── monitoring.py
    ├── interactive.py
    ├── command.py
    ├── web
    │   ├── index.html
    │   ├── packet_queue.js
    │   └── smoothie.js
    ├── nfqueue.py
    ├── libnetfilter_queue.py
    ├── simulation.py
    ├── udp_proxy.py
    └── api_server.py
├── setup.cfg
├── .gitignore
├── screenshot.png
├── scripts
    ├── impaired_network_shell
    ├── impaired_network_clear_iptables
    └── impaired_network_server
├── setup.py
├── Dockerfile
├── CONTRIBUTING.md
├── README.md
├── tests
    ├── test_simulation.py
    ├── test_e2e.py
    └── test_api_server.py
└── LICENSE


/packet_queue/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/setup.cfg:
--------------------------------------------------------------------------------
1 | [bdist_wheel]
2 | 
3 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | *.pyc
2 | *.egg-info
3 | build
4 | dist
5 | 


--------------------------------------------------------------------------------
/screenshot.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/google/packet-queue/HEAD/screenshot.png


--------------------------------------------------------------------------------
/scripts/impaired_network_shell:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | #
 3 | # Copyright 2016 Google Inc. All Rights Reserved.
 4 | #
 5 | # Licensed under the Apache License, Version 2.0 (the "License");
 6 | # you may not use this file except in compliance with the License.
 7 | # You may obtain a copy of the License at
 8 | #
 9 | #     http://www.apache.org/licenses/LICENSE-2.0
10 | #
11 | # Unless required by applicable law or agreed to in writing, software
12 | # distributed under the License is distributed on an "AS IS" BASIS,
13 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | # See the License for the specific language governing permissions and
15 | # limitations under the License.
16 | 
17 | from packet_queue import interactive
18 | 
19 | interactive.main()
20 | 


--------------------------------------------------------------------------------
/scripts/impaired_network_clear_iptables:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | #
 3 | # Copyright 2016 Google Inc. All Rights Reserved.
 4 | #
 5 | # Licensed under the Apache License, Version 2.0 (the "License");
 6 | # you may not use this file except in compliance with the License.
 7 | # You may obtain a copy of the License at
 8 | #
 9 | #     http://www.apache.org/licenses/LICENSE-2.0
10 | #
11 | # Unless required by applicable law or agreed to in writing, software
12 | # distributed under the License is distributed on an "AS IS" BASIS,
13 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | # See the License for the specific language governing permissions and
15 | # limitations under the License.
16 | 
17 | from packet_queue import nfqueue
18 | 
19 | nfqueue.remove_all()
20 | 


--------------------------------------------------------------------------------
/scripts/impaired_network_server:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | #
 3 | # Copyright 2016 Google Inc. All Rights Reserved.
 4 | #
 5 | # Licensed under the Apache License, Version 2.0 (the "License");
 6 | # you may not use this file except in compliance with the License.
 7 | # You may obtain a copy of the License at
 8 | #
 9 | #     http://www.apache.org/licenses/LICENSE-2.0
10 | #
11 | # Unless required by applicable law or agreed to in writing, software
12 | # distributed under the License is distributed on an "AS IS" BASIS,
13 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | # See the License for the specific language governing permissions and
15 | # limitations under the License.
16 | 
17 | from twisted.internet import reactor
18 | from packet_queue import api_server
19 | 
20 | api_server.configure()
21 | reactor.run()
22 | 


--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
 1 | # Copyright 2016 Google Inc. All Rights Reserved.
 2 | #
 3 | # Licensed under the Apache License, Version 2.0 (the "License");
 4 | # you may not use this file except in compliance with the License.
 5 | # You may obtain a copy of the License at
 6 | #
 7 | #     http://www.apache.org/licenses/LICENSE-2.0
 8 | #
 9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 | 
15 | """Setup module for packet queue"""
16 | 
17 | from setuptools import setup, find_packages
18 | from codecs import open
19 | from os import path
20 | 
21 | setup(
22 |     name='packet_queue',
23 |     version='0.1.0',
24 |     zip_safe=False,  # python-iptables doesn't work well with eggs
25 | 
26 |     description='Packet-based impaired network library',
27 |     packages=find_packages(exclude=['contrib', 'docs', 'tests']),
28 |     package_data={'packet_queue': ['web/*']},
29 |     include_package_data=True,
30 | 
31 |     install_requires=[
32 |         'twisted', 'python-iptables', 'netifaces',
33 |     ],
34 |     scripts=[
35 |         'scripts/impaired_network_server',
36 |         'scripts/impaired_network_shell',
37 |         'scripts/impaired_network_clear_iptables',
38 |     ]
39 | )
40 | 


--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
 1 | # Copyright 2016 Google Inc. All Rights Reserved.
 2 | #
 3 | # Licensed under the Apache License, Version 2.0 (the "License");
 4 | # you may not use this file except in compliance with the License.
 5 | # You may obtain a copy of the License at
 6 | #
 7 | #     http://www.apache.org/licenses/LICENSE-2.0
 8 | #
 9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 | #
15 | #
16 | # docker build -t <LABEL> .
17 | # docker run --cap-add=NET_ADMIN -t <LABEL> -p <APP_PORT>,<API_PORT> \
18 | # impaired_network_server -t tcp -l kernel -i auto -p <APP_PORT> -a <API_PORT>
19 | 
20 | FROM ubuntu:14.04
21 | 
22 | RUN apt-get -y update
23 | RUN apt-get -y install python iptables git
24 | RUN apt-get -y install python-setuptools python-dev build-essential python-pip
25 | 
26 | RUN apt-get -y install libnetfilter-queue-dev
27 | 
28 | RUN mkdir /src
29 | WORKDIR /src
30 | 
31 | RUN git clone https://github.com/google/packet-queue.git
32 | 
33 | WORKDIR /src/packet-queue
34 | 
35 | RUN pip install .
36 | 
37 | WORKDIR /src
38 | RUN rm -rf /src/packet-queue
39 | 
40 | RUN groupadd whiterabbit
41 | RUN echo "%whiterabbit ALL=(root) NOPASSWD: "`which impaired_network_server` >> /etc/sudoers.d/whiterabbit
42 | 


--------------------------------------------------------------------------------
/packet_queue/monitoring.py:
--------------------------------------------------------------------------------
 1 | # Copyright 2016 Google Inc. All Rights Reserved.
 2 | #
 3 | # Licensed under the Apache License, Version 2.0 (the "License");
 4 | # you may not use this file except in compliance with the License.
 5 | # You may obtain a copy of the License at
 6 | #
 7 | #     http://www.apache.org/licenses/LICENSE-2.0
 8 | #
 9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 | 
15 | 
16 | class EventLog(object):
17 |   """Records network simulation events for reporting to the web UI.
18 | 
19 |   This implementation assumes a single client, and deletes events that have
20 |   been sent.
21 |   """
22 | 
23 |   max_size = 9000
24 | 
25 |   def __init__(self):
26 |     self.next_id = 1
27 |     self.events = []
28 | 
29 |   def add(self, time, pipe_name, event_type, value):
30 |     event = {
31 |       'id': self.next_id,
32 |       'time': time,
33 |       'pipe': pipe_name,
34 |       'type': event_type,
35 |       'value': value,
36 |     }
37 |     self.next_id += 1
38 |     self.events.append(event)
39 | 
40 |     if len(self.events) > self.max_size:
41 |       self.events = self.events[-self.max_size:]
42 | 
43 |   def get_pending(self):
44 |     events = self.events
45 |     self.events = []
46 |     return events
47 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
 1 | Want to contribute? Great! First, read this page (including the small print at
 2 | the end).
 3 | 
 4 | ### Before you contribute
 5 | Before we can use your code, you must sign the
 6 | [Google Individual Contributor License Agreement]
 7 | (https://cla.developers.google.com/about/google-individual)
 8 | (CLA), which you can do online. The CLA is necessary mainly because you own the
 9 | copyright to your changes, even after your contribution becomes part of our
10 | codebase, so we need your permission to use and distribute your code. We also
11 | need to be sure of various other things—for instance that you'll tell us if you
12 | know that your code infringes on other people's patents. You don't have to sign
13 | the CLA until after you've submitted your code for review and a member has
14 | approved it, but you must do it before we can put your code into our codebase.
15 | Before you start working on a larger contribution, you should get in touch with
16 | us first through the issue tracker with your idea so that we can help out and
17 | possibly guide you. Coordinating up front makes it much easier to avoid
18 | frustration later on.
19 | 
20 | ### Code reviews
21 | All submissions, including submissions by project members, require review. We
22 | use Github pull requests for this purpose.
23 | 
24 | ### The small print
25 | Contributions made by corporations are covered by a different agreement than
26 | the one above, the
27 | [Software Grant and Corporate Contributor License Agreement]
28 | (https://cla.developers.google.com/about/google-corporate).
29 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Packet Queue
 2 | 
 3 | This is a configurable TCP/UDP packet impairment tool for Linux. It looks like
 4 | this:
 5 | 
 6 | <img alt="Screenshot" src="screenshot.png" width="440">
 7 | 
 8 | ## Setup
 9 | 
10 | Install the dependencies, including the Linux nfqueue library:
11 | 
12 | ```
13 | sudo apt-get install libnetfilter-queue-dev
14 | sudo python setup.py develop
15 | ```
16 | 
17 | To get realistic network simulation on the loopback device, you probably want
18 | to set the MTU to something small:
19 | 
20 | ```
21 | ip link show dev lo  # show current MTU
22 | sudo ip link set dev lo mtu 2048
23 | ```
24 | 
25 | ## Running
26 | 
27 | For example, to impair TCP traffic on loopback port 3000:
28 | 
29 | ```
30 | sudo scripts/impaired_network_server -p 3000
31 | ```
32 | 
33 | It can also run as a UDP proxy, without root, if you specify a proxy port:
34 | 
35 | ```
36 | scripts/impaired_network_server -l user -t udp -p 3000 -x 3001
37 | ```
38 | 
39 | To see all of the options:
40 | 
41 | ```
42 | scripts/impaired_network_server --help
43 | ```
44 | 
45 | Packet Queue will clean up its iptables rules on shutdown. If it ever doesn't
46 | shut down gracefully, you can clear the rules like this:
47 | 
48 | ```
49 | sudo scripts/impaired_network_clear_iptables
50 | ```
51 | 
52 | ## Tests
53 | 
54 | You can run most of the tests like this:
55 | 
56 | ```
57 | python -m unittest discover tests  # run all tests in the tests/ directory
58 | ```
59 | 
60 | Some of the end-to-end tests will be skipped with the above command because
61 | they require root:
62 | 
63 | ```
64 | sudo python tests/test_e2e.py
65 | ```
66 | 


--------------------------------------------------------------------------------
/packet_queue/interactive.py:
--------------------------------------------------------------------------------
 1 | # Copyright 2016 Google Inc. All Rights Reserved.
 2 | #
 3 | # Licensed under the Apache License, Version 2.0 (the "License");
 4 | # you may not use this file except in compliance with the License.
 5 | # You may obtain a copy of the License at
 6 | #
 7 | #     http://www.apache.org/licenses/LICENSE-2.0
 8 | #
 9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 | 
15 | """Interactive shell for network simulation."""
16 | 
17 | import code
18 | from twisted.internet import reactor
19 | from twisted.internet import threads
20 | from . import command
21 | 
22 | 
23 | BANNER = '\n'.join([
24 |   '',
25 |   'Network simulation!',
26 |   '',
27 |   'You have an object, p, that you can use to change parameters on the fly.',
28 |   'For example, to delay all packets by 300ms each direction:',
29 |   '  p.delay = 0.3',
30 |   '',
31 |   'You also have any object called m, which does byte metering:',
32 |   '  m',
33 |   'Reset the numbers to zero with the reset() method:',
34 |   '  m.reset()',
35 |   '',
36 | ])
37 | 
38 | 
39 | class ParamsProxy(object):
40 |   def __init__(self, params):
41 |     self.__dict__['_params'] = params
42 | 
43 |   def __getattr__(self, name):
44 |     return self._params[name]
45 | 
46 |   def __setattr__(self, name, value):
47 |     if name not in self._params:
48 |       raise AttributeError(name)
49 |     reactor.callFromThread(self._params.__setitem__, name, value)
50 | 
51 |   def __repr__(self):
52 |     return repr(self._params)
53 | 
54 | 
55 | class MeterProxy(object):
56 |   def __init__(self, pipes):
57 |     self.pipes = pipes
58 | 
59 |   def reset(self):
60 |     reactor.callFromThread(self._atomic_reset)
61 | 
62 |   def _atomic_reset(self):
63 |     self.pipes.up.reset_meter()
64 |     self.pipes.down.reset_meter()
65 | 
66 |   def __repr__(self):
67 |     return '\n'.join([
68 |       'up:',
69 |       '  attempted: {}'.format(self.pipes.up.bytes_attempted),
70 |       '  delivered: {}'.format(self.pipes.up.bytes_delivered),
71 |       'down:',
72 |       '  attempted: {}'.format(self.pipes.down.bytes_attempted),
73 |       '  delivered: {}'.format(self.pipes.down.bytes_delivered),
74 |     ])
75 | 
76 | 
77 | def main():
78 |   params, pipes, _ = command.configure()
79 | 
80 |   def run_shell():
81 |     shell_vars = {
82 |         'p': ParamsProxy(params),
83 |         'm': MeterProxy(pipes),
84 |     }
85 |     code.interact(banner=BANNER, local=shell_vars)
86 | 
87 |   deferred = threads.deferToThread(run_shell)
88 |   deferred.addCallback(lambda result: reactor.stop())
89 |   reactor.run()
90 | 


--------------------------------------------------------------------------------
/packet_queue/command.py:
--------------------------------------------------------------------------------
 1 | # Copyright 2016 Google Inc. All Rights Reserved.
 2 | #
 3 | # Licensed under the Apache License, Version 2.0 (the "License");
 4 | # you may not use this file except in compliance with the License.
 5 | # You may obtain a copy of the License at
 6 | #
 7 | #     http://www.apache.org/licenses/LICENSE-2.0
 8 | #
 9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 | 
15 | import argparse
16 | import netifaces
17 | import sys
18 | from . import monitoring
19 | from . import simulation
20 | from . import udp_proxy
21 | 
22 | 
23 | def configure(rest_server=False):
24 |   """Core startup routine.
25 | 
26 |   Args:
27 |     rest_server: boolean specifying if the API server will be initialized
28 |   Returns:
29 |     A params dictionary object, the PairPipes instance, and results from argparse
30 |   """
31 |   parser = argparse.ArgumentParser()
32 | 
33 |   parser.add_argument(
34 |       '-t', '--transport', type=str, choices=['tcp', 'udp'], default='tcp',
35 |       help='transport protocol')
36 |   parser.add_argument(
37 |       '-l', '--level', type=str, choices=['kernel', 'user'], default='kernel',
38 |       help='permissions level at which network interference will occur')
39 |   parser.add_argument(
40 |       '-i', '--interface', type=str, default='lo',
41 |       help=('impaired TCP interface, defaults to "lo"; set to "auto" to '
42 |             'impair the default outward-facing interface (e.g. eth0)'))
43 |   parser.add_argument(
44 |       '-x', '--proxy_port', type=int,
45 |       help=('proxy port for receiving all inbound traffic if -luser'
46 |             'is specified'))
47 |   parser.add_argument(
48 |       '-p', '--port', type=int, required=True,
49 |       help='flaky inbound/outbound traffic occurs on specified port')
50 | 
51 |   if rest_server:
52 |     parser.add_argument(
53 |         '-a', '--rest_api_port', type=int, default=9000,
54 |         help='port which REST API server will listen on')
55 | 
56 |   params = simulation.Pipe.PARAMS
57 |   event_log = monitoring.EventLog()
58 |   pipes = simulation.PipePair(params, event_log)
59 | 
60 |   args = parser.parse_args()
61 | 
62 |   if args.level == 'kernel':
63 |     import nfqueue # Makes imports that only work on Linux.
64 |     nfqueue.configure(args.transport, args.port, pipes, args.interface)
65 |   else:
66 |     if args.transport == 'tcp':
67 |       print 'Can\'t proxy TCP packets at the user level :('
68 |       sys.exit(1)
69 |     if not args.proxy_port:
70 |       print '--proxy_port is required'
71 |       sys.exit(1)
72 |     udp_proxy.configure(args.port, args.proxy_port, pipes)
73 | 
74 |   return params, pipes, args
75 | 


--------------------------------------------------------------------------------
/packet_queue/web/index.html:
--------------------------------------------------------------------------------
  1 | <!doctype html>
  2 | <!--
  3 | 
  4 | Copyright 2016 Google Inc. All Rights Reserved.
  5 | 
  6 | Licensed under the Apache License, Version 2.0 (the "License");
  7 | you may not use this file except in compliance with the License.
  8 | You may obtain a copy of the License at
  9 | 
 10 |     http://www.apache.org/licenses/LICENSE-2.0
 11 | 
 12 | Unless required by applicable law or agreed to in writing, software
 13 | distributed under the License is distributed on an "AS IS" BASIS,
 14 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 15 | See the License for the specific language governing permissions and
 16 | limitations under the License.
 17 | 
 18 | -->
 19 | 
 20 | <title>Packet Queue</title>
 21 | 
 22 | <script src="smoothie.js"></script>
 23 | <script src="packet_queue.js"></script>
 24 | 
 25 | <style>
 26 | 
 27 | body {
 28 |   font-family: Verdana, sans-serif;
 29 |   margin: 1em 1.2em;
 30 | }
 31 | 
 32 | h2 {
 33 |   font-size: 1.2em;
 34 |   margin: 0.6em 0;
 35 | }
 36 | 
 37 | form {
 38 |   width: 60em;
 39 | }
 40 | 
 41 | th {
 42 |   text-align: left;
 43 | }
 44 | 
 45 | td, th {
 46 |   padding-right: 2em;
 47 | }
 48 | 
 49 | #params-error {
 50 |   color: rgb(200, 0, 0);
 51 |   padding-left: 1em;
 52 |   position: absolute; /* Prevents resizing the table. */
 53 | }
 54 | 
 55 | </style>
 56 | 
 57 | <form id="params">
 58 |   <table>
 59 |     <tr>
 60 |       <th>Parameter</th>
 61 |       <th>New value</th>
 62 |       <th>Current value</th>
 63 |     </tr>
 64 |     <tr>
 65 |       <td><label for="param-bandwidth">Bandwidth (bytes)</td>
 66 |       <td><input id="param-bandwidth" name="bandwidth"></td>
 67 |       <td id="param-value-bandwidth"></td>
 68 |     </tr>
 69 |     <tr>
 70 |       <td><label for="param-buffer">Buffer size (bytes)</td>
 71 |       <td><input id="param-buffer" name="buffer"></td>
 72 |       <td id="param-value-buffer"></td>
 73 |     </tr>
 74 |     <tr>
 75 |       <td><label for="param-delay">One-way delay (seconds)</td>
 76 |       <td><input id="param-delay" name="delay"></td>
 77 |       <td id="param-value-delay"></td>
 78 |     </tr>
 79 |     <tr>
 80 |       <td><label for="param-loss">Random loss (0.0 to 1.0)</label></td>
 81 |       <td><input id="param-loss" name="loss"></td>
 82 |       <td id="param-value-loss"></td>
 83 |     </tr>
 84 |     <tr>
 85 |       <td colspan="3">
 86 |         <input type="submit" value="Update">
 87 |         <span id="params-error"></span>
 88 |       </td>
 89 |     </tr>
 90 |   </table>
 91 | </form>
 92 | 
 93 | <table>
 94 |   <tr>
 95 |     <td>
 96 |       <h2>Upload buffer used (bytes)</h2>
 97 |       <canvas width="450" height="150" id="up-buffer"></canvas>
 98 |     </td>
 99 |     <td>
100 |       <h2>Download buffer used (bytes)</h2>
101 |       <canvas width="450" height="150" id="down-buffer"></canvas>
102 |     </td>
103 |   </tr>
104 |   <tr>
105 |     <td>
106 |       <h2>Upload latency (seconds)</h2>
107 |       <canvas width="450" height="150" id="up-latency"></canvas>
108 |     </td>
109 |     <td>
110 |       <h2>Download latency (seconds)</h2>
111 |       <canvas width="450" height="150" id="down-latency"></canvas>
112 |     </td>
113 |   </tr>
114 |   <tr>
115 |     <td>
116 |       <h2>Upload bytes delivered/dropped</h2>
117 |       <canvas width="450" height="150" id="up-bytes"></canvas>
118 |     </td>
119 |     <td>
120 |       <h2>Download bytes delivered/dropped</h2>
121 |       <canvas width="450" height="150" id="down-bytes"></canvas>
122 |     </td>
123 |   </tr>
124 | </table>
125 | 
126 | 


--------------------------------------------------------------------------------
/packet_queue/nfqueue.py:
--------------------------------------------------------------------------------
 1 | # Copyright 2016 Google Inc. All Rights Reserved.
 2 | #
 3 | # Licensed under the Apache License, Version 2.0 (the "License");
 4 | # you may not use this file except in compliance with the License.
 5 | # You may obtain a copy of the License at
 6 | #
 7 | #     http://www.apache.org/licenses/LICENSE-2.0
 8 | #
 9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 | 
15 | """Network simulation adapter using NFQUEUE on Linux."""
16 | import os
17 | import netifaces
18 | import iptc
19 | from twisted.internet import abstract
20 | from twisted.internet import reactor
21 | 
22 | from packet_queue import libnetfilter_queue
23 | 
24 | 
25 | UP_QUEUE = 1
26 | DOWN_QUEUE = 2
27 | 
28 | 
29 | def packet_handler(manager, pipe):
30 |   def on_packet(packet):
31 |     def accept():
32 |       manager.set_verdict(packet, libnetfilter_queue.NF_ACCEPT)
33 |     def drop():
34 |       manager.set_verdict(packet, libnetfilter_queue.NF_DROP)
35 |     pipe.attempt(accept, drop, packet.size)
36 |   return on_packet
37 | 
38 | 
39 | def configure(protocol, port, pipes, interface):
40 |   remove_all()
41 |   reactor.addSystemEventTrigger('after', 'shutdown', remove_all)
42 | 
43 |   # gets default (outward-facing) network interface (e.g. deciding which of
44 |   # eth0, eth1, wlan0 is being used by the system to connect to the internet)
45 |   if interface == "auto":
46 |     interface = netifaces.gateways()['default'][netifaces.AF_INET][1]
47 |   else:
48 |     if interface not in netifaces.interfaces():
49 |       raise ValueError("Given interface does not exist.", interface)
50 | 
51 |   add(protocol, port, interface)
52 |   manager = libnetfilter_queue.Manager()
53 | 
54 |   manager.bind(UP_QUEUE, packet_handler(manager, pipes.up))
55 |   manager.bind(DOWN_QUEUE, packet_handler(manager, pipes.down))
56 | 
57 |   reader = abstract.FileDescriptor()
58 |   reader.doRead = manager.process
59 |   reader.fileno = lambda: manager.fileno
60 |   reactor.addReader(reader)
61 | 
62 | 
63 | def add(protocol, port, interface):
64 |   """Adds iptables NFQUEUE rules: one each for INPUT and OUTPUT."""
65 |   table = iptc.Table(iptc.Table.FILTER)
66 | 
67 |   params =  [
68 |     ('INPUT', 'in_interface', 'dport', UP_QUEUE),
69 |     ('OUTPUT', 'out_interface', 'sport', DOWN_QUEUE),
70 |   ]
71 | 
72 |   for chain_name, interface_attr, port_attr, queue_num in params:
73 |     chain = iptc.Chain(table, chain_name)
74 |     rule = iptc.Rule()
75 |     setattr(rule, interface_attr, interface)
76 |     rule.protocol = protocol
77 | 
78 |     comment_match = rule.create_match('comment')
79 |     comment_match.comment = 'white rabbit, pid: {}'.format(os.getpid())
80 | 
81 |     protocol_match = rule.create_match(protocol)
82 |     setattr(protocol_match, port_attr, str(port))
83 | 
84 |     rule.target = rule.create_target('NFQUEUE')
85 |     rule.target.set_parameter('queue-num', str(queue_num))
86 |     chain.insert_rule(rule)
87 | 
88 | 
89 | def remove_all():
90 |   """Removes all iptables INPUT/OUTPUT rules commented for deletion."""
91 |   table = iptc.Table(iptc.Table.FILTER)
92 |   for chain_name in ['INPUT', 'OUTPUT']:
93 |     chain = iptc.Chain(table, chain_name)
94 |     for rule in chain.rules:
95 |       for match in rule.matches:
96 |         if match.comment and match.comment.startswith('white rabbit'):
97 |           chain.delete_rule(rule)
98 |           break
99 | 


--------------------------------------------------------------------------------
/packet_queue/libnetfilter_queue.py:
--------------------------------------------------------------------------------
 1 | # Copyright 2016 Google Inc. All Rights Reserved.
 2 | #
 3 | # Licensed under the Apache License, Version 2.0 (the "License");
 4 | # you may not use this file except in compliance with the License.
 5 | # You may obtain a copy of the License at
 6 | #
 7 | #     http://www.apache.org/licenses/LICENSE-2.0
 8 | #
 9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 | 
15 | """ctypes adapter for libnetfilter_queue on Linux."""
16 | import collections
17 | import ctypes
18 | import socket
19 | 
20 | 
21 | BUFFER_SIZE = 0xffff  # Largest possible IP packet.
22 | NF_DROP = 0
23 | NF_ACCEPT = 1
24 | NFQNL_COPY_PACKET = 2
25 | Packet = collections.namedtuple('Packet', ['id', 'size', 'payload', 'qh'])
26 | nfq = ctypes.cdll.LoadLibrary('libnetfilter_queue.so')
27 | 
28 | class nfq_data(ctypes.Structure):
29 |   pass
30 | 
31 | class msg_packet_header(ctypes.Structure):
32 |   _fields_ = [('packet_id', ctypes.c_uint32)]
33 | 
34 | nfq.nfq_get_msg_packet_hdr.restype = ctypes.POINTER(msg_packet_header)
35 | 
36 | nfq_callback_type = ctypes.CFUNCTYPE(ctypes.c_int,
37 |                                      ctypes.c_void_p,
38 |                                      ctypes.c_void_p,
39 |                                      ctypes.POINTER(nfq_data),
40 |                                      ctypes.c_void_p)
41 | 
42 | @nfq_callback_type
43 | def nfq_callback(qh, unused_nfmsg, nfad, unused_data):
44 |   packet = nfq.nfq_get_msg_packet_hdr(nfad).contents
45 |   packet_id = socket.ntohl(packet.packet_id)
46 | 
47 |   payload_pointer = ctypes.c_void_p()
48 |   size = nfq.nfq_get_payload(nfad, ctypes.byref(payload_pointer))
49 |   payload = ctypes.string_at(payload_pointer, size)
50 | 
51 |   packet = Packet(packet_id, size, payload, qh)
52 |   py_callbacks[qh](packet)
53 |   return 0
54 | 
55 | # Maps queue handles to user-specified callbacks.
56 | py_callbacks = {}
57 | 
58 | 
59 | class Manager(object):
60 |   """Manages multiple queues."""
61 | 
62 |   def __init__(self):
63 |     self.handle = nfq.nfq_open()
64 |     self.fileno = nfq.nfq_fd(self.handle)
65 |     self.socket = socket.fromfd(self.fileno, socket.AF_UNIX, socket.SOCK_RAW)
66 | 
67 |     if nfq.nfq_unbind_pf(self.handle, socket.AF_INET) < 0:
68 |       raise OSError('nfq_unbind_pf() failed. Are you root?')
69 | 
70 |     if nfq.nfq_bind_pf(self.handle, socket.AF_INET) < 0:
71 |       raise OSError('nfq_bind_pf() failed. Are you root?')
72 | 
73 |   def set_verdict(self, packet, verdict):
74 |     """Set the verdict on a Packet instance: NF_ACCEPT or NF_DROP."""
75 |     payload_buffer = ctypes.create_string_buffer(packet.payload)
76 |     nfq.nfq_set_verdict(packet.qh,
77 |                         packet.id,
78 |                         verdict,
79 |                         packet.size,
80 |                         payload_buffer)
81 | 
82 |   def bind(self, queue_num, callback):
83 |     """Bind a queue number to a callback.
84 | 
85 |     The callback should take a single argument: a Packet instance.
86 |     """
87 |     qh = nfq.nfq_create_queue(self.handle, queue_num, nfq_callback, None)
88 |     if qh <= 0:
89 |       raise OSError('nfq_create_queue() failed. Is packet queue already running?')
90 | 
91 |     py_callbacks[qh] = callback
92 |     nfq.nfq_set_mode(qh, NFQNL_COPY_PACKET, BUFFER_SIZE)
93 | 
94 |   def process(self):
95 |     """Without blocking, read available packets and invoke their callbacks."""
96 |     data = self.socket.recv(BUFFER_SIZE, socket.MSG_DONTWAIT)
97 |     buf = ctypes.create_string_buffer(data)
98 |     nfq.nfq_handle_packet(self.handle, buf, len(data))
99 | 


--------------------------------------------------------------------------------
/packet_queue/simulation.py:
--------------------------------------------------------------------------------
  1 | # Copyright 2016 Google Inc. All Rights Reserved.
  2 | #
  3 | # Licensed under the Apache License, Version 2.0 (the "License");
  4 | # you may not use this file except in compliance with the License.
  5 | # You may obtain a copy of the License at
  6 | #
  7 | #     http://www.apache.org/licenses/LICENSE-2.0
  8 | #
  9 | # Unless required by applicable law or agreed to in writing, software
 10 | # distributed under the License is distributed on an "AS IS" BASIS,
 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 12 | # See the License for the specific language governing permissions and
 13 | # limitations under the License.
 14 | 
 15 | import random
 16 | import time
 17 | from twisted.internet import reactor
 18 | 
 19 | 
 20 | class PipePair(object):
 21 |   """Holds two Pipe instances sharing a parameter dictionary and event log."""
 22 |   def __init__(self, params, event_log):
 23 |     self.event_log = event_log
 24 |     self.up = Pipe('up', params, event_log)
 25 |     self.down = Pipe('down', params, event_log)
 26 | 
 27 | 
 28 | class Pipe(object):
 29 |   """Takes packets, represented by a callback and a size in bytes, and possibly
 30 |   invokes the callback later.
 31 | 
 32 |   Limits bandwidth by holding packets in a "buffer", and rejects packets when
 33 |   the buffer is full.
 34 | 
 35 |   Applies constant random packet loss prior to packets joining the buffer, and
 36 |   constant delay after they are released.
 37 |   """
 38 | 
 39 |   PARAMS = {
 40 |       'bandwidth': -1,  # bytes per second, defaults to infinity
 41 |       'buffer': -1,  # max bytes allowed, defaults to infinity
 42 |       'delay': 0.0,
 43 |       'loss': 0.0,
 44 |   }
 45 | 
 46 |   def __init__(self, name, params, event_log):
 47 |     self.name = name
 48 |     self.params = params
 49 |     self.events = event_log
 50 |     self.size = 0
 51 | 
 52 |   def attempt(self, deliver_callback, drop_callback, size):
 53 |     """Possibly invoke a callback representing a packet.
 54 | 
 55 |     The callback may be invoked later using the Twisted reactor, simulating
 56 |     network latency, or it may be ignored entirely, simulating packet loss.
 57 |     """
 58 |     attempt_time = time.time()
 59 | 
 60 |     def deliver():
 61 |       delivery_time = time.time()
 62 |       latency = delivery_time - attempt_time
 63 |       self.events.add(delivery_time, self.name, 'deliver', size)
 64 |       self.events.add(delivery_time, self.name, 'latency', latency)
 65 |       deliver_callback()
 66 | 
 67 |     if self.params['buffer'] > 0 and self.size + size > self.params['buffer']:
 68 |       self.events.add(attempt_time, self.name, 'drop', size)
 69 |       drop_callback()
 70 |       return
 71 | 
 72 |     if random.random() < self.params['loss']:
 73 |       self.events.add(attempt_time, self.name, 'drop', size)
 74 |       drop_callback()
 75 |       return
 76 | 
 77 |     self.size += size
 78 |     self.events.add(attempt_time, self.name, 'buffer', self.size)
 79 | 
 80 |     def release_buffer():
 81 |       release_time = time.time()
 82 |       self.size -= size
 83 |       self.events.add(release_time, self.name, 'buffer', self.size)
 84 | 
 85 |     # Delay has two components: throttled (proportional to size) and constant.
 86 |     #
 87 |     # Throttle delay is calculated by estimating the time it will take all of
 88 |     # the enqueued packets to be released, including the current one. Release
 89 |     # the current packet (subtract its size) after this period of time.
 90 |     #
 91 |     # After the packet is released, there is an additional period of constant
 92 |     # delay, so schedule a second event to finally call the packet's callback.
 93 |     throttle_delay = 0
 94 |     if self.params['bandwidth'] > 0:
 95 |       throttle_delay = float(self.size) / self.params['bandwidth']
 96 |     constant_delay = self.params['delay']
 97 | 
 98 |     reactor.callLater(throttle_delay, release_buffer)
 99 |     reactor.callLater(throttle_delay + constant_delay, deliver)
100 | 


--------------------------------------------------------------------------------
/packet_queue/udp_proxy.py:
--------------------------------------------------------------------------------
  1 | # Copyright 2016 Google Inc. All Rights Reserved.
  2 | #
  3 | # Licensed under the Apache License, Version 2.0 (the "License");
  4 | # you may not use this file except in compliance with the License.
  5 | # You may obtain a copy of the License at
  6 | #
  7 | #     http://www.apache.org/licenses/LICENSE-2.0
  8 | #
  9 | # Unless required by applicable law or agreed to in writing, software
 10 | # distributed under the License is distributed on an "AS IS" BASIS,
 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 12 | # See the License for the specific language governing permissions and
 13 | # limitations under the License.
 14 | 
 15 | """Network simulation adapter using a user-level UDP proxy."""
 16 | from twisted.internet import protocol
 17 | from twisted.internet import reactor
 18 | 
 19 | 
 20 | # Header bytes in each UDP packet. Used for bandwidth estimation.
 21 | OVERHEAD = 28
 22 | 
 23 | 
 24 | # Unlike nfqueue, no special action is needed to drop a packet.
 25 | DROP = lambda: None
 26 | 
 27 | 
 28 | def configure(port, proxy_port, pipes):
 29 |   """Starts a UDP proxy server on localhost.
 30 | 
 31 |   Returns the proxy port number, which is the same as the proxy_port param
 32 |   unless zero is passed in.
 33 |   """
 34 |   server = ProxyServer(port, pipes)
 35 |   port = reactor.listenUDP(proxy_port, server.udp)
 36 |   return port.getHost().port
 37 | 
 38 | 
 39 | class UDP(protocol.DatagramProtocol):
 40 |   """Lightweight interface for Twisted UDP functionality.
 41 | 
 42 |   This exists to make it easier to test the interesting stuff, by isolating all
 43 |   of the network interaction and Twisted inheritance.
 44 |   """
 45 |   def __init__(self, receiver):
 46 |     self.receiver = receiver
 47 | 
 48 |   def Send(self, data, address):
 49 |     self.transport.write(data, address)
 50 | 
 51 |   def datagramReceived(self, *args):
 52 |     """Invoked by Twisted."""
 53 |     self.receiver(*args)
 54 | 
 55 | 
 56 | class ProxyServer(object):
 57 |   """Proxies a UDP server. Incoming packets are from clients.
 58 | 
 59 |   Creates a UDP socket for each address it receives data from, and uses it as
 60 |   as a proxy client for the server. This is so that the port for an incoming
 61 |   packet from the server can be used to determine which client it should be
 62 |   relayed to.
 63 |   """
 64 |   def __init__(self, port, pipes):
 65 |     self.udp = UDP(self.Receive)
 66 |     self.server_address = ('127.0.0.1', port)
 67 |     self.proxy_clients = {}
 68 |     self.pipes = pipes
 69 | 
 70 |   def Receive(self, data, address):
 71 |     """Invoked by Twisted when a packet arrives at the client-facing port.
 72 | 
 73 |     Relays the packet to the server using the appropriate proxy client.
 74 |     """
 75 |     proxy_client = self._GetProxyClient(address)
 76 |     def callback():
 77 |       proxy_client.udp.Send(data, self.server_address)
 78 |     self.pipes.up.attempt(callback, DROP, len(data) + OVERHEAD)
 79 | 
 80 |   def _GetProxyClient(self, address):
 81 |     """Gets a proxy client for a given client address.
 82 | 
 83 |     Returns the new proxy client, or an existing one if the address has been
 84 |     used before.
 85 |     """
 86 |     if address in self.proxy_clients:
 87 |       proxy_client = self.proxy_clients[address]
 88 |     else:
 89 |       proxy_client = ProxyClient(self, address)
 90 |       self.proxy_clients[address] = proxy_client
 91 |       reactor.listenUDP(0, proxy_client.udp)
 92 | 
 93 |     return proxy_client
 94 | 
 95 | 
 96 | class ProxyClient(object):
 97 |   """Proxies a UDP client. Incoming packets are from the server."""
 98 |   def __init__(self, proxy_server, relay_address):
 99 |     self.udp = UDP(self.Receive)
100 |     self.proxy_server = proxy_server
101 |     self.relay_address = relay_address
102 | 
103 |   def Receive(self, data, ignore_address):
104 |     """Invoked by Twisted when a packet arrives from the server.
105 | 
106 |     Relays the packet to the actual client, via ProxyServer.
107 |     """
108 |     def callback():
109 |       self.proxy_server.udp.Send(data, self.relay_address)
110 |     self.proxy_server.pipes.down.attempt(callback, DROP, len(data) + OVERHEAD)
111 | 


--------------------------------------------------------------------------------
/tests/test_simulation.py:
--------------------------------------------------------------------------------
  1 | # Copyright 2016 Google Inc. All Rights Reserved.
  2 | #
  3 | # Licensed under the Apache License, Version 2.0 (the "License");
  4 | # you may not use this file except in compliance with the License.
  5 | # You may obtain a copy of the License at
  6 | #
  7 | #     http://www.apache.org/licenses/LICENSE-2.0
  8 | #
  9 | # Unless required by applicable law or agreed to in writing, software
 10 | # distributed under the License is distributed on an "AS IS" BASIS,
 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 12 | # See the License for the specific language governing permissions and
 13 | # limitations under the License.
 14 | 
 15 | import bisect
 16 | import unittest
 17 | from packet_queue import monitoring
 18 | from packet_queue import simulation
 19 | 
 20 | 
 21 | class FakeReactor(object):
 22 |   """Substitute for the Twisted reactor module.
 23 | 
 24 |   Allows tests to explicitly advance time to execute scheduled callbacks.
 25 |   """
 26 |   def __init__(self):
 27 |     self.queue = []
 28 |     self.time = 0.0
 29 | 
 30 |   def advance_time(self, seconds):
 31 |     self.time += seconds
 32 |     while self.queue:
 33 |       time, callback = self.queue[0]
 34 |       if time <= self.time:
 35 |         self.queue.pop(0)
 36 |         callback()
 37 |       else:
 38 |         break
 39 | 
 40 |   def callLater(self, delay, callback):
 41 |     bisect.insort(self.queue, (self.time + delay, callback))
 42 | 
 43 | 
 44 | class FakeReactorTest(unittest.TestCase):
 45 |   def setUp(self):
 46 |     self.reactor = FakeReactor()
 47 |     self.called = []
 48 | 
 49 |   def Add(self, obj):
 50 |     def callback():
 51 |       self.called.append(obj)
 52 |     return callback
 53 | 
 54 |   def test_callbacks(self):
 55 |     self.reactor.callLater(0.0, self.Add(1))
 56 |     self.reactor.callLater(0.5, self.Add(2))
 57 |     self.reactor.callLater(1.0, self.Add(3))
 58 |     self.assertItemsEqual(self.called, [])
 59 | 
 60 |     self.reactor.advance_time(0.0)
 61 |     self.assertItemsEqual(self.called, [1])
 62 | 
 63 |     self.reactor.advance_time(0.5)
 64 |     self.assertItemsEqual(self.called, [1, 2])
 65 |     self.reactor.callLater(0.5, self.Add(4))
 66 | 
 67 |     self.reactor.advance_time(0.5)
 68 |     self.assertItemsEqual(self.called, [1, 2, 3, 4])
 69 | 
 70 | 
 71 | class PipeTest(unittest.TestCase):
 72 |   def setUp(self):
 73 |     params = dict(simulation.Pipe.PARAMS)
 74 |     self.pipe = simulation.Pipe('test', params, monitoring.EventLog())
 75 |     self.received = []
 76 |     self.reactor = FakeReactor()
 77 |     simulation.reactor = self.reactor
 78 | 
 79 |   def configure(self, **kwargs):
 80 |     self.pipe.params.update(kwargs)
 81 | 
 82 |   def send(self, obj, size=0):
 83 |     def callback():
 84 |       self.received.append(obj)
 85 |     self.pipe.attempt(callback, lambda: None, size)
 86 | 
 87 |   def wait(self, seconds):
 88 |     self.reactor.advance_time(seconds)
 89 | 
 90 |   def expect(self, received):
 91 |     self.assertItemsEqual(self.received, received)
 92 | 
 93 |   def test_constant_delay(self):
 94 |     self.configure(delay=0.5)
 95 | 
 96 |     self.send(1)
 97 |     self.send(2)
 98 |     self.expect([])
 99 | 
100 |     self.wait(0.5)
101 |     self.send(3)
102 |     self.expect([1, 2])
103 | 
104 |     self.wait(0.5)
105 |     self.expect([1, 2, 3])
106 | 
107 |   def test_throttle(self):
108 |     self.configure(bandwidth=4096)
109 | 
110 |     self.send(1, 1024)
111 |     self.send(2, 2048)
112 |     self.send(3, 0)
113 |     self.expect([])
114 | 
115 |     self.wait(0.25)
116 |     self.expect([1])
117 | 
118 |     self.wait(0.5)
119 |     self.expect([1, 2, 3])
120 | 
121 |   def test_throttle_plus_constant_delay(self):
122 |     self.configure(bandwidth=4096, delay=2.0)
123 | 
124 |     self.send(1, 2048)
125 |     self.send(2, 2048)
126 |     self.assertEqual(self.pipe.size, 4096)
127 | 
128 |     self.wait(1.0)
129 |     self.expect([])
130 |     self.assertEqual(self.pipe.size, 0)
131 | 
132 |     self.wait(2.0)
133 |     self.expect([1, 2])
134 | 
135 |   def test_buffer_full(self):
136 |     self.configure(bandwidth=1024, buffer=2048)
137 | 
138 |     self.send(1, 1024)
139 |     self.send(2, 1024)
140 |     self.send(3, 1024)
141 |     self.assertEqual(self.pipe.size, 2048)
142 | 
143 |     self.wait(1.0)
144 |     self.expect([1])
145 |     self.assertEqual(self.pipe.size, 1024)
146 |     self.send(4, 1024)
147 | 
148 |     self.wait(1.0)
149 |     self.expect([1, 2])
150 | 
151 |     self.wait(1.0)
152 |     self.expect([1, 2, 4])
153 | 
154 |   def test_drop_all(self):
155 |     self.configure(delay=1.0, loss=1.0)
156 | 
157 |     self.send(1, 1024)
158 |     self.wait(1.0)
159 |     self.expect([])
160 | 


--------------------------------------------------------------------------------
/packet_queue/api_server.py:
--------------------------------------------------------------------------------
  1 | # Copyright 2016 Google Inc. All Rights Reserved.
  2 | #
  3 | # Licensed under the Apache License, Version 2.0 (the "License");
  4 | # you may not use this file except in compliance with the License.
  5 | # You may obtain a copy of the License at
  6 | #
  7 | #     http://www.apache.org/licenses/LICENSE-2.0
  8 | #
  9 | # Unless required by applicable law or agreed to in writing, software
 10 | # distributed under the License is distributed on an "AS IS" BASIS,
 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 12 | # See the License for the specific language governing permissions and
 13 | # limitations under the License.
 14 | 
 15 | """REST API server backend.
 16 | 
 17 | Creates and maintains the pipes params, updating params on the fly.
 18 | """
 19 | 
 20 | import argparse
 21 | import json
 22 | import os
 23 | import sys
 24 | import time
 25 | 
 26 | from twisted.internet import reactor
 27 | from twisted.web import resource
 28 | from twisted.web import static
 29 | from twisted.web import server
 30 | from twisted.web import util
 31 | 
 32 | from . import command
 33 | from . import simulation
 34 | 
 35 | 
 36 | def create_site(params, pipes):
 37 |   source_dir = os.path.dirname(os.path.abspath(__file__))
 38 |   web_dir = os.path.join(source_dir, 'web')
 39 | 
 40 |   root = static.File(web_dir)
 41 |   root.putChild('pipes', PipeResource(params))
 42 |   root.putChild('events', EventsResource(pipes.event_log))
 43 |   return server.Site(root)
 44 | 
 45 | 
 46 | def parse_pipe_params(args, types=None):
 47 |   """Ensure pipe parameter args are of correct type.
 48 | 
 49 |   Args:
 50 |     args: {arg: value} dictionary where "arg" is a key in the types dict
 51 |     type: {arg: type(value)} dictionary; defaults to type of simulation.Pipe.PARAMS
 52 | 
 53 |   Returns:
 54 |     Cleaned {arg: value} dictionary, where value is of correct type
 55 | 
 56 |   Raises:
 57 |     ValueError in case of invalid cast result (raised from attempted
 58 |         typecast PARAM_TYPES[k]())
 59 |     TypeError in case of invalid cast type (raised from attempted typecast)
 60 |   """
 61 | 
 62 |   if types is None:
 63 |     types = {k: type(v) for (k, v) in simulation.Pipe.PARAMS.items()}
 64 | 
 65 |   return {k: types[k](v) for (k, v) in args.items() if k in types}
 66 | 
 67 | 
 68 | class PipeResource(resource.Resource):
 69 |   """RESTful API to handle changing the pipe parameters."""
 70 | 
 71 |   is_leaf = True
 72 | 
 73 |   def __init__(self, params):
 74 |     self.params = params
 75 |     self.param_types = {k: type(v) for (k, v) in params.items()}
 76 |     self.default = dict(params)  # read-only copy of initial params
 77 |     resource.Resource.__init__(self)
 78 | 
 79 |   def render_DELETE(self, request):
 80 |     """Resets params to initial state."""
 81 | 
 82 |     self.params.update(self.default)
 83 | 
 84 |     request.setHeader('Content-Type', 'application/json')
 85 |     return json.dumps(self.params)
 86 | 
 87 |   def render_GET(self, request):
 88 |     request.setHeader('Content-Type', 'application/json')
 89 |     return json.dumps(self.params)
 90 | 
 91 |   def render_PUT(self, request):
 92 |     """Updates the params object.
 93 | 
 94 |     Args:
 95 |       request: HTTP request object; request BODY is set to JSON query
 96 |           note that this is NOT canonical REST request/response, but done here
 97 |           for the sake of code brevity
 98 |     Returns:
 99 |       JSON string representing the page contents
100 |     """
101 |     content = request.content.read()
102 |     request.setHeader('Content-Type', 'application/json')
103 | 
104 |     try:
105 |       params = parse_pipe_params(json.loads(content), self.param_types)
106 |     except (KeyError, ValueError):
107 |       request.setResponseCode(400)
108 |       response = {'error': 'Unable to parse parameters'}
109 |       return json.dumps(response)
110 |     else:
111 |       self.params.update(params)
112 |       return json.dumps(self.params)
113 | 
114 | 
115 | class EventsResource(resource.Resource):
116 |   """Provides a view of recent network simulation events."""
117 | 
118 |   is_leaf = True
119 | 
120 |   def __init__(self, event_log):
121 |     self.event_log = event_log
122 |     resource.Resource.__init__(self)
123 | 
124 |   def render_GET(self, request):
125 |     events = self.event_log.get_pending()
126 |     response = {'now': time.time(), 'events': events}
127 |     return json.dumps(response)
128 | 
129 | 
130 | def configure():
131 |   params, pipes, args = command.configure(rest_server=True)
132 |   port = args.rest_api_port
133 | 
134 |   reactor.listenTCP(port, create_site(params, pipes))
135 |   @reactor.callWhenRunning
136 |   def startup_message():
137 |     print 'Packet Queue is running. Configure at http://localhost:%i' % port
138 |     sys.stdout.flush()
139 | 


--------------------------------------------------------------------------------
/tests/test_e2e.py:
--------------------------------------------------------------------------------
  1 | # Copyright 2016 Google Inc. All Rights Reserved.
  2 | #
  3 | # Licensed under the Apache License, Version 2.0 (the "License");
  4 | # you may not use this file except in compliance with the License.
  5 | # You may obtain a copy of the License at
  6 | #
  7 | #     http://www.apache.org/licenses/LICENSE-2.0
  8 | #
  9 | # Unless required by applicable law or agreed to in writing, software
 10 | # distributed under the License is distributed on an "AS IS" BASIS,
 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 12 | # See the License for the specific language governing permissions and
 13 | # limitations under the License.
 14 | 
 15 | """End-to-end tests for nfqueue and UDP proxy integration."""
 16 | import multiprocessing
 17 | import os
 18 | import select
 19 | import socket
 20 | import unittest
 21 | 
 22 | from packet_queue import monitoring
 23 | from packet_queue import nfqueue
 24 | from packet_queue import simulation
 25 | from packet_queue import udp_proxy
 26 | 
 27 | from twisted.internet import reactor
 28 | 
 29 | 
 30 | def root_required(method):
 31 |   decorator = unittest.skipIf(os.getuid() != 0, 'root required')
 32 |   return decorator(method)
 33 | 
 34 | 
 35 | class FakeApp(object):
 36 |   """Networked client-server app to run simulation on.
 37 | 
 38 |   Consists of a client and a server. The client sends a single packet to the
 39 |   server, and the server echoes it back.
 40 |   """
 41 |   def __init__(self):
 42 |     self.server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
 43 |     self.client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
 44 | 
 45 |   def start_server(self):
 46 |     self.server.bind(('127.0.0.1', 0))
 47 |     return self.server.getsockname()[1]
 48 | 
 49 |   def send_packet(self, port):
 50 |     """Send a test packet from client to server."""
 51 |     self.client.connect(('127.0.0.1', port))
 52 |     self.client.send('test')
 53 | 
 54 |   def send_response(self):
 55 |     """Process an expected packet from the client and respond."""
 56 |     data, address = self.server.recvfrom(4)
 57 |     self.server.sendto(data, address)
 58 | 
 59 |   def get_readable(self):
 60 |     """See whether the server, client, or both are readable.
 61 | 
 62 |     This is potentially flaky since it uses a timeout, and might fail in
 63 |     slow environments.
 64 | 
 65 |     Returns a two-tuple of booleans representing the readable state of the
 66 |     server and client, in that order.
 67 |     """
 68 |     server = self.server.fileno()
 69 |     client = self.client.fileno()
 70 |     readable = select.select([server, client], [], [], 0.1)[0]
 71 |     return server in readable, client in readable
 72 | 
 73 | 
 74 | class EndToEndTest(unittest.TestCase):
 75 |   """Tests that run packet queue (either nfqueue or UDP proxy) as a child
 76 |   process, and run FakeApp in the current process.
 77 | 
 78 |   Multiprocessing is used instead of threading to keep Twisted happy, since it
 79 |   will complain if the reactor runs outside the main thread.
 80 |   """
 81 |   def setUp(self):
 82 |     self.app = FakeApp()
 83 |     self.port = self.app.start_server()
 84 |     self.params = dict(simulation.Pipe.PARAMS)
 85 |     self.child = None  # multiprocessing.Process
 86 |     self.ready = multiprocessing.Event()
 87 |     self.shared = multiprocessing.Manager().Namespace()
 88 | 
 89 |   def tearDown(self):
 90 |     if self.child:
 91 |       self.child.terminate()
 92 | 
 93 |   def set_ready(self):
 94 |     self.ready.set()
 95 | 
 96 |   def start_child(self, target):
 97 |     self.child = multiprocessing.Process(target=target)
 98 |     self.child.start()
 99 |     self.ready.wait(1.0)
100 | 
101 |   def run_nfqueue(self):
102 |     pipes = simulation.PipePair(self.params, monitoring.EventLog())
103 |     nfqueue.configure('udp', self.port, pipes, 'lo')
104 |     reactor.callLater(0, self.set_ready)
105 |     reactor.run()
106 | 
107 |   def run_proxy(self):
108 |     pipes = simulation.PipePair(self.params, monitoring.EventLog())
109 |     proxy_port = udp_proxy.configure(self.port, 0, pipes)
110 |     self.shared.proxy_port = proxy_port
111 |     reactor.callLater(0, self.set_ready)
112 |     reactor.run()
113 | 
114 |   @root_required
115 |   def test_nfqueue_deliver_all(self):
116 |     self.start_child(self.run_nfqueue)
117 | 
118 |     self.app.send_packet(self.port)
119 |     self.assertEqual(self.app.get_readable(), (True, False))
120 | 
121 |     self.app.send_response()
122 |     self.assertEqual(self.app.get_readable(), (False, True))
123 | 
124 |   @root_required
125 |   def test_nfqueue_drop_all(self):
126 |     self.params['loss'] = 1.0
127 |     self.start_child(self.run_nfqueue)
128 | 
129 |     self.app.send_packet(self.port)
130 |     self.assertEqual(self.app.get_readable(), (False, False))
131 | 
132 |   def test_proxy_deliver_all(self):
133 |     self.start_child(self.run_proxy)
134 | 
135 |     self.app.send_packet(self.port)
136 |     self.assertEqual(self.app.get_readable(), (True, False))
137 | 
138 |     self.app.send_response()
139 |     self.assertEqual(self.app.get_readable(), (False, True))
140 | 
141 |   def test_proxy_drop_all(self):
142 |     self.params['loss'] = 1.0
143 |     self.start_child(self.run_proxy)
144 | 
145 |     self.app.send_packet(self.shared.proxy_port)
146 |     self.assertEqual(self.app.get_readable(), (False, False))
147 | 
148 | 
149 | if __name__ == '__main__':
150 |   unittest.main()
151 | 


--------------------------------------------------------------------------------
/packet_queue/web/packet_queue.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Copyright 2016 Google Inc. All Rights Reserved.
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *     http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | 
 17 | var GRAPH_OPTIONS = {
 18 |   millisPerPixel: 40,
 19 |   minValue: 0
 20 | };
 21 | 
 22 | var BLUE_LINE_OPTIONS = {
 23 |   lineWidth: 3,
 24 |   strokeStyle: 'rgb(80, 120, 255)',
 25 |   fillStyle: 'rgba(80, 120, 255, 0.3)'
 26 | };
 27 | 
 28 | var RED_LINE_OPTIONS = {
 29 |   lineWidth: 3,
 30 |   strokeStyle: 'rgb(255, 120, 120)',
 31 |   fillStyle: 'rgba(255, 120, 120, 0.3)'
 32 | };
 33 | 
 34 | var timeSeriesMap = {
 35 |   up: {
 36 |     buffer: new TimeSeries(),
 37 |     latency: new TimeSeries(),
 38 |     deliver: new TimeSeries(),
 39 |     drop: new TimeSeries()
 40 |   },
 41 |   down: {
 42 |     buffer: new TimeSeries(),
 43 |     latency: new TimeSeries(),
 44 |     deliver: new TimeSeries(),
 45 |     drop: new TimeSeries()
 46 |   }
 47 | };
 48 | 
 49 | var byteCount = {
 50 |   up: {
 51 |     drop: 0,
 52 |     deliver: 0
 53 |   },
 54 |   down: {
 55 |     drop: 0,
 56 |     deliver: 0
 57 |   }
 58 | };
 59 | 
 60 | var toMillis = function(seconds) {
 61 |   return Math.floor(seconds * 1000);
 62 | };
 63 | 
 64 | var requestNewEvents = function() {
 65 |   var xhr = new XMLHttpRequest();
 66 |   xhr.responseType = 'json';
 67 |   xhr.open('GET', '/events');
 68 |   xhr.onload = onNewEvents;
 69 |   xhr.send();
 70 | };
 71 | 
 72 | var onNewEvents = function() {
 73 |   var events = this.response.events;
 74 |   var serverTime = toMillis(this.response.now);
 75 |   var timeDiff = Date.now() - serverTime;
 76 | 
 77 |   for (var i = 0; i < events.length; i++) {
 78 |     var e = events[i];
 79 |     var timeSeries = timeSeriesMap[e.pipe][e.type];
 80 | 
 81 |     if (e.type == 'drop' || e.type == 'deliver') {
 82 |       byteCount[e.pipe][e.type] += e.value;
 83 |       var value = byteCount[e.pipe][e.type];
 84 |     } else {
 85 |       var value = e.value;
 86 |     }
 87 | 
 88 |     var time = toMillis(e.time) + timeDiff;
 89 |     timeSeries.append(time, value);
 90 |   }
 91 | };
 92 | 
 93 | var initGraphs = function() {
 94 |   var canvasElements = document.getElementsByTagName('canvas');
 95 |   for (var i = 0; i < canvasElements.length; i++) {
 96 |     var element = canvasElements[i];
 97 |     var idParts = element.id.split('-');
 98 |     var pipe = idParts[0];
 99 |     var graphName = idParts[1];
100 | 
101 |     var graph = new SmoothieChart(GRAPH_OPTIONS);
102 |     graph.streamTo(element, 1000);
103 | 
104 |     if (graphName == 'bytes') {
105 |       var deliverTimeSeries = timeSeriesMap[pipe].deliver;
106 |       var dropTimeSeries = timeSeriesMap[pipe].drop;
107 |       graph.addTimeSeries(deliverTimeSeries, BLUE_LINE_OPTIONS);
108 |       graph.addTimeSeries(dropTimeSeries, RED_LINE_OPTIONS);
109 |     } else {
110 |       var timeSeries = timeSeriesMap[pipe][graphName];
111 |       graph.addTimeSeries(timeSeries, BLUE_LINE_OPTIONS);
112 |     }
113 |   }
114 | 
115 |   setInterval(requestNewEvents, 1000);
116 | };
117 | 
118 | var onParamsSubmit = function(event) {
119 |   event.preventDefault();
120 |   showParamsError('');
121 | 
122 |   var params = {
123 |     bandwidth: parseInt(this.elements.bandwidth.value),
124 |     buffer: parseInt(this.elements.buffer.value),
125 |     delay: parseFloat(this.elements.delay.value),
126 |     loss: parseFloat(this.elements.loss.value)
127 |   };
128 | 
129 |   var xhr = new XMLHttpRequest();
130 |   xhr.responseType = 'json';
131 |   xhr.open('PUT', '/pipes');
132 |   xhr.onload = onParamsResponse;
133 |   xhr.onerror = onParamsNetworkError;
134 |   xhr.setRequestHeader('Content-Type', 'application/json');
135 |   xhr.send(JSON.stringify(params));
136 | };
137 | 
138 | var onParamsResponse = function() {
139 |   var response = this.response;
140 |   if (response) {
141 |     for (key in response) {
142 |       var value = response[key];
143 |       var inputElement = document.getElementById('param-' + key);
144 |       var valueElement = document.getElementById('param-value-' + key);
145 |       inputElement.value = value;
146 |       valueElement.textContent = value;
147 |     }
148 |   } else {
149 |     showParamsError('Updating params failed. Check the server log.')
150 |   }
151 | };
152 | 
153 | var onParamsNetworkError = function() {
154 |   showParamsError('Network error. Is the packet queue running?');
155 | };
156 | 
157 | var showParamsError = function(message) {
158 |   element = document.getElementById('params-error');
159 |   element.textContent = message;
160 | };
161 | 
162 | var initParams = function() {
163 |   var xhr = new XMLHttpRequest();
164 |   xhr.responseType = 'json';
165 |   xhr.open('GET', '/pipes');
166 |   xhr.onload = onParamsResponse;
167 |   xhr.send();
168 | 
169 |   var form = document.getElementById('params');
170 |   form.addEventListener('submit', onParamsSubmit);
171 | };
172 | 
173 | document.addEventListener('DOMContentLoaded', function(event) {
174 |   initParams();
175 |   initGraphs();
176 | });
177 | 


--------------------------------------------------------------------------------
/tests/test_api_server.py:
--------------------------------------------------------------------------------
  1 | # Copyright 2016 Google Inc. All Rights Reserved.
  2 | #
  3 | # Licensed under the Apache License, Version 2.0 (the "License");
  4 | # you may not use this file except in compliance with the License.
  5 | # You may obtain a copy of the License at
  6 | #
  7 | #     http://www.apache.org/licenses/LICENSE-2.0
  8 | #
  9 | # Unless required by applicable law or agreed to in writing, software
 10 | # distributed under the License is distributed on an "AS IS" BASIS,
 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 12 | # See the License for the specific language governing permissions and
 13 | # limitations under the License.
 14 | 
 15 | import json
 16 | import StringIO
 17 | 
 18 | from twisted.trial import unittest
 19 | from twisted.web import http_headers
 20 | 
 21 | from twisted.internet.defer import succeed
 22 | from twisted.web.test import test_web
 23 | 
 24 | from packet_queue import api_server
 25 | from packet_queue import simulation
 26 | 
 27 | 
 28 | def construct_dummy_request(method="GET", data=""):
 29 |   request = test_web.DummyRequest([""])
 30 | 
 31 |   request.content = StringIO.StringIO(data)
 32 |   request.method = method  # checked by Twisted's resource.Resource.render
 33 | 
 34 |   return request
 35 | 
 36 | 
 37 | class DummyReactor(object):
 38 |   """Substitute for the Twisted reactor module.
 39 | 
 40 |   Executes callbacks immediately or not at all.
 41 |   """
 42 |   def __init__(self):
 43 |     self.execute = True
 44 | 
 45 |   def callLater(self, delay, callback):
 46 |     if self.execute:
 47 |       callback()
 48 | 
 49 | 
 50 | class PipeParamsTest(unittest.TestCase):
 51 | 
 52 |   def test_null_case(self):
 53 |     self.assertEqual(api_server.parse_pipe_params({}), {})
 54 | 
 55 |   def test_invalid_key(self):
 56 |     self.assertEqual(api_server.parse_pipe_params({"foo": 0}), {})
 57 | 
 58 |   def test_invalid_cast(self):
 59 |     self.assertRaises(ValueError, api_server.parse_pipe_params, {"bandwidth": "foobar"})
 60 |     self.assertRaises(ValueError, api_server.parse_pipe_params, {"bandwidth": "1.5"})
 61 |     self.assertRaises(TypeError, api_server.parse_pipe_params, {"bandwidth": {}})
 62 |     self.assertRaises(TypeError, api_server.parse_pipe_params, {"bandwidth": ()})
 63 |     self.assertRaises(TypeError, api_server.parse_pipe_params, {"bandwidth": None})
 64 | 
 65 |   def test_normal_case(self):
 66 |     expected = {"bandwidth": -1}
 67 |     actual = api_server.parse_pipe_params({"bandwidth": "-1"})
 68 |     self.assertEqual(actual, expected)
 69 | 
 70 |     expected = {"loss": 0.5}
 71 |     actual = api_server.parse_pipe_params({"loss": ".5"})
 72 |     self.assertEqual(actual, expected)
 73 | 
 74 |   def test_non_default_types(self):
 75 |     types = {"some_int": int, "some_float": float}
 76 |     actual = api_server.parse_pipe_params({"some_int": "1"}, types)
 77 |     self.assertEqual(actual, {"some_int": 1})
 78 | 
 79 |     actual = api_server.parse_pipe_params({"some_float": "1.0"}, types)
 80 |     self.assertEqual(actual, {"some_float": 1.0})
 81 | 
 82 | 
 83 | class PipeResourceTest(unittest.TestCase):
 84 | 
 85 |   BASE_PARAMS = {"foo": 100, "bar": 107}  # base params reference
 86 | 
 87 |   def setUp(self):
 88 |     # mutable reference, mirrors Resource
 89 |     self.params = dict(self.BASE_PARAMS)
 90 | 
 91 |     self.resource = api_server.PipeResource(params=self.params)
 92 | 
 93 |   def test_get_init_state(self):
 94 |     request = construct_dummy_request()
 95 |     content = self.resource.render(request)
 96 |     self.assertEqual(json.loads(content), self.BASE_PARAMS)
 97 | 
 98 |   def test_put_no_content(self):
 99 |     request = construct_dummy_request(method="PUT", data="")
100 |     self.resource.render(request)
101 |     self.assertEqual(request.responseCode, 400)
102 | 
103 |   def test_put_empty_params(self):
104 |     request = construct_dummy_request(method="PUT", data="{}")
105 |     content = self.resource.render(request)
106 |     self.assertEqual(json.loads(content), self.BASE_PARAMS)
107 | 
108 |   def test_put_invalid_request(self):
109 |     """Invalid param types should be caught by handler and indicated in response.
110 | 
111 |     We are not testing the full suite of possible bad params possible --
112 |     this should be already tested in simulation.parse_pipe_params unit tests.
113 |     """
114 | 
115 |     new = {"foo": "blaaaaaah"}
116 |     request = construct_dummy_request(method="PUT", data=json.dumps(new))
117 |     content = self.resource.render(request)
118 | 
119 |     self.assertEqual(request.responseCode, 400)
120 |     data = json.loads(content)
121 |     self.assertTrue("error" in data, data)
122 | 
123 |   def test_put_valid_request(self):
124 |     """Assert PUT requests actually change the simulation parameters."""
125 | 
126 |     new = {"foo": 128}
127 |     expected = {"foo": 128, "bar": 107}
128 | 
129 |     request = construct_dummy_request(method="PUT", data=json.dumps(new))
130 |     content = self.resource.render(request)
131 | 
132 |     # return proper state
133 |     self.assertEqual(json.loads(content), expected)
134 | 
135 |     # correctly set params
136 |     self.assertEqual(self.params, expected)
137 | 
138 |   def test_delete_request(self):
139 |     new = {"foo": 128}
140 | 
141 |     self.resource.render(
142 |         construct_dummy_request(method="PUT", data=json.dumps(new)))
143 | 
144 |     request = construct_dummy_request(method="DELETE")
145 |     content = self.resource.render(request)
146 | 
147 |     self.assertEqual(json.loads(content), self.BASE_PARAMS)
148 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 | 
  2 |                                  Apache License
  3 |                            Version 2.0, January 2004
  4 |                         http://www.apache.org/licenses/
  5 | 
  6 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  7 | 
  8 |    1. Definitions.
  9 | 
 10 |       "License" shall mean the terms and conditions for use, reproduction,
 11 |       and distribution as defined by Sections 1 through 9 of this document.
 12 | 
 13 |       "Licensor" shall mean the copyright owner or entity authorized by
 14 |       the copyright owner that is granting the License.
 15 | 
 16 |       "Legal Entity" shall mean the union of the acting entity and all
 17 |       other entities that control, are controlled by, or are under common
 18 |       control with that entity. For the purposes of this definition,
 19 |       "control" means (i) the power, direct or indirect, to cause the
 20 |       direction or management of such entity, whether by contract or
 21 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 22 |       outstanding shares, or (iii) beneficial ownership of such entity.
 23 | 
 24 |       "You" (or "Your") shall mean an individual or Legal Entity
 25 |       exercising permissions granted by this License.
 26 | 
 27 |       "Source" form shall mean the preferred form for making modifications,
 28 |       including but not limited to software source code, documentation
 29 |       source, and configuration files.
 30 | 
 31 |       "Object" form shall mean any form resulting from mechanical
 32 |       transformation or translation of a Source form, including but
 33 |       not limited to compiled object code, generated documentation,
 34 |       and conversions to other media types.
 35 | 
 36 |       "Work" shall mean the work of authorship, whether in Source or
 37 |       Object form, made available under the License, as indicated by a
 38 |       copyright notice that is included in or attached to the work
 39 |       (an example is provided in the Appendix below).
 40 | 
 41 |       "Derivative Works" shall mean any work, whether in Source or Object
 42 |       form, that is based on (or derived from) the Work and for which the
 43 |       editorial revisions, annotations, elaborations, or other modifications
 44 |       represent, as a whole, an original work of authorship. For the purposes
 45 |       of this License, Derivative Works shall not include works that remain
 46 |       separable from, or merely link (or bind by name) to the interfaces of,
 47 |       the Work and Derivative Works thereof.
 48 | 
 49 |       "Contribution" shall mean any work of authorship, including
 50 |       the original version of the Work and any modifications or additions
 51 |       to that Work or Derivative Works thereof, that is intentionally
 52 |       submitted to Licensor for inclusion in the Work by the copyright owner
 53 |       or by an individual or Legal Entity authorized to submit on behalf of
 54 |       the copyright owner. For the purposes of this definition, "submitted"
 55 |       means any form of electronic, verbal, or written communication sent
 56 |       to the Licensor or its representatives, including but not limited to
 57 |       communication on electronic mailing lists, source code control systems,
 58 |       and issue tracking systems that are managed by, or on behalf of, the
 59 |       Licensor for the purpose of discussing and improving the Work, but
 60 |       excluding communication that is conspicuously marked or otherwise
 61 |       designated in writing by the copyright owner as "Not a Contribution."
 62 | 
 63 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 64 |       on behalf of whom a Contribution has been received by Licensor and
 65 |       subsequently incorporated within the Work.
 66 | 
 67 |    2. Grant of Copyright License. Subject to the terms and conditions of
 68 |       this License, each Contributor hereby grants to You a perpetual,
 69 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 70 |       copyright license to reproduce, prepare Derivative Works of,
 71 |       publicly display, publicly perform, sublicense, and distribute the
 72 |       Work and such Derivative Works in Source or Object form.
 73 | 
 74 |    3. Grant of Patent License. Subject to the terms and conditions of
 75 |       this License, each Contributor hereby grants to You a perpetual,
 76 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 77 |       (except as stated in this section) patent license to make, have made,
 78 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 79 |       where such license applies only to those patent claims licensable
 80 |       by such Contributor that are necessarily infringed by their
 81 |       Contribution(s) alone or by combination of their Contribution(s)
 82 |       with the Work to which such Contribution(s) was submitted. If You
 83 |       institute patent litigation against any entity (including a
 84 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 85 |       or a Contribution incorporated within the Work constitutes direct
 86 |       or contributory patent infringement, then any patent licenses
 87 |       granted to You under this License for that Work shall terminate
 88 |       as of the date such litigation is filed.
 89 | 
 90 |    4. Redistribution. You may reproduce and distribute copies of the
 91 |       Work or Derivative Works thereof in any medium, with or without
 92 |       modifications, and in Source or Object form, provided that You
 93 |       meet the following conditions:
 94 | 
 95 |       (a) You must give any other recipients of the Work or
 96 |           Derivative Works a copy of this License; and
 97 | 
 98 |       (b) You must cause any modified files to carry prominent notices
 99 |           stating that You changed the files; and
100 | 
101 |       (c) You must retain, in the Source form of any Derivative Works
102 |           that You distribute, all copyright, patent, trademark, and
103 |           attribution notices from the Source form of the Work,
104 |           excluding those notices that do not pertain to any part of
105 |           the Derivative Works; and
106 | 
107 |       (d) If the Work includes a "NOTICE" text file as part of its
108 |           distribution, then any Derivative Works that You distribute must
109 |           include a readable copy of the attribution notices contained
110 |           within such NOTICE file, excluding those notices that do not
111 |           pertain to any part of the Derivative Works, in at least one
112 |           of the following places: within a NOTICE text file distributed
113 |           as part of the Derivative Works; within the Source form or
114 |           documentation, if provided along with the Derivative Works; or,
115 |           within a display generated by the Derivative Works, if and
116 |           wherever such third-party notices normally appear. The contents
117 |           of the NOTICE file are for informational purposes only and
118 |           do not modify the License. You may add Your own attribution
119 |           notices within Derivative Works that You distribute, alongside
120 |           or as an addendum to the NOTICE text from the Work, provided
121 |           that such additional attribution notices cannot be construed
122 |           as modifying the License.
123 | 
124 |       You may add Your own copyright statement to Your modifications and
125 |       may provide additional or different license terms and conditions
126 |       for use, reproduction, or distribution of Your modifications, or
127 |       for any such Derivative Works as a whole, provided Your use,
128 |       reproduction, and distribution of the Work otherwise complies with
129 |       the conditions stated in this License.
130 | 
131 |    5. Submission of Contributions. Unless You explicitly state otherwise,
132 |       any Contribution intentionally submitted for inclusion in the Work
133 |       by You to the Licensor shall be under the terms and conditions of
134 |       this License, without any additional terms or conditions.
135 |       Notwithstanding the above, nothing herein shall supersede or modify
136 |       the terms of any separate license agreement you may have executed
137 |       with Licensor regarding such Contributions.
138 | 
139 |    6. Trademarks. This License does not grant permission to use the trade
140 |       names, trademarks, service marks, or product names of the Licensor,
141 |       except as required for reasonable and customary use in describing the
142 |       origin of the Work and reproducing the content of the NOTICE file.
143 | 
144 |    7. Disclaimer of Warranty. Unless required by applicable law or
145 |       agreed to in writing, Licensor provides the Work (and each
146 |       Contributor provides its Contributions) on an "AS IS" BASIS,
147 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
148 |       implied, including, without limitation, any warranties or conditions
149 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
150 |       PARTICULAR PURPOSE. You are solely responsible for determining the
151 |       appropriateness of using or redistributing the Work and assume any
152 |       risks associated with Your exercise of permissions under this License.
153 | 
154 |    8. Limitation of Liability. In no event and under no legal theory,
155 |       whether in tort (including negligence), contract, or otherwise,
156 |       unless required by applicable law (such as deliberate and grossly
157 |       negligent acts) or agreed to in writing, shall any Contributor be
158 |       liable to You for damages, including any direct, indirect, special,
159 |       incidental, or consequential damages of any character arising as a
160 |       result of this License or out of the use or inability to use the
161 |       Work (including but not limited to damages for loss of goodwill,
162 |       work stoppage, computer failure or malfunction, or any and all
163 |       other commercial damages or losses), even if such Contributor
164 |       has been advised of the possibility of such damages.
165 | 
166 |    9. Accepting Warranty or Additional Liability. While redistributing
167 |       the Work or Derivative Works thereof, You may choose to offer,
168 |       and charge a fee for, acceptance of support, warranty, indemnity,
169 |       or other liability obligations and/or rights consistent with this
170 |       License. However, in accepting such obligations, You may act only
171 |       on Your own behalf and on Your sole responsibility, not on behalf
172 |       of any other Contributor, and only if You agree to indemnify,
173 |       defend, and hold each Contributor harmless for any liability
174 |       incurred by, or claims asserted against, such Contributor by reason
175 |       of your accepting any such warranty or additional liability.
176 | 
177 |    END OF TERMS AND CONDITIONS
178 | 
179 |    APPENDIX: How to apply the Apache License to your work.
180 | 
181 |       To apply the Apache License to your work, attach the following
182 |       boilerplate notice, with the fields enclosed by brackets "[]"
183 |       replaced with your own identifying information. (Don't include
184 |       the brackets!)  The text should be enclosed in the appropriate
185 |       comment syntax for the file format. We also recommend that a
186 |       file or class name and description of purpose be included on the
187 |       same "printed page" as the copyright notice for easier
188 |       identification within third-party archives.
189 | 
190 |    Copyright [yyyy] [name of copyright owner]
191 | 
192 |    Licensed under the Apache License, Version 2.0 (the "License");
193 |    you may not use this file except in compliance with the License.
194 |    You may obtain a copy of the License at
195 | 
196 |        http://www.apache.org/licenses/LICENSE-2.0
197 | 
198 |    Unless required by applicable law or agreed to in writing, software
199 |    distributed under the License is distributed on an "AS IS" BASIS,
200 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
201 |    See the License for the specific language governing permissions and
202 |    limitations under the License.
203 | 


--------------------------------------------------------------------------------
/packet_queue/web/smoothie.js:
--------------------------------------------------------------------------------
  1 | // MIT License:
  2 | //
  3 | // Copyright (c) 2010-2013, Joe Walnes
  4 | //               2013-2014, Drew Noakes
  5 | //
  6 | // Permission is hereby granted, free of charge, to any person obtaining a copy
  7 | // of this software and associated documentation files (the "Software"), to deal
  8 | // in the Software without restriction, including without limitation the rights
  9 | // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 10 | // copies of the Software, and to permit persons to whom the Software is
 11 | // furnished to do so, subject to the following conditions:
 12 | //
 13 | // The above copyright notice and this permission notice shall be included in
 14 | // all copies or substantial portions of the Software.
 15 | //
 16 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 17 | // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 18 | // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 19 | // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 20 | // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 21 | // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 22 | // THE SOFTWARE.
 23 | 
 24 | /**
 25 |  * Smoothie Charts - http://smoothiecharts.org/
 26 |  * (c) 2010-2013, Joe Walnes
 27 |  *     2013-2014, Drew Noakes
 28 |  *
 29 |  * v1.0: Main charting library, by Joe Walnes
 30 |  * v1.1: Auto scaling of axis, by Neil Dunn
 31 |  * v1.2: fps (frames per second) option, by Mathias Petterson
 32 |  * v1.3: Fix for divide by zero, by Paul Nikitochkin
 33 |  * v1.4: Set minimum, top-scale padding, remove timeseries, add optional timer to reset bounds, by Kelley Reynolds
 34 |  * v1.5: Set default frames per second to 50... smoother.
 35 |  *       .start(), .stop() methods for conserving CPU, by Dmitry Vyal
 36 |  *       options.interpolation = 'bezier' or 'line', by Dmitry Vyal
 37 |  *       options.maxValue to fix scale, by Dmitry Vyal
 38 |  * v1.6: minValue/maxValue will always get converted to floats, by Przemek Matylla
 39 |  * v1.7: options.grid.fillStyle may be a transparent color, by Dmitry A. Shashkin
 40 |  *       Smooth rescaling, by Kostas Michalopoulos
 41 |  * v1.8: Set max length to customize number of live points in the dataset with options.maxDataSetLength, by Krishna Narni
 42 |  * v1.9: Display timestamps along the bottom, by Nick and Stev-io
 43 |  *       (https://groups.google.com/forum/?fromgroups#!topic/smoothie-charts/-Ywse8FCpKI%5B1-25%5D)
 44 |  *       Refactored by Krishna Narni, to support timestamp formatting function
 45 |  * v1.10: Switch to requestAnimationFrame, removed the now obsoleted options.fps, by Gergely Imreh
 46 |  * v1.11: options.grid.sharpLines option added, by @drewnoakes
 47 |  *        Addressed warning seen in Firefox when seriesOption.fillStyle undefined, by @drewnoakes
 48 |  * v1.12: Support for horizontalLines added, by @drewnoakes
 49 |  *        Support for yRangeFunction callback added, by @drewnoakes
 50 |  * v1.13: Fixed typo (#32), by @alnikitich
 51 |  * v1.14: Timer cleared when last TimeSeries removed (#23), by @davidgaleano
 52 |  *        Fixed diagonal line on chart at start/end of data stream, by @drewnoakes
 53 |  * v1.15: Support for npm package (#18), by @dominictarr
 54 |  *        Fixed broken removeTimeSeries function (#24) by @davidgaleano
 55 |  *        Minor performance and tidying, by @drewnoakes
 56 |  * v1.16: Bug fix introduced in v1.14 relating to timer creation/clearance (#23), by @drewnoakes
 57 |  *        TimeSeries.append now deals with out-of-order timestamps, and can merge duplicates, by @zacwitte (#12)
 58 |  *        Documentation and some local variable renaming for clarity, by @drewnoakes
 59 |  * v1.17: Allow control over font size (#10), by @drewnoakes
 60 |  *        Timestamp text won't overlap, by @drewnoakes
 61 |  * v1.18: Allow control of max/min label precision, by @drewnoakes
 62 |  *        Added 'borderVisible' chart option, by @drewnoakes
 63 |  *        Allow drawing series with fill but no stroke (line), by @drewnoakes
 64 |  * v1.19: Avoid unnecessary repaints, and fixed flicker in old browsers having multiple charts in document (#40), by @asbai
 65 |  * v1.20: Add SmoothieChart.getTimeSeriesOptions and SmoothieChart.bringToFront functions, by @drewnoakes
 66 |  * v1.21: Add 'step' interpolation mode, by @drewnoakes
 67 |  * v1.22: Add support for different pixel ratios. Also add optional y limit formatters, by @copacetic
 68 |  * v1.23: Fix bug introduced in v1.22 (#44), by @drewnoakes
 69 |  * v1.24: Fix bug introduced in v1.23, re-adding parseFloat to y-axis formatter defaults, by @siggy_sf
 70 |  * v1.25: Fix bug seen when adding a data point to TimeSeries which is older than the current data, by @Nking92
 71 |  *        Draw time labels on top of series, by @comolosabia
 72 |  *        Add TimeSeries.clear function, by @drewnoakes
 73 |  * v1.26: Add support for resizing on high device pixel ratio screens, by @copacetic
 74 |  * v1.27: Fix bug introduced in v1.26 for non whole number devicePixelRatio values, by @zmbush
 75 |  * v1.28: Add 'minValueScale' option, by @megawac
 76 |  */
 77 | 
 78 | ;(function(exports) {
 79 | 
 80 |   var Util = {
 81 |     extend: function() {
 82 |       arguments[0] = arguments[0] || {};
 83 |       for (var i = 1; i < arguments.length; i++)
 84 |       {
 85 |         for (var key in arguments[i])
 86 |         {
 87 |           if (arguments[i].hasOwnProperty(key))
 88 |           {
 89 |             if (typeof(arguments[i][key]) === 'object') {
 90 |               if (arguments[i][key] instanceof Array) {
 91 |                 arguments[0][key] = arguments[i][key];
 92 |               } else {
 93 |                 arguments[0][key] = Util.extend(arguments[0][key], arguments[i][key]);
 94 |               }
 95 |             } else {
 96 |               arguments[0][key] = arguments[i][key];
 97 |             }
 98 |           }
 99 |         }
100 |       }
101 |       return arguments[0];
102 |     }
103 |   };
104 | 
105 |   /**
106 |    * Initialises a new <code>TimeSeries</code> with optional data options.
107 |    *
108 |    * Options are of the form (defaults shown):
109 |    *
110 |    * <pre>
111 |    * {
112 |    *   resetBounds: true,        // enables/disables automatic scaling of the y-axis
113 |    *   resetBoundsInterval: 3000 // the period between scaling calculations, in millis
114 |    * }
115 |    * </pre>
116 |    *
117 |    * Presentation options for TimeSeries are specified as an argument to <code>SmoothieChart.addTimeSeries</code>.
118 |    *
119 |    * @constructor
120 |    */
121 |   function TimeSeries(options) {
122 |     this.options = Util.extend({}, TimeSeries.defaultOptions, options);
123 |     this.clear();
124 |   }
125 | 
126 |   TimeSeries.defaultOptions = {
127 |     resetBoundsInterval: 3000,
128 |     resetBounds: true
129 |   };
130 | 
131 |   /**
132 |    * Clears all data and state from this TimeSeries object.
133 |    */
134 |   TimeSeries.prototype.clear = function() {
135 |     this.data = [];
136 |     this.maxValue = Number.NaN; // The maximum value ever seen in this TimeSeries.
137 |     this.minValue = Number.NaN; // The minimum value ever seen in this TimeSeries.
138 |   };
139 | 
140 |   /**
141 |    * Recalculate the min/max values for this <code>TimeSeries</code> object.
142 |    *
143 |    * This causes the graph to scale itself in the y-axis.
144 |    */
145 |   TimeSeries.prototype.resetBounds = function() {
146 |     if (this.data.length) {
147 |       // Walk through all data points, finding the min/max value
148 |       this.maxValue = this.data[0][1];
149 |       this.minValue = this.data[0][1];
150 |       for (var i = 1; i < this.data.length; i++) {
151 |         var value = this.data[i][1];
152 |         if (value > this.maxValue) {
153 |           this.maxValue = value;
154 |         }
155 |         if (value < this.minValue) {
156 |           this.minValue = value;
157 |         }
158 |       }
159 |     } else {
160 |       // No data exists, so set min/max to NaN
161 |       this.maxValue = Number.NaN;
162 |       this.minValue = Number.NaN;
163 |     }
164 |   };
165 | 
166 |   /**
167 |    * Adds a new data point to the <code>TimeSeries</code>, preserving chronological order.
168 |    *
169 |    * @param timestamp the position, in time, of this data point
170 |    * @param value the value of this data point
171 |    * @param sumRepeatedTimeStampValues if <code>timestamp</code> has an exact match in the series, this flag controls
172 |    * whether it is replaced, or the values summed (defaults to false.)
173 |    */
174 |   TimeSeries.prototype.append = function(timestamp, value, sumRepeatedTimeStampValues) {
175 |     // Rewind until we hit an older timestamp
176 |     var i = this.data.length - 1;
177 |     while (i >= 0 && this.data[i][0] > timestamp) {
178 |       i--;
179 |     }
180 | 
181 |     if (i === -1) {
182 |       // This new item is the oldest data
183 |       this.data.splice(0, 0, [timestamp, value]);
184 |     } else if (this.data.length > 0 && this.data[i][0] === timestamp) {
185 |       // Update existing values in the array
186 |       if (sumRepeatedTimeStampValues) {
187 |         // Sum this value into the existing 'bucket'
188 |         this.data[i][1] += value;
189 |         value = this.data[i][1];
190 |       } else {
191 |         // Replace the previous value
192 |         this.data[i][1] = value;
193 |       }
194 |     } else if (i < this.data.length - 1) {
195 |       // Splice into the correct position to keep timestamps in order
196 |       this.data.splice(i + 1, 0, [timestamp, value]);
197 |     } else {
198 |       // Add to the end of the array
199 |       this.data.push([timestamp, value]);
200 |     }
201 | 
202 |     this.maxValue = isNaN(this.maxValue) ? value : Math.max(this.maxValue, value);
203 |     this.minValue = isNaN(this.minValue) ? value : Math.min(this.minValue, value);
204 |   };
205 | 
206 |   TimeSeries.prototype.dropOldData = function(oldestValidTime, maxDataSetLength) {
207 |     // We must always keep one expired data point as we need this to draw the
208 |     // line that comes into the chart from the left, but any points prior to that can be removed.
209 |     var removeCount = 0;
210 |     while (this.data.length - removeCount >= maxDataSetLength && this.data[removeCount + 1][0] < oldestValidTime) {
211 |       removeCount++;
212 |     }
213 |     if (removeCount !== 0) {
214 |       this.data.splice(0, removeCount);
215 |     }
216 |   };
217 | 
218 |   /**
219 |    * Initialises a new <code>SmoothieChart</code>.
220 |    *
221 |    * Options are optional, and should be of the form below. Just specify the values you
222 |    * need and the rest will be given sensible defaults as shown:
223 |    *
224 |    * <pre>
225 |    * {
226 |    *   minValue: undefined,                      // specify to clamp the lower y-axis to a given value
227 |    *   maxValue: undefined,                      // specify to clamp the upper y-axis to a given value
228 |    *   maxValueScale: 1,                         // allows proportional padding to be added above the chart. for 10% padding, specify 1.1.
229 |    *   minValueScale: 1,                         // allows proportional padding to be added below the chart. for 10% padding, specify 1.1.
230 |    *   yRangeFunction: undefined,                // function({min: , max: }) { return {min: , max: }; }
231 |    *   scaleSmoothing: 0.125,                    // controls the rate at which y-value zoom animation occurs
232 |    *   millisPerPixel: 20,                       // sets the speed at which the chart pans by
233 |    *   enableDpiScaling: true,                   // support rendering at different DPI depending on the device
234 |    *   yMinFormatter: function(min, precision) { // callback function that formats the min y value label
235 |    *     return parseFloat(min).toFixed(precision);
236 |    *   },
237 |    *   yMaxFormatter: function(max, precision) { // callback function that formats the max y value label
238 |    *     return parseFloat(max).toFixed(precision);
239 |    *   },
240 |    *   maxDataSetLength: 2,
241 |    *   interpolation: 'bezier'                   // one of 'bezier', 'linear', or 'step'
242 |    *   timestampFormatter: null,                 // optional function to format time stamps for bottom of chart
243 |    *                                             // you may use SmoothieChart.timeFormatter, or your own: function(date) { return ''; }
244 |    *   scrollBackwards: false,                   // reverse the scroll direction of the chart
245 |    *   horizontalLines: [],                      // [ { value: 0, color: '#ffffff', lineWidth: 1 } ]
246 |    *   grid:
247 |    *   {
248 |    *     fillStyle: '#000000',                   // the background colour of the chart
249 |    *     lineWidth: 1,                           // the pixel width of grid lines
250 |    *     strokeStyle: '#777777',                 // colour of grid lines
251 |    *     millisPerLine: 1000,                    // distance between vertical grid lines
252 |    *     sharpLines: false,                      // controls whether grid lines are 1px sharp, or softened
253 |    *     verticalSections: 2,                    // number of vertical sections marked out by horizontal grid lines
254 |    *     borderVisible: true                     // whether the grid lines trace the border of the chart or not
255 |    *   },
256 |    *   labels
257 |    *   {
258 |    *     disabled: false,                        // enables/disables labels showing the min/max values
259 |    *     fillStyle: '#ffffff',                   // colour for text of labels,
260 |    *     fontSize: 15,
261 |    *     fontFamily: 'sans-serif',
262 |    *     precision: 2
263 |    *   }
264 |    * }
265 |    * </pre>
266 |    *
267 |    * @constructor
268 |    */
269 |   function SmoothieChart(options) {
270 |     this.options = Util.extend({}, SmoothieChart.defaultChartOptions, options);
271 |     this.seriesSet = [];
272 |     this.currentValueRange = 1;
273 |     this.currentVisMinValue = 0;
274 |     this.lastRenderTimeMillis = 0;
275 |   }
276 | 
277 |   SmoothieChart.defaultChartOptions = {
278 |     millisPerPixel: 20,
279 |     enableDpiScaling: true,
280 |     yMinFormatter: function(min, precision) {
281 |       return parseFloat(min).toFixed(precision);
282 |     },
283 |     yMaxFormatter: function(max, precision) {
284 |       return parseFloat(max).toFixed(precision);
285 |     },
286 |     maxValueScale: 1,
287 |     minValueScale: 1,
288 |     interpolation: 'bezier',
289 |     scaleSmoothing: 0.125,
290 |     maxDataSetLength: 2,
291 |     scrollBackwards: false,
292 |     grid: {
293 |       fillStyle: '#000000',
294 |       strokeStyle: '#777777',
295 |       lineWidth: 1,
296 |       sharpLines: false,
297 |       millisPerLine: 1000,
298 |       verticalSections: 2,
299 |       borderVisible: true
300 |     },
301 |     labels: {
302 |       fillStyle: '#ffffff',
303 |       disabled: false,
304 |       fontSize: 10,
305 |       fontFamily: 'monospace',
306 |       precision: 2
307 |     },
308 |     horizontalLines: []
309 |   };
310 | 
311 |   // Based on http://inspirit.github.com/jsfeat/js/compatibility.js
312 |   SmoothieChart.AnimateCompatibility = (function() {
313 |     var requestAnimationFrame = function(callback, element) {
314 |           var requestAnimationFrame =
315 |             window.requestAnimationFrame        ||
316 |             window.webkitRequestAnimationFrame  ||
317 |             window.mozRequestAnimationFrame     ||
318 |             window.oRequestAnimationFrame       ||
319 |             window.msRequestAnimationFrame      ||
320 |             function(callback) {
321 |               return window.setTimeout(function() {
322 |                 callback(new Date().getTime());
323 |               }, 16);
324 |             };
325 |           return requestAnimationFrame.call(window, callback, element);
326 |         },
327 |         cancelAnimationFrame = function(id) {
328 |           var cancelAnimationFrame =
329 |             window.cancelAnimationFrame ||
330 |             function(id) {
331 |               clearTimeout(id);
332 |             };
333 |           return cancelAnimationFrame.call(window, id);
334 |         };
335 | 
336 |     return {
337 |       requestAnimationFrame: requestAnimationFrame,
338 |       cancelAnimationFrame: cancelAnimationFrame
339 |     };
340 |   })();
341 | 
342 |   SmoothieChart.defaultSeriesPresentationOptions = {
343 |     lineWidth: 1,
344 |     strokeStyle: '#ffffff'
345 |   };
346 | 
347 |   /**
348 |    * Adds a <code>TimeSeries</code> to this chart, with optional presentation options.
349 |    *
350 |    * Presentation options should be of the form (defaults shown):
351 |    *
352 |    * <pre>
353 |    * {
354 |    *   lineWidth: 1,
355 |    *   strokeStyle: '#ffffff',
356 |    *   fillStyle: undefined
357 |    * }
358 |    * </pre>
359 |    */
360 |   SmoothieChart.prototype.addTimeSeries = function(timeSeries, options) {
361 |     this.seriesSet.push({timeSeries: timeSeries, options: Util.extend({}, SmoothieChart.defaultSeriesPresentationOptions, options)});
362 |     if (timeSeries.options.resetBounds && timeSeries.options.resetBoundsInterval > 0) {
363 |       timeSeries.resetBoundsTimerId = setInterval(
364 |         function() {
365 |           timeSeries.resetBounds();
366 |         },
367 |         timeSeries.options.resetBoundsInterval
368 |       );
369 |     }
370 |   };
371 | 
372 |   /**
373 |    * Removes the specified <code>TimeSeries</code> from the chart.
374 |    */
375 |   SmoothieChart.prototype.removeTimeSeries = function(timeSeries) {
376 |     // Find the correct timeseries to remove, and remove it
377 |     var numSeries = this.seriesSet.length;
378 |     for (var i = 0; i < numSeries; i++) {
379 |       if (this.seriesSet[i].timeSeries === timeSeries) {
380 |         this.seriesSet.splice(i, 1);
381 |         break;
382 |       }
383 |     }
384 |     // If a timer was operating for that timeseries, remove it
385 |     if (timeSeries.resetBoundsTimerId) {
386 |       // Stop resetting the bounds, if we were
387 |       clearInterval(timeSeries.resetBoundsTimerId);
388 |     }
389 |   };
390 | 
391 |   /**
392 |    * Gets render options for the specified <code>TimeSeries</code>.
393 |    *
394 |    * As you may use a single <code>TimeSeries</code> in multiple charts with different formatting in each usage,
395 |    * these settings are stored in the chart.
396 |    */
397 |   SmoothieChart.prototype.getTimeSeriesOptions = function(timeSeries) {
398 |     // Find the correct timeseries to remove, and remove it
399 |     var numSeries = this.seriesSet.length;
400 |     for (var i = 0; i < numSeries; i++) {
401 |       if (this.seriesSet[i].timeSeries === timeSeries) {
402 |         return this.seriesSet[i].options;
403 |       }
404 |     }
405 |   };
406 | 
407 |   /**
408 |    * Brings the specified <code>TimeSeries</code> to the top of the chart. It will be rendered last.
409 |    */
410 |   SmoothieChart.prototype.bringToFront = function(timeSeries) {
411 |     // Find the correct timeseries to remove, and remove it
412 |     var numSeries = this.seriesSet.length;
413 |     for (var i = 0; i < numSeries; i++) {
414 |       if (this.seriesSet[i].timeSeries === timeSeries) {
415 |         var set = this.seriesSet.splice(i, 1);
416 |         this.seriesSet.push(set[0]);
417 |         break;
418 |       }
419 |     }
420 |   };
421 | 
422 |   /**
423 |    * Instructs the <code>SmoothieChart</code> to start rendering to the provided canvas, with specified delay.
424 |    *
425 |    * @param canvas the target canvas element
426 |    * @param delayMillis an amount of time to wait before a data point is shown. This can prevent the end of the series
427 |    * from appearing on screen, with new values flashing into view, at the expense of some latency.
428 |    */
429 |   SmoothieChart.prototype.streamTo = function(canvas, delayMillis) {
430 |     this.canvas = canvas;
431 |     this.delay = delayMillis;
432 |     this.start();
433 |   };
434 | 
435 |   /**
436 |    * Make sure the canvas has the optimal resolution for the device's pixel ratio.
437 |    */
438 |   SmoothieChart.prototype.resize = function() {
439 |     // TODO this function doesn't handle the value of enableDpiScaling changing during execution
440 |     if (!this.options.enableDpiScaling || !window || window.devicePixelRatio === 1)
441 |       return;
442 | 
443 |     var dpr = window.devicePixelRatio;
444 |     var width = parseInt(this.canvas.getAttribute('width'));
445 |     var height = parseInt(this.canvas.getAttribute('height'));
446 | 
447 |     if (!this.originalWidth || (Math.floor(this.originalWidth * dpr) !== width)) {
448 |       this.originalWidth = width;
449 |       this.canvas.setAttribute('width', (Math.floor(width * dpr)).toString());
450 |       this.canvas.style.width = width + 'px';
451 |       this.canvas.getContext('2d').scale(dpr, dpr);
452 |     }
453 | 
454 |     if (!this.originalHeight || (Math.floor(this.originalHeight * dpr) !== height)) {
455 |       this.originalHeight = height;
456 |       this.canvas.setAttribute('height', (Math.floor(height * dpr)).toString());
457 |       this.canvas.style.height = height + 'px';
458 |       this.canvas.getContext('2d').scale(dpr, dpr);
459 |     }
460 |   };
461 | 
462 |   /**
463 |    * Starts the animation of this chart.
464 |    */
465 |   SmoothieChart.prototype.start = function() {
466 |     if (this.frame) {
467 |       // We're already running, so just return
468 |       return;
469 |     }
470 | 
471 |     // Renders a frame, and queues the next frame for later rendering
472 |     var animate = function() {
473 |       this.frame = SmoothieChart.AnimateCompatibility.requestAnimationFrame(function() {
474 |         this.render();
475 |         animate();
476 |       }.bind(this));
477 |     }.bind(this);
478 | 
479 |     animate();
480 |   };
481 | 
482 |   /**
483 |    * Stops the animation of this chart.
484 |    */
485 |   SmoothieChart.prototype.stop = function() {
486 |     if (this.frame) {
487 |       SmoothieChart.AnimateCompatibility.cancelAnimationFrame(this.frame);
488 |       delete this.frame;
489 |     }
490 |   };
491 | 
492 |   SmoothieChart.prototype.updateValueRange = function() {
493 |     // Calculate the current scale of the chart, from all time series.
494 |     var chartOptions = this.options,
495 |         chartMaxValue = Number.NaN,
496 |         chartMinValue = Number.NaN;
497 | 
498 |     for (var d = 0; d < this.seriesSet.length; d++) {
499 |       // TODO(ndunn): We could calculate / track these values as they stream in.
500 |       var timeSeries = this.seriesSet[d].timeSeries;
501 |       if (!isNaN(timeSeries.maxValue)) {
502 |         chartMaxValue = !isNaN(chartMaxValue) ? Math.max(chartMaxValue, timeSeries.maxValue) : timeSeries.maxValue;
503 |       }
504 | 
505 |       if (!isNaN(timeSeries.minValue)) {
506 |         chartMinValue = !isNaN(chartMinValue) ? Math.min(chartMinValue, timeSeries.minValue) : timeSeries.minValue;
507 |       }
508 |     }
509 | 
510 |     // Scale the chartMaxValue to add padding at the top if required
511 |     if (chartOptions.maxValue != null) {
512 |       chartMaxValue = chartOptions.maxValue;
513 |     } else {
514 |       chartMaxValue *= chartOptions.maxValueScale;
515 |     }
516 | 
517 |     // Set the minimum if we've specified one
518 |     if (chartOptions.minValue != null) {
519 |       chartMinValue = chartOptions.minValue;
520 |     } else {
521 |       chartMinValue -= Math.abs(chartMinValue * chartOptions.minValueScale - chartMinValue);
522 |     }
523 | 
524 |     // If a custom range function is set, call it
525 |     if (this.options.yRangeFunction) {
526 |       var range = this.options.yRangeFunction({min: chartMinValue, max: chartMaxValue});
527 |       chartMinValue = range.min;
528 |       chartMaxValue = range.max;
529 |     }
530 | 
531 |     if (!isNaN(chartMaxValue) && !isNaN(chartMinValue)) {
532 |       var targetValueRange = chartMaxValue - chartMinValue;
533 |       var valueRangeDiff = (targetValueRange - this.currentValueRange);
534 |       var minValueDiff = (chartMinValue - this.currentVisMinValue);
535 |       this.isAnimatingScale = Math.abs(valueRangeDiff) > 0.1 || Math.abs(minValueDiff) > 0.1;
536 |       this.currentValueRange += chartOptions.scaleSmoothing * valueRangeDiff;
537 |       this.currentVisMinValue += chartOptions.scaleSmoothing * minValueDiff;
538 |     }
539 | 
540 |     this.valueRange = { min: chartMinValue, max: chartMaxValue };
541 |   };
542 | 
543 |   SmoothieChart.prototype.render = function(canvas, time) {
544 |     var nowMillis = new Date().getTime();
545 | 
546 |     if (!this.isAnimatingScale) {
547 |       // We're not animating. We can use the last render time and the scroll speed to work out whether
548 |       // we actually need to paint anything yet. If not, we can return immediately.
549 | 
550 |       // Render at least every 1/6th of a second. The canvas may be resized, which there is
551 |       // no reliable way to detect.
552 |       var maxIdleMillis = Math.min(1000/6, this.options.millisPerPixel);
553 | 
554 |       if (nowMillis - this.lastRenderTimeMillis < maxIdleMillis) {
555 |         return;
556 |       }
557 |     }
558 | 
559 |     this.resize();
560 | 
561 |     this.lastRenderTimeMillis = nowMillis;
562 | 
563 |     canvas = canvas || this.canvas;
564 |     time = time || nowMillis - (this.delay || 0);
565 | 
566 |     // Round time down to pixel granularity, so motion appears smoother.
567 |     time -= time % this.options.millisPerPixel;
568 | 
569 |     var context = canvas.getContext('2d'),
570 |         chartOptions = this.options,
571 |         dimensions = { top: 0, left: 0, width: canvas.clientWidth, height: canvas.clientHeight },
572 |         // Calculate the threshold time for the oldest data points.
573 |         oldestValidTime = time - (dimensions.width * chartOptions.millisPerPixel),
574 |         valueToYPixel = function(value) {
575 |           var offset = value - this.currentVisMinValue;
576 |           return this.currentValueRange === 0
577 |             ? dimensions.height
578 |             : dimensions.height - (Math.round((offset / this.currentValueRange) * dimensions.height));
579 |         }.bind(this),
580 |         timeToXPixel = function(t) {
581 |           if(chartOptions.scrollBackwards) {
582 |             return Math.round((time - t) / chartOptions.millisPerPixel);
583 |           }
584 |           return Math.round(dimensions.width - ((time - t) / chartOptions.millisPerPixel));
585 |         };
586 | 
587 |     this.updateValueRange();
588 | 
589 |     context.font = chartOptions.labels.fontSize + 'px ' + chartOptions.labels.fontFamily;
590 | 
591 |     // Save the state of the canvas context, any transformations applied in this method
592 |     // will get removed from the stack at the end of this method when .restore() is called.
593 |     context.save();
594 | 
595 |     // Move the origin.
596 |     context.translate(dimensions.left, dimensions.top);
597 | 
598 |     // Create a clipped rectangle - anything we draw will be constrained to this rectangle.
599 |     // This prevents the occasional pixels from curves near the edges overrunning and creating
600 |     // screen cheese (that phrase should need no explanation).
601 |     context.beginPath();
602 |     context.rect(0, 0, dimensions.width, dimensions.height);
603 |     context.clip();
604 | 
605 |     // Clear the working area.
606 |     context.save();
607 |     context.fillStyle = chartOptions.grid.fillStyle;
608 |     context.clearRect(0, 0, dimensions.width, dimensions.height);
609 |     context.fillRect(0, 0, dimensions.width, dimensions.height);
610 |     context.restore();
611 | 
612 |     // Grid lines...
613 |     context.save();
614 |     context.lineWidth = chartOptions.grid.lineWidth;
615 |     context.strokeStyle = chartOptions.grid.strokeStyle;
616 |     // Vertical (time) dividers.
617 |     if (chartOptions.grid.millisPerLine > 0) {
618 |       context.beginPath();
619 |       for (var t = time - (time % chartOptions.grid.millisPerLine);
620 |            t >= oldestValidTime;
621 |            t -= chartOptions.grid.millisPerLine) {
622 |         var gx = timeToXPixel(t);
623 |         if (chartOptions.grid.sharpLines) {
624 |           gx -= 0.5;
625 |         }
626 |         context.moveTo(gx, 0);
627 |         context.lineTo(gx, dimensions.height);
628 |       }
629 |       context.stroke();
630 |       context.closePath();
631 |     }
632 | 
633 |     // Horizontal (value) dividers.
634 |     for (var v = 1; v < chartOptions.grid.verticalSections; v++) {
635 |       var gy = Math.round(v * dimensions.height / chartOptions.grid.verticalSections);
636 |       if (chartOptions.grid.sharpLines) {
637 |         gy -= 0.5;
638 |       }
639 |       context.beginPath();
640 |       context.moveTo(0, gy);
641 |       context.lineTo(dimensions.width, gy);
642 |       context.stroke();
643 |       context.closePath();
644 |     }
645 |     // Bounding rectangle.
646 |     if (chartOptions.grid.borderVisible) {
647 |       context.beginPath();
648 |       context.strokeRect(0, 0, dimensions.width, dimensions.height);
649 |       context.closePath();
650 |     }
651 |     context.restore();
652 | 
653 |     // Draw any horizontal lines...
654 |     if (chartOptions.horizontalLines && chartOptions.horizontalLines.length) {
655 |       for (var hl = 0; hl < chartOptions.horizontalLines.length; hl++) {
656 |         var line = chartOptions.horizontalLines[hl],
657 |             hly = Math.round(valueToYPixel(line.value)) - 0.5;
658 |         context.strokeStyle = line.color || '#ffffff';
659 |         context.lineWidth = line.lineWidth || 1;
660 |         context.beginPath();
661 |         context.moveTo(0, hly);
662 |         context.lineTo(dimensions.width, hly);
663 |         context.stroke();
664 |         context.closePath();
665 |       }
666 |     }
667 | 
668 |     // For each data set...
669 |     for (var d = 0; d < this.seriesSet.length; d++) {
670 |       context.save();
671 |       var timeSeries = this.seriesSet[d].timeSeries,
672 |           dataSet = timeSeries.data,
673 |           seriesOptions = this.seriesSet[d].options;
674 | 
675 |       // Delete old data that's moved off the left of the chart.
676 |       timeSeries.dropOldData(oldestValidTime, chartOptions.maxDataSetLength);
677 | 
678 |       // Set style for this dataSet.
679 |       context.lineWidth = seriesOptions.lineWidth;
680 |       context.strokeStyle = seriesOptions.strokeStyle;
681 |       // Draw the line...
682 |       context.beginPath();
683 |       // Retain lastX, lastY for calculating the control points of bezier curves.
684 |       var firstX = 0, lastX = 0, lastY = 0;
685 |       for (var i = 0; i < dataSet.length && dataSet.length !== 1; i++) {
686 |         var x = timeToXPixel(dataSet[i][0]),
687 |             y = valueToYPixel(dataSet[i][1]);
688 | 
689 |         if (i === 0) {
690 |           firstX = x;
691 |           context.moveTo(x, y);
692 |         } else {
693 |           switch (chartOptions.interpolation) {
694 |             case "linear":
695 |             case "line": {
696 |               context.lineTo(x,y);
697 |               break;
698 |             }
699 |             case "bezier":
700 |             default: {
701 |               // Great explanation of Bezier curves: http://en.wikipedia.org/wiki/Bezier_curve#Quadratic_curves
702 |               //
703 |               // Assuming A was the last point in the line plotted and B is the new point,
704 |               // we draw a curve with control points P and Q as below.
705 |               //
706 |               // A---P
707 |               //     |
708 |               //     |
709 |               //     |
710 |               //     Q---B
711 |               //
712 |               // Importantly, A and P are at the same y coordinate, as are B and Q. This is
713 |               // so adjacent curves appear to flow as one.
714 |               //
715 |               context.bezierCurveTo( // startPoint (A) is implicit from last iteration of loop
716 |                 Math.round((lastX + x) / 2), lastY, // controlPoint1 (P)
717 |                 Math.round((lastX + x)) / 2, y, // controlPoint2 (Q)
718 |                 x, y); // endPoint (B)
719 |               break;
720 |             }
721 |             case "step": {
722 |               context.lineTo(x,lastY);
723 |               context.lineTo(x,y);
724 |               break;
725 |             }
726 |           }
727 |         }
728 | 
729 |         lastX = x; lastY = y;
730 |       }
731 | 
732 |       if (dataSet.length > 1) {
733 |         if (seriesOptions.fillStyle) {
734 |           // Close up the fill region.
735 |           context.lineTo(dimensions.width + seriesOptions.lineWidth + 1, lastY);
736 |           context.lineTo(dimensions.width + seriesOptions.lineWidth + 1, dimensions.height + seriesOptions.lineWidth + 1);
737 |           context.lineTo(firstX, dimensions.height + seriesOptions.lineWidth);
738 |           context.fillStyle = seriesOptions.fillStyle;
739 |           context.fill();
740 |         }
741 | 
742 |         if (seriesOptions.strokeStyle && seriesOptions.strokeStyle !== 'none') {
743 |           context.stroke();
744 |         }
745 |         context.closePath();
746 |       }
747 |       context.restore();
748 |     }
749 | 
750 |     // Draw the axis values on the chart.
751 |     if (!chartOptions.labels.disabled && !isNaN(this.valueRange.min) && !isNaN(this.valueRange.max)) {
752 |       var maxValueString = chartOptions.yMaxFormatter(this.valueRange.max, chartOptions.labels.precision),
753 |           minValueString = chartOptions.yMinFormatter(this.valueRange.min, chartOptions.labels.precision),
754 |           labelPos = chartOptions.scrollBackwards ? 0 : dimensions.width - context.measureText(maxValueString).width - 2;
755 |       context.fillStyle = chartOptions.labels.fillStyle;
756 |       context.fillText(maxValueString, labelPos, chartOptions.labels.fontSize);
757 |       context.fillText(minValueString, labelPos, dimensions.height - 2);
758 |     }
759 | 
760 |     // Display timestamps along x-axis at the bottom of the chart.
761 |     if (chartOptions.timestampFormatter && chartOptions.grid.millisPerLine > 0) {
762 |       var textUntilX = chartOptions.scrollBackwards
763 |         ? context.measureText(minValueString).width
764 |         : dimensions.width - context.measureText(minValueString).width + 4;
765 |       for (var t = time - (time % chartOptions.grid.millisPerLine);
766 |            t >= oldestValidTime;
767 |            t -= chartOptions.grid.millisPerLine) {
768 |         var gx = timeToXPixel(t);
769 |         // Only draw the timestamp if it won't overlap with the previously drawn one.
770 |         if ((!chartOptions.scrollBackwards && gx < textUntilX) || (chartOptions.scrollBackwards && gx > textUntilX))  {
771 |           // Formats the timestamp based on user specified formatting function
772 |           // SmoothieChart.timeFormatter function above is one such formatting option
773 |           var tx = new Date(t),
774 |             ts = chartOptions.timestampFormatter(tx),
775 |             tsWidth = context.measureText(ts).width;
776 | 
777 |           textUntilX = chartOptions.scrollBackwards
778 |             ? gx + tsWidth + 2
779 |             : gx - tsWidth - 2;
780 | 
781 |           context.fillStyle = chartOptions.labels.fillStyle;
782 |           if(chartOptions.scrollBackwards) {
783 |             context.fillText(ts, gx, dimensions.height - 2);
784 |           } else {
785 |             context.fillText(ts, gx - tsWidth, dimensions.height - 2);
786 |           }
787 |         }
788 |       }
789 |     }
790 | 
791 |     context.restore(); // See .save() above.
792 |   };
793 | 
794 |   // Sample timestamp formatting function
795 |   SmoothieChart.timeFormatter = function(date) {
796 |     function pad2(number) { return (number < 10 ? '0' : '') + number }
797 |     return pad2(date.getHours()) + ':' + pad2(date.getMinutes()) + ':' + pad2(date.getSeconds());
798 |   };
799 | 
800 |   exports.TimeSeries = TimeSeries;
801 |   exports.SmoothieChart = SmoothieChart;
802 | 
803 | })(typeof exports === 'undefined' ? this : exports);
804 | 
805 | 


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