@Override public <T extends RestEntity> T deserialize(Class<T> dataType, String data) throws RestException { throw new RestException("Streaming of raw string data not supported"); }
@Override public void serialize(RestEntity entity, OutputStream outputStream) throws RestException { try { mapper.writeValue(outputStream, entity); } catch (IOException e) { throw new RestException("Unable to serialize entity", e); } }
@Override public <T extends RestEntity> T deserialize(Class<T> dataType, InputStream inputStream) throws RestException { try { return mapper.readValue(inputStream, dataType); } catch (IOException e) { throw new RestException("Unable to parse input document: " + e.getMessage()); } }
@RequestMapping(value = "/Instances({instanceId})", method = DELETE, produces = "application/json") public RestEntity removeEntry(@PathVariable String instanceId) throws RestException { try { LOG.debug("Receiving a instance delete operation for instance: {}", instanceId); instanceFactory.deleteInstance(instanceId); return null; } catch(JasDBStorageException e) { throw new RestException("Unable to remove instance: " + instanceId); } } }
@Override public <T extends RestEntity> T deserialize(Class<T> dataType, String data) throws RestException { try { return deserialize(dataType, new ByteArrayInputStream(data.getBytes(ENCODING))); } catch (UnsupportedEncodingException e) { throw new RestException("Unable to parse input document: " + e.getMessage()); } }
@RequestMapping(value = "/Instances({instanceId})/Bags({bagName})/Indexes({indexName})", method = DELETE, consumes = "application/json", produces = "application/json") public ResponseEntity<?> removeEntry(@PathVariable String instanceId, @PathVariable String bagName, @PathVariable String indexName) throws RestException { if(StringUtils.hasText(instanceId) && StringUtils.hasText(bagName)) { LOG.debug("Removing index from instance: {} bag: {} with name: {}", instanceId, bagName, indexName); try { StorageService storageService = storageServiceFactory.getStorageService(instanceId, bagName); storageService.removeIndex(indexName); return response(null, HttpStatus.NO_CONTENT); } catch(JasDBStorageException e) { throw new RestException("Unable to remove index data: " + e.getMessage()); } } else { throw new RestException("Cannot remove index without a specified bag or InstanceId"); } }
private void generateEntityOutput(long size, long timeMilliseconds, QueryResult result, OutputStream outputStream) throws RestException { try { JsonGenerator generator = factory.createGenerator(outputStream); generator.writeStartObject(); generator.writeNumberField(COLLECTION_SIZE, size); generator.writeNumberField(COLLECTION_TIME, timeMilliseconds); generator.writeArrayFieldStart(COLLECTION_ENTITIES); JsonEntitySerializer entitySerializer = new JsonEntitySerializer(); for(Entity entity : result) { if(entity != null) { entitySerializer.serializeEntity(entity, generator); } } generator.writeEndArray(); generator.close(); } catch(IOException e) { throw new RestException("Unable to serialize entity collection", e); } catch(MetadataParseException e) { throw new RestException("Unable to serialize entity collection: " + e.getMessage()); } }
@RequestMapping(value = "/Users({userId})", produces = "application/json", consumes = "application/json", method = DELETE) public RestEntity removeEntry(@PathVariable String userId, HttpServletRequest request) throws RestException { if (StringUtils.stringNotEmpty(userId)) { try { RequestContext requestContext = ControllerUtil.getRequestContext(request); userManager.deleteUser(requestContext.getUserSession(), userId); return null; } catch (JasDBStorageException e) { throw new RestException("Unable to remove user", e); } } else { throw new RestException("Unable to delete user, no id specified"); } } }
@Override public <T extends RestEntity> T deserialize(Class<T> dataType, String data) throws RestException { JsonEntityDeserializer entityDeserializer = new JsonEntityDeserializer(); try { return dataType.cast(new StreamedEntity(entityDeserializer.deserializeEntity(data))); } catch(MetadataParseException e) { throw new RestException("Unable to parse entity", e); } }
throw new RestException("Unable to parse streamable entity collection");
@Override public <T extends RestEntity> T deserialize(Class<T> dataType, InputStream inputStream) throws RestException { try { try (JsonParser parser = factory.createParser(inputStream)) { return dataType.cast(new StreamedEntity(new JsonEntityDeserializer().deserializeEntity(parser))); } } catch(IOException | MetadataParseException e) { throw new RestException("Unable to parse entity", e); } }
private RestEntity loadAllGrantObjects(RequestContext context) throws RestException { try { List<GrantObject> grantObjects = userManager.getGrantObjects(context.getUserSession()); List<RestGrantObject> restGrantObjects = new ArrayList<>(); for(GrantObject grantObject : grantObjects) { restGrantObjects.add(GrantModelMapper.map(grantObject)); } return new RestGrantObjectCollection(restGrantObjects); } catch(JasDBStorageException e) { throw new RestException("Unable to load grant objects", e); } }
@Override public void serialize(RestEntity entity, OutputStream outputStream) throws RestException { if(entity instanceof StreamedEntity) { try { StreamedEntity streamedEntity = (StreamedEntity) entity; JsonGenerator generator = factory.createGenerator(outputStream); generator.configure(JsonGenerator.Feature.AUTO_CLOSE_TARGET, false); generator.configure(JsonGenerator.Feature.FLUSH_PASSED_TO_STREAM, false); try { JsonEntitySerializer entitySerializer = new JsonEntitySerializer(); entitySerializer.serializeEntity(streamedEntity.getEntity(), generator); } finally { generator.close(); } } catch(IOException | MetadataParseException e) { throw new RestException("Unable to serialize entity", e); } } else { throw new RestException("Unable to serialize entity not of type Entity"); } }
private RestEntity loadSpecificGrantObject(RequestContext context, String object) throws RestException { try { GrantObject grantObject = userManager.getGrantObject(context.getUserSession(), object); return GrantModelMapper.map(grantObject); } catch(JasDBStorageException e) { throw new RestException("Unable to load grant objects", e); } }
@Override public void serialize(RestEntity entity, OutputStream outputStream) throws RestException { if(entity instanceof StreamableEntityCollection) { StreamableEntityCollection entityCollection = (StreamableEntityCollection) entity; generateEntityOutput(entityCollection.getSize(), entityCollection.getTimeMilliseconds(), entityCollection.getResult(), outputStream); } else { throw new RestException("Unable to serialize the entity, not of type: " + StreamableEntityCollection.class.getName()); } }
@RequestMapping(value = "/Instances({instanceId})/Bags({bagName})/Indexes", method = POST, consumes = "application/json", produces = "application/json") public RestEntity writeEntry(@PathVariable String instanceId, @PathVariable String bagName, @RequestBody IndexEntry indexEntry) throws RestException { if(StringUtils.hasText(instanceId) && StringUtils.hasText(bagName)) { try { StorageService storageService = storageServiceFactory.getStorageService(instanceId, bagName); KeyInfo keyInfo = new KeyInfoImpl(indexEntry.getKeyHeader(), indexEntry.getValueHeader()); List<IndexField> indexFields = keyInfo.getIndexKeyFields(); List<IndexField> indexFieldValues = keyInfo.getIndexValueFields(); IndexField[] indexFieldValueArray = indexFieldValues.toArray(new IndexField[indexFieldValues.size()]); if (indexFields.size() > SINGLE_KEY_FIELD) { CompositeIndexField compositeIndexField = new SimpleCompositeIndexField(indexFields.toArray(new IndexField[indexFields.size()])); storageService.ensureIndex(compositeIndexField, indexEntry.isUniqueConstraint(), indexFieldValueArray); } else if (indexFields.size() == SINGLE_KEY_FIELD) { storageService.ensureIndex(indexFields.get(0), indexEntry.isUniqueConstraint(), indexFieldValueArray); } else { throw new RestException("Unable to create index, no key fields specified"); } return indexEntry; } catch (JasDBStorageException e) { throw new RestException("Unable to write index data: " + e.getMessage()); } } else { throw new RestException("No InstanceId or Bag Name where specified when creating index"); } }
@RequestMapping(value = "/Instances", method = POST, consumes = "application/json", produces = "application/json") public RestEntity writeEntry(@RequestBody InstanceRest dbInstance) throws RestException { try { instanceFactory.addInstance(dbInstance.getInstanceId()); return getInstance(dbInstance.getInstanceId()); } catch(JasDBStorageException e) { throw new RestException("Unable to create new instance: " + e.getMessage()); } }
private RestEntity loadUserList(RequestContext context) throws RestException { try { List<String> userList = userManager.getUsers(context.getUserSession()); return new RestUserList(userList); } catch(JasDBStorageException e) { throw new RestException("Unable to load user list", e); } }
@RequestMapping(value = "/Instances({instanceId})/Bags({bagName})/Entities({entityId})", produces = "application/json", method = DELETE) public RestEntity removeEntry(@PathVariable String instanceId, @PathVariable String bagName, @PathVariable String entityId, HttpServletRequest request) throws RestException { if(stringNotEmpty(instanceId) && stringNotEmpty(bagName) && stringNotEmpty(entityId)) { try { LOG.debug("Doing remove of entity with id: {}", entityId); StorageService storageService = storageServiceFactory.getOrCreateStorageService(instanceId, bagName); storageService.removeEntity(getRequestContext(request), entityId); return null; } catch(JasDBStorageException e) { throw new RestException("Unable to remove entity: " + e.getMessage()); } } else { throw new SyntaxException("Cannot remove entity, invalid parameters for delete operation"); } }
@RequestMapping(value = "/Grants({grantId})", produces = "application/json", method = DELETE) public RestEntity removeEntry(@RequestBody RestGrant grant, HttpServletRequest request) throws RestException { if(StringUtils.stringNotEmpty(grant.getObjectName()) && StringUtils.stringNotEmpty(grant.getUsername())) { try { RequestContext requestContext = getRequestContext(request); userManager.revoke(requestContext.getUserSession(), grant.getObjectName(), grant.getUsername()); return null; } catch(JasDBStorageException e) { throw new RestException("Unable to revoke grant", e); } } else { throw new RestException("Cannot remove without user and object specified"); } } }