private ReplicationFolder GetReplicationFolder(ConfigReplicationFolder configReplicationFolder)
{
if (configReplicationFolder == null)
{
throw new ArgumentNullException("configReplicationFolder");
}
ReplicationFolder replicationFolder = null;
IStorageMetadata replicationNodeMetadata = this.Engine.MetadataAdapter.GetStorage(configReplicationFolder.SourceNode);
if (replicationNodeMetadata != null)
{
StorageNode replicationNode = this.GetStorage(replicationNodeMetadata.UniqueID);
if (replicationNode == null)
{
throw new Exception(string.Format("Невозможно найти узел репликации {0} для папки {1}",
configReplicationFolder.SourceNode,
configReplicationFolder.Url));
}
replicationFolder = this.GetReplicationFolder(replicationNode.UniqueID, configReplicationFolder.Url);
}
return(replicationFolder);
}
private IStorageTransferTask PutData(NSData data, IStorageMetadata metadata = null)
{
var wrapper = new StorageTransferTaskWrapper <StorageUploadTask, NativeStorageMetadata>();
wrapper.TransferTask = _wrapped.PutData(data, metadata?.ToNative(), (x, e) => wrapper.CompletionHandler(x, e));
return(wrapper);
}
private void InitSchema()
{
object initConfig = ConfigurationManager.GetSection("StorageInitConfiguration");
if (initConfig == null)
{
throw new Exception(string.Format("Не задана секция инициализации конфигурации хранилища"));
}
XmlNode initNode = (XmlNode)initConfig;
string currentStorageHost = null;
XmlAttribute currentStorageAttr = initNode.Attributes["CurrentStorage"];
if (currentStorageAttr != null)
{
currentStorageHost = currentStorageAttr.Value;
}
if (string.IsNullOrEmpty(currentStorageHost))
{
throw new Exception(string.Format("В настройках не задан адрес текущего узла хранилища."));
}
bool requiredUpdate = true;
IStorageMetadata currentStorage = this.MetadataAdapter.CurrentStorage;
if (currentStorage == null)
{
currentStorage = this.MetadataAdapter.GetStorage(currentStorageHost);
}
else
{
//текущая нода есть в метаданных, проверяем соответствие хоста
string metadataHost = currentStorage.Host;
if (currentStorage.IsCurrent &&
!string.IsNullOrEmpty(metadataHost) &&
metadataHost.ToLower() == currentStorageHost.ToLower())
{
requiredUpdate = false;
}
}
if (requiredUpdate)
{
//нет ни текущей ноды, ни ноды с адресом из настройки
if (currentStorage == null)
{
//=> создаем текущую ноду
currentStorage = this.MetadataAdapter.CreateCurrentStorageNode(currentStorageHost);
}
else
{
currentStorage.Host = currentStorageHost.ToLower();
currentStorage.IsCurrent = true;
}
this.MetadataAdapter.SaveStorage(currentStorage);
}
}
public static NativeStorageMetadata ToNative(this IStorageMetadata @this)
{
return(new NativeStorageMetadata {
ContentDisposition = @this.ContentDisposition,
ContentEncoding = @this.ContentEncoding,
ContentLanguage = @this.ContentLanguage,
ContentType = @this.ContentType,
CustomMetadata = @this.CustomMetadata?.ToNSDictionary()
});
}
public StorageNode(StorageEngine storage, IStorageMetadata metadata)
{
if (storage == null)
{
throw new ArgumentNullException("storage");
}
if (metadata == null)
{
throw new ArgumentNullException("metadata");
}
this.TypedStorage = storage;
this.Metadata = metadata;
}
public void SaveStorage(IStorageMetadata storage)
{
if (storage == null)
{
throw new ArgumentNullException("storage");
}
this.Logger.WriteFormatMessage("SaveStorage: начало host: '{0}' isCurrent: '{1}'", storage.Host, storage.IsCurrent);
StorageMetadata typedStorage = (StorageMetadata)storage;
this.StorageAdapter.Update(typedStorage);
this.Logger.WriteMessage("SaveStorage: конец.");
}
public static NativeStorageMetadata ToNative(this IStorageMetadata @this)
{
var builder = new NativeStorageMetadata.Builder()
.SetCacheControl(@this.CacheControl)
.SetContentDisposition(@this.ContentDisposition)
.SetContentEncoding(@this.ContentEncoding)
.SetContentLanguage(@this.ContentLanguage)
.SetContentType(@this.ContentType);
@this
.CustomMetadata?
.ToList()
.ForEach(x => builder.SetCustomMetadata(x.Key, x.Value));
return(builder.Build());
}
internal ReplicationFolderMetadata(IFolderMetadata folder, IStorageMetadata storage)
{
if (folder == null)
{
throw new ArgumentNullException("folder");
}
if (storage == null)
{
throw new ArgumentNullException("storage");
}
this.SourceStorage = storage;
this.Folder = folder;
this.StorageID = storage.ID;
this.FolderID = folder.ID;
}
private StorageNode EnsureNode(Guid uniqueID, string host, out bool justCreated)
{
if (uniqueID == Guid.Empty)
{
throw new ArgumentNullException("uniqueID");
}
justCreated = false;
StorageNode savedNode = this.GetStorage(uniqueID);
if (savedNode == null)
{
lock (_updateStorageLocker)
{
savedNode = this.GetStorage(uniqueID);
if (savedNode == null)
{
//ноды нет в словаре, создаем
IStorageMetadata nodeMetadata = this.Engine.MetadataAdapter.CreateStorageNode(host, uniqueID);
nodeMetadata.LastAccessTime = DateTime.Now;
savedNode = new StorageNode(this.Engine, nodeMetadata);
this.Engine.MetadataAdapter.SaveStorage(nodeMetadata);
//добавляем в словарь
this.AddStorageNode(savedNode);
justCreated = true;
//после сохранения узла, может стать доступна настройка
//репликации с тим узлом
this.RebuildStorageReplicationFolders(savedNode);
}
}
}
return(savedNode);
}
public IStorageTransferTask PutBytes(byte[] bytes, IStorageMetadata metadata = null)
{
return(metadata == null
? _wrapped.PutBytes(bytes).ToAbstract()
: _wrapped.PutBytes(bytes, metadata.ToNative()).ToAbstract());
}
public async Task <IStorageMetadata> UpdateMetadataAsync(IStorageMetadata metadata)
{
return((await _wrapped.UpdateMetadataAsync(metadata.ToNative())).ToAbstract());
}
public IStorageTransferTask PutStream(Stream stream, IStorageMetadata metadata = null)
{
return(PutData(NSData.FromStream(stream), metadata));
}
public IStorageTransferTask PutFile(string filePath, IStorageMetadata metadata = null)
{
return(PutData(NSData.FromStream(File.Open(filePath, FileMode.Open)), metadata));
}
public IStorageTransferTask PutStream(Stream stream, IStorageMetadata metadata = null)
{
return(metadata == null
? _wrapped.PutStream(stream).ToAbstract()
: _wrapped.PutStream(stream, metadata.ToNative()).ToAbstract());
}
public IStorageTransferTask PutBytes(byte[] bytes, IStorageMetadata metadata = null)
{
return(PutData(NSData.FromArray(bytes), metadata));
}
/// <summary>
/// Создает метаданные существующего файла.
/// </summary>
/// <param name="storageMetadata">Метаданные хранилища.</param>
/// <param name="blobMetadata">Метаданные блоба.</param>
/// <param name="folderMetadata">Метаданные папки.</param>
/// <param name="fileHeader">Заголовок файла.</param>
/// <param name="blobStartPosition">Начальная позиция файла в блобе.</param>
/// <param name="blobEndPosition">Конечная позиция файла в блобе.</param>
/// <returns></returns>
public IBlobFileMetadata AddExistsFileVersion(IStorageMetadata storageMetadata, IBlobMetadata blobMetadata, IFolderMetadata folderMetadata, IFileHeader fileHeader, long blobStartPosition, long blobEndPosition)
{
if (storageMetadata == null)
{
throw new ArgumentNullException("storageMetadata");
}
if (blobMetadata == null)
{
throw new ArgumentNullException("blobMetadata");
}
if (folderMetadata == null)
{
throw new ArgumentNullException("folderMetadata");
}
if (fileHeader == null)
{
throw new ArgumentNullException("fileHeader");
}
if (blobStartPosition < 0)
{
throw new ArgumentNullException("blobStartPosition");
}
IBlobFileHeader blobHeader = (IBlobFileHeader)((object)fileHeader);
FileMetadata file = this.FileAdapter.GetFile(fileHeader.UniqueID, folderMetadata);
bool justCreated = false;
if (file == null)
{
justCreated = true;
file = new FileMetadata(this.FileAdapter);
file.UniqueID = fileHeader.UniqueID;
file.VersionUniqueID = fileHeader.VersionUniqueID;
file.FolderID = folderMetadata.ID;
file.FolderMetadata = folderMetadata;
file.Name = fileHeader.FileName;
file.BlobID = blobMetadata.ID;
file.BlobStartPosition = blobStartPosition;
file.BlobEndPosition = blobEndPosition;
file.Deleted = false;
file.Size = blobHeader.ContentLength;
file.TimeCreated = fileHeader.TimeCreated;
file.TimeModified = fileHeader.TimeCreated;
this.FileAdapter.UpdateFileTransparent(file);
}
else
{
if (file.Versions.Any(x => x.UniqueID == fileHeader.VersionUniqueID))
{
throw new Exception(String.Format("Версия с идентификатором [{0}] уже существует.", fileHeader.VersionUniqueID.ToString()));
}
}
//создание версии файла
FileVersionMetadata version = new FileVersionMetadata(file);
version.UniqueID = fileHeader.VersionUniqueID;
version.BlobID = blobMetadata.ID;
version.BlobStartPosition = blobStartPosition;
version.BlobEndPosition = blobEndPosition;
version.Size = blobHeader.ContentLength;
version.TimeCreated = fileHeader.TimeCreated;
version.CreatedStorageID = storageMetadata.ID;
version.Name = fileHeader.FileName;
//сохранение версии
this.FileAdapter.VersionAdapter.InsertVerion(file, version);
file.ResetVersions();
//обновление параметров существующего файла
if (!justCreated)
{
bool fileUpdate = false;
if (version.TimeCreated > file.TimeModified)
{
file.TimeModified = version.TimeCreated;
file.VersionUniqueID = version.UniqueID;
file.BlobID = version.BlobID;
fileUpdate = true;
}
if (version.TimeCreated < file.TimeCreated)
{
file.TimeCreated = version.TimeCreated;
fileUpdate = true;
}
//обновление файла
if (fileUpdate)
{
this.FileAdapter.UpdateFileTransparent(file);
}
}
return(file);
}
public IReplicationFolderMetadata CreateReplicationFolder(IFolderMetadata folder, IStorageMetadata targetStorage)
{
if (folder == null)
{
throw new ArgumentNullException("folder");
}
if (targetStorage == null)
{
throw new ArgumentNullException("targetStorage");
}
ReplicationFolderMetadata metadata = new ReplicationFolderMetadata(folder, targetStorage);
return(metadata);
}
public IStorageTransferTask PutFile(string filePath, IStorageMetadata metadata = null)
{
return(metadata == null
? _wrapped.PutFile(AndroidUri.FromFile(new File(filePath))).ToAbstract()
: _wrapped.PutFile(AndroidUri.FromFile(new File(filePath)), metadata.ToNative()).ToAbstract());
}
public IReplicationFolderMetadata GetReplicationFolder(IFolderMetadata folder, IStorageMetadata storage)
{
if (folder == null)
{
throw new ArgumentNullException("folder");
}
if (storage == null)
{
throw new ArgumentNullException("storage");
}
string condition = string.Format("[StorageID] = {0} AND [FolderID] = {1}",
storage.ID,
folder.ID);
IReplicationFolderMetadata result = null;
DBCollection <ReplicationFolderMetadata> replicationFolders = this.ReplicationFolderAdapter.GetReplicationFolders(condition);
if (replicationFolders != null && replicationFolders.Count > 0)
{
result = replicationFolders[0];
}
return(result);
}
/// <summary>
/// Возвращает метаданные папки репликации. Если ее не существует, то создает ее.
/// </summary>
/// <param name="folder">Папка.</param>
/// <param name="sourceStorage">Узел источник для репликации.</param>
/// <returns></returns>
public IReplicationFolderMetadata EnsureReplicationFolder(IFolderMetadata folder, IStorageMetadata sourceStorage)
{
if (folder == null)
{
throw new ArgumentNullException("folder");
}
if (sourceStorage == null)
{
throw new ArgumentNullException("sourceStorage");
}
IReplicationFolderMetadata replicationFolder = this.GetReplicationFolder(folder, sourceStorage);
if (replicationFolder == null)
{
replicationFolder = new ReplicationFolderMetadata(folder, sourceStorage);
this.SaveReplicationFolder(replicationFolder);
}
return(replicationFolder);
}
public Tuple <Guid, Guid>[] GetReplicationFiles(IStorageMetadata requestNode, IFolderMetadata folder, DateTime from)
{
if (requestNode == null)
{
throw new ArgumentNullException("requestNode");
}
if (folder == null)
{
throw new ArgumentNullException("folder");
}
List <Tuple <Guid, Guid> > files = new List <Tuple <Guid, Guid> >();
string folderDBName = folder.Url.Trim('/').Replace('/', '_');
string versionsPostfix = "Versions";
string searchPattern = string.Format("Files_{0}_%_{1}", folderDBName, versionsPostfix);
Dictionary <string, bool> partitions = this.GetExistsTables(searchPattern);
List <FileVersionData> allVersions = new List <FileVersionData>();
//идентификатор узла хранилища, который запрашивает файлы
//т.е. для текущего узла, на который пришел запрос он будет являтся
//узлом назначения для отправки файлов.
int targetStorageID = requestNode.ID;
if (partitions != null && partitions.Count > 0)
{
int n = MetadataConsts.Replication.BatchSize / partitions.Count;
//1 - получить TOP(n) файлов из каждого partition
string partitionsQuery = string.Empty;
foreach (string partition in partitions.Keys)
{
if (!string.IsNullOrEmpty(partitionsQuery))
{
partitionsQuery += string.Format(" {0}UNION ALL{0} ", Environment.NewLine);
}
string filesTableName = partition.TrimEnd(string.Format("_{0}", versionsPostfix).ToCharArray());
partitionsQuery += string.Format(@"SELECT TOP {0} f.UniqueID as FID, v.UniqueID as VID, v.TimeCreated
FROM [{1}] v
WITH(NOLOCK)
INNER JOIN [{2}] f
ON f.ID = v.FileID
AND v.CreatedStorageID <> {3}
AND v.TimeCreated > @startDate",
n,
partition,
filesTableName,
targetStorageID);
}
if (!string.IsNullOrEmpty(partitionsQuery))
{
string resultQuery = string.Format("WITH AllPartitions AS ({0}) SELECT FID, VID, TimeCreated FROM AllPartitions ORDER BY TimeCreated ASC",
partitionsQuery);
DateTime startDate;
if (from == DateTime.MinValue)
{
//пришла пустая дата
//выдаем минимальную дату ms sql
startDate = new DateTime(1753, 1, 1, 0, 0, 0, DateTimeKind.Utc);
}
else
{
//пришла дата
startDate = new DateTime(from.Year, from.Month, from.Day, from.Hour, from.Minute, from.Second, 0, DateTimeKind.Utc);
}
SqlParameter startDateParam = new SqlParameter("startDate", startDate);
DataTable resultTable = this.DataAdapter.GetDataTable(resultQuery, startDateParam);
if (resultTable != null && resultTable.Rows != null)
{
using (resultTable)
{
foreach (DataRow row in resultTable.Rows)
{
//FID, VID, TimeCreated
Guid fileID = DataRowReader.GetGuidValue(row, "FID");
if (fileID == Guid.Empty)
{
throw new Exception(string.Format("Не удалось получить идентификатор файла"));
}
Guid versionID = DataRowReader.GetGuidValue(row, "VID");
if (versionID == Guid.Empty)
{
throw new Exception(string.Format("Не удалось получить идентификатор версии файла"));
}
DateTime versionTime = DataRowReader.GetDateTimeValue(row, "TimeCreated");
if (versionTime == DateTime.MinValue)
{
throw new Exception(string.Format("Не удалось получить дату создания версии файла"));
}
FileVersionData fileVersionData = new FileVersionData(fileID, versionID, versionTime);
allVersions.Add(fileVersionData);
}
}
}
//сортируем и формируем кортеж идентификаторов
if (allVersions.Count > 1)
{
var sortedVersions = allVersions.OrderBy(v => v.VersionTime);
foreach (FileVersionData version in allVersions)
{
files.Add(Tuple.Create <Guid, Guid>(version.FileID, version.VersionID));
}
}
}
}
Tuple <Guid, Guid>[] filesToReplication = files.ToArray();
return(filesToReplication);
}
