/// <summary>
/// Download the attachment at the url and store it locally at the given location
/// </summary>
public async Task DownloadAttachmentAsync(string relativeUrl, string destinationPath)
{
var additionalRequestConfiguration = new RequestConfiguration();
additionalRequestConfiguration.AttachmentDownloadPath = destinationPath;
await SendAsync(relativeUrl, null, RequestType.GetOctet, null, true, additionalRequestConfiguration);
}
public async Task <ResponseWrapper> SendAsync(string restRelativeUri, string queryParams, RequestType requestType, string data, bool allowReconnect = true, RequestConfiguration additionalRequestConfiguration = null)
{
if (!IsConnected())
{
throw new NotConnectedException();
}
restRelativeUri = string.IsNullOrWhiteSpace(queryParams) ? restRelativeUri : restRelativeUri + (restRelativeUri.Contains("?") ? "&" : "?") + queryParams;
HttpWebRequest request = CreateRequest(restRelativeUri, requestType, additionalRequestConfiguration);
if ((requestType == RequestType.Post || requestType == RequestType.Update) && !string.IsNullOrEmpty(data))
{
byte[] byteData = Encoding.UTF8.GetBytes(data);
bool gzip = additionalRequestConfiguration != null && additionalRequestConfiguration.GZipCompression;
if (gzip)
{
using (Stream postStream = await request.GetRequestStreamAsync().ConfigureAwait(AwaitContinueOnCapturedContext))
{
using (var zipStream = new GZipStream(postStream, CompressionMode.Compress))
{
zipStream.Write(byteData, 0, byteData.Length);
}
}
}
else
{
request.ContentLength = byteData.Length;
using (Stream postStream = await request.GetRequestStreamAsync().ConfigureAwait(AwaitContinueOnCapturedContext))
{
postStream.Write(byteData, 0, byteData.Length);
}
}
}
InvalidCredentialException originalException = null;
try
{
if (requestType == RequestType.GetOctet && additionalRequestConfiguration != null)
{
return(await DownloadAttachmentInternalAsync(request, additionalRequestConfiguration.AttachmentDownloadPath).ConfigureAwait(AwaitContinueOnCapturedContext));
}
else
{
return(await DoSendAsync(request).ConfigureAwait(AwaitContinueOnCapturedContext));
}
}
//catch - intended to handle the case LWSSO is expired, we will try reconnect and resend original request
catch (InvalidCredentialException e)
{
// await can't exist in a catch because the CLR would lose the ambient exception.
// We don’t need the ambient exception (i.e. we don't "throw;",
// so we need to trick it out by putting retry logic after the catch
originalException = e;
}
//RECONNECT SECTION
try
{
bool reconnected = allowReconnect && await Reconnect();
if (!reconnected)
{
throw originalException;
}
// we reconnected,
// but await can't exist in a catch because the CLR would lose the ambient exception.
// We don’t need the ambient exception (i.e. we don't "throw;",
// so we need to trick it out by putting retry logic after the catch
}
catch
{
//if reconnect throwed any exception - we rethrow original exception
throw originalException;
}
//resend after reconnect
return(await SendAsync(restRelativeUri, queryParams, requestType, data, false, additionalRequestConfiguration)
.ConfigureAwait(AwaitContinueOnCapturedContext));
}
public Task <ResponseWrapper> ExecuteDeleteAsync(string restRelativeUri, RequestConfiguration additionalRequestConfiguration = null)
{
return(SendAsync(restRelativeUri, null, RequestType.Delete, null, true, additionalRequestConfiguration));
}
public ResponseWrapper Send(string restRelativeUri, string queryParams, RequestType requestType, string data, RequestConfiguration additionalData = null)
{
return(SendAsync(restRelativeUri, queryParams, requestType, data, true, additionalData).Result);
}
public ResponseWrapper ExecuteDelete(string restRelativeUri, RequestConfiguration additionalRequestConfiguration = null)
{
return(ExecuteDeleteAsync(restRelativeUri, additionalRequestConfiguration).Result);
}
public Task <ResponseWrapper> ExecutePutAsync(string restRelativeUri, string queryParams, string data, RequestConfiguration additionalRequestConfiguration = null)
{
return(SendAsync(restRelativeUri, queryParams, RequestType.Update, data, true, additionalRequestConfiguration));
}
public ResponseWrapper ExecutePut(string restRelativeUri, string queryParams, string data, RequestConfiguration additionalRequestConfiguration = null)
{
return(ExecutePutAsync(restRelativeUri, queryParams, data, additionalRequestConfiguration).Result);
}
private HttpWebRequest CreateRequest(string restRelativeUri, RequestType requestType, RequestConfiguration additionalRequestConfiguration)
{
string url = Host + restRelativeUri;
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
if (NetworkSettings.CustomProxy != null)
{
request.Proxy = NetworkSettings.CustomProxy;
}
//Add authentication cookies/headers
authenticationStrategy.PrepareRequest(request);
//add internal API token
request.Headers.Add("HPECLIENTTYPE", "HPE_CI_CLIENT");
//set content type/accept/method
switch (requestType)
{
case RequestType.Get:
request.Accept = CONTENT_TYPE_JSON;
request.Method = METHOD_GET;
break;
case RequestType.GetOctet:
request.Accept = CONTENT_TYPE_STREAM;
request.Method = METHOD_GET;
break;
case RequestType.Post:
request.ContentType = CONTENT_TYPE_JSON;
request.Accept = CONTENT_TYPE_JSON;
request.Method = METHOD_POST;
break;
case RequestType.PostOctet:
request.ContentType = CONTENT_TYPE_STREAM;
request.Method = METHOD_POST;
break;
case RequestType.Delete:
request.Accept = CONTENT_TYPE_JSON;
request.Method = METHOD_DELETE;
break;
case RequestType.Update:
request.ContentType = CONTENT_TYPE_JSON;
request.Accept = CONTENT_TYPE_JSON;
request.Method = METHOD_PUT;
break;
case RequestType.MultiPart:
request.ContentType = CONTENT_TYPE_MULTIPART;
request.Accept = CONTENT_TYPE_JSON;
request.Method = METHOD_POST;
break;
default:
break;
}
if (additionalRequestConfiguration != null)
{
if (additionalRequestConfiguration.Timeout.HasValue)
{
request.Timeout = additionalRequestConfiguration.Timeout.Value;
}
if (additionalRequestConfiguration.Headers != null)
{
foreach (KeyValuePair <string, string> header2value in additionalRequestConfiguration.Headers)
{
switch (header2value.Key.ToLower())
{
case "contenttype":
request.ContentType = header2value.Value;
break;
case "accept":
request.Accept = header2value.Value;
break;
default:
request.Headers.Add(header2value.Key, header2value.Value);
break;
}
}
}
if (additionalRequestConfiguration.GZipCompression)
{
request.Headers.Add("Content-Encoding", "gzip");
}
}
return(request);
}
private HttpWebRequest CreateRequest(string restRelativeUri, RequestType requestType, RequestConfiguration additionalRequestConfiguration)
{
String url = host + restRelativeUri;
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
//add cookies
String cookieDomain = request.Address.Host;
String cookiePath = "/";
request.CookieContainer = new CookieContainer();
request.CookieContainer.Add(new Cookie(LWSSO_COOKIE_NAME, lwSsoCookie, cookiePath, cookieDomain));
request.CookieContainer.Add(new Cookie(OCTANE_USER_COOKIE_NAME, octaneUserCookie, cookiePath, cookieDomain));
//add internal API token
request.Headers.Add("HPECLIENTTYPE", "HPE_CI_CLIENT");
//request.Headers.Add("ALM_OCTANE_TECH_PREVIEW", "true");
//set content type/accept/method
switch (requestType)
{
case RequestType.Get:
request.Accept = CONTENT_TYPE_JSON;
request.Method = METHOD_GET;
break;
case RequestType.GetOctet:
request.Accept = CONTENT_TYPE_STREAM;
request.Method = METHOD_GET;
break;
case RequestType.Post:
request.ContentType = CONTENT_TYPE_JSON;
request.Accept = CONTENT_TYPE_JSON;
request.Method = METHOD_POST;
break;
case RequestType.PostOctet:
request.ContentType = CONTENT_TYPE_STREAM;
request.Method = METHOD_POST;
break;
case RequestType.Delete:
request.Accept = CONTENT_TYPE_JSON;
request.Method = METHOD_DELETE;
break;
case RequestType.Update:
request.ContentType = CONTENT_TYPE_JSON;
request.Accept = CONTENT_TYPE_JSON;
request.Method = METHOD_PUT;
break;
case RequestType.MultiPart:
request.ContentType = CONTENT_TYPE_MULTIPART;
request.Accept = CONTENT_TYPE_JSON;
request.Method = METHOD_POST;
break;
default:
break;
}
if (additionalRequestConfiguration != null)
{
if (additionalRequestConfiguration.Timeout.HasValue)
{
request.Timeout = additionalRequestConfiguration.Timeout.Value;
}
if (additionalRequestConfiguration.Headers != null)
{
foreach (KeyValuePair <string, string> header2value in additionalRequestConfiguration.Headers)
{
switch (header2value.Key.ToLower())
{
case "contenttype":
request.ContentType = header2value.Value;
break;
case "accept":
request.Accept = header2value.Value;
break;
default:
request.Headers.Add(header2value.Key, header2value.Value);
break;
}
}
}
if (additionalRequestConfiguration.GZipCompression)
{
request.Headers.Add("Content-Encoding", "gzip");
}
}
return(request);
}
