public async Task <IHttpResponseMessageAbstraction> SendAsync() { var requestMessage = new HttpRequestMessage(); requestMessage.Method = this.Method; requestMessage.RequestUri = this.RequestUri; if (this.Method == HttpMethod.Post || this.Method == HttpMethod.Put) { requestMessage.Content = this.CopyContent(); requestMessage.Content.Headers.ContentType = new MediaTypeHeaderValue(this.ContentType); } requestMessage.Headers.Clear(); foreach (KeyValuePair <string, string> header in this.RequestHeaders) { requestMessage.Headers.Add(header.Key, header.Value); } this.client.Timeout = this.Timeout; DateTime start = DateTime.Now; try { var result = await this.client.SendAsync(requestMessage, this.cancellationToken); string content = null; if (result.Content.IsNotNull()) { content = result.Content.ReadAsStringAsync().WaitForResult(); } var retval = new HttpResponseMessageAbstraction(result.StatusCode, new HttpResponseHeadersAbstraction(result.Headers), content); this.LogRequestResponseDetails(retval); return(retval); } catch (Exception ex) { this.LogRequestException(ex); var tcex = ex as TaskCanceledException; if (tcex.IsNotNull()) { if (this.cancellationToken.IsCancellationRequested) { throw new OperationCanceledException("The operation was canceled at the users request.", tcex, this.cancellationToken); } else if (DateTime.Now - start > this.Timeout) { throw new TimeoutException(string.Format(CultureInfo.InvariantCulture, "The requested task failed to complete in the allotted time ({0}).", this.Timeout)); } } throw; } }
/// <summary> /// Append to an existing file. /// </summary> /// <param name="path">The existing file to be appended.</param> /// <param name="data">Data to be appended</param> /// <param name="bufferSize">The size of the buffer to be used.</param> /// <returns>Confirmation message</returns> public Task<IHttpResponseMessageAbstraction> Append(string path, Stream data) { ApplianceStorageSimulatorItem file = this.GetItem(path); if (file.IsNotNull()) { var byteData = file.Data.Concat(ReadToEnd(data)).ToArray(); this.ChangeItemData(file, byteData); IHttpResponseMessageAbstraction response = new HttpResponseMessageAbstraction(HttpStatusCode.OK, null, String.Empty); return Task.FromResult(response); } else { throw new FileNotFoundException("File to be appended is not found"); } }
private void LogRequestResponseDetails(HttpResponseMessageAbstraction response) { bool isFirst; var requestHeaders = this.GetFormatedRequestHeaders(); isFirst = true; StringBuilder responseHeaders = new StringBuilder(); var responseContentType = HttpConstants.ApplicationXml; foreach (var header in response.Headers) { if (!isFirst) { responseHeaders.Append(string.Empty.PadLeft(15)); } if (header.Key == HttpConstants.ContentTypeHeader && header.Value.IsNotNull()) { responseContentType = string.Join(",", header.Value); } responseHeaders.Append(header.Key); responseHeaders.Append(" = "); bool innerFirst = true; foreach (var value in header.Value) { if (!innerFirst) { responseHeaders.Append(string.Empty.PadLeft(15 + header.Key.Length + 3)); } responseHeaders.AppendLine(value); innerFirst = false; } isFirst = false; } var formattedRequestContent = this.StringContent; if (this.ContentType == HttpConstants.ApplicationXml) { TryPrettyPrintXml(formattedRequestContent, out formattedRequestContent); } var formattedResponseContent = response.Content; if (responseContentType == HttpConstants.ApplicationXml) { TryPrettyPrintXml(formattedResponseContent, out formattedResponseContent); } string message = string.Format(CultureInfo.InvariantCulture, ResponseLogFormat, this.RequestUri, this.Method, this.ContentType, requestHeaders, formattedRequestContent, response.StatusCode, responseHeaders, formattedResponseContent, this.GetType().Assembly.GetName().Version); this.LogMessage(message, Severity.Informational, Verbosity.Detailed); }
public async Task<IHttpResponseMessageAbstraction> SendAsync() { var requestMessage = new HttpRequestMessage(); requestMessage.Method = this.Method; requestMessage.RequestUri = this.RequestUri; if (this.Method == HttpMethod.Post || this.Method == HttpMethod.Put) { requestMessage.Content = this.CopyContent(); requestMessage.Content.Headers.ContentType = new MediaTypeHeaderValue(this.ContentType); } requestMessage.Headers.Clear(); foreach (KeyValuePair<string, string> header in this.RequestHeaders) { requestMessage.Headers.Add(header.Key, header.Value); } this.client.Timeout = this.Timeout; DateTime start = DateTime.Now; try { var result = await this.client.SendAsync(requestMessage, this.cancellationToken); string content = null; if (result.Content.IsNotNull()) { content = result.Content.ReadAsStringAsync().WaitForResult(); } var retval = new HttpResponseMessageAbstraction(result.StatusCode, new HttpResponseHeadersAbstraction(result.Headers), content); this.LogRequestResponseDetails(retval); return retval; } catch (Exception ex) { this.LogRequestException(ex); var tcex = ex as TaskCanceledException; if (tcex.IsNotNull()) { if (this.cancellationToken.IsCancellationRequested) { throw new OperationCanceledException("The operation was canceled at the users request.", tcex, this.cancellationToken); } else if (DateTime.Now - start > this.Timeout) { throw new TimeoutException(string.Format(CultureInfo.InvariantCulture, "The requested task failed to complete in the allotted time ({0}).", this.Timeout)); } } throw; } }
/// <summary> /// Create file and open it for write. /// </summary> /// <param name="path">The file name to create and open.</param> /// <param name="data">File content</param> /// <param name="overwrite">Specifies if existing file should be overwritten.</param> /// <returns>Confirmation message and WebHDFS URI to file location</returns> public Task<IHttpResponseMessageAbstraction> Write(string path, Stream data, bool? overwrite) { ApplianceStorageSimulatorItem file = this.GetItem(path); if (!(overwrite.HasValue && overwrite.Value)) { file = this.CreateTree(path); } file.Data = ReadToEnd(data); // TODO: This location is not presented in format webhdfs://<HOST>:<PORT>/<PATH> by only by relative <PATH> // var header = new HttpResponseHeadersAbstraction { { "Location", path } }; IHttpResponseMessageAbstraction response = new HttpResponseMessageAbstraction(HttpStatusCode.Created, header, String.Empty); return Task.FromResult(response); }
/// <summary> /// Set replication for an existing file. /// </summary> /// <param name="path">Path to file</param> /// <param name="replication">New replication factor</param> /// <returns>Confirmation message with success indicator flag.</returns> public Task<IHttpResponseMessageAbstraction> SetReplication(string path, short replication) { ApplianceStorageSimulatorItem file = this.GetItem(path); string message; if (file.IsNotNull()) { if (file.FileStatus.EntryType == DirectoryEntryType.FILE) { file.FileStatus.Replication = replication; message = "{\"boolean\": true}"; } else { message = "{\"boolean\": false}"; } } else { message = "{\"boolean\": false}"; } IHttpResponseMessageAbstraction response = new HttpResponseMessageAbstraction(HttpStatusCode.OK, null, message); return Task.FromResult(response); }
/// <summary> /// Set owner of a path (i.e. a file or a directory). The parameters owner and group cannot both be null. /// </summary> /// <param name="path">Path to file/directory</param> /// <param name="owner">New owner of file. If it is null, the original owner name remains unchanged.</param> /// <param name="group">New group owner of file. If it is null, the original group name remains unchanged.</param> /// <returns>Confirmation message</returns> public Task<IHttpResponseMessageAbstraction> SetOwner(string path, string owner, string group) { ApplianceStorageSimulatorItem file = this.GetItem(path); if (file.IsNotNull()) { if (owner.IsNotNullOrEmpty()) { file.FileStatus.Owner = owner; } if (group.IsNotNullOrEmpty()) { file.FileStatus.Group = group; } IHttpResponseMessageAbstraction response = new HttpResponseMessageAbstraction(HttpStatusCode.OK, null, String.Empty); return Task.FromResult(response); } throw new FileNotFoundException("File cannot be found."); }
/// <summary> /// Return a file status data above given path. /// </summary> /// <param name="path">The path we want information from.</param> /// <returns>File status for given path</returns> public Task<IHttpResponseMessageAbstraction> GetFileStatus(string path) { ApplianceStorageSimulatorItem file = this.GetItem(path); if (file.IsNotNull()) { var result = new DirectoryEntryContainer() { Entry = file.FileStatus }; IHttpResponseMessageAbstraction response = new HttpResponseMessageAbstraction( HttpStatusCode.OK, null, this.ConvertToJson(result)); return Task.FromResult(response); } else { throw new FileNotFoundException("File cannot be found."); } }
/// <summary> /// Rename file /// </summary> /// <param name="path">Source path</param> /// <param name="destination">Destination path</param> /// <returns>Confirmation message with success indicator flag.</returns> public Task<IHttpResponseMessageAbstraction> Rename(string path, string destination) { PathInfo sourcePathInfo = new PathInfo(new Uri(this.credentials.Server, path)); ApplianceStorageSimulatorItem sourceFile = this.GetItem(sourcePathInfo); string message = String.Empty; if (sourceFile.IsNotNull()) { PathInfo destinationPathInfo = new PathInfo(new Uri(this.credentials.Server, destination)); ApplianceStorageSimulatorItem destinationFile = this.CreateTree(destinationPathInfo, sourceFile.FileStatus.EntryType); ApplianceStorageSimulatorItem destinationFileParent = GetItem(destinationPathInfo, true); sourceFile.FileStatus.PathSuffix = destinationFile.FileStatus.PathSuffix; destinationFileParent.ChildItems[destinationPathInfo.PathParts.Last()] = sourceFile; ApplianceStorageSimulatorItem sourceFileParent = this.GetItem(sourcePathInfo, true); sourceFileParent.ChildItems.Remove(sourcePathInfo.PathParts.Last()); this.UpdateParrentContentSummary(sourceFileParent); this.UpdateParrentContentSummary(destinationFileParent); message = "{\"boolean\": true}"; } else { message = "{\"boolean\": false}"; } IHttpResponseMessageAbstraction response = new HttpResponseMessageAbstraction(HttpStatusCode.OK, null, message); return Task.FromResult(response); }
/// <summary> /// Checks whether given path exists in the file system. /// </summary> /// <param name="path">Path to check.</param> /// <returns>True if the given path exists in the file system, otherwise false.</returns> public Task<IHttpResponseMessageAbstraction> Exists(string path) { var item = this.GetItem(path); IHttpResponseMessageAbstraction response; if (item.IsNotNull()) { response = new HttpResponseMessageAbstraction(HttpStatusCode.OK, null, "{boolean:true}"); } else { response = new HttpResponseMessageAbstraction(HttpStatusCode.NotFound, null, "{boolean:false}"); } return Task.FromResult(response); }
/// <summary> /// Opens data stream at indicated path. /// </summary> /// <param name="path">File name to open.</param> /// <param name="offset">The starting byte position.</param> /// <param name="length">The number of bytes to be processed. Null means entire file</param> /// <param name="buffersize">The size of the buffer to be used. NOT SIMULATED</param> /// <returns>Redirected exact location of chosen file</returns> public Task<IHttpResponseMessageAbstraction> Read(string path, long? offset, long? length, int? buffersize) { ApplianceStorageSimulatorItem file = this.GetItem(path); if (file.IsNotNull()) { if (offset.IsNull()) { offset = 0; } if (length.IsNull()) { length = file.Data.Length; } using (var ms = new MemoryStream(file.Data, (int)offset, (int)length)) { using (var sr = new StreamReader(ms)) { IHttpResponseMessageAbstraction response = new HttpResponseMessageAbstraction(HttpStatusCode.OK, null, sr.ReadToEnd()); return Task.FromResult(response); } } } throw new FileNotFoundException("File cannot be found."); }
/// <summary> /// Make the given file and all non-existent parents into directories. Has the semantics of Unix 'mkdir -p'. Existence /// of the directory hierarchy is not an error. /// </summary> /// <param name="path">Path to directory</param> /// <returns>Confirmation message with success indicator flag.</returns> public Task<IHttpResponseMessageAbstraction> CreateDirectory(string path) { ApplianceStorageSimulatorItem file = this.GetItem(path); string message; if (file.IsNotNull()) { message = "{\"boolean\": false}"; } else { file = this.CreateTree(path, DirectoryEntryType.DIRECTORY); ApplianceStorageSimulatorItem parent = GetItem(path, true); this.UpdateParrentContentSummary(parent); message = "{\"boolean\": true}"; } IHttpResponseMessageAbstraction response = new HttpResponseMessageAbstraction(HttpStatusCode.OK, null, message); return Task.FromResult(response); }
/// <summary> /// List the statuses of the files/directories in the given path if the path is a directory. /// </summary> /// <param name="path">Path to directory</param> /// <returns> /// The statuses of the files/directories in the given path returns null, if path does not exist in the file /// system /// </returns> public Task<IHttpResponseMessageAbstraction> ListStatus(string path) { ApplianceStorageSimulatorItem file = this.GetItem(path); if (file.IsNotNull()) { var allStatuses = new DirectoryListing(); var statuses = new List<DirectoryEntry>(); foreach (ApplianceStorageSimulatorItem fileDetails in file.ChildItems.Values) { statuses.Add(fileDetails.FileStatus); } allStatuses.Entries = statuses; var result = new DirectoryListingContainer() { Listing = allStatuses }; IHttpResponseMessageAbstraction response = new HttpResponseMessageAbstraction( HttpStatusCode.OK, null, this.ConvertToJson(result)); return Task.FromResult(response); } throw new FileNotFoundException("File cannot be found."); }
/// <summary> /// Set permission of a path. /// </summary> /// <param name="path">Path to file/directory.</param> /// <param name="permission">The permission of a file/directory in OCTAL format.</param> /// <returns>Confirmation message</returns> public Task<IHttpResponseMessageAbstraction> SetPermission(string path, string permission) { ApplianceStorageSimulatorItem file = this.GetItem(path); if (file.IsNotNull()) { file.FileStatus.Permission = permission; IHttpResponseMessageAbstraction response = new HttpResponseMessageAbstraction(HttpStatusCode.OK, null, String.Empty); return Task.FromResult(response); } throw new FileNotFoundException("File cannot be found."); }
public Task<IHttpResponseMessageAbstraction> ReturnResponse(PassthroughResponse passthroughResponse) { string responsePayload; var converter = new ClusterProvisioningServerPayloadConverter(); responsePayload = converter.SerailizeChangeRequestResponse(passthroughResponse); var response = new HttpResponseMessageAbstraction(HttpStatusCode.Accepted, new HttpResponseHeadersAbstraction(), responsePayload); return Task.FromResult((IHttpResponseMessageAbstraction)response); }
/// <summary> /// Delete file /// </summary> /// <param name="path">The path to delete.</param> /// <param name="recursive"> /// If path is a directory and set to true, the directory is deleted else throws an exception. In /// case of a file the recursive can be set to either true or false. /// </param> /// <returns>Confirmation message with 'true' in message content if delete is successful, else 'false'.</returns> public Task<IHttpResponseMessageAbstraction> Delete(string path, bool? recursive) { var pathInfo = new PathInfo(new Uri(this.credentials.Server, path)); ApplianceStorageSimulatorItem item = this.GetItem(pathInfo, true); if (item.IsNotNull() && item.ChildItems.ContainsKey(pathInfo.PathParts[pathInfo.PathParts.Length - 1])) { item.ChildItems.Remove(pathInfo.PathParts[pathInfo.PathParts.Length - 1]); } this.UpdateParrentContentSummary(item); IHttpResponseMessageAbstraction response = new HttpResponseMessageAbstraction(HttpStatusCode.OK, null, "{\"boolean\": true}"); return Task.FromResult(response); }