public static IMd Create(int level)
{
var locator = new MdLocator(new byte[32], DataProtocol.DEFAULT_PROTOCOL);
_rand.NextBytes(locator.XORName);
return(Locate(locator, level));
}
async Task <IMdNode> GetNewMdNodeAsync()
{
// Create Permissions
using (var permissionsHandle = await _dataOps.Session.MDataPermissions.NewAsync())
{
using (var appSignPkH = await _dataOps.Session.Crypto.AppPubSignKeyAsync())
await _dataOps.Session.MDataPermissions.InsertAsync(permissionsHandle, appSignPkH, _dataOps.GetFullPermissions());
// Set Permissions
foreach (var pair in _permissions.MdHeadPermissions)
{
var userSignKeyH = await _dataOps.Session.Crypto.SignPubKeyNewAsync(pair.Key);
await _dataOps.Session.MDataPermissions.InsertAsync(permissionsHandle, userSignKeyH, pair.Value);
}
// New mdHead
var mdInfo = await _dataOps.CreateEmptyRandomPrivateMd(permissionsHandle, DataProtocol.DEFAULT_AD_PROTOCOL); // TODO: DataProtocol.MD_HEAD);
var locator = new MdLocator(mdInfo.Name, mdInfo.TypeTag, mdInfo.EncKey, mdInfo.EncNonce);
var mdResult = await _nodeFactory.LocateAsync(locator);
if (!mdResult.HasValue)
{
throw new ArgumentException(mdResult.ErrorMsg);
}
return(mdResult.Value);
}
}
public RecordInfo(string path, MdLocator locator,
Func <string, Result <StoredValue> > infoReader, Func <string, StoredValue, Result <Pointer> > infoWriter)
{
Path = path;
Locator = locator;
_infoReader = infoReader;
_infoWriter = infoWriter;
}
public async Task <MdHead> GetOrAddHeadAsync(string mdName)
{
if (mdName.Contains(".") || mdName.Contains("@"))
{
throw new NotSupportedException("Unsupported characters '.' and '@'.");
}
var mdId = $"{_protocol}/{mdName}";
if (_mdContainer.MdLocators.ContainsKey(mdId))
{
var location = _mdContainer.MdLocators[mdId];
var mdResult = await LocateMdNode(location);
return(new MdHead(mdResult.Value, mdId));
}
// Create Permissions
using (var permissionsHandle = await _dataOps.Session.MDataPermissions.NewAsync())
{
using (var appSignPkH = await _dataOps.Session.Crypto.AppPubSignKeyAsync())
{
await _dataOps.Session.MDataPermissions.InsertAsync(permissionsHandle, appSignPkH, _dataOps.GetFullPermissions());
}
// New mdHead
var mdInfo = await _dataOps.CreateEmptyRandomPrivateMd(permissionsHandle, DataProtocol.DEFAULT_PROTOCOL); // TODO: DataProtocol.MD_HEAD);
var location = new MdLocator(mdInfo.Name, mdInfo.TypeTag, mdInfo.EncKey, mdInfo.EncNonce);
// add mdHead to mdContainer
_mdContainer.MdLocators[mdId] = location;
// Finally update App Container with newly serialized mdContainer
var serializedMdContainer = _mdContainer.Json();
var appContainer = await _dataOps.Session.AccessContainer.GetMDataInfoAsync(APP_CONTAINER_PATH);
var mdKeyCipherBytes = await _dataOps.Session.MDataInfoActions.EncryptEntryKeyAsync(appContainer, MD_CONTAINER_KEY_BYTES);
var mdCipherBytes = await _dataOps.Session.MDataInfoActions.EncryptEntryValueAsync(appContainer, serializedMdContainer.ToUtfBytes());
using (var appContEntryActionsH = await _dataOps.Session.MDataEntryActions.NewAsync())
{
await _dataOps.Session.MDataEntryActions.UpdateAsync(appContEntryActionsH, mdKeyCipherBytes, mdCipherBytes, _mdContainerVersion + 1);
await _dataOps.Session.MData.MutateEntriesAsync(appContainer, appContEntryActionsH); // <---------------------------------------------- Commit ------------------------
}
++_mdContainerVersion;
var mdResult = await LocateMdNode(location);
return(new MdHead(mdResult.Value, mdId));
}
}
public static async Task <Result <IIndexer> > GetOrAddAsync(string directoryPath)
{
var indexLocation = new MdLocator(Encoding.UTF8.GetBytes($"{directoryPath}_indexer"), DataProtocol.DEFAULT_PROTOCOL);
var indexMd = await MdAccess.LocateAsync(indexLocation).ConfigureAwait(false);
if (!indexMd.HasValue)
{
indexMd = Result.OK(await MdAccess.CreateAsync(0));
}
var indexHead = new MdHead(indexMd.Value, directoryPath);
var indexer = await Indexer.GetOrAddAsync(indexHead);
return(Result.OK((IIndexer)indexer));
}
public static async Task <Result <IMd> > LocateAsync(MdLocator location, NetworkDataOps networkDataOp)
{
var mdResult = await networkDataOp.LocatePublicMd(location.XORName, location.TypeTag);
if (!mdResult.HasValue)
{
return(new KeyNotFound <IMd>($"Could not locate md: {location.TypeTag}, {location.XORName}"));
}
var mdInfo = mdResult.Value;
var md = new MdOps(mdInfo, networkDataOp.Session);
await md.GetOrAddMetadata();
return(Result.OK((IMd)md));
}
public static async Task <Result <IMdNode> > LocateAsync(MdLocator location, Session session)
{
var networkDataOps = new NetworkDataOps(session);
// var mdResult = await networkDataOps.LocatePublicMd(location.XORName, location.TypeTag);
var mdResult = await networkDataOps.LocatePrivateMd(location.XORName, location.TypeTag, location.SecEncKey, location.Nonce);
if (!mdResult.HasValue)
{
return(new KeyNotFound <IMdNode>($"Could not locate md: {location.TypeTag}, {location.XORName}"));
}
var mdInfo = mdResult.Value;
var md = new MdNode(mdInfo, networkDataOps.Session);
await md.GetOrAddMetadata();
return(Result.OK((IMdNode)md));
}
public async Task <Result <IMdNode> > LocateAsync(MdLocator location)
{
// var mdResult = await networkDataOps.LocatePublicMd(location.XORName, location.TypeTag);
var mdResult = await _networkOps.LocatePrivateMd(location.XORName, location.TypeTag, location.SecEncKey, location.Nonce)
.ConfigureAwait(false);
if (!mdResult.HasValue)
{
return(new KeyNotFound <IMdNode>($"Could not locate md: {location.TypeTag}, {location.XORName}"));
}
var mdInfo = mdResult.Value;
var dataOps = new MdDataOps(this, _networkOps, mdInfo);
var md = new MdNode(dataOps, _snapshotter);
await md.Initialize(metadata : null).ConfigureAwait(false);
return(Result.OK((IMdNode)md));
}
public static async Task <Result <Directory> > GetOrAddAsync(string directoryPath)
{
var indexer = await IndexerFactory.GetOrAddAsync(directoryPath);
if (!indexer.HasValue)
{
return(Result.Fail <Directory>(indexer.ErrorCode.Value, indexer.ErrorMsg));
}
var dirLocation = new MdLocator(Encoding.UTF8.GetBytes(directoryPath), DataProtocol.DEFAULT_PROTOCOL);
var dirMd = await MdAccess.LocateAsync(dirLocation).ConfigureAwait(false);
if (!dirMd.HasValue)
{
dirMd = Result.OK(await MdAccess.CreateAsync(0));
}
var dirHead = new MdHead(dirMd.Value, directoryPath);
var dirResult = await Directory.GetOrAddAsync(dirHead, indexer.Value);
return(dirResult);
}
public async Task <IDatabase> GetOrAddDataBaseAsync(string dbName)
{
var indexLocation = new MdLocator(System.Text.Encoding.UTF8.GetBytes($"{dbName}_indexer"), DataProtocol.DEFAULT_PROTOCOL, null, null);
var indexMd = await MdAccess.LocateAsync(indexLocation).ConfigureAwait(false);
if (!indexMd.HasValue)
{
throw new System.Exception(indexMd.ErrorMsg);
}
var indexHead = new MdHead(indexMd.Value, dbName);
var indexer = await Indexer.GetOrAddAsync(indexHead);
var dbLocation = new MdLocator(System.Text.Encoding.UTF8.GetBytes(dbName), DataProtocol.DEFAULT_PROTOCOL, null, null);
var dbMd = await MdAccess.LocateAsync(dbLocation).ConfigureAwait(false);
if (!dbMd.HasValue)
{
throw new System.Exception(dbMd.ErrorMsg);
}
var dbHead = new MdHead(dbMd.Value, dbName);
var dbResult = await Database.GetOrAddAsync(dbHead, indexer);
return(dbResult.Value);
}
public static IMd Locate(MdLocator locator, int level = 0)
{
var xorString = GetString(locator);
using (var db = GetRocksDb())
{
var metaKey = $"{xorString}_0"; // entry 0
var column = db.GetColumnFamily(COLUMN_FAMILY);
var value = db.Get(metaKey, cf: column);
if (value == null) // if not found, create with level 0
{
var data = new LocalMdData
{
Locator = locator,
LocatorString = xorString,
Level = level
};
value = data.Json();
db.Put(metaKey, new StoredValue(level).Json(), cf: column); // store level 0
return(new LocalMd(data));
}
else
{
var existing = new LocalMdData
{
Locator = locator,
LocatorString = xorString,
Level = value.Parse <StoredValue>().Payload.Parse <int>()
};
int.TryParse(db.Get($"{xorString}_Count", cf: column), out existing.Count);
return(new LocalMd(existing));
}
}
}
static string GetString(MdLocator locator)
{
var xorString = $"{locator.XORName.Json()}_{locator.TypeTag}";
return(xorString);
}
public MdFileInfo(string path, MdLocator locator,
Func <string, Result <StoredValue> > infoReader, Func <string, StoredValue, Result <Pointer> > infoWriter)
: base(path, locator, infoReader, infoWriter)
{
}
public static async Task <Result <Directory> > GetOrAddAsync(string directoryPath, MdLocator dirLocator)
{
var indexer = await IndexerFactory.GetOrAddAsync(directoryPath);
if (!indexer.HasValue)
{
return(Result.Fail <Directory>(indexer.ErrorCode.Value, indexer.ErrorMsg));
}
var dirMd = await MdAccess.LocateAsync(dirLocator).ConfigureAwait(false);
if (!dirMd.HasValue)
{
return(Result.Fail <Directory>(dirMd.ErrorCode.Value, dirMd.ErrorMsg));
}
var dirHead = new MdHead(dirMd.Value, directoryPath);
var dirResult = await Directory.GetOrAddAsync(dirHead, indexer.Value);
return(dirResult);
}
async Task UpdateTypeStores(string type, MdLocator location)
{
await _typeInfo.UpdateAsync(type, location).ConfigureAwait(false);
_dataTreeAddresses[type] = location;
}
public Task <Result <IMd> > LocateMdOps(MdLocator location)
{
return(MdOps.LocateAsync(location, new NetworkDataOps(Session)));
}
public Task <Result <IMdNode> > LocateMdNode(MdLocator location)
{
return(MdNode.LocateAsync(location, _dataOps.Session));
}
