def query(cls, **args):
data = {'model': cls.__name__}
data.update(
dict(('{0}_{1}'.format(cls.__name__, key), value)
for key, value in list(args.items())))
code, reason, response = get_request(query_url, data, encode, decode,
headers, timeout, monitor)
if (code // 100 != 2):
if monitor: monitor({'status': "error", 'reason': reason.lower()})
raise BadResponseError(code, reason, response)
if response is None:
if monitor:
monitor({
'status': "error",
'reason': "invalid response format"
})
raise BadResponseError(code, reason, response)
message = None
try:
message = BaseMessage(response)
except KeyError:
if monitor:
monitor({
'status': "error",
'reason': "invalid message format"
})
raise BadResponseError("response object isn't a valid BaseMessage",
response)
return message.query(cls).all()
def handle_repair(data=None, session=None):
"Handle repair request. Return whole server database."
include_extensions = 'exclude_extensions' not in (data or {})
latest_version_id = core.get_latest_version_id(session=session)
message = BaseMessage()
for model in list(core.synched_models.models.keys()):
for obj in query_model(session, model):
message.add_object(obj, include_extensions=include_extensions)
response = message.to_json()
response['latest_version_id'] = latest_version_id
return response
def handle_repair(data=None, session=None):
"Handle repair request. Return whole server database."
include_extensions = 'exclude_extensions' not in (data or {})
latest_version_id = core.get_latest_version_id(session=session)
message = BaseMessage()
for model in core.synched_models.models.iterkeys():
for obj in query_model(session, model):
message.add_object(obj, include_extensions=include_extensions)
response = message.to_json()
response['latest_version_id'] = latest_version_id
return response
def handle_query(data, session=None):
"Responds to a query request."
model = core.synched_models.model_names.\
get(data.get('model', None), core.null_model).model
if model is None: return None
mname = model.__name__
filters = dict((k, v) for k, v in ((k[len(mname) + 1:], v)
for k, v in list(data.items())
if k.startswith(mname + '_'))
if k and k in column_properties(model))
message = BaseMessage()
q = query_model(session, model)
if filters:
q = q.filter_by(**filters)
for obj in q:
message.add_object(obj)
return message.to_json()
def handle_query(data, session=None):
"Responds to a query request."
model = core.synched_models.model_names.\
get(data.get('model', None), core.null_model).model
if model is None: return None
mname = model.__name__
filters = dict((k, v) for k, v in ((k[len(mname) + 1:], v)
for k, v in data.iteritems()
if k.startswith(mname + '_'))
if k and k in column_properties(model))
message = BaseMessage()
q = query_model(session, model)
if filters:
q = q.filter_by(**filters)
for obj in q:
message.add_object(obj)
return message.to_json()
def repair(repair_url,
include_extensions=True,
extra_data=None,
encode=None,
decode=None,
headers=None,
timeout=None,
monitor=None):
"""
Fetches the server database and replaces the local one with it.
*include_extensions* includes or excludes extension fields from
the operation.
*extra_data* can be used to add user credentials.
By default, the *encode* function is ``json.dumps``, the *decode*
function is ``json.loads``, and the *headers* are appropriate HTTP
headers for JSON.
"""
assert isinstance(repair_url, str), "repair url must be a string"
assert bool(repair_url), "repair url can't be empty"
if extra_data is not None:
assert isinstance(extra_data, dict), "extra data must be a dictionary"
assert 'exclude_extensions' not in extra_data, "reserved request key"
data = {'exclude_extensions': ""} if not include_extensions else {}
data.update(extra_data or {})
code, reason, response = get_request(repair_url, data, encode, decode,
headers, timeout, monitor)
if (code // 100 != 2):
if monitor: monitor({'status': "error", 'reason': reason.lower()})
raise BadResponseError(code, reason, response)
if response is None:
if monitor:
monitor({'status': "error", 'reason': "invalid response format"})
raise BadResponseError(code, reason, response)
message = None
try:
message = BaseMessage(response)
except KeyError:
if monitor:
monitor({'status': "error", 'reason': "invalid message format"})
raise BadResponseError("response object isn't a valid BaseMessage",
response)
if monitor: monitor({'status': "repairing"})
repair_database(message,
response.get("latest_version_id", None),
include_extensions=include_extensions)
if monitor: monitor({'status': "done"})
return response
def query(cls, **args):
data = {'model': cls.__name__}
data.update(dict(('{0}_{1}'.format(cls.__name__, key), value)
for key, value in args.iteritems()))
code, reason, response = get_request(
query_url, data, encode, decode, headers, timeout, monitor)
if (code // 100 != 2):
if monitor: monitor({'status': "error", 'reason': reason.lower()})
raise BadResponseError(code, reason, response)
if response is None:
if monitor: monitor({'status': "error",
'reason': "invalid response format"})
raise BadResponseError(code, reason, response)
message = None
try:
message = BaseMessage(response)
except KeyError:
if monitor: monitor({'status': "error",
'reason': "invalid message format"})
raise BadResponseError(
"response object isn't a valid BaseMessage", response)
return message.query(cls).all()
