public async Task <IActionResult> Get(StorableIdentifier identifier, string key)
{
IStorageObject storageObject = await _storageService.LoadAsync(identifier).ConfigureAwait(false);
Request.HttpContext.Response.Headers.Add("Metadata", storageObject.Metadata);
return(new FileStreamResult(storageObject.DataStream, "application/octet-stream"));
}
private async Task <WebResponse> callLoadAsync(StorableIdentifier identifier)
{
var request = WebRequest.Create($"{GetProtocol()}://{Config.Host}/api/store/{identifier.Category}/{identifier.UniqueName}/{Config.Key}");
request.Method = "GET";
return(await request.GetResponseAsync().ConfigureAwait(false));
}
public async Task SaveAsync(Stream dataStream, string metadata, StorableIdentifier identifier)
{
using (MemoryStream memStream = new MemoryStream())
{
await dataStream.CopyToAsync(memStream);
memStream.Seek(0, SeekOrigin.Begin);
StorageObject binObj = new StorageObject()
{
Category = identifier.Category,
UniqueName = identifier.UniqueName,
Content = memStream.ToArray(),
Metadata = metadata
};
StorageObject oldStorageObj = _context.StorageObjects.Where(so => so.Category == identifier.Category && so.UniqueName == identifier.UniqueName).FirstOrDefault();
if (oldStorageObj != null)
{
_context.StorageObjects.Remove(oldStorageObj);
await _context.SaveChangesAsync().ConfigureAwait(false);
}
await _context.StorageObjects.AddAsync(binObj).ConfigureAwait(false);
await _context.SaveChangesAsync().ConfigureAwait(false);
}
}
public async Task DeleteAsync(StorableIdentifier identifier)
{
StorageObject storageObject = _context.StorageObjects.Where(so => so.Category == identifier.Category && so.UniqueName == identifier.UniqueName).FirstOrDefault();
if (storageObject != null)
{
_context.StorageObjects.Remove(storageObject);
}
await _context.SaveChangesAsync().ConfigureAwait(false);
}
public Task <IStorageObject> LoadAsync(StorableIdentifier identifier)
{
IStorageObject storageObject = _context.StorageObjects.Where(so => so.Category == identifier.Category && so.UniqueName == identifier.UniqueName).FirstOrDefault();
if (storageObject == null)
{
return(Task.FromResult <IStorageObject>(null));
}
return(Task.FromResult(storageObject));
}
/// <summary>
/// Loads a storable from the server.
/// </summary>
/// <param name="identifier"></param>
/// <returns></returns>
public async Task <IStorable> LoadStorableAsync(StorableIdentifier identifier)
{
WebResponse response = await callLoadAsync(identifier).ConfigureAwait(false);
Storable storable = new Storable
{
DataStream = response.GetResponseStream(),
Metadata = response.Headers["Metadata"]
};
return(storable);
}
/// <summary>
/// Saves a strong-typed object to the server.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="data"></param>
/// <param name="identifier"></param>
/// <returns></returns>
public async Task SaveAsync <T>(T data, StorableIdentifier identifier)
where T : class
{
DataContractJsonSerializer jsonSerializer = new DataContractJsonSerializer(typeof(T));
using (MemoryStream memStream = new MemoryStream())
{
jsonSerializer.WriteObject(memStream, data);
memStream.Seek(0, SeekOrigin.Begin);
await callSaveAsync(memStream, typeof(T).FullName, identifier).ConfigureAwait(false);
}
}
/// <summary>
/// Loads a strong-typed object to the server.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="identifier"></param>
/// <returns></returns>
public async Task <T> LoadAsync <T>(StorableIdentifier identifier)
where T : class
{
WebResponse response = await callLoadAsync(identifier).ConfigureAwait(false);
DataContractJsonSerializer jsonSerializer = new DataContractJsonSerializer(typeof(T));
using (Stream stream = response.GetResponseStream())
{
T result = jsonSerializer.ReadObject(stream) as T;
return(result);
}
}
public async Task TestSaveLoadObjectAsync()
{
TestData testData = new TestData()
{
StringData = "Hello world!"
};
//IHitmanClient hitmanClient = new HitmanCoreClient(new HitmanCoreConfig() { Host="localhost:51195"});
IHitmanClient hitmanClient = new HitmanStorageClient(new HitmanStorageConfig()
{
Host = "hitmanservice.azurewebsites.net"
});
StorableIdentifier identifier = new StorableIdentifier()
{
Category = "Test",
UniqueName = "01"
};
await hitmanClient.SaveAsync(testData, identifier);
TestData result = await hitmanClient.LoadAsync <TestData>(identifier);
Assert.Equal(testData.StringData, result.StringData);
}
public async Task <IActionResult> Delete(StorableIdentifier identifier, string key)
{
await _storageService.DeleteAsync(identifier).ConfigureAwait(false);
return(new OkResult());
}
public async Task <IActionResult> Post(StorableIdentifier identifier, string key)
{
await _storageService.SaveAsync(Request.Body, Request.Headers["Metadata"], identifier).ConfigureAwait(false);
return(new OkResult());
}
private async Task <WebResponse> callSaveAsync(Stream dataStream, string metadata, StorableIdentifier identifier)
{
var request = WebRequest.Create($"{GetProtocol()}://{Config.Host}/api/store/{identifier.Category}/{identifier.UniqueName}/{Config.Key}");
request.Headers.Add("Metadata", metadata);
request.Method = "POST";
using (Stream requestStream = request.GetRequestStream())
{
await dataStream.CopyToAsync(requestStream).ConfigureAwait(false);
}
return(await request.GetResponseAsync().ConfigureAwait(false));
}
/// <summary>
/// Saves a storable to the server.
/// </summary>
/// <param name="storable"></param>
/// <param name="identifier"></param>
/// <returns></returns>
public async Task SaveStorableAsync(IStorable storable, StorableIdentifier identifier)
{
await callSaveAsync(storable.DataStream, storable.Metadata, identifier).ConfigureAwait(false);
}
