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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
|
# Copyright (C) 2012 Aleksey Lim
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import logging
import hashlib
import tempfile
from os.path import exists, join
import active_document as ad
from sugar_network import node
from sugar_network.node.sync_master import SyncCommands
from sugar_network.resources.volume import Commands
from sugar_network.toolkit import router
from active_toolkit import util, enforce
_DEFAULT_MASTER_GUID = 'api-testing.network.sugarlabs.org'
_logger = logging.getLogger('node.commands')
class NodeCommands(ad.VolumeCommands, Commands):
def __init__(self, volume):
ad.VolumeCommands.__init__(self, volume)
Commands.__init__(self)
self._is_master = False
node_path = join(volume.root, 'node')
master_path = join(volume.root, 'master')
if exists(node_path):
with file(node_path) as f:
self._guid = f.read().strip()
elif exists(master_path):
with file(master_path) as f:
self._guid = f.read().strip()
self._is_master = True
else:
self._guid = ad.uuid()
with file(node_path, 'w') as f:
f.write(self._guid)
if not self._is_master and not exists(master_path):
with file(master_path, 'w') as f:
f.write(_DEFAULT_MASTER_GUID)
@property
def is_master(self):
return self._is_master
def connect(self, callback, condition=None, **kwargs):
self.volume.connect(callback, condition)
@ad.volume_command(method='GET', mime_type='text/html')
def hello(self):
return _HELLO_HTML
@ad.volume_command(method='GET', cmd='stat',
mime_type='application/json')
def stat(self):
return {'guid': self._guid,
'master': self._is_master,
'seqno': self.volume.seqno.value,
}
@ad.document_command(method='DELETE',
permissions=ad.ACCESS_AUTH | ad.ACCESS_AUTHOR)
def delete(self, document, guid):
# Servers data should not be deleted immediately
# to let master-node synchronization possible
directory = self.volume[document]
directory.update(guid, {'layer': ['deleted']})
def resolve(self, request):
cmd = ad.VolumeCommands.resolve(self, request)
if cmd is None:
return
if cmd.permissions & ad.ACCESS_AUTH:
enforce(request.principal is not None, router.Unauthorized,
'User is not authenticated')
if cmd.permissions & ad.ACCESS_AUTHOR and 'guid' in request:
doc = self.volume[request['document']].get(request['guid'])
enforce(request.principal in doc['user'], ad.Forbidden,
'Operation is permitted only for authors')
return cmd
def before_create(self, request, props):
if request['document'] == 'user':
props['guid'], props['pubkey'] = _load_pubkey(props['pubkey'])
else:
props['user'] = [request.principal]
self._set_author(props)
if self._is_master and 'implement' in props:
implement = props['implement']
if not isinstance(implement, basestring):
implement = implement[0]
props['guid'] = implement
ad.VolumeCommands.before_create(self, request, props)
def before_update(self, request, props):
if 'user' in props:
self._set_author(props)
ad.VolumeCommands.before_update(self, request, props)
@ad.directory_command_pre(method='GET')
def _NodeCommands_find_pre(self, request):
if 'limit' not in request:
request['limit'] = node.find_limit.value
elif request['limit'] > node.find_limit.value:
_logger.warning('The find limit is restricted to %s',
node.find_limit.value)
request['limit'] = node.find_limit.value
layer = request.get('layer', ['public'])
if 'deleted' in layer:
_logger.warning('Requesting "deleted" layer')
layer.remove('deleted')
request['layer'] = layer
@ad.document_command_post(method='GET')
def _NodeCommands_get_post(self, request, response, result):
directory = self.volume[request['document']]
doc = directory.get(request['guid'])
enforce('deleted' not in doc['layer'], ad.NotFound,
'Document deleted')
return result
def _set_author(self, props):
users = self.volume['user']
authors = []
for user_guid in props['user']:
if not users.exists(user_guid):
_logger.warning('No %r user to set author property',
user_guid)
continue
user = users.get(user_guid)
if user['name']:
authors.append(user['name'])
props['author'] = authors
class MasterCommands(NodeCommands, SyncCommands):
def __init__(self, volume):
NodeCommands.__init__(self, volume)
SyncCommands.__init__(self)
@ad.document_command(method='PUT', cmd='merge',
permissions=ad.ACCESS_AUTH)
def merge(self, document, guid, request):
directory = self.volume[document]
directory.merge(guid, request.content)
def _load_pubkey(pubkey):
pubkey = pubkey.strip()
try:
with tempfile.NamedTemporaryFile() as key_file:
key_file.file.write(pubkey)
key_file.file.flush()
# SSH key needs to be converted to PKCS8 to ket M2Crypto read it
pubkey_pkcs8 = util.assert_call(
['ssh-keygen', '-f', key_file.name, '-e', '-m', 'PKCS8'])
except Exception:
message = 'Cannot read DSS public key gotten for registeration'
util.exception(message)
if node.trust_users.value:
logging.warning('Failed to read registration pubkey, '
'but we trust users')
# Keep SSH key for further converting to PKCS8
pubkey_pkcs8 = pubkey
else:
raise ad.Forbidden(message)
return str(hashlib.sha1(pubkey.split()[1]).hexdigest()), pubkey_pkcs8
_HELLO_HTML = """\
<h2>Welcome to Sugar Network API!</h2>
Consult <a href="http://wiki.sugarlabs.org/go/Platform_Team/Sugar_Network/API">
Sugar Labs Wiki</a> to learn how it can be used.
"""
|
