1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
#!/usr/bin/env python
# encoding: utf-8
import functools
import Queue
import threading
import time
import zmq
from leap.bitmask.backend.api import API, STOP_REQUEST
from leap.bitmask.backend.utils import get_backend_certificates
import logging
logger = logging.getLogger(__name__)
class BackendProxy(object):
"""
The BackendProxy handles calls from the GUI and forwards (through ZMQ)
to the backend.
"""
PORT = '5556'
SERVER = "tcp://localhost:%s" % PORT
def __init__(self):
self._socket = None
# initialize ZMQ stuff:
context = zmq.Context()
logger.debug("Connecting to server...")
socket = context.socket(zmq.REQ)
# public, secret = zmq.curve_keypair()
client_keys = zmq.curve_keypair()
socket.curve_publickey = client_keys[0]
socket.curve_secretkey = client_keys[1]
# The client must know the server's public key to make a CURVE
# connection.
public, _ = get_backend_certificates()
socket.curve_serverkey = public
socket.setsockopt(zmq.RCVTIMEO, 1000)
socket.connect(self.SERVER)
self._socket = socket
self._call_queue = Queue.Queue()
self._worker_caller = threading.Thread(target=self._worker)
self._worker_caller.start()
def _worker(self):
"""
Worker loop that processes the Queue of pending requests to do.
"""
while True:
try:
request = self._call_queue.get(block=False)
# break the loop after sending the 'stop' action to the
# backend.
if request == STOP_REQUEST:
break
self._send_request(request)
except Queue.Empty:
pass
time.sleep(0.01)
logger.debug("BackendProxy worker stopped.")
def _api_call(self, *args, **kwargs):
"""
Call the `api_method` method in backend (through zmq).
:param kwargs: named arguments to forward to the backend api method.
:type kwargs: dict
Note: is mandatory to have the kwarg 'api_method' defined.
"""
if args:
# Use a custom message to be more clear about using kwargs *only*
raise Exception("All arguments need to be kwargs!")
api_method = kwargs.pop('api_method', None)
if api_method is None:
raise Exception("Missing argument, no method name specified.")
request = {
'api_method': api_method,
'arguments': kwargs,
}
try:
request_json = zmq.utils.jsonapi.dumps(request)
except Exception as e:
msg = ("Error serializing request into JSON.\n"
"Exception: {0} Data: {1}")
msg = msg.format(e, request)
logger.critical(msg)
raise
# queue the call in order to handle the request in a thread safe way.
self._call_queue.put(request_json)
if api_method == STOP_REQUEST:
self._call_queue.put(STOP_REQUEST)
def _send_request(self, request):
"""
Send the given request to the server.
This is used from a thread safe loop in order to avoid sending a
request without receiving a response from a previous one.
:param request: the request to send.
:type request: str
"""
logger.debug("Sending request to backend: {0}".format(request))
self._socket.send(request)
try:
# Get the reply.
response = self._socket.recv()
msg = "Received reply for '{0}' -> '{1}'".format(request, response)
logger.debug(msg)
except zmq.error.Again as e:
msg = "Timeout error contacting backend. {0!r}".format(e)
logger.critical(msg)
def __getattribute__(self, name):
"""
This allows the user to do:
bp = BackendProxy()
bp.some_method()
Just by having defined 'some_method' in the API
:param name: the attribute name that is requested.
:type name: str
"""
if name in API:
return functools.partial(self._api_call, api_method=name)
else:
return object.__getattribute__(self, name)
|
