private void ResponseCallback(IAsyncResult result, Action <SshApiResponse> callback, SshCommand sshCommand)
{
var response = new SshApiResponse
{
ResponseStatus = ResponseStatus.None
};
//var str = string.Empty;
try
{
//WaitHandle.WaitAny(new[] {result.AsyncWaitHandle});
//var cmd = (SshCommand) result.AsyncState;
//str = cmd.EndExecute(result);
//var b = result.IsCompleted;
//apiResponse.Content = str;
using (sshCommand)
{
ExtractResponseData(response, sshCommand);
PopulateErrorForIncompleteResponse(response, sshCommand);
}
}
catch (Exception e)
{
response = ResponseCallbackError(e);
}
callback(response);
}
private void ProcessResponse(ISshRequest request, SshApiResponse sshApiResponse,
SshRequestAsyncHandle asyncHandle, Action <ISshApiResponse, SshRequestAsyncHandle> callback)
{
// SshApiResponse restResponse = ConvertToRestResponse(request, httpResponse);
//var sshApiResponse = httpResponse;
sshApiResponse.Request = request;
callback(sshApiResponse, asyncHandle);
}
private void PopulateErrorForIncompleteResponse(SshApiResponse apiResponse, SshCommand sshCommand)
{
if (sshCommand.ExitStatus > 0)
{
apiResponse.ResponseStatus = ResponseStatus.Error;
apiResponse.ErrorMessage = sshCommand.Error;
apiResponse.ExitStatus = sshCommand.ExitStatus;
}
//apiResponse.ErrorException = (Exception)apiResponse.ResponseStatus.ToWebException();
//apiResponse.ErrorMessage = apiResponse.ErrorException.Message;
}
public void Create()
{
var obj = new SshApiResponse();
Assert.IsNotNull(obj);
Assert.IsNull(obj.Content);
Assert.AreEqual(0L, obj.ContentLength);
Assert.IsNull(obj.ErrorException);
Assert.IsNull(obj.ErrorMessage);
Assert.AreEqual(0, obj.ExitStatus);
Assert.AreEqual(ResponseStatus.None, obj.ResponseStatus);
Assert.IsNull(obj.Request);
}
private SshApiResponse CreateErrorResponse(Exception ex)
{
var sshResponse = new SshApiResponse();
//WebException webException;
//if ((webException = ex as WebException) != null && webException.Status == WebExceptionStatus.RequestCanceled)
//{
// httpResponse.ResponseStatus = this.timeoutState.TimedOut ? ResponseStatus.TimedOut : ResponseStatus.Aborted;
// return httpResponse;
//}
sshResponse.ErrorMessage = ex.Message;
sshResponse.ErrorException = ex;
sshResponse.ResponseStatus = ResponseStatus.Error;
return(sshResponse);
}
public void SetValues()
{
var content = "toto";
var errorMsg = "My errors _";
var statExit = 42;
var StatusCode = 12;
var obj = new SshApiResponse()
{
Content = content,
ContentLength = content.Length,
ErrorMessage = errorMsg,
ExitStatus = statExit,
StatusCode = StatusCode,
};
Assert.IsNotNull(obj);
Assert.AreEqual(content, obj.Content);
Assert.AreEqual(content.Length, obj.ContentLength);
Assert.AreEqual(errorMsg, obj.ErrorMessage);
Assert.AreEqual(statExit, obj.ExitStatus);
Assert.AreEqual(StatusCode, obj.StatusCode);
}
private void DeserializeResponse <T>(ISshRequest request,
Action <ISshApiResponse <T>, SshRequestAsyncHandle> callback, ISshApiResponse apiResponse,
SshRequestAsyncHandle asyncHandle)
{
ISshApiResponse <T> sshApiResponse1;
try
{
sshApiResponse1 = Deserialize <T>(request, apiResponse);
}
catch (Exception ex)
{
Logger.Error(ex);
var restResponse2 = new SshApiResponse <T>();
restResponse2.Request = request;
restResponse2.ResponseStatus = ResponseStatus.Error;
restResponse2.ErrorMessage = ex.Message;
restResponse2.ErrorException = ex;
sshApiResponse1 = restResponse2;
}
callback(sshApiResponse1, asyncHandle);
}
private void ExtractResponseData(SshApiResponse apiResponse, SshCommand sshCommand)
{
apiResponse.Content = sshCommand.Result;
apiResponse.ResponseStatus = ResponseStatus.Completed;
apiResponse.StatusCode = sshCommand.ExitStatus;
}
private void ExecuteCallback(SshApiResponse apiResponse, Action <SshApiResponse> callback)
{
callback(apiResponse);
}
