public ChunkData(byte[] id, byte[] data, byte[][] dependencies, byte[][] signatures, ChunkRepository source)
{
if (id == null)
throw new ArgumentNullException ("id");
if (data == null)
throw new ArgumentNullException ("data");
if (dependencies == null)
throw new ArgumentNullException ("dependencies");
for (int n = 0; n != dependencies.Length; n++) {
if (dependencies [n] == null) {
throw new ArgumentNullException (string.Format ("dependencies[{0}]", n));
}
}
if (source == null)
throw new ArgumentNullException ("source");
if (signatures == null)
throw new ArgumentNullException ("signatures");
for (int n = 0; n != signatures.Length; n++) {
if (signatures [n] == null) {
throw new ArgumentNullException (string.Format ("signatures[{0}]", n));
}
}
this.id = id;
this.data = data;
this.dependencies = dependencies;
this.source = source;
this.signatures = signatures;
}
public bool Login(byte[] userID, string password, string pepper)
{
if (userStorage.LoggedInUsers.Contains(userID))
{
throw new InvalidOperationException(string.Format("User [0x{0}] is already logged in.", userID.ToHexadecimal()));
}
bool v = userStorage.Login(userID, password, pepper);
if (v)
{
foreach (var ur in userStorage.GetUserRepositories(userID))
{
byte[] repoInfo = userStorage.GetRawRepositoryInfo(ur);
System.Xml.Serialization.XmlSerializer xmls = new System.Xml.Serialization.XmlSerializer(typeof(ChunkRepositoryConfiguration));
ChunkRepositoryConfiguration cri = (ChunkRepositoryConfiguration)xmls.Deserialize(new MemoryStream(repoInfo, false));
DatabasePath dbp = GetRepositoryPath(cri.ID);
if (dataStorage.ContainsKey(ur))
{
foreach (var sk in userStorage.GetUserRepository(ur).SymmetricKeys)
{
if (!dataStorage [ur].LencryptedData.ContainsKey(sk.Key))
{
dataStorage [ur].LencryptedData.Add(sk.Key, new AESEncryptingKeyValueStorage(
new LevelDBKeyValueStorage(dbp.CreatePath("Encrypted").CreatePath(sk.Key.ToHexadecimal()))
, sk.Value));
}
}
}
else
{
SortedDictionary <byte[], KeyValueStorage <byte[]> > EncryptedData = new SortedDictionary <byte[], KeyValueStorage <byte[]> > ();
foreach (var sk in userStorage.GetUserRepository(ur).SymmetricKeys)
{
KeyValueStorageConfiguration ESC = new KeyValueStorageConfiguration();
ESC.Type = cri.Data.Type;
ESC.Path = sk.Key.ToHexadecimal();
EncryptedData.Add(sk.Key, new AESEncryptingKeyValueStorage(
ESC.OpenStorage <byte[]> (dbp.CreatePath("Encrypted")), sk.Value));
}
ChunkRepository cr = new ChunkRepository(
cri.Data.OpenStorage <byte[]> (dbp),
cri.TopLevels.OpenStorage <byte[][]> (dbp),
cri.Dependencies.OpenStorage <byte[][]> (dbp),
cri.Meta.OpenStorage <byte[]> (dbp),
cri.MetaTopLevels.OpenStorage <byte[][]> (dbp),
cri.MetaDependencies.OpenStorage <byte[][]> (dbp),
cri.Signatures.OpenStorage <byte[][]> (dbp),
cri.ChunkSymmetricKeys.OpenStorage <byte[][]> (dbp),
cri.Index.OpenStorage <byte[]> (dbp),
EncryptedData);
dataStorage.Add(cr.ID, cr);
}
//encryptedStorageManager.Add (ur, new EncryptedStorageManager (cr, userStorage));
}
}
return(v);
}
public ChunkAgent(ServiceAgentMode serviceAgentMode, ObjectBusSession objectBusSession, Action flush, ChunkRepository repository)
: base(serviceAgentMode, objectBusSession, flush, false)
{
if (repository == null)
throw new ArgumentNullException ("repository");
this.repository = repository;
objectBusSession.RegisterType (typeof(TopLevelChunksRequestMessage), RequestTopLevelChunkDeltaMessageReceived);
// objectBusSession.RegisterType (typeof(BD2.Chunk.Daemon.Common.PollChunksRequestMessage), );
// objectBusSession.RegisterType (typeof(BD2.Chunk.Daemon.Common.PollNewChunksRequestMessage), );
// objectBusSession.RegisterType (typeof(BD2.Chunk.Daemon.Common.PushChunksRequestMessage), );
//this.repository.Enumerate ();
}
public ChunkData(byte[] id, byte[] data, byte[][] dependencies, byte[][] signatures, ChunkRepository source)
{
if (id == null)
{
throw new ArgumentNullException("id");
}
if (data == null)
{
throw new ArgumentNullException("data");
}
if (dependencies == null)
{
throw new ArgumentNullException("dependencies");
}
for (int n = 0; n != dependencies.Length; n++)
{
if (dependencies [n] == null)
{
throw new ArgumentNullException(string.Format("dependencies[{0}]", n));
}
}
if (source == null)
{
throw new ArgumentNullException("source");
}
if (signatures == null)
{
throw new ArgumentNullException("signatures");
}
for (int n = 0; n != signatures.Length; n++)
{
if (signatures [n] == null)
{
throw new ArgumentNullException(string.Format("signatures[{0}]", n));
}
}
this.id = id;
this.data = data;
this.dependencies = dependencies;
this.source = source;
this.signatures = signatures;
}
public void AddChunkRepository(ChunkRepository chunkRepository)
{
crs.Add(chunkRepository);
if (chunkRepository == null)
{
throw new ArgumentNullException("chunkRepository");
}
foreach (var user in userRepository.LoggedInUsers)
{
GenericUserRepositoryCollection userreps = userRepository.GetUserRepository(user);
RSAEncryptingKeyValueStorage symmetricKeys = userreps.SymmetricKeys;
foreach (var sk in symmetricKeys)
{
if (!permanentStorage.ContainsKey(sk.Key))
{
permanentStorage.Add(sk.Key, new AESEncryptingKeyValueStorage(chunkRepository.LencryptedData [sk.Key], sk.Value));
}
}
}
}
void LoadRepository(ChunkRepository cr)
{
SortedDictionary <byte[], byte[]> pendingData = new SortedDictionary <byte[], byte[]> (ByteSequenceComparer.Shared);
foreach (var d in cr.Ldata)
{
pendingData.Add(d.Key, d.Value);
}
while (pendingData.Count != 0)
{
foreach (var tup in new SortedDictionary <byte[], byte[]>(pendingData, BD2.Core.ByteSequenceComparer.Shared))
{
//Console.WriteLine ("Testing object");
byte[] nchunk = tup.Key;
byte[][] deps = cr.LdataDependencies.Get(nchunk);
if (deps == null)
{
throw new InvalidDataException();
}
Console.WriteLine("dependency count = {0}", deps.Length);
foreach (byte[] dep in deps)
{
if (pendingData.ContainsKey(dep))
{
Console.WriteLine("Found an unloaded dependency, skipping...");
nchunk = null;
}
}
if (nchunk == null)
{
continue;
}
Console.WriteLine("All the dependencies are loaded, proceeding...");
byte[] chunkData = tup.Value;
LoadChunk(nchunk, chunkData);
pendingData.Remove(nchunk);
}
}
}
public static SortedSet <byte[]> CreateSmallestDependencyCollection(ChunkRepository repo, SortedSet <byte[]> chunks, int extraPasses = 4)
{
SortedSet <byte[]> removables = new SortedSet <byte[]> (ByteSequenceComparer.Shared);
SortedSet <byte[]> resolved = new SortedSet <byte[]> (chunks, ByteSequenceComparer.Shared);
SortedSet <byte[]> results = new SortedSet <byte[]> (chunks, ByteSequenceComparer.Shared);
foreach (byte[] chunk in chunks)
{
removables.UnionWith(repo.ldataDependencies.Get(chunk));
}
for (int n = 0; n != extraPasses; n++)
{
foreach (byte[] chunk in removables)
{
if (!resolved.Contains(chunk))
{
removables.UnionWith(repo.ldataDependencies.Get(chunk));
resolved.Add(chunk);
}
}
}
results.ExceptWith(removables);
return(results);
}
public ChunkAgentOptions(ChunkRepository repository)
{
if (repository == null)
throw new ArgumentNullException ("repository");
this.repository = repository;
}
public static ServiceAgent CreateAgent(ServiceAgentMode serviceAgentMode, ObjectBusSession objectBusSession, Action flush, ChunkRepository repository)
{
if (repository == null)
throw new ArgumentNullException ("repository");
return new ChunkAgent (serviceAgentMode, objectBusSession, flush, repository);
}
void LoadUserStorageBase(byte[] userID, byte[] ur)
{
Log.WriteLine ("Database.LoadUserStorageBase()");
{
byte[] repoInfo = userStorage.GetRawRepositoryInfo (ur);
Log.WriteLine ("Raw Repository info:{0}", repoInfo.ToHexadecimal ());
System.Xml.Serialization.XmlSerializer xmls = new System.Xml.Serialization.XmlSerializer (typeof(ChunkRepositoryConfiguration));
ChunkRepositoryConfiguration cri = (ChunkRepositoryConfiguration)xmls.Deserialize (new MemoryStream (repoInfo, false));
Log.WriteLine ("Repository info id:{0}", cri.ID);
DatabasePath dbp = GetRepositoryPath (cri.ID);
if (dataStorage.ContainsKey (ur)) {
Log.WriteLine ("repo {0} is already loaded. loading encrypted parts with new keys.", ur);
foreach (var sk in userStorage.GetUserStorage (userID).SymmetricKeys) {
if (!dataStorage [ur].LencryptedData.ContainsKey (sk.Key)) {
Log.WriteLine ("loading key {0}", sk.Key.ToHexadecimal ());
KeyValueStorageConfiguration ESC = new KeyValueStorageConfiguration ();
ESC.Type = cri.Data.Type;
ESC.Path = sk.Key.ToHexadecimal ();
dataStorage [ur].LencryptedData.Add (sk.Key, new AESEncryptingKeyValueStorage (ESC.OpenStorage<byte[]> (dbp.CreatePath ("Encrypted")), sk.Value));
}
}
} else {
SortedDictionary<byte[], KeyValueStorage<byte[]>> EncryptedData = new SortedDictionary<byte[], KeyValueStorage<byte[]>> ();
foreach (var sk in userStorage.GetUserStorage (userID).SymmetricKeys) {
KeyValueStorageConfiguration ESC = new KeyValueStorageConfiguration ();
ESC.Type = cri.Data.Type;
ESC.Path = sk.Key.ToHexadecimal ();
EncryptedData.Add (sk.Key, new AESEncryptingKeyValueStorage (ESC.OpenStorage<byte[]> (dbp.CreatePath ("Encrypted")), sk.Value));
}
ChunkRepository cr = new ChunkRepository (cri.ID, cri.Data.OpenStorage<byte[]> (dbp), cri.TopLevels.OpenStorage<byte[][]> (dbp), cri.Dependencies.OpenStorage<byte[][]> (dbp), cri.Meta.OpenStorage<byte[]> (dbp), cri.MetaTopLevels.OpenStorage<byte[][]> (dbp), cri.MetaDependencies.OpenStorage<byte[][]> (dbp), cri.Signatures.OpenStorage<byte[][]> (dbp), cri.ChunkSymmetricKeys.OpenStorage<byte[][]> (dbp), cri.Index.OpenStorage<byte[]> (dbp), cri.InternalMeta.OpenStorage<byte[]> (dbp), EncryptedData);
dataStorage.Add (cr.ID, cr);
ChunkRepositoryAdded (this, new ChunkRepositoryAddedEventArgs (cr));
}
//encryptedStorageManager.Add (ur, new EncryptedStorageManager (cr, userStorage));
}
{
byte[] cus = userStorage.GetCommonStorage ();
Log.WriteLine ("Common storage id is {0}", cus.ToHexadecimal ());
if (!dataStorage.ContainsKey (cus)) {
Log.WriteLine ("and we don't have it.");
Log.WriteLine ("we only have:");
foreach (var t in dataStorage)
Log.WriteLine (" ID: {0}", t.Key.ToHexadecimal ());
throw new NotImplementedException ();
byte[] repoInfo = userStorage.GetRawRepositoryInfo (ur);
SortedDictionary<byte[], KeyValueStorage<byte[]>> EncryptedData = new SortedDictionary<byte[], KeyValueStorage<byte[]>> ();
System.Xml.Serialization.XmlSerializer xmls = new System.Xml.Serialization.XmlSerializer (typeof(ChunkRepositoryConfiguration));
ChunkRepositoryConfiguration cri = (ChunkRepositoryConfiguration)xmls.Deserialize (new MemoryStream (repoInfo, false));
DatabasePath dbp = GetRepositoryPath (cri.ID);
KeyValueStorageConfiguration ESC = new KeyValueStorageConfiguration ();
ESC.Type = cri.Data.Type;
ESC.Path = cus.ToHexadecimal ();
byte[] ak = null;
EncryptedData.Add (cus, new AESEncryptingKeyValueStorage (ESC.OpenStorage<byte[]> (dbp.CreatePath ("Encrypted")), ak));
ChunkRepository cr = new ChunkRepository (cri.ID, cri.Data.OpenStorage<byte[]> (dbp), cri.TopLevels.OpenStorage<byte[][]> (dbp), cri.Dependencies.OpenStorage<byte[][]> (dbp), cri.Meta.OpenStorage<byte[]> (dbp), cri.MetaTopLevels.OpenStorage<byte[][]> (dbp), cri.MetaDependencies.OpenStorage<byte[][]> (dbp), cri.Signatures.OpenStorage<byte[][]> (dbp), cri.ChunkSymmetricKeys.OpenStorage<byte[][]> (dbp), cri.Index.OpenStorage<byte[]> (dbp), cri.InternalMeta.OpenStorage<byte[]> (dbp), EncryptedData);
dataStorage.Add (cr.ID, cr);
ChunkRepositoryAdded (this, new ChunkRepositoryAddedEventArgs (cr));
}
}
}
void LoadRepository(ChunkRepository cr)
{
Log.WriteLine ("Database.LoadRepository()");
SortedSet<byte[]> pendingData = new SortedSet<byte[]> (ByteSequenceComparer.Shared);
var e = cr.Ldata.EnumerateKeys ();
while (e.MoveNext ())
pendingData.Add (e.Current);
while (pendingData.Count != 0)
foreach (var nchunk in new SortedSet<byte[]>(pendingData, ByteSequenceComparer.Shared)) {
//Log.WriteLine ("Testing object");
byte[][] deps = cr.LdataDependencies.Get (nchunk);
if (deps == null)
throw new InvalidDataException ();
Log.WriteLine ("dependency count = {0}", deps.Length);
if (pendingData.Overlaps (deps)) {
Log.WriteLine ("Found an unloaded dependency, skipping...");
continue;
}
Log.WriteLine ("All the dependencies are loaded, proceeding...");
LoadChunk (nchunk, cr);
pendingData.Remove (nchunk);
}
}
ChunkHeaderv1 LoadChunk(byte[] chunkID, ChunkRepository cr)
{
Log.WriteLine ("Database.LoadChunk()");
foreach (var f in frontends)
f.Value.AddDataObjects (chunkID, cr);
return null;
}
public static SortedSet<byte[]> CreateSmallestDependencyCollection(ChunkRepository repo, SortedSet<byte[]> chunks, int extraPasses = 4)
{
SortedSet<byte[]> removables = new SortedSet<byte[]> (ByteSequenceComparer.Shared);
SortedSet<byte[]> resolved = new SortedSet<byte[]> (chunks, ByteSequenceComparer.Shared);
SortedSet<byte[]> results = new SortedSet<byte[]> (chunks, ByteSequenceComparer.Shared);
foreach (byte[] chunk in chunks) {
removables.UnionWith (repo.ldataDependencies.Get (chunk));
}
for (int n = 0; n != extraPasses; n++) {
foreach (byte[] chunk in removables) {
if (!resolved.Contains (chunk)) {
removables.UnionWith (repo.ldataDependencies.Get (chunk));
resolved.Add (chunk);
}
}
}
results.ExceptWith (removables);
return results;
}
public ChunkRepositoryAddedEventArgs(ChunkRepository chunkRepository)
{
if (chunkRepository == null)
throw new ArgumentNullException ("chunkRepository");
this.chunkRepository = chunkRepository;
}
static void OpenLevelDBRepository(string[] commandParts)
{
string nick = commandParts [2];
string path = commandParts [3];
ChunkRepository LRepo = new ChunkRepository (path);
lock (repositories)
repositories.Add (nick, LRepo);
}
