public async Task <bool> Update(IStorableObject o)
{
await cache.InsertObject(o.CacheKey, JsonConvert.SerializeObject(o, o.GetType(), settings));
Debug.WriteLine("Updating in the cache: {0} ", o);
return(true);
}
public async Task <bool> Delete(IStorableObject o)
{
await cache.InvalidateObject <IStorableObject>(o.CacheKey);
Debug.WriteLine("Deleting from the cache: {0} ", o);
return(true);
}
public async Task <bool> Delete(IStorableObject o, bool deleteChildren)
{
bool success = true;
var delete = (o is User) ? UserInitiated.Delete((o as User).UserToken, deleteChildren) : UserInitiated.Delete(o as MedicalDevice);
if (await FinetunerServerReachable())
{
//returns void - to solve
await Policy
.Handle <WebException>()
.WaitAndRetryAsync
(
retryCount: 5,
sleepDurationProvider: retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt))
)
.ExecuteAsync(async() => await delete);
}
else
{
o.ExpirationTime = DateTime.Now;
Queue.Enqueue(o);
System.Diagnostics.Debug.WriteLine(Queue);
}
return(success);
}
public async Task <bool> Store(IStorableObject o, string key)
{
await cache.InsertObject(key, JsonConvert.SerializeObject(o, o.GetType(), settings));
Debug.WriteLine("Storing in the cache: {0} ", o);
return(true);
}
internal static T LoadObjectFromContent <T>(Repository repo, GitObjectReader input, string sha, long length) where T : IStorableObject
{
ConstructorInfo constr = typeof(T).GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[] { typeof(Repository), typeof(String) }, null);
IStorableObject result = (IStorableObject)constr.Invoke(new object[] { repo, sha });
// Let the respective object type load itself from the object content
result.Deserialize(input);
return((T)result);
}
internal static Tag Load(Repository repo, string sha, string path)
{
if (!Utility.IsValidSHA(sha))
{
throw new ParseException("Tag does not contain valid sha");
}
IStorableObject obj = repo.Storage.GetObject(sha);
// This is kind of flaky but for now the only way we can distinguish a regular and a lightweight tag
if (obj is Tag)
{
((Tag)obj).Path = path;
return((Tag)obj);
}
else
{
Tag t = new Tag(repo, sha);
t.Object = obj;
t.Path = path;
return(t);
}
}
/// <summary>
/// Find object in database and return it as an IStorableObject. Use the generic overload if you know the type up front. Throws ObjectNotFoundException if object was not found in database.
/// </summary>
/// <param name="sha">SHA object identifier. Throws ArgumentException if it is null or not a valid sha</param>
/// <returns>GitObject in database</returns>
public IStorableObject GetObject(string sha)
{
if (!Utility.SHAExpression.IsMatch(sha))
{
throw new ArgumentException("Need a valid sha", "sha");
}
string looseObjectPath = Path.Combine(ObjectsDir, Path.Combine(sha.Substring(0, 2), sha.Substring(2)));
// First check if object is stored in loose format
if (File.Exists(looseObjectPath))
{ // Object is stored loose. Inflate and load it from content
using (GitObjectReader reader = new GitObjectReader(Zlib.Decompress(looseObjectPath)))
{
long size;
ObjectType type;
size = reader.ReadObjectHeader(out type);
switch (type)
{
case ObjectType.Commit:
return(ObjectStorage.LoadObjectFromContent <Commit>(Repo, reader, sha, size));
case ObjectType.Tree:
return(ObjectStorage.LoadObjectFromContent <Tree>(Repo, reader, sha, size));
case ObjectType.Blob:
return(ObjectStorage.LoadObjectFromContent <Blob>(Repo, reader, sha, size));
case ObjectType.Tag:
return(ObjectStorage.LoadObjectFromContent <Tag>(Repo, reader, sha, size));
default:
throw new NotImplementedException();
}
}
}
else
{
IStorableObject result = null;
foreach (Pack pack in Packs)
{
try
{
result = pack.GetObject(sha);
}
catch (ObjectNotFoundException)
{ }
}
if (result != null)
{
return(result);
}
}
// Object was not found
throw new ObjectNotFoundException(sha);
}
public bool Store(IStorableObject target)
{
throw new NotImplementedException();
}
public bool SaveToDatabase(IStorableObject target)
{
throw new NotImplementedException();
}
