private static JournalElement UpdateConfiguration(JournalElement conf)
{
string settingsFile = Path.Combine(conf.DefaultPath, MetadataConstants.JOURNAL_SETTINGS_FILE_NAME);
JournalElement existingConfig = null;
if (File.Exists(settingsFile))
{
try
{
using (var dbXml = File.OpenRead(settingsFile))
{
existingConfig = ConfigurationSerializer.ReadJournalConfiguration(dbXml);
}
}
catch (IOException)
{
}
catch (InvalidOperationException)
{
}
if (existingConfig != null)
{
existingConfig.OpenPartitionTtl = conf.OpenPartitionTtl;
existingConfig.MaxOpenPartitions = conf.MaxOpenPartitions;
existingConfig.LagHours = conf.LagHours;
existingConfig.DefaultPath = conf.DefaultPath;
existingConfig.SerializerName = conf.SerializerName;
existingConfig.FromDisk = true;
return(existingConfig);
}
}
return(conf);
}
public static JournalMetadata CreateNewJournalMetadata(JournalElement config, Type t = null)
{
if (t != null)
{
var serializerFactory =
JournalSerializerRegistry.Instance.GetSerializer(config.SerializerName ??
MetadataConstants.DEFAULT_SERIALIZER_NAME);
return(new JournalMetadata(config, serializerFactory, t));
}
return(new JournalMetadata(config, new RecordSerializerFactory(config), null));
}
internal JournalMetadata(JournalElement config, ISerializerFactory serializerFactory, Type itemType)
{
_serializerFactory = serializerFactory;
var columnSerializers = _serializerFactory.Initialize(itemType);
columnSerializers = CheckColumnMatch(config, columnSerializers, itemType);
_columns = ParseColumns(columnSerializers, config.Columns);
_settings = new JournalSettings(config, _columns);
// Parse.
FileCount = CalcFilesCount(_columns);
// Timestamp.
if (!string.IsNullOrEmpty(config.TimestampColumn))
{
var timestampColumn = _columns.FirstOrDefault(c =>
c.PropertyName.Equals(config.TimestampColumn, StringComparison.OrdinalIgnoreCase));
if (timestampColumn == null)
{
throw new NFSdbConfigurationException("Timestamp column with name {0} is not found",
config.TimestampColumn);
}
if (timestampColumn.ColumnType != EFieldType.DateTime &&
timestampColumn.ColumnType != EFieldType.DateTimeEpochMs &&
timestampColumn.ColumnType != EFieldType.Int64)
{
throw new NFSdbConfigurationException("Timestamp column {0} must be DateTime or Int64 but was {1}",
config.TimestampColumn, timestampColumn.ColumnType);
}
_timestampColumn = _columns.Single(c => c.FileName.Equals(config.TimestampColumn, StringComparison.OrdinalIgnoreCase));
TimestampColumnID = _timestampColumn.ColumnID;
}
// IsNull.
var last = _columns.Last();
if (last.ColumnType == EFieldType.BitSet)
{
IsNullColumnID = last.ColumnID;
}
// Misc.
PartitionTtl = TimeSpan.FromMilliseconds(config.OpenPartitionTtl);
Name = config.Class;
}
internal JournalSettings(JournalElement jconf, IEnumerable <ColumnMetadata> actualColumns)
{
_defaultPath = jconf.DefaultPath;
_timestampColumn = jconf.TimestampColumn;
_keySymbol = jconf.Key;
_partitionType = jconf.PartitionType;
_openPartitionTtl = jconf.OpenPartitionTtl;
_maxOpenPartitions = jconf.MaxOpenPartitions;
_lagHours = jconf.LagHours;
_columns = actualColumns.ToArray();
_recordHint = jconf.RecordHint;
if (_recordHint <= 0)
{
_recordHint = MetadataConstants.DEFAULT_RECORD_HINT;
}
}
public IJournal <T> ToJournal <T>()
{
_config = UpdateConfiguration(_config);
var serializerFactory =
JournalSerializerRegistry.Instance.GetSerializer(_config.SerializerName ??
MetadataConstants.DEFAULT_SERIALIZER_NAME);
var meta = new JournalMetadata(_config, serializerFactory, typeof(T));
var fileFactory = new CompositeFileFactory(_config.FileFlags);
if (_server != null)
{
var partMan = new PartitionManager(meta, _access, fileFactory, _server);
return(new Journal <T>(meta, partMan, _server));
}
else
{
var server = new AsyncJournalServer(_serverTasksLatency);
var partMan = new PartitionManager(meta, _access, fileFactory, server);
partMan.OnDisposed += server.Dispose;
return(new Journal <T>(meta, partMan, _server));
}
}
private static IEnumerable <IColumnSerializerMetadata> CheckColumnMatch(JournalElement jconf,
IEnumerable <IColumnSerializerMetadata> columns, Type itemType)
{
if (!jconf.FromDisk)
{
return(columns);
}
var columnsList = columns as IList <IColumnSerializerMetadata>;
if (columnsList == null)
{
columnsList = columns.ToList();
}
// Columns and column order must match.
// If bitset exists it must be the last one.
var hasBitSet = columnsList[columnsList.Count - 1].ColumnType == EFieldType.BitSet;
var parsedColLen = hasBitSet ? columnsList.Count - 1 : columnsList.Count;
var confColumns = jconf.Columns;
if (parsedColLen != confColumns.Count)
{
throw new NFSdbConfigurationException("Settings loaded from disk has '{0}' " +
"columns but the serializer parsed " +
"class of '{1}' as '{2}' fields. Column count mismatch.",
confColumns.Count, itemType, parsedColLen);
}
for (int i = 0; i < confColumns.Count; i++)
{
bool found = false;
for (int j = i; j < parsedColLen; j++)
{
if (string.Equals(confColumns[i].Name, columnsList[j].PropertyName,
StringComparison.OrdinalIgnoreCase))
{
if (columnsList[j].ColumnType != confColumns[i].ColumnType)
{
if (!(confColumns[i].ColumnType == EFieldType.Symbol &&
columnsList[i].ColumnType == EFieldType.String))
{
throw new NFSdbConfigurationException("Type '{0}' has field '{1}' of type '{2}' " +
"while data on disk has column '{3}' of type '{4}'",
itemType, columnsList[j].PropertyName, columnsList[j].ColumnType,
confColumns[i].Name, confColumns[i].ColumnType);
}
}
// Put column j at place i in columnList
if (i != j)
{
var t = columnsList[j];
columnsList[j] = columnsList[i];
columnsList[i] = t;
}
found = true;
break;
}
}
if (!found)
{
throw new NFSdbConfigurationException("Type '{0}' does not have field for column name '{1}'",
itemType, confColumns[i].Name);
}
}
return(columnsList);
}
public JournalBuilder(JournalElement configuration)
{
_access = EFileAccess.ReadWrite;
_config = configuration;
}
public JournalBuilder()
{
_access = EFileAccess.ReadWrite;
_config = new JournalElement();
_config.SerializerName = MetadataConstants.POCO_SERIALIZER_NAME;
}
public static JournalMetadata CreateJournalMetadata(JournalElement config, Type t = null)
{
config = UpdateConfiguration(config);
return(CreateNewJournalMetadata(config));
}
public static void WriteJournalConfiguration(Stream output, JournalElement element)
{
JOURNAL_SERIALIZER.Serialize(output, element);
}
