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); }