def writeResourceToStorage(self, resource_name, resource_def):
"""
Store a resource definition.
No return value, but raises GluException if there is an issue.
@param resource_name: The storage name for this resource
@type resource_name: string
@param resource_def: The dictionary containing the resource definition.
@type resource_def: dict
@raise GluException: If the resource cannot be stored.
"""
try:
existing_resources = ResourceStorage.gql("WHERE name = :1", resource_name)
try:
# Make sure we update old ones
resource = existing_resources[0]
except Exception, e:
# No old ones? Make a new one.
resource = ResourceStorage()
resource.name = resource_name
resource.data = json.dumps(resource_def)
resource.put()
return "No error"
def render(self, data, top_level=False):
"""
Render the provided data for output.
@param data: An object containing the data to be rendered.
@param data: object
@param top_level: Flag indicating whether this we are at the
top level for output (this function is called
recursively and therefore may not always find
itself at the top level). This is important for
some renderers, since they can insert any framing
elements that might be required at the top level.
However, for the JSON renderer this is just
ignored.
@param top_level: boolean
@return: Output buffer with completed representation.
@rtype: string
"""
# simplejson can only handle some of the base Python datatypes.
# Since we also have other types in the output dictionaries (URIs
# for example), we need to provide a 'default' method, which
# simplejson calls in case it doesn't know what to do.
# Need to use our newly defined Url encoder, since otherwise
# json wouldn't know how to encode a URL
if PLATFORM == PLATFORM_GAE:
# That doesn't seem to be supported when running in
# GAE, though. So, in that case we first perform a very
# manual fixup of the object, replacing all occurrances
# of unusual types with their string representations.
data = _recursive_type_fixer(data)
out = json.dumps(data, sort_keys=True, indent=4)
else:
out = json.dumps(data, default=_default, sort_keys=True, indent=4)
return out
def writeResourceToStorage(self, resource_name, resource_def):
"""
Store a resource definition.
No return value, but raises GluException if there is an issue.
@param resource_name: The storage name for this resource
@type resource_name: string
@param resource_def: The dictionary containing the resource definition.
@type resource_def: dict
@raise GluException: If the resource cannot be stored.
"""
try:
buf = json.dumps(resource_def, indent=4)
self.storeFile(resource_name, buf)
except Exception, e:
raise GluException("Problems storing new resource: " + str(e))
def orders(self, request, input, params, method):
"""
Stored or retrieves data from the storage bucket for Marakana orders.
@param request: Information about the HTTP request.
@type request: BaseHttpRequest
@param input: Any data that came in the body of the request.
@type input: string
@param params: Dictionary of parameter values.
@type params: dict
@param method: The HTTP request method.
@type method: string
@return: The output data of this service.
@rtype: string
"""
# Access to our storage bucket
storage = self.getFileStorage()
# Get my parameters
param_order_id = params.get('id')
code = 200
if not param_order_id and not input:
# User didn't specify a specific order (and also doesn't POST a new order object),
# which means we should generate a list of all the orders we have stored.
data = self.__get_order_list(storage)
else:
if method == "DELETE":
if param_order_id:
storage.deleteFile(param_order_id)
data = "File deleted"
else:
code = 400
data = "Missing order id"
else:
if input:
# Parse the input into JSON
d = self.__xml_to_dict(input)
# Sanity check
try:
if 'product-order' in d['spark-domain']:
is_product_order = True
doc_name = 'product-order'
self.__dict_struct_compare(d, self.__PRODUCT_ORDER_TEMPLATE)
order_id = d['spark-domain']['product-order']['__attributes']['id']
else:
is_product_order = False
doc_name = 'registration-order'
self.__dict_struct_compare(d, self.__REGISTRATION_ORDER_TEMPLATE)
order_id = d['spark-domain']['registration-order']['__attributes']['id']
except Exception, e:
return 400, "Malformed request body: " + str(e)
# Creating or updating order
location_str = "%s/orders/%s" % (self.getMyResourceUri(), order_id)
if param_order_id:
if param_order_id != order_id:
return 400, "Order ID in URL and message body do not match (%s vs. %s)" % (param_order_id, order_id)
# Update an already existing order? Throws exception if it does not
# exist, which is exactly what we want.
dummy_data = storage.loadFile(order_id)
code = 200
data = "Successfully updated: %s" % location_str
else:
# Creating a new order? We need to extract the order id.
if request:
request.setResponseHeader("Location", location_str)
code = 201
data = "Successfully stored: %s" % location_str
# Store the data, but only the dictionary that contains the actual order info.
# We store it in a dictionary that contains a single key and this data, since
# that makes it look ... nice.
storage.storeFile(order_id, json.dumps({ doc_name : d['spark-domain'][doc_name] }))
else:
# Just want to retrieve an existing order
data = json.loads(storage.loadFile(param_order_id))
def _send_data(relative_url, obj):
"""
Helper method that POSTs an object to URL as JSON.
@param relative_url: The relative URL on the server. A starting slash may be
specified, but either way, it's always interpreted to be
relative to "/".
@type relative_url: string
@param obj: The object to be parsed to JSON and sent.
@type obj: object
@return: The JSON interpreted data and the response object as a tuple.
@rtype tuple
"""
if relative_url.startswith("/"):
relative_url = relative_url[1:]
resp = http.urlopen("POST", SERVER_URL + "/" + relative_url, headers={"Accept" : "application/json"}, data=json.dumps(obj))
buf = resp.read()
if resp.getStatus() >= 200 and resp.getStatus() <= 300:
data = json.loads(buf)
else:
data = buf
return (data, resp)
def _pretty_json(obj):
"""
Output an object as pretty-printed JSON.
"""
return json.dumps(obj, indent=4)