def search(request):
# Handle search requests
query = request.GET['q']
if not query or query == "":
return HttpResonse(simplejson.encode(GetSiteList()))
else:
# FIXME: This isn't actually a real search function at the moment.
return HttpResonse(simplejson.encode(GetSiteList()))
def identity_handler(self, conn, msg):
mod = "%s:%s" % (self.__class__.__name__, sys._getframe().f_code.co_name)
self.log.debug("%s:<--%s" % (mod, msg))
pdb.set_trace()
ip = self.get_lan_ip()
keys = ['domain', 'name', 'my_role', 'id']
response = {
"result": {
"name": ("controller:%s" % ip),
"my_roles": ["controller"],
"domain": "my_domeain",
"id": "24df1d04-d5cb-41e1-8de5-61ed77c558df",
"roles": [{"role": "controller", "connectivity_info": ("%s" % ip)},
{"role": "repository", "connectivity_info": ("%s" % ip)}]
}
}
self.log.info("IDENTITY: %s" % msg)
if (self.validate_keys(keys, msg['params'])):
json_rsp = json.encode(response);
self.log.debug("%s: json_rsp=%s", mod, json_rsp)
conn.send(json_rsp)
else:
self.log.error("%s: JSON message validation error: expected keys=%s, actual=%s",
mod, keys, msg['params'].keys())
self.log.debug("%s:<--" % (mod))
def addsite(request):
# Handle Add Site requests
response = {'saved': False, 'error': "Not handled"}
siteform = SiteForm(request.GET)
if not request.user.is_authenticated():
response["error"] = "You must be logged in to register sites."
return HttpResponse(simplejson.encode(response))
if siteform.is_valid():
site = siteform.save(commit=False)
site.manager = request.user
site.save()
response["saved"] = True
return HttpResponse(simplejson.encode(response))
else:
response["error"] = "Must fill required fields."
response["newtable"] = siteform.as_table()
return HttpResponse(simplejson.encode(response))
def _obfuscate_event(self, event):
"""Obfuscate event by removing/stubbing user information."""
# Create a string to use when logging errors, to provide some context.
debug_str = self._get_log_string_for_event(event)
# Remap the user information stored in the event, and collect for later searching.
event_data = eventlog.get_event_data(event)
user_info = self._remap_user_info_in_event(event, event_data)
# Clean or remove values from context.
if 'context' in event:
# These aren't present in current events, but are generated historically by some implicit events.
event['context'].pop('host', None)
event['context'].pop('ip', None)
# Not sure how to clean this, so removing.
event['context'].pop('path', None)
# Clean out some of the more obvious values in (mobile) client:
if 'client' in event['context']:
event['context']['client'].pop('device', None)
event['context']['client'].pop('ip', None)
# Do remaining cleanup on the entire event payload (assuming user-based remapping has been done).
if event_data:
# Remove possibly sensitive payload fields (or fields we don't know how to clean).
for key in [
'certificate_id', 'certificate_url', 'source_url', 'fileName', 'GET', 'POST',
'requesting_student_id', 'report_url', 'url', 'url_name']:
event_data.pop(key, None)
for key in ['answer', 'saved_response']:
if key in event_data and 'file_upload_key' in event_data[key]:
event_data[key].pop('file_upload_key')
# Clean up remaining event payload recursively.
updated_event_data = self.obfuscator.obfuscate_structure(event_data, u"event", user_info)
if updated_event_data is not None:
if self.obfuscator.is_logging_enabled():
log.info(u"Obfuscated payload: %s", debug_str)
event_data = updated_event_data
# Re-encode payload as a json string if it originally was one.
# (This test works because we throw away string values that didn't parse as JSON.)
if isinstance(event.get('event'), basestring):
event['event'] = simplejson.encode(event_data)
else:
event['event'] = event_data
# Delete base properties other than username.
for key in ['host', 'ip', 'page', 'referer']:
event.pop(key, None)
return event
def setsite(request):
if not request.has_key('siteid'):
return HttpResponse(simplejson.encode({'error': 'Must supply site ID'}))
siteid = request.GET['siteid']
vars = {}
for a in ('name', 'locname', 'latitude', 'longitude', 'website', 'access'):
if request.GET.has_key(a):
vars[a] = request.GET[a]
else:
vars[a] = None
SetSite(siteid, **vars)
def request(self, method, params=None):
"""
Creates a new request using the passed method and parameters.
"""
req_id = generate_random_uuid().hex
req = {
'jsonrpc': self.rpc_version,
'method': method,
'id': req_id,
}
if params:
req['params'] = params
enc_req = encode(req)
self._c.send(enc_req)
enc_res = self._c.recv(self.buffer_size)
res = decode(enc_res)
if res.get('id') != req_id:
raise RuntimeError("Received unexpected response: %s" \
% (res, ))
return res.get('result')
def filter_row(self, row):
user_id = row[3]
user_info = {'user_id': [user_id, ]}
try:
user_id = int(user_id)
entry = self.user_by_id[user_id]
if 'username' in entry:
user_info['username'] = [entry['username'], ]
if 'name' in entry:
user_info['name'] = [entry['name'], ]
except KeyError:
log.error("Unable to find CWSM user_id: %r in the user_by_id map of size %s", user_id, len(self.user_by_id))
row[3] = self.remap_id(user_id) # student_id
# Courseware_studentmodule is not processed with the other SQL tables, so it
# is not escaped in the same way. In particular, we will not decode and encode it,
# but merely transform double backslashes.
state_str = row[4].replace('\\\\', '\\')
try:
state_dict = simplejson.decode(state_str, all_unicode=True)
# Traverse the dictionary, looking for entries that need to be scrubbed.
updated_state_dict = self.obfuscator.obfuscate_structure(state_dict, u"state", user_info)
except Exception: # pylint: disable=broad-except
log.exception(u"Unable to parse state as JSON for record %s: type = %s, state = %r",
row[0], type(state_str), state_str)
updated_state_dict = {}
if updated_state_dict is not None:
# Can't reset values, so update original fields.
updated_state = simplejson.encode(updated_state_dict).replace('\\', '\\\\')
row[4] = updated_state
if self.obfuscator.is_logging_enabled():
log.info(u"Obfuscated state for user_id '%s' module_id '%s'", user_id, row[2])
return row
def show_json(json):
colorful_json = highlight(json.encode('UTF-8'), lexers.JsonLexer(),
formatters.TerminalFormatter())
print(colorful_json)
def post(self):
client = subscribeme.api.oauth.OAuthClient('twitter', self)
self.response.out.write(simplejson.encode(
{'auth_cookie': client.get_cookie()}))
def sitedetails(request):
# Return very detailed information about a site.
if not request.GET.has_key('siteid'):
return HttpResponse(simplejson.encode({'error': 'Must supply ID'}))
return HttpResponse(simplejson.encode(GetSiteDetails(request.GET['siteid'])))
def getsite(request):
if not request.GET['siteid']:
return HttpResponse(simplejson.encode({'error': 'Must supply site ID'}))
return HttpResponse(simplejson.encode(GetSiteDetails(request.GET['siteid'])))
def encode_json(obj):
"""Wrapper to re-encode JSON string in an implementation-independent way."""
# TODO: Verify correctness of simplejson
return simplejson.encode(obj)
def save(self, _path=None):
fd = open(_path if _path else self._local_file, 'w')
fd.write(encode(self._local, indent=" "))
