/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.jackrabbit.core.persistence.util;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.math.BigDecimal;
import java.util.Calendar;
import java.util.Collection;
import java.util.GregorianCalendar;
import javax.jcr.PropertyType;
import javax.jcr.RepositoryException;
import org.apache.commons.io.IOExceptionWithCause;
import org.apache.commons.io.IOUtils;
import org.apache.jackrabbit.core.id.NodeId;
import org.apache.jackrabbit.core.value.InternalValue;
import org.apache.jackrabbit.core.persistence.util.NodePropBundle.ChildNodeEntry;
import org.apache.jackrabbit.core.persistence.util.NodePropBundle.PropertyEntry;
import org.apache.jackrabbit.spi.Name;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Bundle serializer.
*
* @see BundleReader
*/
class BundleWriter {
/** Logger instance */
private static Logger log = LoggerFactory.getLogger(BundleWriter.class);
private final BundleBinding binding;
private final DataOutputStream out;
/**
* The default namespace and the first six other namespaces used in this
* bundle. Used by the {@link #writeName(Name)} method to keep track of
* already seen namespaces.
*/
private final String[] namespaces =
// NOTE: The length of this array must be seven
{ Name.NS_DEFAULT_URI, null, null, null, null, null, null };
/**
* Creates a new bundle serializer.
*
* @param binding bundle binding
* @param stream stream to which the bundle will be written
* @throws IOException if an I/O error occurs.
*/
public BundleWriter(BundleBinding binding, OutputStream stream)
throws IOException {
assert namespaces.length == 7;
this.binding = binding;
this.out = new DataOutputStream(stream);
this.out.writeByte(BundleBinding.VERSION_CURRENT);
}
/**
* Serializes a <code>NodePropBundle</code> to a data output stream
*
* @param bundle the bundle to serialize
* @throws IOException if an I/O error occurs.
*/
public void writeBundle(NodePropBundle bundle)
throws IOException {
long size = out.size();
// primaryType
writeName(bundle.getNodeTypeName());
// parentUUID
NodeId parentId = bundle.getParentId();
if (parentId == null) {
parentId = BundleBinding.NULL_PARENT_ID;
}
writeNodeId(parentId);
// write mod count
writeVarInt(bundle.getModCount());
Collection<Name> mixins = bundle.getMixinTypeNames();
Collection<PropertyEntry> properties = bundle.getPropertyEntries();
Collection<ChildNodeEntry> nodes = bundle.getChildNodeEntries();
Collection<NodeId> shared = bundle.getSharedSet();
int mn = mixins.size();
int pn = properties.size();
int nn = nodes.size();
int sn = shared.size();
int referenceable = 0;
if (bundle.isReferenceable()) {
referenceable = 1;
}
out.writeByte(
Math.min(mn, 1) << 7
| Math.min(pn, 7) << 4
| Math.min(nn, 3) << 2
| Math.min(sn, 1) << 1
| referenceable);
// mixin types
writeVarInt(mn, 1);
for (Name name : mixins) {
writeName(name);
}
// properties
writeVarInt(pn, 7);
for (PropertyEntry property : properties) {
writeState(property);
}
// child nodes (list of name/uuid pairs)
writeVarInt(nn, 3);
for (ChildNodeEntry child : nodes) {
writeName(child.getName()); // name
writeNodeId(child.getId()); // uuid
}
// write shared set
writeVarInt(sn, 1);
for (NodeId nodeId: shared) {
writeNodeId(nodeId);
}
// set size of bundle
bundle.setSize(out.size() - size);
}
/**
* Serializes a property entry. The serialization begins with the
* property name followed by a single byte that encodes the type and
* multi-valuedness of the property:
* <pre>
* +-------------------------------+
* | mv count | type |
* +-------------------------------+
* </pre>
* <p>
* The lower four bits encode the property type (0-12 in JCR 2.0) and
* higher bits indicate whether this is a multi-valued property and how
* many property values there are. A value of 0 is reserved for
* single-valued properties (that are guaranteed to always have just a
* single value), and all non-zero values indicate a multi-valued property.
* <p>
* In multi-valued properties the exact value of the "mv count" field is
* the number of property values plus one and truncated at 15 (the highest
* four-bit value). If there are 14 or more (14 + 1 == 15) property values,
* then the number of additional values is serialized as a variable-length
* integer (see {@link #writeVarInt(int)}) right after this byte.
* <p>
* The modification count of the property state is written next as a
* variable-length integer, followed by the serializations of all the
* values of this property.
*
* @param state the property entry to store
* @throws IOException if an I/O error occurs.
*/
private void writeState(NodePropBundle.PropertyEntry state)
throws IOException {
writeName(state.getName());
InternalValue[] values = state.getValues();
int type = state.getType();
if (type < 0 || type > 0xf) {
throw new IOException("Illegal property type " + type);
}
if (state.isMultiValued()) {
int len = values.length + 1;
if (len < 0x0f) {
out.writeByte(len << 4 | type);
} else {
out.writeByte(0xf0 | type);
writeVarInt(len - 0x0f);
}
} else {
if (values.length != 1) {
throw new IOException(
"Single values property with " + values.length + " values: " +
state.getName());
}
out.writeByte(type);
}
writeVarInt(state.getModCount());
// values
for (int i = 0; i < values.length; i++) {
InternalValue val = values[i];
switch (type) {
case PropertyType.BINARY:
try {
long size = val.getLength();
if (val.isInDataStore()) {
out.writeInt(BundleBinding.BINARY_IN_DATA_STORE);
writeString(val.toString());
} else if (binding.dataStore != null) {
writeSmallBinary(val, state, i);
} else if (size < 0) {
log.warn("Blob has negative size. Potential loss of data. "
+ "id={} idx={}", state.getId(), String.valueOf(i));
out.writeInt(0);
values[i] = InternalValue.create(new byte[0]);
val.discard();
} else if (size > binding.getMinBlobSize()) {
// special handling required for binary value:
// spool binary value to file in blob store
out.writeInt(BundleBinding.BINARY_IN_BLOB_STORE);
String blobId = state.getBlobId(i);
if (blobId == null) {
BLOBStore blobStore = binding.getBlobStore();
try {
InputStream in = val.getStream();
try {
blobId = blobStore.createId(state.getId(), i);
blobStore.put(blobId, in, size);
state.setBlobId(blobId, i);
} finally {
IOUtils.closeQuietly(in);
}
} catch (Exception e) {
String msg = "Error while storing blob. id="
+ state.getId() + " idx=" + i + " size=" + size;
log.error(msg, e);
throw new IOExceptionWithCause(msg, e);
}
try {
// replace value instance with value
// backed by resource in blob store and delete temp file
if (blobStore instanceof ResourceBasedBLOBStore) {
values[i] = InternalValue.create(((ResourceBasedBLOBStore) blobStore).getResource(blobId));
} else {
values[i] = InternalValue.create(blobStore.get(blobId));
}
} catch (Exception e) {
log.error("Error while reloading blob. truncating. id="
+ state.getId() + " idx=" + i + " size=" + size, e);
values[i] = InternalValue.create(new byte[0]);
}
val.discard();
}
// store id of blob as property value
writeString(blobId); // value
} else {
// delete evt. blob
byte[] data = writeSmallBinary(val, state, i);
// replace value instance with value
// backed by resource in blob store and delete temp file
values[i] = InternalValue.create(data);
val.discard();
}
} catch (RepositoryException e) {
String msg = "Error while storing blob. id="
+ state.getId() + " idx=" + i + " value=" + val;
log.error(msg, e);
throw new IOExceptionWithCause(msg, e);
}
break;
case PropertyType.DOUBLE:
try {
out.writeDouble(val.getDouble());
} catch (RepositoryException e) {
throw convertToIOException(type, e);
}
break;
case PropertyType.DECIMAL:
try {
writeDecimal(val.getDecimal());
} catch (RepositoryException e) {
throw convertToIOException(type, e);
}
break;
case PropertyType.LONG:
try {
writeVarLong(val.getLong());
} catch (RepositoryException e) {
throw convertToIOException(type, e);
}
break;
case PropertyType.BOOLEAN:
try {
out.writeBoolean(val.getBoolean());
} catch (RepositoryException e) {
throw convertToIOException(type, e);
}
break;
case PropertyType.NAME:
try {
writeName(val.getName());
} catch (RepositoryException e) {
throw convertToIOException(type, e);
}
break;
case PropertyType.WEAKREFERENCE:
case PropertyType.REFERENCE:
writeNodeId(val.getNodeId());
break;
case PropertyType.DATE:
try {
writeDate(val.getCalendar());
} catch (RepositoryException e) {
throw convertToIOException(type, e);
}
break;
case PropertyType.STRING:
case PropertyType.PATH:
case PropertyType.URI:
writeString(val.toString());
break;
default:
throw new IOException("Inknown property type: " + type);
}
}
}
private static IOException convertToIOException(int propertyType, Exception e) {
String typeName = PropertyType.nameFromValue(propertyType);
String message = "Unexpected error for property type "+ typeName +" value.";
log.error(message, e);
return new IOExceptionWithCause(message, e);
}
/**
* Write a small binary value and return the data.
*
* @param value the binary value
* @param state the property state (for error messages)
* @param i the index (for error messages)
* @return the data
* @throws IOException if the data could not be read
*/
private byte[] writeSmallBinary(
InternalValue value, NodePropBundle.PropertyEntry state, int i)
throws IOException {
try {
int size = (int) value.getLength();
out.writeInt(size);
byte[] data = new byte[size];
DataInputStream in =
new DataInputStream(value.getStream());
try {
in.readFully(data);
} finally {
IOUtils.closeQuietly(in);
}
out.write(data, 0, data.length);
return data;
} catch (Exception e) {
String msg = "Error while storing blob. id="
+ state.getId() + " idx=" + i + " value=" + value;
log.error(msg, e);
throw new IOExceptionWithCause(msg, e);
}
}
/**
* Serializes a node identifier
*
* @param id the node id
* @throws IOException in an I/O error occurs.
*/
private void writeNodeId(NodeId id) throws IOException {
out.writeLong(id.getMostSignificantBits());
out.writeLong(id.getLeastSignificantBits());
}
/**
* Serializes a BigDecimal
*
* @param decimal the decimal number
* @throws IOException in an I/O error occurs.
*/
private void writeDecimal(BigDecimal decimal) throws IOException {
if (decimal == null) {
out.writeBoolean(false);
} else {
out.writeBoolean(true);
// TODO more efficient serialization format
writeString(decimal.toString());
}
}
/**
* Serializes a name. The name encoding works as follows:
* <p>
* First; if the name is known by the {@link BundleNames} class (this
* includes the <code>null</code> name), then the name is serialized
* as a single byte using the following format.
* <pre>
* +-------------------------------+
* | 0 | common name index |
* +-------------------------------+
* </pre>
* <p>
* Second; if the name is not known, it gets serialized as a
* variable-length field whose first byte looks like this:
* <pre>
* +-------------------------------+
* | 1 | ns index | name length |
* +-------------------------------+
* </pre>
* <p>
* The three-bit namespace index identifies the namespace of the name.
* The serializer keeps track of the default namespace (value 0) and at
* most six other other namespaces (values 1-6), in the order they appear
* in the bundle. When one of these six custom namespaces first appears
* in the bundle, then the namespace URI is written using
* {@link #writeString(String)} right after this byte.
* Later uses of such a namespace simply refers back to the already read
* namespace URI string. Any other namespaces are identified with value 7
* and always written to the bundle after this byte.
* <p>
* The four-bit name length field indicates the length (in UTF-8 bytes)
* of the local part of the name. Since zero-length local names are not
* allowed, the length is first decremented by one before storing in this
* field. The UTF-8 byte sequence is written out after this byte and the
* possible namespace URI string. If the length of the local name is
* larger than 15 (i.e. would be stored as 0x0f or more), then the value
* 0x0f is stored as the name length and the name string is written as
* UTF-8 using {@link #writeBytes(byte[], int)} with a base length of
* 0x10 (0x0f + 1).
*
* @param name the name
* @throws IOException in an I/O error occurs.
*/
private void writeName(Name name) throws IOException {
int index = BundleNames.nameToIndex(name);
if (index != -1) {
assert 0 <= index && index < 0x80;
out.writeByte(index);
} else {
String uri = name.getNamespaceURI();
int ns = 0;
while (ns < namespaces.length
&& namespaces[ns] != null
&& !namespaces[ns].equals(uri)) {
ns++;
}
String local = name.getLocalName();
if (local.length() == 0) {
throw new IOException("Attempt to write an empty local name: " + name);
}
byte[] bytes = local.getBytes("UTF-8");
int len = Math.min(bytes.length - 1, 0x0f);
out.writeByte(0x80 | ns << 4 | len);
if (ns == namespaces.length || namespaces[ns] == null) {
writeString(uri);
if (ns < namespaces.length) {
namespaces[ns] = uri;
}
}
if (len != 0x0f) {
out.write(bytes);
} else {
writeBytes(bytes, 0x0f + 1);
}
}
}
/**
* Serializes an integer using a variable-length encoding that favors
* small positive numbers. The serialization consists of one to five
* bytes of the following format:
* <pre>
* +-------------------------------+
* | c | 7 least significant bits |
* +-------------------------------+
* </pre>
* <p>
* If the given integer fits in seven bits (i.e. the value between
* 0 and 127, inclusive), then it is written as-is in a single byte.
* Otherwise the continuation flag <code>c</code> is set and the least
* significant seven bits are written together with the flag as a single
* byte. The integer is then shifed right seven bits and the process
* continues from the beginning.
* <p>
* This format uses a single byte for values 0-127, two bytes for
* 128-16343, three for 16343-2097151, four for 2097152-268435455
* and five bytes for all other 32-bit numbers (including negative ones).
*
* @param integer integer value
* @throws IOException if an I/O error occurs
*/
private void writeVarInt(int value) throws IOException {
while (true) {
int b = value & 0x7f;
if (b != value) {
out.writeByte(b | 0x80);
value >>>= 7; // unsigned shift
} else {
out.writeByte(b);
return;
}
}
}
private void writeVarInt(int value, int base) throws IOException {
if (value >= base) {
writeVarInt(value - base);
}
}
/**
* Serializes a long value using a variable length encoding like the
* one used by {@link #writeVarInt(int)} for integer values. Before
* writing out, the value is first normalized to an unsigned value
* by moving the sign bit to be the end negating the other bits of
* a negative value. This normalization step maximizes the number of
* zero high order bits for typical small values (positive or negative),
* and thus keeps the serialization short.
*
* @param value long value
* @throws IOException if an I/O error occurs
*/
private void writeVarLong(long value) throws IOException {
// Normalize to an unsigned value with the sign as the lowest bit
if (value < 0) {
value = ~value << 1 | 1;
} else {
value <<= 1;
}
while (true) {
long b = value & 0x7f;
if (b != value) {
out.writeByte((int) b | 0x80);
value >>>= 7; // unsigned shift
} else {
out.writeByte((int) b);
return;
}
}
}
/**
* Serializes a JCR date value using the {@link #writeVarLong(long)}
* serialization on a special 64-bit date encoding. This encoding maps
* the <code>sYYYY-MM-DDThh:mm:ss.sssTZD</code> date format used by
* JCR to an as small 64 bit integer (positive or negative) as possible,
* while preserving full accuracy (including time zone offsets) and
* favouring common levels of accuracy (per minute, hour and day) over
* full millisecond level detail.
* <p>
* Each date value is mapped to separate timestamp and timezone fields,
* both of whose lenghts are variable:
* <pre>
* +----- ... ------- ... --+
* | timestamp | timezone |
* +----- ... ------- ... --+
* </pre>
* <p>
* The type and length of the timezone field can be determined by looking
* at the two least significant bits of the value:
* <dl>
* <dt><code>?0</code></dt>
* <dd>
* UTC time. The length of the timezone field is just one bit,
* i.e. the second bit is already a part of the timestamp field.
* </dd>
* <dt><code>01</code></dt>
* <dd>
* The offset is counted as hours from UTC, and stored as the number
* of hours (positive or negative) in the next 5 bits (range from
* -16 to +15 hours), making the timezone field 7 bits long in total.
* </dd>
* <dt><code>11</code></dt>
* <dd>
* The offset is counted as hours and minutes from UTC, and stored
* as the total minute offset (positive or negative) in the next
* 11 bits (range from -17 to +17 hours), making the timezone field
* 13 bits long in total.
* </dd>
* </dl>
* <p>
* The remaining 51-63 bits of the encoded value make up the timestamp
* field that also uses the two least significant bits to indicate the
* type and length of the field:
* <dl>
* <dt><code>00</code></dt>
* <dd>
* <code>sYYYY-MM-DDT00:00:00.000</code>, i.e. midnight of the
* specified date. The next 9 bits encode the day within the year
* (starting from 1, maximum value 366) and the remaining bits are
* used for the year, stored as an offset from year 2010.
* </dd>
* <dt><code>01</code></dt>
* <dd>
* <code>sYYYY-MM-DDThh:00:00.000</code>, i.e. at the hour. The
* next 5 bits encode the hour within the day (starting from 0,
* maximum value 23) and the remaining bits are used as described
* above for the date.
* </dd>
* <dt><code>10</code></dt>
* <dd>
* <code>sYYYY-MM-DDThh:mm:00.000</code>, i.e. at the minute. The
* next 11 bits encode the minute within the day (starting from 0,
* maximum value 1439) and the remaining bits are used as described
* above for the date.
* </dd>
* <dt><code>11</code></dt>
* <dd>
* <code>sYYYY-MM-DDThh:mm:ss.sss</code>, i.e. full millisecond
* accuracy. The next 30 bits encode the millisecond within the
* day (starting from 0, maximum value 87839999) and the remaining
* bits are used as described above for the date.
* </dd>
* </dl>
* <p>
* With full timezone and millisecond accuracies, this encoding leaves
* 10 bits (64 - 9 - 30 - 2 - 11 - 2) for the date offset, which allows
* for representation of all timestamps between years 1498 and 2521.
* Timestamps outside this range and with a minute-level timezone offset
* are automatically truncated to minute-level accuracy to support the
* full range of years -9999 to 9999 specified in JCR.
* <p>
* Note that the year, day of year, and time of day values are stored
* as separate bit sequences to avoid problems with changing leap second
* or leap year definitions. Bit fields are used for better encoding and
* decoding performance than what would be possible with the slightly more
* space efficient mechanism of using multiplication and modulo divisions
* to separate the different timestamp fields.
*
* @param value date value
* @throws IOException if an I/O error occurs
*/
private void writeDate(Calendar value) throws IOException {
int y = value.get(Calendar.YEAR);
if (value.isSet(Calendar.ERA)
&& value.get(Calendar.ERA) == GregorianCalendar.BC) {
y = 1 - y; // convert to an astronomical year
}
y -= 2010; // use a recent offset NOTE: do not change this!
int d = value.get(Calendar.DAY_OF_YEAR);
int h = value.get(Calendar.HOUR_OF_DAY);
int m = value.get(Calendar.MINUTE);
int s = value.get(Calendar.SECOND);
int u = value.get(Calendar.MILLISECOND);
int z = value.getTimeZone().getOffset(value.getTimeInMillis()) / (60 * 1000);
int zh = z / 60;
int zm = z - zh * 60;
long ts = y << 9 | d & 0x01ff;
if ((u != 0 || s != 0) && ((-512 <= y && y < 512) || zm == 0)) {
ts <<= 30;
ts |= (((h * 60 + m) * 60 + s) * 1000 + u) & 0x3fffffff; // 30 bits
ts <<= 2;
ts |= 3;
} else if (m != 0) {
ts <<= 11;
ts |= (h * 60 + m) & 0x07ff; // 11 bits
ts <<= 2;
ts |= 2;
} else if (h != 0) {
ts <<= 5;
ts |= h & 0x1f; // 5 bits
ts <<= 2;
ts |= 1;
} else {
ts <<= 2;
}
if (zm != 0) {
ts <<= 11;
ts |= z & 0x07ff; // 11 bits
writeVarLong(ts << 2 | 3);
} else if (zh != 0) {
ts <<= 5;
ts |= zh & 0x1f; // 5 bits
writeVarLong(ts << 2 | 1);
} else {
writeVarLong(ts << 1);
}
}
/**
* Serializes a string in UTF-8. The length of the UTF-8 byte sequence
* is first written as a variable-length string (see
* {@link #writeVarInt(int)}), and then the sequence itself is written.
*
* @param value string value
* @throws IOException if an I/O error occurs
*/
private void writeString(String value) throws IOException {
writeBytes(value.getBytes("UTF-8"), 0);
}
/**
* Serializes the given array of bytes. The length of the byte array is
* first written as a {@link #writeVarInt(int) variable length integer},
* followed by the given bytes.
*
* @param bytes the bytes to be serialized
* @param base optional base length
* @throws IOException if an I/O error occurs
*/
private void writeBytes(byte[] bytes, int base) throws IOException {
assert bytes.length >= base;
writeVarInt(bytes.length - base);
out.write(bytes);
}
}