@Override public InputStream getFileAsStream( long companyId, long repositoryId, String fileName, String versionLabel) throws PortalException, SystemException { Session session = null; try { session = JCRFactoryUtil.createSession(); Node contentNode = getFileContentNode(session, companyId, repositoryId, fileName, versionLabel); Property property = contentNode.getProperty(JCRConstants.JCR_DATA); Value value = property.getValue(); Binary binary = value.getBinary(); if ((session instanceof Map)) { Map<String, Binary> mapSession = (Map<String, Binary>) session; mapSession.put(fileName, binary); } return binary.getStream(); } catch (RepositoryException re) { throw new SystemException(re); } finally { JCRFactoryUtil.closeSession(session); } }
private void persistBinaryContent(JcrRepository repository) throws RepositoryException, IOException { assertNotNull(repository); long minimumBinarySize = repository.getConfiguration().getBinaryStorage().getMinimumBinarySizeInBytes(); long binarySize = minimumBinarySize + 1; Session session = repository.login(); InputStream binaryValueStream = null; try { byte[] content = new byte[(int) binarySize]; new Random().nextBytes(content); JCR_TOOLS.uploadFile(session, "folder/file", new ByteArrayInputStream(content)); session.save(); Node nodeWithBinaryContent = session.getNode("/folder/file/jcr:content"); Binary binaryValue = nodeWithBinaryContent.getProperty("jcr:data").getBinary(); binaryValueStream = binaryValue.getStream(); byte[] retrievedContent = IoUtil.readBytes(binaryValueStream); assertArrayEquals(content, retrievedContent); } finally { if (binaryValueStream != null) { binaryValueStream.close(); } session.logout(); } }
@Override public boolean execute(Property inputProperty, Node outputNode, Context context) throws Exception { Binary binaryValue = inputProperty.getBinary(); CheckArg.isNotNull(binaryValue, "binary"); if (!outputNode.isNew()) { outputNode = outputNode.addNode(XmlLexicon.DOCUMENT); } XmlSequencerHandler sequencingHandler = new XmlSequencerHandler(outputNode, scoping); // Create the reader ... XMLReader reader = XMLReaderFactory.createXMLReader(); reader.setContentHandler(sequencingHandler); reader.setErrorHandler(sequencingHandler); // Ensure handler acting as entity resolver 2 reader.setProperty(DECL_HANDLER_FEATURE, sequencingHandler); // Ensure handler acting as lexical handler reader.setProperty(LEXICAL_HANDLER_FEATURE, sequencingHandler); // Ensure handler acting as entity resolver 2 setFeature(reader, ENTITY_RESOLVER_2_FEATURE, true); // Prevent loading of external DTDs setFeature(reader, LOAD_EXTERNAL_DTDS_FEATURE, false); // Prevent the resolving of DTD entities into fully-qualified URIS setFeature(reader, RESOLVE_DTD_URIS_FEATURE, false); // Parse XML document try (InputStream stream = binaryValue.getStream()) { reader.parse(new InputSource(stream)); } return true; }
@Override public long setContent( Node parentNode, String resourceName, InputStream newContent, String contentType, String characterEncoding) throws RepositoryException, IOException { Node contentNode; if (parentNode.hasNode(CONTENT_NODE_NAME)) { contentNode = parentNode.getNode(CONTENT_NODE_NAME); } else { contentNode = parentNode.addNode(CONTENT_NODE_NAME, newContentPrimaryType); } // contentNode.setProperty(MIME_TYPE_PROP_NAME, contentType != null ? contentType : // "application/octet-stream"); contentNode.setProperty( ENCODING_PROP_NAME, characterEncoding != null ? characterEncoding : "UTF-8"); Binary binary = parentNode.getSession().getValueFactory().createBinary(newContent); contentNode.setProperty(DATA_PROP_NAME, binary); contentNode.setProperty(MODIFIED_PROP_NAME, Calendar.getInstance()); // Copy the content to the property, THEN re-read the content from the Binary value to avoid // discaring the first // bytes of the stream if (contentType == null) { contentType = mimeTypeDetector.mimeTypeOf(resourceName, binary.getStream()); } return contentNode.getProperty(DATA_PROP_NAME).getLength(); }
protected void assertCanObtainValue(Value value, int expectedType) throws Exception { switch (expectedType) { case PropertyType.BINARY: Binary binary = value.getBinary(); try { InputStream stream = binary.getStream(); assertThat(stream, is(notNullValue())); try { stream.read(); } finally { stream.close(); } } finally { binary.dispose(); } break; case PropertyType.BOOLEAN: assertThat(value.getBoolean() || !value.getBoolean(), is(true)); break; case PropertyType.DATE: Calendar cal = value.getDate(); assertThat(cal, is(notNullValue())); break; case PropertyType.DOUBLE: double doubleValue = value.getDouble(); assertThat(doubleValue < 0.0d || doubleValue >= -1.0d, is(true)); break; case PropertyType.LONG: long longValue = value.getLong(); assertThat(longValue < 0L || longValue >= 0L, is(true)); break; case PropertyType.NAME: context.getValueFactories().getNameFactory().create(value.getString()); break; case PropertyType.PATH: context.getValueFactories().getPathFactory().create(value.getString()); break; case PropertyType.REFERENCE: UUID uuid = context.getValueFactories().getUuidFactory().create(value.getString()); assertThat(uuid, is(notNullValue())); break; case PropertyType.STRING: value.getString(); break; } }
/** * Fires the appropriate SAX events on the content handler to build the XML elements for the * value. * * @param value the value to be exported * @param contentHandler the SAX content handler for which SAX events will be invoked as the XML * document is created. * @param propertyType the {@link PropertyType} for the given value * @param skipBinary if <code>true</code>, indicates that binary properties should not be exported * @param isModified true if the property is modified; any modified binary properties will not be * purged * @throws SAXException if an exception occurs during generation of the XML document * @throws RepositoryException if an exception occurs accessing the content repository */ private void emitValue( Value value, ContentHandler contentHandler, int propertyType, boolean skipBinary, boolean isModified) throws RepositoryException, SAXException { if (PropertyType.BINARY == propertyType) { startElement(contentHandler, JcrSvLexicon.VALUE, null); // Per section 6.5 of the 1.0.1 spec, we need to emit one empty-value tag for each value if // the property is // multi-valued and skipBinary is true if (!skipBinary) { byte[] bytes = new byte[BASE_64_BUFFER_SIZE]; int len; Binary binary = value.getBinary(); try { InputStream stream = new Base64.InputStream(binary.getStream(), Base64.ENCODE); while (-1 != (len = stream.read(bytes))) { contentHandler.characters(new String(bytes, 0, len).toCharArray(), 0, len); } } catch (IOException ioe) { throw new RepositoryException(ioe); } finally { try { binary.dispose(); } finally { if (!isModified) { if (binary instanceof org.modeshape.graph.property.Binary) { ((org.modeshape.graph.property.Binary) binary).purge(); } } } } } endElement(contentHandler, JcrSvLexicon.VALUE); } else { emitValue(value.getString(), contentHandler); } }
@FixFor("MODE-1308") @Test public void shouldAllowAnyBinaryImplementation() throws Exception { Node node = rootNode.addNode("nodeWithBinaryProperty", "nt:unstructured"); final String stringValue = "This is the string stringValue"; Binary binaryValue = new Binary() { public InputStream getStream() throws RepositoryException { return new ByteArrayInputStream(stringValue.getBytes()); } public int read(byte[] b, long position) throws IOException, RepositoryException { byte[] content = stringValue.getBytes(); int length = b.length + position < content.length ? b.length : (int) (content.length - position); System.arraycopy(content, (int) position, b, 0, length); return length; } public long getSize() throws RepositoryException { return stringValue.getBytes().length; } public void dispose() {} }; node.setProperty("binProp", binaryValue); Binary nodeValue = node.getProperty("binProp").getBinary(); assertNotNull(nodeValue); assertEquals(stringValue.getBytes().length, nodeValue.getSize()); byte[] buffer = new byte[100]; int available; InputStream inputStream = nodeValue.getStream(); ByteArrayOutputStream byteOut = new ByteArrayOutputStream(); while ((available = inputStream.read(buffer)) != -1) { byteOut.write(buffer, 0, available); } assertArrayEquals(stringValue.getBytes(), byteOut.toByteArray()); }
private File createFile(Node node) throws RepositoryException { if (node.hasProperty("jcr:content/jcr:data")) { Property data = node.getProperty("jcr:content/jcr:data"); Binary binary = data.getBinary(); OutputStream out = null; InputStream in = null; try { File result = new File(fontsDir, node.getName()); result.createNewFile(); result.deleteOnExit(); in = binary.getStream(); out = new FileOutputStream(result); IOUtils.copy(in, out); return result; } catch (IOException e) { logger.error("Failed exporting FOP font data.", e); } finally { IOUtils.closeQuietly(in); IOUtils.closeQuietly(out); binary.dispose(); } } return null; }
@Test public void testRuleExecution() throws RepositoryException, RuleExecutionException { String path = "/test/ruleset"; Mockito.when(request.getResourceResolver()).thenReturn(resourceResolver); Mockito.when(resourceResolver.adaptTo(Session.class)).thenReturn(session); Mockito.when(session.getUserID()).thenReturn("ieb"); Mockito.when(resourceResolver.getResource(path)).thenReturn(ruleSet); Mockito.when(ruleSet.getResourceType()).thenReturn(RuleConstants.SAKAI_RULE_SET); Mockito.when(ruleSet.adaptTo(Node.class)).thenReturn(ruleSetNode); Mockito.when(context.getBundleContext()).thenReturn(bundleContext); Mockito.when(ruleSetNode.getPath()).thenReturn(path); Mockito.when(ruleSetNode.getNodes()).thenReturn(nodeIterator); // specify the rule processor Mockito.when(ruleSetNode.hasProperty(RuleConstants.PROP_SAKAI_RULE_EXECUTION_PREPROCESSOR)) .thenReturn(true); Mockito.when(ruleSetNode.getProperty(RuleConstants.PROP_SAKAI_RULE_EXECUTION_PREPROCESSOR)) .thenReturn(preprocessorProperty); Mockito.when(preprocessorProperty.getString()).thenReturn("message-test-preprocessor"); // when the service referece is invoked we need to give it out processor Mockito.when(reference.getProperty(RuleConstants.PROCESSOR_NAME)) .thenReturn("message-test-preprocessor"); RuleExecutionPreProcessor messageRuleExcutionPreProcessor = new MesageRuleExcutionPreProcessor(); Mockito.when(bundleContext.getService(reference)).thenReturn(messageRuleExcutionPreProcessor); // turn on debug for this rule execution, just needs the property to exist. Mockito.when(ruleSetNode.hasProperty(RuleConstants.PROP_SAKAI_RULE_DEBUG)) .thenReturn(true, true, false); Mockito.when(nodeIterator.hasNext()).thenReturn(true, false, true, false); Mockito.when(nodeIterator.nextNode()).thenReturn(packageNode, packageNode); Mockito.when(packageNode.getPrimaryNodeType()).thenReturn(packageNodeType); Mockito.when(packageNodeType.getName()).thenReturn(NodeType.NT_FILE); Mockito.when(packageNode.getPath()).thenReturn(path + "/package1"); Mockito.when(packageNode.getNode(Node.JCR_CONTENT)).thenReturn(packageFileNode); Mockito.when(packageFileNode.getProperty(Property.JCR_LAST_MODIFIED)).thenReturn(property); Calendar lastModified = GregorianCalendar.getInstance(); lastModified.setTimeInMillis(System.currentTimeMillis()); Calendar lastModifiedLater = GregorianCalendar.getInstance(); lastModifiedLater.setTimeInMillis(System.currentTimeMillis() + 20000); Mockito.when(property.getDate()).thenReturn(lastModified, lastModified, lastModifiedLater); Mockito.when(packageFileNode.getProperty(Property.JCR_DATA)).thenReturn(packageFileBody); Mockito.when(packageFileBody.getBinary()).thenReturn(binary); Mockito.when(binary.getStream()) .thenAnswer( new Answer<InputStream>() { public InputStream answer(InvocationOnMock invocation) throws Throwable { return this.getClass() .getResourceAsStream( "/SLING-INF/content/var/rules/org.sakaiproject.nakamura.rules/org.sakaiproject.nakamura.rules.example/0.7-SNAPSHOT/org.sakaiproject.nakamura.rules.example-0.7-SNAPSHOT.pkg"); } }); RuleExecutionServiceImpl res = new RuleExecutionServiceImpl(); res.activate(context); res.bindProcessor(reference); Map<String, Object> result = res.executeRuleSet(path, request, targetResource, ruleContext, null); Assert.assertNotNull(result); Assert.assertTrue(result.size() > 0); // execute a second time to use the cache. result = res.executeRuleSet(path, request, targetResource, ruleContext, null); Assert.assertNotNull(result); Assert.assertTrue(result.size() > 0); // execute a third time time to reload. result = res.executeRuleSet(path, request, targetResource, ruleContext, null); Assert.assertNotNull(result); Assert.assertTrue(result.size() > 0); res.deactivate(context); }