public async Task HandleResponseAsync(IResponse response, IRequestOptions requestOptions, IResponseOptions responseOptions)
{
if (response == null)
{
throw new ArgumentNullException(nameof(response), "One of required parameters are missing");
}
if (requestOptions == null)
{
throw new ArgumentNullException(nameof(requestOptions), "One of required parameters are missing");
}
if (responseOptions == null)
{
throw new ArgumentNullException(nameof(responseOptions), "One of required parameters are missing");
}
string fileHeader;
if (response.Handled && response.Code >= 200 && response.Code < 300)
{
fileHeader = $"{response.Code} Success\n";
}
else
{
fileHeader = $"{response.Code} Fail\n";
}
string textToSave = fileHeader + response.Content;
await File.WriteAllTextAsync(responseOptions.Path, textToSave);
}
public async Task <IResponse> HandleRequestAsync(IRequestOptions requestOptions)
{
if (requestOptions == null)
{
throw new ArgumentNullException($"{nameof(requestOptions)} is missing.");
}
if (!requestOptions.IsValid)
{
throw new ArgumentOutOfRangeException($"{nameof(requestOptions)} is not valid.");
}
HttpMethod httpMethod = new HttpMethod(requestOptions.Method.ToString().ToUpper());
HttpRequestMessage request = new HttpRequestMessage(httpMethod, requestOptions.Address);
if (!string.IsNullOrWhiteSpace(requestOptions.Body) &&
!string.IsNullOrWhiteSpace(requestOptions.ContentType))
{
//var contentBytes = Encoding.UTF8.GetBytes(requestOptions.Body);
//request.Content = new ByteArrayContent(contentBytes);
//request.Headers.Add("Content-type", requestOptions.ContentType);
request.Content = new StringContent(requestOptions.Body,
Encoding.UTF8,
requestOptions.ContentType);
}
HttpResponseMessage response = await _httpClient.SendAsync(request);
return(await response.MapToCustomResponse());
}
/// <inheritdoc/>
public async Task <bool> PerformRequestAsync(
IRequestOptions requestOptions,
IResponseOptions responseOptions)
{
Response response = null;
try
{
logger.Log($"Send: {requestOptions.Name}");
MainMenu.ConsoleWrite($"Send: {requestOptions.Name}");
response = (Response)await requestHandler.HandleRequestAsync(requestOptions);
logger.Log($"Response: {requestOptions.Name} Code:{response.Code}");
MainMenu.ConsoleWrite($"Response: {requestOptions.Name} Code:{response.Code}");
await responseHandler.HandleResponseAsync(response, requestOptions, responseOptions);
return(true);
}
catch (Exception exception)
{
if (response != null)
{
response.Handled = false;
await responseHandler.HandleResponseAsync(response, requestOptions, responseOptions);
}
throw new PerformException("", exception);
}
}
internal static QueryProtocolOptions CreateFromQuery(
ProtocolVersion protocolVersion, Statement query, IRequestOptions requestOptions)
{
if (query == null)
{
return(Default);
}
var consistency = query.ConsistencyLevel ?? requestOptions.ConsistencyLevel;
var pageSize = query.PageSize != 0 ? query.PageSize : requestOptions.PageSize;
long?timestamp = null;
if (query.Timestamp != null)
{
timestamp = TypeSerializer.SinceUnixEpoch(query.Timestamp.Value).Ticks / 10;
}
else if (protocolVersion.SupportsTimestamp())
{
timestamp = requestOptions.TimestampGenerator.Next();
if (timestamp == long.MinValue)
{
timestamp = null;
}
}
return(new QueryProtocolOptions(
consistency,
query.QueryValues,
query.SkipMetadata,
pageSize,
query.PagingState,
requestOptions.GetSerialConsistencyLevelOrDefault(query),
timestamp,
query.Keyspace));
}
internal static void SetRequestOptions(ref SerializableRequestOptions serializer, IRequestOptions requestOptions)
{
if (null == serializer && null == requestOptions)
{
return;
}
if (null == serializer)
{
serializer = CreateSerializableRequestOptions(requestOptions);
}
else
{
if ((requestOptions is FileRequestOptions)
&& (serializer is SerializableBlobRequestOptions))
{
serializer = new SerializableFileRequestOptions();
}
else if ((requestOptions is BlobRequestOptions)
&& (serializer is SerializableFileRequestOptions))
{
serializer = new SerializableBlobRequestOptions();
}
serializer.RequestOptions = requestOptions;
}
}
private void ValidateArguments(IRequestOptions requestOptions, IResponseOptions responseOptions)
{
if (requestOptions == null)
{
var exception = new ArgumentNullException(nameof(requestOptions), "One of required parameters are missing.");
_logger.Log(exception, "Exception was thrown.");
throw exception;
}
if (responseOptions == null)
{
var exception = new ArgumentNullException(nameof(responseOptions), "One of required parameters are missing.");
_logger.Log(exception, "Exception was thrown.");
throw exception;
}
if (!requestOptions.IsValid)
{
var exception = new ArgumentOutOfRangeException(nameof(requestOptions), "One of parameters is not valid.");
_logger.Log(exception, "Exception was thrown.");
throw exception;
}
if (!responseOptions.IsValid)
{
var exception = new ArgumentOutOfRangeException(nameof(responseOptions), "One of parameters is not valid.");
_logger.Log(exception, "Exception was thrown.");
throw exception;
}
}
private async Task <IStatement> GetAnalyticsPrimary(
IStatement statement, IGraphStatement graphStatement, IRequestOptions requestOptions)
{
if (!(statement is TargettedSimpleStatement) || !requestOptions.GraphOptions.IsAnalyticsQuery(graphStatement))
{
return(statement);
}
var targetedSimpleStatement = (TargettedSimpleStatement)statement;
RowSet rs;
try
{
rs = await _session.ExecuteAsync(
new SimpleStatement("CALL DseClientTool.getAnalyticsGraphServer()"), requestOptions).ConfigureAwait(false);
}
catch (Exception ex)
{
GraphRequestHandler.Logger.Verbose("Error querying graph analytics server, query will not be routed optimally: {0}", ex);
return(statement);
}
return(AdaptRpcPrimaryResult(rs, targetedSimpleStatement));
}
public async Task <IResponse> HandleRequestAsync(IRequestOptions requestOptions)
{
if (requestOptions == null)
{
throw new ArgumentNullException(nameof(requestOptions));
}
if (!requestOptions.IsValid)
{
throw new ArgumentOutOfRangeException(nameof(requestOptions));
}
var httpMethod = MapMethod(requestOptions.Method);
using var message = new HttpRequestMessage(httpMethod, new Uri(requestOptions.Address));
if (httpMethod != HttpMethod.Get && requestOptions.ContentType != null)
{
message.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(requestOptions.ContentType));
message.Content = new StringContent(requestOptions.Body ?? "");
}
using var response = await _client.SendAsync(message);
return(new Response(response.IsSuccessStatusCode,
(int)response.StatusCode,
await response.Content.ReadAsStringAsync()));
}
public async Task <IResponse> HandleRequestAsync(IRequestOptions requestOptions)
{
if (requestOptions == null)
{
throw new ArgumentNullException(nameof(requestOptions));
}
if (!requestOptions.IsValid)
{
throw new ArgumentOutOfRangeException(nameof(requestOptions));
}
using var content = new StringContent(requestOptions.Body ?? "");
using var message = new HttpRequestMessage(MappingMethod(requestOptions.Method),
new Uri(requestOptions.Address));
message.Content = content;
// content-type:
//client.DefaultRequestHeaders.Add("User-Agent", "C# console program");
//client.DefaultRequestHeaders.Accept.Clear();
//client.DefaultRequestHeaders.Accept.Add(
// new MediaTypeWithQualityHeaderValue("application/json"));
var response = client.SendAsync(message, HttpCompletionOption.ResponseContentRead);
var asdf = Task.WhenAll(response);
var response2 = asdf.Result;
var rez = new Response(response2[0].IsSuccessStatusCode,
(int)response2[0].StatusCode, response2[0].Content.ReadAsStringAsync().Result);
return(rez);
}
public JsonWebClient(IClientSettings settings, IRequestOptions defaultOptions = null)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
this.settings = settings;
DefaultRequestOptions = defaultOptions ?? new RequestOptions();
logger = LogManager.GetCurrentClassLogger();
// call something on this object so it gets initialized in single threaded context
HttpEncoder.Default.SerializeToString();
//need to add the following call for Mono -- https://bugzilla.xamarin.com/show_bug.cgi?id=12565
if (Helpers.IsRunningOnMono())
{
HttpEncoder.Current = HttpEncoder.Default;
}
HttpEncoder.Current.SerializeToString();
client = new JsonServiceClient(settings.BaseSpaceApiUrl);
client.LocalHttpWebRequestFilter += WebRequestFilter;
if (settings.TimeoutMin > 0)
{
client.Timeout = TimeSpan.FromMinutes(settings.TimeoutMin);
}
clientBilling = new JsonServiceClient(settings.BaseSpaceBillingApiUrl);
clientBilling.LocalHttpWebRequestFilter += WebRequestFilter;
}
public async Task <string> SendAsync(IRequestOptions requestOptions)
{
HttpRequestMessage requestMessage = requestOptions.ComposeRequestMessage();
HttpResponseMessage response = await _client.SendAsync(requestMessage);
string content = await response.Content.ReadAsStringAsync();
return(content);
}
public async Task HandleResponseAsync(IResponse response, IRequestOptions requestOptions,
IResponseOptions responseOptions)
{
if (!response.Handled)
{
return;
}
await File.WriteAllTextAsync(responseOptions.Path, response.Content);
}
public BaseSpaceClient(IClientSettings settings, IWebClient client, IRequestOptions defaultOptions = null)
{
if (settings == null || client == null)
{
throw new ArgumentNullException("settings");
}
ClientSettings = settings;
WebClient = client;
SetDefaultRequestOptions(defaultOptions);
}
private void AddEtagOptions(IRequestOptions options)
{
var parentResourceInfo = Client.GetMostInheritedResourceInterfaceInfo(this.parent.GetType());
if (parentResourceInfo.HasEtagProperty)
{
var etag = parentResourceInfo.EtagProperty.GetValue(this.parent, null);
options.ModifyRequest(r => r.Headers.Add("If-Match", $"\"{etag}\""));
}
}
public BaseSpaceClient(IClientSettings settings, IRequestOptions defaultOptions = null)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
Settings = settings;
WebClient = new JsonWebClient(settings, defaultOptions);
}
public BaseSpaceClient(IClientSettings settings, IWebClient client, IRequestOptions defaultOptions = null)
{
if (settings == null || client == null)
{
throw new ArgumentNullException("settings");
}
ClientSettings = settings;
WebClient = client;
SetDefaultRequestOptions(defaultOptions);
}
public BaseSpaceClient(IClientSettings settings, IRequestOptions defaultOptions = null)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
Settings = settings;
WebClient = new JsonWebClient(settings, defaultOptions);
}
private async Task <bool> FeedRequestConsumersAsync(IRequestOptions options, IEnumerable <IRequestConsumer> consumers)
{
string response = await SendAsync(options);
foreach (var consumer in consumers)
{
consumer.Consume(response);
}
return(true);
}
public async Task HandleResponseAsync(IResponse response,
IRequestOptions requestOptions,
IResponseOptions responseOptions)
{
await using var writer = File.CreateText(responseOptions.Path);
writer.Write("Status code: " + response.Code + Environment.NewLine);
writer.Write("Is handled: " + response.Handled + Environment.NewLine);
writer.Write("Content: " + Environment.NewLine);
writer.Write(response.Content + Environment.NewLine);
writer.Flush();
}
internal void ApplyRequestOptions(IRequestOptions options)
{
if (options.ServerTimeout.HasValue)
{
this.ServerTimeoutInSeconds = (int)options.ServerTimeout.Value.TotalSeconds;
}
if (options.MaximumExecutionTime.HasValue)
{
this.ClientMaxTimeout = options.MaximumExecutionTime.HasValue ? options.MaximumExecutionTime.Value : Constants.MaximumAllowedTimeout;
}
}
async Task IResponseHandler.HandleResponseAsync(IResponse response, IRequestOptions requestOptions, IResponseOptions responseOptions)
{
if (response == null || requestOptions == null)
{
throw new ArgumentNullException();
}
// creating content to file
var content = $"Status code: {response.Code}, handled: {response.Handled}" +
$"\n{response.Content}";
await File.WriteAllTextAsync(responseOptions.Path, content);
}
public async Task <IResponse> HandleRequestAsync(IRequestOptions requestOptions)
{
if (requestOptions == null)
{
throw new ArgumentNullException(nameof(requestOptions));
}
if (!requestOptions.IsValid)
{
throw new ArgumentOutOfRangeException(nameof(requestOptions));
}
using var content = new StringContent(requestOptions.Body ?? "");
var response = new HttpResponseMessage();
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(100));
switch (requestOptions.Method)
{
case RequestMethod.Undefined:
throw new InvalidOperationException(nameof(requestOptions.Method));
case RequestMethod.Get:
response = await _httpClient.GetAsync(requestOptions.Address, cts.Token);
break;
case RequestMethod.Post:
response = await _httpClient.PostAsync(requestOptions.Address, content, cts.Token);
break;
case RequestMethod.Put:
response = await _httpClient.PutAsync(requestOptions.Address, content, cts.Token);
break;
case RequestMethod.Patch:
response = await _httpClient.PatchAsync(requestOptions.Address, content, cts.Token);
break;
case RequestMethod.Delete:
response = await _httpClient.DeleteAsync(requestOptions.Address, cts.Token);
break;
default:
break;
}
return(new Response(true, (int)response.StatusCode, await response.Content.ReadAsStringAsync()));
}
public Task <TResponse> SendAsync <TResponse>(HttpMethods httpMethod, string relativeOrAbsoluteUrl, object request,
IRequestOptions options = null) where TResponse : class
{
var rr = new RestRequest()
{
Method = httpMethod,
RelativeOrAbsoluteUrl = relativeOrAbsoluteUrl,
Request = request,
Options = options ?? DefaultRequestOptions,
Name = string.Format("ASYNC {0} request to {1} ", httpMethod, relativeOrAbsoluteUrl)
};
return(ExecuteTask <TResponse>(Client, rr, Logger));
}
public BatchRequest(
ISerializer serializer,
IDictionary <string, byte[]> payload,
BatchStatement statement,
ConsistencyLevel consistency,
IRequestOptions requestOptions) : base(serializer, statement.IsTracing, payload)
{
if (!serializer.ProtocolVersion.SupportsBatch())
{
throw new NotSupportedException("Batch request is supported in C* >= 2.0.x");
}
if (statement.Timestamp != null && !serializer.ProtocolVersion.SupportsTimestamp())
{
throw new NotSupportedException(
"Timestamp for BATCH request is supported in Cassandra 2.1 or above.");
}
_type = statement.BatchType;
_requests = statement.Queries
.Select(q => q.CreateBatchRequest(serializer))
.ToArray();
Consistency = consistency;
if (!serializer.ProtocolVersion.SupportsBatchFlags())
{
// if flags are not supported, then the following additional parameters aren't either
return;
}
SerialConsistency = requestOptions.GetSerialConsistencyLevelOrDefault(statement);
_batchFlags |= QueryProtocolOptions.QueryFlags.WithSerialConsistency;
if (serializer.ProtocolVersion.SupportsTimestamp())
{
_timestamp = BatchRequest.GetRequestTimestamp(statement, requestOptions.TimestampGenerator);
}
if (_timestamp != null)
{
_batchFlags |= QueryProtocolOptions.QueryFlags.WithDefaultTimestamp;
}
_keyspace = statement.Keyspace;
if (serializer.ProtocolVersion.SupportsKeyspaceInRequest() && _keyspace != null)
{
_batchFlags |= QueryProtocolOptions.QueryFlags.WithKeyspace;
}
}
internal ExecutionProfile(IRequestOptions requestOptions)
{
if (requestOptions == null)
{
throw new ArgumentNullException(nameof(requestOptions));
}
Initialize(
requestOptions.ConsistencyLevel,
requestOptions.SerialConsistencyLevel,
requestOptions.ReadTimeoutMillis,
requestOptions.LoadBalancingPolicy,
requestOptions.SpeculativeExecutionPolicy,
requestOptions.RetryPolicy);
}
public async Task <IResponse> HandleRequestAsync(IRequestOptions requestOptions)
{
using var message = new HttpRequestMessage(
MapMetod(requestOptions.Method),
new Uri(requestOptions.Address));
if (requestOptions.Body != null)
{
message.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(requestOptions.ContentType));
message.Content = new StringContent(requestOptions.Body);
}
using var response = await httpClient.SendAsync(message);
response.Content.Headers.ContentType.CharSet = "UTF-8";
return(new Response((int)response.StatusCode, await response.Content.ReadAsStringAsync()));
}
/// <inheritdoc/>
public async Task <bool> PerformRequestAsync(
IRequestOptions requestOptions,
IResponseOptions responseOptions)
{
ValidateArguments(requestOptions, responseOptions);
bool result = true;
IResponse response;
try
{
_logger.Log("Sending request...");
response = await _requestHandler.HandleRequestAsync(requestOptions);
_logger.Log("Response received.");
}
catch (TaskCanceledException exception)
{
response = new Response
{
Handled = false,
Code = 504,
Content = null
};
_logger.Log(exception, "Timeout exception occured when sending request.");
result = false;
}
catch (Exception exception)
{
if (exception is ArgumentNullException ||
exception is ArgumentOutOfRangeException ||
exception is InvalidOperationException ||
exception is HttpRequestException)
{
var performException = new PerformException("Critical performer error. See inner exception for more details", exception);
_logger.Log(performException, "Exception was thrown.");
throw performException;
}
throw;
}
bool isSaveSuccess = await SaveResponse(requestOptions, responseOptions, response);
result = result && isSaveSuccess;
return(result);
}
public TReturn Send <TReturn>(AbstractRequest <TReturn> request, IRequestOptions options = null)
where TReturn : class
{
try
{
if (logger.IsDebugEnabled)
{
var debugMessage = request.GetDebugLogMessage();
if (!string.IsNullOrWhiteSpace(debugMessage))
{
logger.Debug(debugMessage);
}
}
if (logger.IsInfoEnabled)
{
var infoMessage = request.GetInfoLogMessage();
if (!string.IsNullOrEmpty(infoMessage))
{
logger.Info(infoMessage);
}
}
TReturn result = null;
options = options ?? DefaultRequestOptions;
var clientForRequest = PickClientForApiName(request.GetApiName());
RetryLogic.DoWithRetry(options.RetryAttempts, request.GetName(),
() => result = request.GetSendFunc(clientForRequest)(), logger);
return(result);
}
catch (WebServiceException webx)
{
string errorCode = string.Empty;
if (!string.IsNullOrEmpty(webx.ErrorCode))
{
errorCode = string.Format(" ({0})", webx.ErrorCode);
}
var msg = string.Format("{0} status: {1} ({2}) Message: {3}{4}", request.GetName(), webx.StatusCode,
webx.StatusDescription, webx.ErrorMessage, errorCode);
throw new BaseSpaceException(msg, webx.ErrorCode, webx);
}
catch (Exception x)
{
throw new BaseSpaceException(request.GetName() + " failed", string.Empty, x);
}
}
public Task <TResponse> PostFileWithRequestAsync <TResponse>(string relativeOrAbsoluteUrl, FileInfo fileToUpload,
object request,
IRequestOptions options = null) where TResponse : class
{
var rr = new FileRestRequest()
{
Method = HttpMethods.PUT,
RelativeOrAbsoluteUrl = relativeOrAbsoluteUrl,
Request = request,
FileInfo = fileToUpload,
Options = options ?? DefaultRequestOptions,
Name = string.Format("ASYNC File Put request to {0} for file {1}", relativeOrAbsoluteUrl, fileToUpload.FullName)
};
return(ExecuteTask <TResponse>(Client, rr, Logger));
}
public async Task <IResponse> HandleRequestAsync(IRequestOptions requestOptions)
{
var handler = new HttpClientHandler();
handler.ServerCertificateCustomValidationCallback += (sender, certificate, chain, errors) => true;
_client = new HttpClient(handler);
if (requestOptions == null)
{
throw new ArgumentNullException(nameof(requestOptions));
}
if (!requestOptions.IsValid)
{
throw new ArgumentOutOfRangeException(nameof(requestOptions));
}
using var msg = new HttpRequestMessage(MapMethod(requestOptions.Method), new Uri(requestOptions.Address));
try
{
if (MapMethod(requestOptions.Method) == HttpMethod.Delete)
{
using var responseD = await _client.SendAsync(msg);
var bodyD = await responseD.Content.ReadAsStringAsync();
return(new Response(true, (int)responseD.StatusCode, bodyD));
}
if (MapMethod(requestOptions.Method) != HttpMethod.Get)
{
msg.Content = new StringContent(requestOptions.Body, Encoding.UTF8, requestOptions.ContentType);
using var responseForPushingData = await _client.SendAsync(msg);
var bodyForPushing = await responseForPushingData.Content.ReadAsStringAsync();
return(new Response(true, (int)responseForPushingData.StatusCode, bodyForPushing));
}
using var response = await _client.SendAsync(msg);
var body = await response.Content.ReadAsStringAsync();
return(new Response(true, (int)response.StatusCode, body));
}
catch (HttpRequestException) //todo: probably redo
{
return(new Response(false, 500, "Server is not responding!"));
}
}
public Task <TResponse> PostFileWithRequestAsync <TResponse>(string relativeOrAbsoluteUrl, Stream fileToUpload,
object request, string fileName,
IRequestOptions options = null) where TResponse : class
{
var rr = new StreamingRestRequest()
{
Method = HttpMethods.PUT,
RelativeOrAbsoluteUrl = relativeOrAbsoluteUrl,
Request = request,
Stream = fileToUpload,
FileName = fileName,
Options = options ?? DefaultRequestOptions,
Name = string.Format("ASYNC File put request to {0} from stream with file name {1} ", relativeOrAbsoluteUrl, fileName)
};
return(ExecuteTask <TResponse>(Client, rr, Logger));
}
private async Task <bool> SaveResponse(IRequestOptions requestOptions, IResponseOptions responseOptions, IResponse response)
{
try
{
await _responseHandler.HandleResponseAsync(response, requestOptions, responseOptions);
_logger.Log("Response was saved");
return(true);
}
catch (ArgumentNullException exception)
{
_logger.Log(exception, "One of required parameters for response handling are missing. See inner exception for more details");
return(false);
}
}
internal static void Execute <TResult>(JsonServiceClient client, RestRequest request, ILog log,
TaskCompletionSource <TResult> tcs)
where TResult : class
{
try
{
tcs.SetResult(Execute <TResult>(client, request, log));
}
catch (Exception e)
{
tcs.SetException(e);
}
finally
{
currentRequestOptions = null;
}
}
public CreateProjectResponse CreateProject(CreateProjectRequest request, IRequestOptions options = null)
{
return WebClient.Send(request, options);
}
public Task<ListVariantsResponse> ListVariantsAsync(ListVariantsRequest request, IRequestOptions options = null)
{
return WebClient.SendAsync<ListVariantsResponse>(HttpMethods.GET, request.BuildUrl(ClientSettings.Version), null, options);
}
public OAuthDeviceAccessTokenResponse FinishOAuthDeviceAuth(OAuthDeviceAccessTokenRequest request, IRequestOptions options = null)
{
try
{
return WebClient.Send<OAuthDeviceAccessTokenResponse> (HttpMethods.POST, request.BuildUrl (ClientSettings.Version), request, options);
}
catch (BaseSpaceException bex)
{
if(bex.InnerException != null && bex.InnerException.GetType() == typeof(WebServiceException))
{
var wsex = (WebServiceException)bex.InnerException;
return wsex.ResponseBody.FromJson<OAuthDeviceAccessTokenResponse>();
}
}
return null;
}
private static SerializableRequestOptions CreateSerializableRequestOptions(IRequestOptions requestOptions)
{
if (requestOptions is FileRequestOptions)
{
return new SerializableFileRequestOptions()
{
RequestOptions = requestOptions
};
}
else
{
Debug.Assert(requestOptions is BlobRequestOptions, "Request options should be an instance of BlobRequestOptions when code reach here.");
return new SerializableBlobRequestOptions()
{
RequestOptions = requestOptions
};
}
}
public ListVariantsResponse ListVariants(ListVariantsRequest request, IRequestOptions options = null)
{
return WebClient.Send(request, options);
}
public PostAppResultResponse CreateAppResult(PostAppResultRequest request, IRequestOptions options = null)
{
return WebClient.Send<PostAppResultResponse>(HttpMethods.POST, request.BuildUrl(ClientSettings.Version), request, options);
}
/// <summary>
/// Set service properties
/// </summary>
/// <param name="account">Cloud storage account</param>
/// <param name="type">Service type</param>
/// <param name="properties">Service properties</param>
/// <param name="options">Request options</param>
/// <param name="operationContext">Operation context</param>
public void SetStorageServiceProperties(StorageServiceType type, ServiceProperties properties, IRequestOptions options, OperationContext operationContext)
{
CloudStorageAccount account = StorageContext.StorageAccount;
switch (type)
{
case StorageServiceType.Blob:
account.CreateCloudBlobClient().SetServiceProperties(properties, (BlobRequestOptions)options, operationContext);
break;
case StorageServiceType.Queue:
account.CreateCloudQueueClient().SetServiceProperties(properties, (QueueRequestOptions)options, operationContext);
break;
case StorageServiceType.Table:
account.CreateCloudTableClient().SetServiceProperties(properties, (TableRequestOptions)options, operationContext);
break;
case StorageServiceType.File:
if (null != properties.Logging)
{
throw new InvalidOperationException(Resources.FileNotSupportLogging);
}
if (null != properties.HourMetrics || null != properties.MinuteMetrics)
{
throw new InvalidOperationException(Resources.FileNotSupportMetrics);
}
FileServiceProperties fileServiceProperties = new FileServiceProperties();
fileServiceProperties.Cors = properties.Cors;
account.CreateCloudFileClient().SetServiceProperties(fileServiceProperties, (FileRequestOptions)options, operationContext);
break;
default:
throw new ArgumentException(Resources.InvalidStorageServiceType, "type");
}
}
public BaseSpaceClient(IClientSettings settings, IRequestOptions defaultOptions = null)
: this(settings, new JsonWebClient(settings), defaultOptions)
{
}
public UpdateAppSessionResponse UpdateAppSession(UpdateAppSessionRequest request, IRequestOptions options = null)
{
return WebClient.Send(request, options);
}
/// <summary>
/// Get the service properties
/// </summary>
/// <param name="account">Cloud storage account</param>
/// <param name="type">Service type</param>
/// <param name="options">Request options</param>
/// <param name="operationContext">Operation context</param>
/// <returns>The service properties of the specified service type</returns>
public ServiceProperties GetStorageServiceProperties(StorageServiceType type, IRequestOptions options, OperationContext operationContext)
{
CloudStorageAccount account = StorageContext.StorageAccount;
switch (type)
{
case StorageServiceType.Blob:
return account.CreateCloudBlobClient().GetServiceProperties((BlobRequestOptions) options, operationContext);
case StorageServiceType.Queue:
return account.CreateCloudQueueClient().GetServiceProperties((QueueRequestOptions) options, operationContext);
case StorageServiceType.Table:
return account.CreateCloudTableClient().GetServiceProperties((TableRequestOptions) options, operationContext);
case StorageServiceType.File:
FileServiceProperties fileServiceProperties = account.CreateCloudFileClient().GetServiceProperties((FileRequestOptions)options, operationContext);
ServiceProperties sp = new ServiceProperties();
sp.Clean();
sp.Cors = fileServiceProperties.Cors;
return sp;
default:
throw new ArgumentException(Resources.InvalidStorageServiceType, "type");
}
}
public UploadFileToFileSetResponse UploadFileToFileSet(UploadFileToFileSetRequest request, IRequestOptions options = null)
{
var fileUploadClient = new FileUpload(WebClient, Settings, options ?? WebClient.DefaultRequestOptions);
return fileUploadClient.UploadFile(request);
}
public OAuthDeviceAuthResponse BeginOAuthDeviceAuth(OAuthDeviceAuthRequest request, IRequestOptions options = null)
{
return WebClient.Send(request, options);
}
public CreateAppSessionLogsResponse CreateAppSessionLogs(CreateAppSessionLogsRequest request, IRequestOptions options = null)
{
return WebClient.Send(request, options);
}
public void SetDefaultRequestOptions(IRequestOptions options)
{
WebClient.SetDefaultRequestOptions(options);
}
/// <summary>
/// Get the service properties
/// </summary>
/// <param name="account">Cloud storage account</param>
/// <param name="type">Service type</param>
/// <param name="options">Request options</param>
/// <param name="operationContext">Operation context</param>
/// <returns>The service properties of the specified service type</returns>
public ServiceProperties GetStorageServiceProperties(StorageServiceType type, IRequestOptions options, OperationContext operationContext)
{
throw new NotImplementedException("No need to cover this in unit test since the logic is quite simple. For more details, please read GetAzureStorageServiceLogging.cs");
}
public Task<UpdateAppSessionResponse> UpdateAppSessionAsync(UpdateAppSessionRequest request, IRequestOptions options = null)
{
return WebClient.SendAsync<UpdateAppSessionResponse>(HttpMethods.POST, request.BuildUrl(ClientSettings.Version), request, options);
}
/// <summary>
/// Set service properties
/// </summary>
/// <param name="account">Cloud storage account</param>
/// <param name="type">Service type</param>
/// <param name="properties">Service properties</param>
/// <param name="options">Request options</param>
/// <param name="operationContext">Operation context</param>
public void SetStorageServiceProperties(StorageServiceType type, WindowsAzure.Storage.Shared.Protocol.ServiceProperties properties, IRequestOptions options, OperationContext operationContext)
{
throw new NotImplementedException("No need to cover this in unit test since there are no additional logics on this api");
}
public BaseSpaceClient(IRequestOptions options)
: this(defaultSettings, new JsonWebClient(defaultSettings, options), options)
{
}
public Task<GetCoverageMetadataResponse> GetCoverageMetadataAsync(GetCoverageMetadataRequest request, IRequestOptions options = null)
{
return WebClient.SendAsync<GetCoverageMetadataResponse>(HttpMethods.GET, request.BuildUrl(ClientSettings.Version), null, options);
}
public OAuthDeviceAuthResponse BeginOAuthDeviceAuth(OAuthDeviceAuthRequest request, IRequestOptions options = null)
{
return WebClient.Send<OAuthDeviceAuthResponse>(HttpMethods.POST, request.BuildUrl(ClientSettings.Version), request, options);
}
public GetUserResponse GetUser(GetUserRequest request, IRequestOptions options = null)
{
return WebClient.Send<GetUserResponse>(HttpMethods.GET, request.BuildUrl(ClientSettings.Version), null, options);
}
public Task<PostProjectResponse> CreateProjectAsync(PostProjectRequest request, IRequestOptions options = null)
{
return WebClient.SendAsync<PostProjectResponse>(HttpMethods.POST, request.BuildUrl(ClientSettings.Version), request, options);
}
public Task<GetVariantHeaderResponse> GetVariantHeaderAsync(GetVariantHeaderRequest request, IRequestOptions options = null)
{
return WebClient.SendAsync<GetVariantHeaderResponse>(HttpMethods.GET, request.BuildUrl(ClientSettings.Version), null, options);
}
public ListSamplesResponse ListSamples(ListSamplesRequest request, IRequestOptions options = null)
{
return WebClient.Send(request, options);
}
public ListSamplesResponse ListSamples(ListSamplesRequest request, IRequestOptions options)
{
return WebClient.Send<ListSamplesResponse>(HttpMethods.GET, request.BuildUrl(ClientSettings.Version), null, options);
}
/// <summary>
/// Set service properties
/// </summary>
/// <param name="account">Cloud storage account</param>
/// <param name="type">Service type</param>
/// <param name="properties">Service properties</param>
/// <param name="options">Request options</param>
/// <param name="operationContext">Operation context</param>
public void SetStorageServiceProperties(StorageServiceType type, ServiceProperties properties, IRequestOptions options, OperationContext operationContext)
{
CloudStorageAccount account = StorageContext.StorageAccount;
switch (type)
{
case StorageServiceType.Blob:
account.CreateCloudBlobClient().SetServiceProperties(properties, (BlobRequestOptions)options, operationContext);
break;
case StorageServiceType.Queue:
account.CreateCloudQueueClient().SetServiceProperties(properties, (QueueRequestOptions)options, operationContext);
break;
case StorageServiceType.Table:
account.CreateCloudTableClient().SetServiceProperties(properties, (TableRequestOptions)options, operationContext);
break;
default:
throw new ArgumentException(Resources.InvalidStorageServiceType, "type");
}
}
private static void AssignToRequestOptions(IRequestOptions targetRequestOptions, IRequestOptions customRequestOptions)
{
if (null != customRequestOptions.MaximumExecutionTime)
{
targetRequestOptions.MaximumExecutionTime = customRequestOptions.MaximumExecutionTime;
}
if (null != customRequestOptions.RetryPolicy)
{
targetRequestOptions.RetryPolicy = customRequestOptions.RetryPolicy;
}
if (null != customRequestOptions.ServerTimeout)
{
targetRequestOptions.ServerTimeout = customRequestOptions.ServerTimeout;
}
targetRequestOptions.LocationMode = customRequestOptions.LocationMode;
}
