public static void _update_pl_tracing(IBaseUnit sprite, Tracing trace, int frang, int trang, int cur_clock_tm) { bool can_reach = true; IMapUnit pl = sprite.get_pack_data(); if (trace.trace_tm_left > 0 || cur_clock_tm - sprite.last_trace_target_tm > 500) { } }
// Constructor. public CommandSettings(IHostContext context, string[] args) { ArgUtil.NotNull(context, nameof(context)); _context = context; _promptManager = context.GetService<IPromptManager>(); _trace = context.GetTrace(nameof(CommandSettings)); // Parse the command line args. _parser = new CommandLineParser( hostContext: context, secretArgNames: Constants.Agent.CommandLine.Args.Secrets); _parser.Parse(args); }
/// <summary> /// The Add Service Certificate operation adds a certificate to a /// hosted service. The Add Service Certificate operation is an /// asynchronous operation. To determine whether the management /// service has finished processing the request, call Get Operation /// Status. (see /// http://msdn.microsoft.com/en-us/library/windowsazure/ee460817.aspx /// for more information) /// </summary> /// <param name='serviceName'> /// The DNS prefix name of your service. /// </param> /// <param name='parameters'> /// Parameters supplied to the Create Service Certificate operation. /// </param> /// <param name='cancellationToken'> /// Cancellation token. /// </param> /// <returns> /// A standard service response including an HTTP status code and /// request ID. /// </returns> public async System.Threading.Tasks.Task <OperationResponse> BeginCreatingAsync(string serviceName, ServiceCertificateCreateParameters parameters, CancellationToken cancellationToken) { // Validate if (serviceName == null) { throw new ArgumentNullException("serviceName"); } // TODO: Validate serviceName is a valid DNS name. if (parameters == null) { throw new ArgumentNullException("parameters"); } if (parameters.Data == null) { throw new ArgumentNullException("parameters.Data"); } // Tracing bool shouldTrace = CloudContext.Configuration.Tracing.IsEnabled; string invocationId = null; if (shouldTrace) { invocationId = Tracing.NextInvocationId.ToString(); Dictionary <string, object> tracingParameters = new Dictionary <string, object>(); tracingParameters.Add("serviceName", serviceName); tracingParameters.Add("parameters", parameters); Tracing.Enter(invocationId, this, "BeginCreatingAsync", tracingParameters); } // Construct URL string url = new Uri(this.Client.BaseUri, "/").AbsoluteUri + this.Client.Credentials.SubscriptionId + "/services/hostedservices/" + serviceName + "/certificates"; // Create HTTP transport objects HttpRequestMessage httpRequest = null; try { httpRequest = new HttpRequestMessage(); httpRequest.Method = HttpMethod.Post; httpRequest.RequestUri = new Uri(url); // Set Headers httpRequest.Headers.Add("x-ms-version", "2013-11-01"); // Set Credentials cancellationToken.ThrowIfCancellationRequested(); await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false); // Serialize Request string requestContent = null; XDocument requestDoc = new XDocument(); XElement certificateFileElement = new XElement(XName.Get("CertificateFile", "http://schemas.microsoft.com/windowsazure")); requestDoc.Add(certificateFileElement); XElement dataElement = new XElement(XName.Get("Data", "http://schemas.microsoft.com/windowsazure")); dataElement.Value = Convert.ToBase64String(parameters.Data); certificateFileElement.Add(dataElement); XElement certificateFormatElement = new XElement(XName.Get("CertificateFormat", "http://schemas.microsoft.com/windowsazure")); certificateFormatElement.Value = ComputeManagementClient.CertificateFormatToString(parameters.CertificateFormat); certificateFileElement.Add(certificateFormatElement); if (parameters.Password != null) { XElement passwordElement = new XElement(XName.Get("Password", "http://schemas.microsoft.com/windowsazure")); passwordElement.Value = parameters.Password; certificateFileElement.Add(passwordElement); } requestContent = requestDoc.ToString(); httpRequest.Content = new StringContent(requestContent, Encoding.UTF8); httpRequest.Content.Headers.ContentType = new MediaTypeHeaderValue("application/xml"); // Send Request HttpResponseMessage httpResponse = null; try { if (shouldTrace) { Tracing.SendRequest(invocationId, httpRequest); } cancellationToken.ThrowIfCancellationRequested(); httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false); if (shouldTrace) { Tracing.ReceiveResponse(invocationId, httpResponse); } HttpStatusCode statusCode = httpResponse.StatusCode; if (statusCode != HttpStatusCode.Accepted) { cancellationToken.ThrowIfCancellationRequested(); CloudException ex = CloudException.Create(httpRequest, requestContent, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false), CloudExceptionType.Xml); if (shouldTrace) { Tracing.Error(invocationId, ex); } throw ex; } // Create Result OperationResponse result = null; result = new OperationResponse(); result.StatusCode = statusCode; if (httpResponse.Headers.Contains("x-ms-request-id")) { result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault(); } if (shouldTrace) { Tracing.Exit(invocationId, result); } return(result); } finally { if (httpResponse != null) { httpResponse.Dispose(); } } } finally { if (httpRequest != null) { httpRequest.Dispose(); } } }
/// <summary> /// The Delete Service Certificate operation deletes a service /// certificate from the certificate store of a hosted service. The /// Delete Service Certificate operation is an asynchronous operation. /// To determine whether the management service has finished /// processing the request, call Get Operation Status. (see /// http://msdn.microsoft.com/en-us/library/windowsazure/ee460803.aspx /// for more information) /// </summary> /// <param name='parameters'> /// Parameters supplied to the Delete Service Certificate operation. /// </param> /// <param name='cancellationToken'> /// Cancellation token. /// </param> /// <returns> /// The response body contains the status of the specified asynchronous /// operation, indicating whether it has succeeded, is inprogress, or /// has failed. Note that this status is distinct from the HTTP status /// code returned for the Get Operation Status operation itself. If /// the asynchronous operation succeeded, the response body includes /// the HTTP status code for the successful request. If the /// asynchronous operation failed, the response body includes the HTTP /// status code for the failed request, and also includes error /// information regarding the failure. /// </returns> public async System.Threading.Tasks.Task <Microsoft.WindowsAzure.Management.Compute.Models.ComputeOperationStatusResponse> DeleteAsync(ServiceCertificateDeleteParameters parameters, CancellationToken cancellationToken) { ComputeManagementClient client = this.Client; bool shouldTrace = CloudContext.Configuration.Tracing.IsEnabled; string invocationId = null; if (shouldTrace) { invocationId = Tracing.NextInvocationId.ToString(); Dictionary <string, object> tracingParameters = new Dictionary <string, object>(); tracingParameters.Add("parameters", parameters); Tracing.Enter(invocationId, this, "DeleteAsync", tracingParameters); } try { if (shouldTrace) { client = this.Client.WithHandler(new ClientRequestTrackingHandler(invocationId)); } cancellationToken.ThrowIfCancellationRequested(); OperationResponse response = await client.ServiceCertificates.BeginDeletingAsync(parameters, cancellationToken).ConfigureAwait(false); cancellationToken.ThrowIfCancellationRequested(); ComputeOperationStatusResponse result = await client.GetOperationStatusAsync(response.RequestId, cancellationToken).ConfigureAwait(false); int delayInSeconds = 30; while ((result.Status != ComputeOperationStatus.InProgress) == false) { cancellationToken.ThrowIfCancellationRequested(); await TaskEx.Delay(delayInSeconds * 1000, cancellationToken).ConfigureAwait(false); cancellationToken.ThrowIfCancellationRequested(); result = await client.GetOperationStatusAsync(response.RequestId, cancellationToken).ConfigureAwait(false); delayInSeconds = 30; } if (shouldTrace) { Tracing.Exit(invocationId, result); } if (result.Status != ComputeOperationStatus.Succeeded) { if (result.Error != null) { CloudException ex = new CloudException(result.Error.Code + " : " + result.Error.Message); ex.ErrorCode = result.Error.Code; ex.ErrorMessage = result.Error.Message; if (shouldTrace) { Tracing.Error(invocationId, ex); } throw ex; } else { CloudException ex = new CloudException(""); if (shouldTrace) { Tracing.Error(invocationId, ex); } throw ex; } } return(result); } finally { if (client != null && shouldTrace) { client.Dispose(); } } }
public ValidatedRequest Validate(AuthorizeRequest request) { var validatedRequest = new ValidatedRequest(); // validate request model binding if (request == null) { throw new AuthorizeRequestResourceOwnerException("Invalid request parameters."); } // make sure redirect uri is present if (string.IsNullOrWhiteSpace(request.redirect_uri)) { throw new AuthorizeRequestResourceOwnerException("Missing redirect URI"); } // validate client if (string.IsNullOrWhiteSpace(request.client_id)) { throw new AuthorizeRequestResourceOwnerException("Missing client identifier"); } var client = Clients.Get(request.client_id); if (client == null) { throw new AuthorizeRequestResourceOwnerException("Invalid client: " + request.client_id); } validatedRequest.Client = client; Tracing.InformationFormat("Client: {0} ({1})", validatedRequest.Client.Name, validatedRequest.Client.ClientId); // make sure redirect_uri is a valid uri, and in case of http is over ssl Uri redirectUri; if (Uri.TryCreate(request.redirect_uri, UriKind.Absolute, out redirectUri)) { if (redirectUri.Scheme == Uri.UriSchemeHttp) { throw new AuthorizeRequestClientException( "Redirect URI not over SSL : " + request.redirect_uri, new Uri(request.redirect_uri), OAuth2Constants.Errors.InvalidRequest, string.Empty, validatedRequest.State); } // make sure redirect uri is registered with client if (!validatedRequest.Client.RedirectUris.Contains(request.redirect_uri)) { throw new AuthorizeRequestResourceOwnerException("Invalid redirect URI: " + request.redirect_uri); } validatedRequest.RedirectUri = request.redirect_uri; Tracing.InformationFormat("Redirect URI: {0}", validatedRequest.RedirectUri); } else { throw new AuthorizeRequestResourceOwnerException("Invalid redirect URI: " + request.redirect_uri); } // check state if (!string.IsNullOrWhiteSpace(request.state)) { validatedRequest.State = request.state; Tracing.Information("State: " + validatedRequest.State); } else { Tracing.Information("No state supplied."); } // validate response type if (String.IsNullOrWhiteSpace(request.response_type)) { throw new AuthorizeRequestClientException( "response_type is null or empty", new Uri(validatedRequest.RedirectUri), OAuth2Constants.Errors.InvalidRequest, string.Empty, validatedRequest.State); } // check response type (only code and token are supported) if (!request.response_type.Equals(OAuth2Constants.ResponseTypes.Token, StringComparison.Ordinal) && !request.response_type.Equals(OAuth2Constants.ResponseTypes.Code, StringComparison.Ordinal)) { throw new AuthorizeRequestClientException( "response_type is not token or code: " + request.response_type, new Uri(validatedRequest.RedirectUri), OAuth2Constants.Errors.UnsupportedResponseType, string.Empty, validatedRequest.State); } validatedRequest.ResponseType = request.response_type; Tracing.Information("Response type: " + validatedRequest.ResponseType); // scope is required if (string.IsNullOrWhiteSpace(request.scope)) { throw new AuthorizeRequestClientException( "Missing scope", new Uri(validatedRequest.RedirectUri), OAuth2Constants.Errors.InvalidScope, validatedRequest.ResponseType, validatedRequest.State); } // validate scopes if (!request.scope.StartsWith("openid")) { throw new AuthorizeRequestClientException( "Invalid scope: " + request.scope, new Uri(validatedRequest.RedirectUri), OAuth2Constants.Errors.InvalidScope, validatedRequest.ResponseType, validatedRequest.State); } validatedRequest.Scopes = request.scope; if (request.response_type == OAuth2Constants.ResponseTypes.Code) { ValidateCodeResponseType(validatedRequest, request); } else if (request.response_type == OAuth2Constants.ResponseTypes.Token) { ValidateTokenResponseType(validatedRequest, request); } else { throw new AuthorizeRequestClientException( "Invalid response_type: " + request.response_type, new Uri(validatedRequest.RedirectUri), OAuth2Constants.Errors.UnsupportedResponseType, request.response_type, validatedRequest.State); } return(validatedRequest); }
/// <summary> /// Gets a next list of deployments operations. /// </summary> /// <param name='nextLink'> /// Required. NextLink from the previous successful call to List /// operation. /// </param> /// <param name='cancellationToken'> /// Cancellation token. /// </param> /// <returns> /// List of deployment operations. /// </returns> public async Task <DeploymentOperationsListResult> ListNextAsync(string nextLink, CancellationToken cancellationToken) { // Validate if (nextLink == null) { throw new ArgumentNullException("nextLink"); } // Tracing bool shouldTrace = CloudContext.Configuration.Tracing.IsEnabled; string invocationId = null; if (shouldTrace) { invocationId = Tracing.NextInvocationId.ToString(); Dictionary <string, object> tracingParameters = new Dictionary <string, object>(); tracingParameters.Add("nextLink", nextLink); Tracing.Enter(invocationId, this, "ListNextAsync", tracingParameters); } // Construct URL string url = nextLink.Trim(); // Create HTTP transport objects HttpRequestMessage httpRequest = null; try { httpRequest = new HttpRequestMessage(); httpRequest.Method = HttpMethod.Get; httpRequest.RequestUri = new Uri(url); // Set Headers // Set Credentials cancellationToken.ThrowIfCancellationRequested(); await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false); // Send Request HttpResponseMessage httpResponse = null; try { if (shouldTrace) { Tracing.SendRequest(invocationId, httpRequest); } cancellationToken.ThrowIfCancellationRequested(); httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false); if (shouldTrace) { Tracing.ReceiveResponse(invocationId, httpResponse); } HttpStatusCode statusCode = httpResponse.StatusCode; if (statusCode != HttpStatusCode.OK) { cancellationToken.ThrowIfCancellationRequested(); CloudException ex = CloudException.Create(httpRequest, null, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false), CloudExceptionType.Json); if (shouldTrace) { Tracing.Error(invocationId, ex); } throw ex; } // Create Result DeploymentOperationsListResult result = null; // Deserialize Response cancellationToken.ThrowIfCancellationRequested(); string responseContent = await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); result = new DeploymentOperationsListResult(); JToken responseDoc = null; if (string.IsNullOrEmpty(responseContent) == false) { responseDoc = JToken.Parse(responseContent); } if (responseDoc != null && responseDoc.Type != JTokenType.Null) { JToken valueArray = responseDoc["value"]; if (valueArray != null && valueArray.Type != JTokenType.Null) { foreach (JToken valueValue in ((JArray)valueArray)) { DeploymentOperation deploymentOperationInstance = new DeploymentOperation(); result.Operations.Add(deploymentOperationInstance); JToken operationIdValue = valueValue["operationId"]; if (operationIdValue != null && operationIdValue.Type != JTokenType.Null) { string operationIdInstance = ((string)operationIdValue); deploymentOperationInstance.OperationId = operationIdInstance; } JToken propertiesValue = valueValue["properties"]; if (propertiesValue != null && propertiesValue.Type != JTokenType.Null) { DeploymentOperationProperties propertiesInstance = new DeploymentOperationProperties(); deploymentOperationInstance.Properties = propertiesInstance; JToken provisioningStateValue = propertiesValue["provisioningState"]; if (provisioningStateValue != null && provisioningStateValue.Type != JTokenType.Null) { string provisioningStateInstance = ((string)provisioningStateValue); propertiesInstance.ProvisioningState = provisioningStateInstance; } JToken timestampValue = propertiesValue["timestamp"]; if (timestampValue != null && timestampValue.Type != JTokenType.Null) { DateTime timestampInstance = ((DateTime)timestampValue); propertiesInstance.Timestamp = timestampInstance; } JToken statusCodeValue = propertiesValue["statusCode"]; if (statusCodeValue != null && statusCodeValue.Type != JTokenType.Null) { string statusCodeInstance = ((string)statusCodeValue); propertiesInstance.StatusCode = statusCodeInstance; } JToken statusMessageValue = propertiesValue["statusMessage"]; if (statusMessageValue != null && statusMessageValue.Type != JTokenType.Null) { string statusMessageInstance = statusMessageValue.ToString(Formatting.Indented); propertiesInstance.StatusMessage = statusMessageInstance; } JToken targetResourceValue = propertiesValue["targetResource"]; if (targetResourceValue != null && targetResourceValue.Type != JTokenType.Null) { TargetResource targetResourceInstance = new TargetResource(); propertiesInstance.TargetResource = targetResourceInstance; JToken idValue = targetResourceValue["id"]; if (idValue != null && idValue.Type != JTokenType.Null) { string idInstance = ((string)idValue); targetResourceInstance.Id = idInstance; } JToken resourceNameValue = targetResourceValue["resourceName"]; if (resourceNameValue != null && resourceNameValue.Type != JTokenType.Null) { string resourceNameInstance = ((string)resourceNameValue); targetResourceInstance.ResourceName = resourceNameInstance; } JToken resourceTypeValue = targetResourceValue["resourceType"]; if (resourceTypeValue != null && resourceTypeValue.Type != JTokenType.Null) { string resourceTypeInstance = ((string)resourceTypeValue); targetResourceInstance.ResourceType = resourceTypeInstance; } } } } } JToken odatanextLinkValue = responseDoc["@odata.nextLink"]; if (odatanextLinkValue != null && odatanextLinkValue.Type != JTokenType.Null) { string odatanextLinkInstance = ((string)odatanextLinkValue); result.NextLink = odatanextLinkInstance; } } result.StatusCode = statusCode; if (httpResponse.Headers.Contains("x-ms-request-id")) { result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault(); } if (shouldTrace) { Tracing.Exit(invocationId, result); } return(result); } finally { if (httpResponse != null) { httpResponse.Dispose(); } } } finally { if (httpRequest != null) { httpRequest.Dispose(); } } }
public Plugin() { Tracing.Trace("+--------------------------------"); Tracing.Trace("Imgur::ctor ({0:X8})", this.GetHashCode()); }
public override void Disconnect() { Tracing.Trace("Imgur::Disconnect"); base.Disconnect(); }
/// <summary> /// The Create Store Item operation creates Windows Azure Store entries /// in a Windows Azure subscription. /// </summary> /// <param name='cloudServiceName'> /// The name of the cloud service to which this store item will be /// assigned. /// </param> /// <param name='resourceName'> /// The name of this resource. /// </param> /// <param name='addOnName'> /// The add on name. /// </param> /// <param name='parameters'> /// Parameters used to specify how the Create procedure will function. /// </param> /// <param name='cancellationToken'> /// Cancellation token. /// </param> /// <returns> /// The response body contains the status of the specified asynchronous /// operation, indicating whether it has succeeded, is inprogress, or /// has failed. Note that this status is distinct from the HTTP status /// code returned for the Get Operation Status operation itself. If /// the asynchronous operation succeeded, the response body includes /// the HTTP status code for the successful request. If the /// asynchronous operation failed, the response body includes the HTTP /// status code for the failed request, and also includes error /// information regarding the failure. /// </returns> public async System.Threading.Tasks.Task <Microsoft.WindowsAzure.Management.Store.Models.AddOnOperationStatusResponse> BeginCreatingAsync(string cloudServiceName, string resourceName, string addOnName, AddOnCreateParameters parameters, CancellationToken cancellationToken) { // Validate if (cloudServiceName == null) { throw new ArgumentNullException("cloudServiceName"); } if (resourceName == null) { throw new ArgumentNullException("resourceName"); } if (addOnName == null) { throw new ArgumentNullException("addOnName"); } if (parameters == null) { throw new ArgumentNullException("parameters"); } if (parameters.Plan == null) { throw new ArgumentNullException("parameters.Plan"); } if (parameters.Type == null) { throw new ArgumentNullException("parameters.Type"); } // Tracing bool shouldTrace = CloudContext.Configuration.Tracing.IsEnabled; string invocationId = null; if (shouldTrace) { invocationId = Tracing.NextInvocationId.ToString(); Dictionary <string, object> tracingParameters = new Dictionary <string, object>(); tracingParameters.Add("cloudServiceName", cloudServiceName); tracingParameters.Add("resourceName", resourceName); tracingParameters.Add("addOnName", addOnName); tracingParameters.Add("parameters", parameters); Tracing.Enter(invocationId, this, "BeginCreatingAsync", tracingParameters); } // Construct URL string url = new Uri(this.Client.BaseUri, "/").ToString() + this.Client.Credentials.SubscriptionId + "/CloudServices/" + cloudServiceName + "/resources/" + parameters.Type + "/" + resourceName + "/" + addOnName; // Create HTTP transport objects HttpRequestMessage httpRequest = null; try { httpRequest = new HttpRequestMessage(); httpRequest.Method = HttpMethod.Put; httpRequest.RequestUri = new Uri(url); // Set Headers httpRequest.Headers.Add("x-ms-version", "2013-06-01"); // Set Credentials cancellationToken.ThrowIfCancellationRequested(); await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false); // Serialize Request string requestContent = null; XDocument requestDoc = new XDocument(); XElement resourceElement = new XElement(XName.Get("Resource", "http://schemas.microsoft.com/windowsazure")); requestDoc.Add(resourceElement); XElement typeElement = new XElement(XName.Get("Type", "http://schemas.microsoft.com/windowsazure")); typeElement.Value = parameters.Type; resourceElement.Add(typeElement); XElement planElement = new XElement(XName.Get("Plan", "http://schemas.microsoft.com/windowsazure")); planElement.Value = parameters.Plan; resourceElement.Add(planElement); if (parameters.PromotionCode != null) { XElement promotionCodeElement = new XElement(XName.Get("PromotionCode", "http://schemas.microsoft.com/windowsazure")); promotionCodeElement.Value = parameters.PromotionCode; resourceElement.Add(promotionCodeElement); } requestContent = requestDoc.ToString(); httpRequest.Content = new StringContent(requestContent, Encoding.UTF8); httpRequest.Content.Headers.ContentType = new MediaTypeHeaderValue("application/xml"); // Send Request HttpResponseMessage httpResponse = null; try { if (shouldTrace) { Tracing.SendRequest(invocationId, httpRequest); } cancellationToken.ThrowIfCancellationRequested(); httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false); if (shouldTrace) { Tracing.ReceiveResponse(invocationId, httpResponse); } HttpStatusCode statusCode = httpResponse.StatusCode; if (statusCode != HttpStatusCode.Accepted) { cancellationToken.ThrowIfCancellationRequested(); CloudException ex = CloudException.Create(httpRequest, requestContent, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false), CloudExceptionType.Xml); if (shouldTrace) { Tracing.Error(invocationId, ex); } throw ex; } // Create Result AddOnOperationStatusResponse result = null; result = new AddOnOperationStatusResponse(); result.StatusCode = statusCode; if (httpResponse.Headers.Contains("x-ms-request-id")) { result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault(); } if (shouldTrace) { Tracing.Exit(invocationId, result); } return(result); } finally { if (httpResponse != null) { httpResponse.Dispose(); } } } finally { if (httpRequest != null) { httpRequest.Dispose(); } } }
/// <summary> /// The Delete Store Item operation deletes Windows Azure Store entries /// that re provisioned for a subscription. /// </summary> /// <param name='cloudServiceName'> /// The name of the cloud service to which this store item will be /// assigned. /// </param> /// <param name='resourceProviderNamespace'> /// The namespace in which this store item resides. /// </param> /// <param name='resourceProviderType'> /// The type of store item to be deleted. /// </param> /// <param name='resourceProviderName'> /// The name of this resource provider. /// </param> /// <param name='cancellationToken'> /// Cancellation token. /// </param> /// <returns> /// The response body contains the status of the specified asynchronous /// operation, indicating whether it has succeeded, is inprogress, or /// has failed. Note that this status is distinct from the HTTP status /// code returned for the Get Operation Status operation itself. If /// the asynchronous operation succeeded, the response body includes /// the HTTP status code for the successful request. If the /// asynchronous operation failed, the response body includes the HTTP /// status code for the failed request, and also includes error /// information regarding the failure. /// </returns> public async System.Threading.Tasks.Task <Microsoft.WindowsAzure.Management.Store.Models.AddOnOperationStatusResponse> BeginDeletingAsync(string cloudServiceName, string resourceProviderNamespace, string resourceProviderType, string resourceProviderName, CancellationToken cancellationToken) { // Validate if (cloudServiceName == null) { throw new ArgumentNullException("cloudServiceName"); } if (resourceProviderNamespace == null) { throw new ArgumentNullException("resourceProviderNamespace"); } if (resourceProviderType == null) { throw new ArgumentNullException("resourceProviderType"); } if (resourceProviderName == null) { throw new ArgumentNullException("resourceProviderName"); } // Tracing bool shouldTrace = CloudContext.Configuration.Tracing.IsEnabled; string invocationId = null; if (shouldTrace) { invocationId = Tracing.NextInvocationId.ToString(); Dictionary <string, object> tracingParameters = new Dictionary <string, object>(); tracingParameters.Add("cloudServiceName", cloudServiceName); tracingParameters.Add("resourceProviderNamespace", resourceProviderNamespace); tracingParameters.Add("resourceProviderType", resourceProviderType); tracingParameters.Add("resourceProviderName", resourceProviderName); Tracing.Enter(invocationId, this, "BeginDeletingAsync", tracingParameters); } // Construct URL string url = new Uri(this.Client.BaseUri, "/").ToString() + this.Client.Credentials.SubscriptionId + "/CloudServices/" + cloudServiceName + "/resources/" + resourceProviderNamespace + "/" + resourceProviderType + "/" + resourceProviderName; // Create HTTP transport objects HttpRequestMessage httpRequest = null; try { httpRequest = new HttpRequestMessage(); httpRequest.Method = HttpMethod.Delete; httpRequest.RequestUri = new Uri(url); // Set Headers httpRequest.Headers.Add("x-ms-version", "2013-06-01"); // Set Credentials cancellationToken.ThrowIfCancellationRequested(); await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false); // Send Request HttpResponseMessage httpResponse = null; try { if (shouldTrace) { Tracing.SendRequest(invocationId, httpRequest); } cancellationToken.ThrowIfCancellationRequested(); httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false); if (shouldTrace) { Tracing.ReceiveResponse(invocationId, httpResponse); } HttpStatusCode statusCode = httpResponse.StatusCode; if (statusCode != HttpStatusCode.Accepted) { cancellationToken.ThrowIfCancellationRequested(); CloudException ex = CloudException.Create(httpRequest, null, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false), CloudExceptionType.Xml); if (shouldTrace) { Tracing.Error(invocationId, ex); } throw ex; } // Create Result AddOnOperationStatusResponse result = null; result = new AddOnOperationStatusResponse(); result.StatusCode = statusCode; if (httpResponse.Headers.Contains("x-ms-request-id")) { result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault(); } if (shouldTrace) { Tracing.Exit(invocationId, result); } return(result); } finally { if (httpResponse != null) { httpResponse.Dispose(); } } } finally { if (httpRequest != null) { httpRequest.Dispose(); } } }
public MemoryLayoutPacket(_DBG.BitStream stream) : base(Commands.c_Profiling_Memory_Layout) { m_heapAddress = ReadAndUnpackBits(stream); m_heapLength = ReadAndUnpackBits(stream); Tracing.PacketTrace("layout {0}:{1}", m_heapAddress, m_heapLength); }
/// <summary> /// The Begin Setting Network Configuration operation asynchronously /// configures the virtual network. (see /// http://msdn.microsoft.com/en-us/library/windowsazure/jj157181.aspx /// for more information) /// </summary> /// <param name='parameters'> /// Required. Parameters supplied to the Set Network Configuration /// operation. /// </param> /// <param name='cancellationToken'> /// Cancellation token. /// </param> /// <returns> /// A standard service response including an HTTP status code and /// request ID. /// </returns> public async System.Threading.Tasks.Task <OperationResponse> BeginSettingConfigurationAsync(NetworkSetConfigurationParameters parameters, CancellationToken cancellationToken) { // Validate if (parameters == null) { throw new ArgumentNullException("parameters"); } if (parameters.Configuration == null) { throw new ArgumentNullException("parameters.Configuration"); } // Tracing bool shouldTrace = CloudContext.Configuration.Tracing.IsEnabled; string invocationId = null; if (shouldTrace) { invocationId = Tracing.NextInvocationId.ToString(); Dictionary <string, object> tracingParameters = new Dictionary <string, object>(); tracingParameters.Add("parameters", parameters); Tracing.Enter(invocationId, this, "BeginSettingConfigurationAsync", tracingParameters); } // Construct URL string baseUrl = this.Client.BaseUri.AbsoluteUri; string url = "/" + (this.Client.Credentials.SubscriptionId != null ? this.Client.Credentials.SubscriptionId.Trim() : "") + "/services/networking/media"; // Trim '/' character from the end of baseUrl and beginning of url. if (baseUrl[baseUrl.Length - 1] == '/') { baseUrl = baseUrl.Substring(0, baseUrl.Length - 1); } if (url[0] == '/') { url = url.Substring(1); } url = baseUrl + "/" + url; // Create HTTP transport objects HttpRequestMessage httpRequest = null; try { httpRequest = new HttpRequestMessage(); httpRequest.Method = HttpMethod.Put; httpRequest.RequestUri = new Uri(url); // Set Headers httpRequest.Headers.Add("x-ms-version", "2014-05-01"); // Set Credentials cancellationToken.ThrowIfCancellationRequested(); await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false); // Serialize Request string requestContent = parameters.Configuration; httpRequest.Content = new StringContent(requestContent, Encoding.UTF8); httpRequest.Content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream"); // Send Request HttpResponseMessage httpResponse = null; try { if (shouldTrace) { Tracing.SendRequest(invocationId, httpRequest); } cancellationToken.ThrowIfCancellationRequested(); httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false); if (shouldTrace) { Tracing.ReceiveResponse(invocationId, httpResponse); } HttpStatusCode statusCode = httpResponse.StatusCode; if (statusCode != HttpStatusCode.Accepted) { cancellationToken.ThrowIfCancellationRequested(); CloudException ex = CloudException.Create(httpRequest, requestContent, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false)); if (shouldTrace) { Tracing.Error(invocationId, ex); } throw ex; } // Create Result OperationResponse result = null; result = new OperationResponse(); result.StatusCode = statusCode; if (httpResponse.Headers.Contains("x-ms-request-id")) { result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault(); } if (shouldTrace) { Tracing.Exit(invocationId, result); } return(result); } finally { if (httpResponse != null) { httpResponse.Dispose(); } } } finally { if (httpRequest != null) { httpRequest.Dispose(); } } }
/// <summary> /// The Set Network Configuration operation asynchronously configures /// the virtual network. (see /// http://msdn.microsoft.com/en-us/library/windowsazure/jj157181.aspx /// for more information) /// </summary> /// <param name='parameters'> /// Required. Parameters supplied to the Set Network Configuration /// operation. /// </param> /// <param name='cancellationToken'> /// Cancellation token. /// </param> /// <returns> /// The response body contains the status of the specified asynchronous /// operation, indicating whether it has succeeded, is inprogress, or /// has failed. Note that this status is distinct from the HTTP status /// code returned for the Get Operation Status operation itself. If /// the asynchronous operation succeeded, the response body includes /// the HTTP status code for the successful request. If the /// asynchronous operation failed, the response body includes the HTTP /// status code for the failed request, and also includes error /// information regarding the failure. /// </returns> public async System.Threading.Tasks.Task <OperationStatusResponse> SetConfigurationAsync(NetworkSetConfigurationParameters parameters, CancellationToken cancellationToken) { NetworkManagementClient client = this.Client; bool shouldTrace = CloudContext.Configuration.Tracing.IsEnabled; string invocationId = null; if (shouldTrace) { invocationId = Tracing.NextInvocationId.ToString(); Dictionary <string, object> tracingParameters = new Dictionary <string, object>(); tracingParameters.Add("parameters", parameters); Tracing.Enter(invocationId, this, "SetConfigurationAsync", tracingParameters); } try { if (shouldTrace) { client = this.Client.WithHandler(new ClientRequestTrackingHandler(invocationId)); } cancellationToken.ThrowIfCancellationRequested(); OperationResponse response = await client.Networks.BeginSettingConfigurationAsync(parameters, cancellationToken).ConfigureAwait(false); cancellationToken.ThrowIfCancellationRequested(); OperationStatusResponse result = await client.GetOperationStatusAsync(response.RequestId, cancellationToken).ConfigureAwait(false); int delayInSeconds = 30; if (client.LongRunningOperationInitialTimeout >= 0) { delayInSeconds = client.LongRunningOperationInitialTimeout; } while ((result.Status != OperationStatus.InProgress) == false) { cancellationToken.ThrowIfCancellationRequested(); await TaskEx.Delay(delayInSeconds * 1000, cancellationToken).ConfigureAwait(false); cancellationToken.ThrowIfCancellationRequested(); result = await client.GetOperationStatusAsync(response.RequestId, cancellationToken).ConfigureAwait(false); delayInSeconds = 30; if (client.LongRunningOperationRetryTimeout >= 0) { delayInSeconds = client.LongRunningOperationRetryTimeout; } } if (shouldTrace) { Tracing.Exit(invocationId, result); } if (result.Status != OperationStatus.Succeeded) { if (result.Error != null) { CloudException ex = new CloudException(result.Error.Code + " : " + result.Error.Message); ex.ErrorCode = result.Error.Code; ex.ErrorMessage = result.Error.Message; if (shouldTrace) { Tracing.Error(invocationId, ex); } throw ex; } else { CloudException ex = new CloudException(""); if (shouldTrace) { Tracing.Error(invocationId, ex); } throw ex; } } return(result); } finally { if (client != null && shouldTrace) { client.Dispose(); } } }
/// <summary> /// The List Virtual network sites operation retrieves the virtual /// networks configured for the subscription. (see /// http://msdn.microsoft.com/en-us/library/windowsazure/jj157185.aspx /// for more information) /// </summary> /// <param name='cancellationToken'> /// Cancellation token. /// </param> /// <returns> /// The response structure for the Network Operations List operation. /// </returns> public async System.Threading.Tasks.Task <Microsoft.WindowsAzure.Management.Network.Models.NetworkListResponse> ListAsync(CancellationToken cancellationToken) { // Validate // Tracing bool shouldTrace = CloudContext.Configuration.Tracing.IsEnabled; string invocationId = null; if (shouldTrace) { invocationId = Tracing.NextInvocationId.ToString(); Dictionary <string, object> tracingParameters = new Dictionary <string, object>(); Tracing.Enter(invocationId, this, "ListAsync", tracingParameters); } // Construct URL string baseUrl = this.Client.BaseUri.AbsoluteUri; string url = "/" + (this.Client.Credentials.SubscriptionId != null ? this.Client.Credentials.SubscriptionId.Trim() : "") + "/services/networking/virtualnetwork"; // Trim '/' character from the end of baseUrl and beginning of url. if (baseUrl[baseUrl.Length - 1] == '/') { baseUrl = baseUrl.Substring(0, baseUrl.Length - 1); } if (url[0] == '/') { url = url.Substring(1); } url = baseUrl + "/" + url; // Create HTTP transport objects HttpRequestMessage httpRequest = null; try { httpRequest = new HttpRequestMessage(); httpRequest.Method = HttpMethod.Get; httpRequest.RequestUri = new Uri(url); // Set Headers httpRequest.Headers.Add("x-ms-version", "2014-05-01"); // Set Credentials cancellationToken.ThrowIfCancellationRequested(); await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false); // Send Request HttpResponseMessage httpResponse = null; try { if (shouldTrace) { Tracing.SendRequest(invocationId, httpRequest); } cancellationToken.ThrowIfCancellationRequested(); httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false); if (shouldTrace) { Tracing.ReceiveResponse(invocationId, httpResponse); } HttpStatusCode statusCode = httpResponse.StatusCode; if (statusCode != HttpStatusCode.OK) { cancellationToken.ThrowIfCancellationRequested(); CloudException ex = CloudException.Create(httpRequest, null, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false)); if (shouldTrace) { Tracing.Error(invocationId, ex); } throw ex; } // Create Result NetworkListResponse result = null; // Deserialize Response cancellationToken.ThrowIfCancellationRequested(); string responseContent = await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); result = new NetworkListResponse(); XDocument responseDoc = XDocument.Parse(responseContent); XElement virtualNetworkSitesSequenceElement = responseDoc.Element(XName.Get("VirtualNetworkSites", "http://schemas.microsoft.com/windowsazure")); if (virtualNetworkSitesSequenceElement != null) { foreach (XElement virtualNetworkSitesElement in virtualNetworkSitesSequenceElement.Elements(XName.Get("VirtualNetworkSite", "http://schemas.microsoft.com/windowsazure"))) { NetworkListResponse.VirtualNetworkSite virtualNetworkSiteInstance = new NetworkListResponse.VirtualNetworkSite(); result.VirtualNetworkSites.Add(virtualNetworkSiteInstance); XElement nameElement = virtualNetworkSitesElement.Element(XName.Get("Name", "http://schemas.microsoft.com/windowsazure")); if (nameElement != null) { string nameInstance = nameElement.Value; virtualNetworkSiteInstance.Name = nameInstance; } XElement labelElement = virtualNetworkSitesElement.Element(XName.Get("Label", "http://schemas.microsoft.com/windowsazure")); if (labelElement != null) { string labelInstance = labelElement.Value; virtualNetworkSiteInstance.Label = labelInstance; } XElement idElement = virtualNetworkSitesElement.Element(XName.Get("Id", "http://schemas.microsoft.com/windowsazure")); if (idElement != null) { string idInstance = idElement.Value; virtualNetworkSiteInstance.Id = idInstance; } XElement affinityGroupElement = virtualNetworkSitesElement.Element(XName.Get("AffinityGroup", "http://schemas.microsoft.com/windowsazure")); if (affinityGroupElement != null) { string affinityGroupInstance = affinityGroupElement.Value; virtualNetworkSiteInstance.AffinityGroup = affinityGroupInstance; } XElement stateElement = virtualNetworkSitesElement.Element(XName.Get("State", "http://schemas.microsoft.com/windowsazure")); if (stateElement != null) { string stateInstance = stateElement.Value; virtualNetworkSiteInstance.State = stateInstance; } XElement addressSpaceElement = virtualNetworkSitesElement.Element(XName.Get("AddressSpace", "http://schemas.microsoft.com/windowsazure")); if (addressSpaceElement != null) { NetworkListResponse.AddressSpace addressSpaceInstance = new NetworkListResponse.AddressSpace(); virtualNetworkSiteInstance.AddressSpace = addressSpaceInstance; XElement addressPrefixesSequenceElement = addressSpaceElement.Element(XName.Get("AddressPrefixes", "http://schemas.microsoft.com/windowsazure")); if (addressPrefixesSequenceElement != null) { foreach (XElement addressPrefixesElement in addressPrefixesSequenceElement.Elements(XName.Get("AddressPrefix", "http://schemas.microsoft.com/windowsazure"))) { addressSpaceInstance.AddressPrefixes.Add(addressPrefixesElement.Value); } } } XElement subnetsSequenceElement = virtualNetworkSitesElement.Element(XName.Get("Subnets", "http://schemas.microsoft.com/windowsazure")); if (subnetsSequenceElement != null) { foreach (XElement subnetsElement in subnetsSequenceElement.Elements(XName.Get("Subnet", "http://schemas.microsoft.com/windowsazure"))) { NetworkListResponse.Subnet subnetInstance = new NetworkListResponse.Subnet(); virtualNetworkSiteInstance.Subnets.Add(subnetInstance); XElement nameElement2 = subnetsElement.Element(XName.Get("Name", "http://schemas.microsoft.com/windowsazure")); if (nameElement2 != null) { string nameInstance2 = nameElement2.Value; subnetInstance.Name = nameInstance2; } XElement addressPrefixElement = subnetsElement.Element(XName.Get("AddressPrefix", "http://schemas.microsoft.com/windowsazure")); if (addressPrefixElement != null) { string addressPrefixInstance = addressPrefixElement.Value; subnetInstance.AddressPrefix = addressPrefixInstance; } } } XElement dnsElement = virtualNetworkSitesElement.Element(XName.Get("Dns", "http://schemas.microsoft.com/windowsazure")); if (dnsElement != null) { XElement dnsServersSequenceElement = dnsElement.Element(XName.Get("DnsServers", "http://schemas.microsoft.com/windowsazure")); if (dnsServersSequenceElement != null) { foreach (XElement dnsServersElement in dnsServersSequenceElement.Elements(XName.Get("DnsServer", "http://schemas.microsoft.com/windowsazure"))) { NetworkListResponse.DnsServer dnsServerInstance = new NetworkListResponse.DnsServer(); virtualNetworkSiteInstance.DnsServers.Add(dnsServerInstance); XElement nameElement3 = dnsServersElement.Element(XName.Get("Name", "http://schemas.microsoft.com/windowsazure")); if (nameElement3 != null) { string nameInstance3 = nameElement3.Value; dnsServerInstance.Name = nameInstance3; } XElement addressElement = dnsServersElement.Element(XName.Get("Address", "http://schemas.microsoft.com/windowsazure")); if (addressElement != null) { string addressInstance = addressElement.Value; dnsServerInstance.Address = addressInstance; } } } } XElement gatewayElement = virtualNetworkSitesElement.Element(XName.Get("Gateway", "http://schemas.microsoft.com/windowsazure")); if (gatewayElement != null) { NetworkListResponse.Gateway gatewayInstance = new NetworkListResponse.Gateway(); virtualNetworkSiteInstance.Gateway = gatewayInstance; XElement profileElement = gatewayElement.Element(XName.Get("Profile", "http://schemas.microsoft.com/windowsazure")); if (profileElement != null) { GatewayProfile profileInstance = ((GatewayProfile)Enum.Parse(typeof(GatewayProfile), profileElement.Value, true)); gatewayInstance.Profile = profileInstance; } XElement sitesSequenceElement = gatewayElement.Element(XName.Get("Sites", "http://schemas.microsoft.com/windowsazure")); if (sitesSequenceElement != null) { foreach (XElement sitesElement in sitesSequenceElement.Elements(XName.Get("LocalNetworkSite", "http://schemas.microsoft.com/windowsazure"))) { NetworkListResponse.LocalNetworkSite localNetworkSiteInstance = new NetworkListResponse.LocalNetworkSite(); gatewayInstance.Sites.Add(localNetworkSiteInstance); XElement nameElement4 = sitesElement.Element(XName.Get("Name", "http://schemas.microsoft.com/windowsazure")); if (nameElement4 != null) { string nameInstance4 = nameElement4.Value; localNetworkSiteInstance.Name = nameInstance4; } XElement vpnGatewayAddressElement = sitesElement.Element(XName.Get("VpnGatewayAddress", "http://schemas.microsoft.com/windowsazure")); if (vpnGatewayAddressElement != null) { string vpnGatewayAddressInstance = vpnGatewayAddressElement.Value; localNetworkSiteInstance.VpnGatewayAddress = vpnGatewayAddressInstance; } XElement addressSpaceElement2 = sitesElement.Element(XName.Get("AddressSpace", "http://schemas.microsoft.com/windowsazure")); if (addressSpaceElement2 != null) { NetworkListResponse.AddressSpace addressSpaceInstance2 = new NetworkListResponse.AddressSpace(); localNetworkSiteInstance.AddressSpace = addressSpaceInstance2; XElement addressPrefixesSequenceElement2 = addressSpaceElement2.Element(XName.Get("AddressPrefixes", "http://schemas.microsoft.com/windowsazure")); if (addressPrefixesSequenceElement2 != null) { foreach (XElement addressPrefixesElement2 in addressPrefixesSequenceElement2.Elements(XName.Get("AddressPrefix", "http://schemas.microsoft.com/windowsazure"))) { addressSpaceInstance2.AddressPrefixes.Add(addressPrefixesElement2.Value); } } } XElement connectionsSequenceElement = sitesElement.Element(XName.Get("Connections", "http://schemas.microsoft.com/windowsazure")); if (connectionsSequenceElement != null) { foreach (XElement connectionsElement in connectionsSequenceElement.Elements(XName.Get("Connection", "http://schemas.microsoft.com/windowsazure"))) { NetworkListResponse.Connection connectionInstance = new NetworkListResponse.Connection(); localNetworkSiteInstance.Connections.Add(connectionInstance); XElement typeElement = connectionsElement.Element(XName.Get("Type", "http://schemas.microsoft.com/windowsazure")); if (typeElement != null) { LocalNetworkConnectionType typeInstance = NetworkManagementClient.ParseLocalNetworkConnectionType(typeElement.Value); connectionInstance.Type = typeInstance; } } } } } XElement vPNClientAddressPoolElement = gatewayElement.Element(XName.Get("VPNClientAddressPool", "http://schemas.microsoft.com/windowsazure")); if (vPNClientAddressPoolElement != null) { NetworkListResponse.VPNClientAddressPool vPNClientAddressPoolInstance = new NetworkListResponse.VPNClientAddressPool(); gatewayInstance.VPNClientAddressPool = vPNClientAddressPoolInstance; XElement addressPrefixesSequenceElement3 = vPNClientAddressPoolElement.Element(XName.Get("AddressPrefixes", "http://schemas.microsoft.com/windowsazure")); if (addressPrefixesSequenceElement3 != null) { foreach (XElement addressPrefixesElement3 in addressPrefixesSequenceElement3.Elements(XName.Get("AddressPrefix", "http://schemas.microsoft.com/windowsazure"))) { vPNClientAddressPoolInstance.AddressPrefixes.Add(addressPrefixesElement3.Value); } } } } } } result.StatusCode = statusCode; if (httpResponse.Headers.Contains("x-ms-request-id")) { result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault(); } if (shouldTrace) { Tracing.Exit(invocationId, result); } return(result); } finally { if (httpResponse != null) { httpResponse.Dispose(); } } } finally { if (httpRequest != null) { httpRequest.Dispose(); } } }
/// <summary> /// Adds a new server-level Firewall Rule for an Azure SQL Database /// Server. /// </summary> /// <param name='serverName'> /// Required. The name of the Azure SQL Database Server to which this /// rule will be applied. /// </param> /// <param name='parameters'> /// Required. The parameters for the Create Firewall Rule operation. /// </param> /// <param name='cancellationToken'> /// Cancellation token. /// </param> /// <returns> /// Contains the response to a Create Firewall Rule operation. /// </returns> public async System.Threading.Tasks.Task<Microsoft.WindowsAzure.Management.Sql.Models.FirewallRuleCreateResponse> CreateAsync(string serverName, FirewallRuleCreateParameters parameters, CancellationToken cancellationToken) { // Validate if (serverName == null) { throw new ArgumentNullException("serverName"); } if (parameters == null) { throw new ArgumentNullException("parameters"); } if (parameters.EndIPAddress == null) { throw new ArgumentNullException("parameters.EndIPAddress"); } if (parameters.Name == null) { throw new ArgumentNullException("parameters.Name"); } if (parameters.StartIPAddress == null) { throw new ArgumentNullException("parameters.StartIPAddress"); } // Tracing bool shouldTrace = CloudContext.Configuration.Tracing.IsEnabled; string invocationId = null; if (shouldTrace) { invocationId = Tracing.NextInvocationId.ToString(); Dictionary<string, object> tracingParameters = new Dictionary<string, object>(); tracingParameters.Add("serverName", serverName); tracingParameters.Add("parameters", parameters); Tracing.Enter(invocationId, this, "CreateAsync", tracingParameters); } // Construct URL string url = "/" + (this.Client.Credentials.SubscriptionId != null ? this.Client.Credentials.SubscriptionId.Trim() : "") + "/services/sqlservers/servers/" + serverName.Trim() + "/firewallrules"; string baseUrl = this.Client.BaseUri.AbsoluteUri; // Trim '/' character from the end of baseUrl and beginning of url. if (baseUrl[baseUrl.Length - 1] == '/') { baseUrl = baseUrl.Substring(0, baseUrl.Length - 1); } if (url[0] == '/') { url = url.Substring(1); } url = baseUrl + "/" + url; url = url.Replace(" ", "%20"); // Create HTTP transport objects HttpRequestMessage httpRequest = null; try { httpRequest = new HttpRequestMessage(); httpRequest.Method = HttpMethod.Post; httpRequest.RequestUri = new Uri(url); // Set Headers httpRequest.Headers.Add("x-ms-version", "2012-03-01"); // Set Credentials cancellationToken.ThrowIfCancellationRequested(); await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false); // Serialize Request string requestContent = null; XDocument requestDoc = new XDocument(); XElement serviceResourceElement = new XElement(XName.Get("ServiceResource", "http://schemas.microsoft.com/windowsazure")); requestDoc.Add(serviceResourceElement); XElement nameElement = new XElement(XName.Get("Name", "http://schemas.microsoft.com/windowsazure")); nameElement.Value = parameters.Name; serviceResourceElement.Add(nameElement); XElement startIPAddressElement = new XElement(XName.Get("StartIPAddress", "http://schemas.microsoft.com/windowsazure")); startIPAddressElement.Value = parameters.StartIPAddress; serviceResourceElement.Add(startIPAddressElement); XElement endIPAddressElement = new XElement(XName.Get("EndIPAddress", "http://schemas.microsoft.com/windowsazure")); endIPAddressElement.Value = parameters.EndIPAddress; serviceResourceElement.Add(endIPAddressElement); requestContent = requestDoc.ToString(); httpRequest.Content = new StringContent(requestContent, Encoding.UTF8); httpRequest.Content.Headers.ContentType = MediaTypeHeaderValue.Parse("application/xml"); // Send Request HttpResponseMessage httpResponse = null; try { if (shouldTrace) { Tracing.SendRequest(invocationId, httpRequest); } cancellationToken.ThrowIfCancellationRequested(); httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false); if (shouldTrace) { Tracing.ReceiveResponse(invocationId, httpResponse); } HttpStatusCode statusCode = httpResponse.StatusCode; if (statusCode != HttpStatusCode.Created) { cancellationToken.ThrowIfCancellationRequested(); CloudException ex = CloudException.Create(httpRequest, requestContent, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false)); if (shouldTrace) { Tracing.Error(invocationId, ex); } throw ex; } // Create Result FirewallRuleCreateResponse result = null; // Deserialize Response cancellationToken.ThrowIfCancellationRequested(); string responseContent = await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); result = new FirewallRuleCreateResponse(); XDocument responseDoc = XDocument.Parse(responseContent); XElement serviceResourceElement2 = responseDoc.Element(XName.Get("ServiceResource", "http://schemas.microsoft.com/windowsazure")); if (serviceResourceElement2 != null) { FirewallRule serviceResourceInstance = new FirewallRule(); result.FirewallRule = serviceResourceInstance; XElement startIPAddressElement2 = serviceResourceElement2.Element(XName.Get("StartIPAddress", "http://schemas.microsoft.com/windowsazure")); if (startIPAddressElement2 != null) { string startIPAddressInstance = startIPAddressElement2.Value; serviceResourceInstance.StartIPAddress = startIPAddressInstance; } XElement endIPAddressElement2 = serviceResourceElement2.Element(XName.Get("EndIPAddress", "http://schemas.microsoft.com/windowsazure")); if (endIPAddressElement2 != null) { string endIPAddressInstance = endIPAddressElement2.Value; serviceResourceInstance.EndIPAddress = endIPAddressInstance; } XElement nameElement2 = serviceResourceElement2.Element(XName.Get("Name", "http://schemas.microsoft.com/windowsazure")); if (nameElement2 != null) { string nameInstance = nameElement2.Value; serviceResourceInstance.Name = nameInstance; } XElement typeElement = serviceResourceElement2.Element(XName.Get("Type", "http://schemas.microsoft.com/windowsazure")); if (typeElement != null) { string typeInstance = typeElement.Value; serviceResourceInstance.Type = typeInstance; } XElement stateElement = serviceResourceElement2.Element(XName.Get("State", "http://schemas.microsoft.com/windowsazure")); if (stateElement != null) { string stateInstance = stateElement.Value; serviceResourceInstance.State = stateInstance; } } result.StatusCode = statusCode; if (httpResponse.Headers.Contains("x-ms-request-id")) { result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault(); } if (shouldTrace) { Tracing.Exit(invocationId, result); } return result; } finally { if (httpResponse != null) { httpResponse.Dispose(); } } } finally { if (httpRequest != null) { httpRequest.Dispose(); } } }
/// <summary> /// The List Management Certificates operation lists and returns basic /// information about all of the management certificates associated /// with the specified subscription. Management certificates, which /// are also known as subscription certificates, authenticate clients /// attempting to connect to resources associated with your Windows /// Azure subscription. (see /// http://msdn.microsoft.com/en-us/library/windowsazure/jj154105.aspx /// for more information) /// </summary> /// <param name='cancellationToken'> /// Cancellation token. /// </param> /// <returns> /// The List Management Certificates operation response. /// </returns> public async System.Threading.Tasks.Task <Microsoft.WindowsAzure.Management.Models.ManagementCertificateListResponse> ListAsync(CancellationToken cancellationToken) { // Validate // Tracing bool shouldTrace = CloudContext.Configuration.Tracing.IsEnabled; string invocationId = null; if (shouldTrace) { invocationId = Tracing.NextInvocationId.ToString(); Dictionary <string, object> tracingParameters = new Dictionary <string, object>(); Tracing.Enter(invocationId, this, "ListAsync", tracingParameters); } // Construct URL string url = new Uri(this.Client.BaseUri, "/").ToString() + this.Client.Credentials.SubscriptionId + "/certificates"; // Create HTTP transport objects HttpRequestMessage httpRequest = null; try { httpRequest = new HttpRequestMessage(); httpRequest.Method = HttpMethod.Get; httpRequest.RequestUri = new Uri(url); // Set Headers httpRequest.Headers.Add("x-ms-version", "2013-03-01"); // Set Credentials cancellationToken.ThrowIfCancellationRequested(); await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false); // Send Request HttpResponseMessage httpResponse = null; try { if (shouldTrace) { Tracing.SendRequest(invocationId, httpRequest); } cancellationToken.ThrowIfCancellationRequested(); httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false); if (shouldTrace) { Tracing.ReceiveResponse(invocationId, httpResponse); } HttpStatusCode statusCode = httpResponse.StatusCode; if (statusCode != HttpStatusCode.OK) { cancellationToken.ThrowIfCancellationRequested(); CloudException ex = CloudException.Create(httpRequest, null, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false), CloudExceptionType.Xml); if (shouldTrace) { Tracing.Error(invocationId, ex); } throw ex; } // Create Result ManagementCertificateListResponse result = null; // Deserialize Response cancellationToken.ThrowIfCancellationRequested(); string responseContent = await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); result = new ManagementCertificateListResponse(); XDocument responseDoc = XDocument.Parse(responseContent); XElement subscriptionCertificatesSequenceElement = responseDoc.Element(XName.Get("SubscriptionCertificates", "http://schemas.microsoft.com/windowsazure")); if (subscriptionCertificatesSequenceElement != null) { foreach (XElement subscriptionCertificatesElement in subscriptionCertificatesSequenceElement.Elements(XName.Get("SubscriptionCertificate", "http://schemas.microsoft.com/windowsazure"))) { ManagementCertificateListResponse.SubscriptionCertificate subscriptionCertificateInstance = new ManagementCertificateListResponse.SubscriptionCertificate(); result.SubscriptionCertificates.Add(subscriptionCertificateInstance); XElement subscriptionCertificatePublicKeyElement = subscriptionCertificatesElement.Element(XName.Get("SubscriptionCertificatePublicKey", "http://schemas.microsoft.com/windowsazure")); if (subscriptionCertificatePublicKeyElement != null) { byte[] subscriptionCertificatePublicKeyInstance = Convert.FromBase64String(subscriptionCertificatePublicKeyElement.Value); subscriptionCertificateInstance.PublicKey = subscriptionCertificatePublicKeyInstance; } XElement subscriptionCertificateThumbprintElement = subscriptionCertificatesElement.Element(XName.Get("SubscriptionCertificateThumbprint", "http://schemas.microsoft.com/windowsazure")); if (subscriptionCertificateThumbprintElement != null) { string subscriptionCertificateThumbprintInstance = subscriptionCertificateThumbprintElement.Value; subscriptionCertificateInstance.Thumbprint = subscriptionCertificateThumbprintInstance; } XElement subscriptionCertificateDataElement = subscriptionCertificatesElement.Element(XName.Get("SubscriptionCertificateData", "http://schemas.microsoft.com/windowsazure")); if (subscriptionCertificateDataElement != null) { byte[] subscriptionCertificateDataInstance = Convert.FromBase64String(subscriptionCertificateDataElement.Value); subscriptionCertificateInstance.Data = subscriptionCertificateDataInstance; } XElement createdElement = subscriptionCertificatesElement.Element(XName.Get("Created", "http://schemas.microsoft.com/windowsazure")); if (createdElement != null) { DateTime createdInstance = DateTime.Parse(createdElement.Value, CultureInfo.InvariantCulture); subscriptionCertificateInstance.Created = createdInstance; } } } result.StatusCode = statusCode; if (httpResponse.Headers.Contains("x-ms-request-id")) { result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault(); } if (shouldTrace) { Tracing.Exit(invocationId, result); } return(result); } finally { if (httpResponse != null) { httpResponse.Dispose(); } } } finally { if (httpRequest != null) { httpRequest.Dispose(); } } }
public static bool TryGetValue(Tracing trace, IDictionary<string, string> source, string name, out string val) { if (source.TryGetValue(name, out val)) { val = val ?? string.Empty; trace.Verbose($"Get '{name}': '{val}'"); return true; } val = null; trace.Verbose($"Get '{name}' (not found)"); return false; }
public ActionResult HandleConsentResponse(string appName, string button, string[] scopes, AuthorizeRequest request, int?rememberDuration = null) { Tracing.Start("OAuth2 Authorize Endoint - Consent response"); // make sure application is registered var application = _config.FindApplication(appName); if (application == null) { Tracing.Error("Application not found: " + appName); return(HttpNotFound()); } if (button == "no") { Tracing.Information("User denies access token request."); return(new ClientErrorResult(new Uri(request.redirect_uri), OAuthConstants.Errors.AccessDenied, request.response_type, request.state)); } if (button == "yes") { Tracing.Information("User allows access token request."); ValidatedRequest validatedRequest; try { validatedRequest = new AuthorizeRequestValidator().Validate(application, request); validatedRequest.RememberOptions = GetRememberOptions(application); } catch (AuthorizeRequestValidationException ex) { Tracing.Error("Aborting OAuth2 authorization request"); return(this.AuthorizeValidationError(ex)); } if (scopes == null || scopes.Length == 0) { ModelState.AddModelError("", "Please choose at least one permission."); return(View("Consent", validatedRequest)); } if (rememberDuration != null) { if (!application.RememberOptions.Any(r => r.Value == rememberDuration)) { ModelState.AddModelError("", "Please choose a duration from the list."); return(View("Consent", validatedRequest)); } } // parse scopes form post and substitue scopes validatedRequest.Scopes.RemoveAll(x => !scopes.Contains(x.Name)); // store consent decision if // checkbox was checked // and storage is allowed // and flow == implicit if (validatedRequest.Application.AllowRememberConsentDecision && validatedRequest.ResponseType == OAuthConstants.ResponseTypes.Token && rememberDuration == -1) { var handle = StoredGrant.CreateConsentDecision( ClaimsPrincipal.Current.GetSubject(), validatedRequest.Client, validatedRequest.Application, validatedRequest.Scopes); _handleManager.Add(handle); Tracing.Information("Consent decision stored."); } // parse refresh token lifetime if // code flow is used // and refresh tokens are allowed if (validatedRequest.RequestingRefreshToken && rememberDuration != null && validatedRequest.Client.Flow == OAuthFlow.Code) { if (rememberDuration == -1) { validatedRequest.RequestedRefreshTokenExpiration = DateTime.UtcNow.AddYears(50); } else { validatedRequest.RequestedRefreshTokenExpiration = DateTime.UtcNow.AddHours(rememberDuration.Value); } Tracing.Information("Selected refresh token lifetime in hours: " + rememberDuration); } var grantResult = PerformGrant(validatedRequest); if (grantResult != null) { return(grantResult); } } return(new ClientErrorResult( new Uri(request.redirect_uri), OAuthConstants.Errors.InvalidRequest, request.response_type, request.state)); }
// these methods are needed only for diagnostic purposes. public override void Connect(IPersistableOutput persistableOutput) { Tracing.Trace("Imgur::Connect"); base.Connect(persistableOutput); }
private IExportService initializeAssembly() { if (this.serviceSetting == null) { return((IExportService)null); } string str1 = SystemSettings.EpassDataDir + this.serviceSetting.FilePath; Tracing.Log(ExportService.sw, TraceLevel.Verbose, nameof(ExportService), "Initialize Assembly: " + str1); if (!File.Exists(str1)) { throw new FileNotFoundException(); } string fullName1 = AssemblyName.GetAssemblyName(str1).FullName; Tracing.Log(ExportService.sw, TraceLevel.Verbose, nameof(ExportService), "Display Name: " + fullName1); Assembly assembly1 = (Assembly)null; foreach (Assembly assembly2 in AppDomain.CurrentDomain.GetAssemblies()) { if (assembly2.FullName == fullName1) { assembly1 = assembly2; } } if (assembly1 == (Assembly)null) { FileStream fileStream = File.OpenRead(str1); byte[] numArray = new byte[fileStream.Length]; fileStream.Read(numArray, 0, numArray.Length); fileStream.Close(); Tracing.Log(ExportService.sw, TraceLevel.Verbose, nameof(ExportService), "Loading Assembly"); assembly1 = Assembly.Load(numArray); } string fullName2 = typeof(IExportService).FullName; string typeName = (string)null; try { foreach (Type type in assembly1.GetTypes()) { if (type.GetInterface(fullName2) != (Type)null) { typeName = type.FullName; } } } catch (ReflectionTypeLoadException ex) { string str2 = "ReflectionTypeLoadException occured:\r\n" + ex.Message + "\r\n\r\n" + "Assembly Types:\r\n"; foreach (Type type in ex.Types) { if (!(type == (Type)null)) { str2 = str2 + "Assembly: " + (object)type.Assembly + "\r\n" + "AssemblyQualifiedName: " + type.AssemblyQualifiedName + "\r\n" + "FullName: " + type.FullName + "\r\n" + "\r\n"; } } string str3 = str2 + "LoaderException messages:\r\n"; foreach (Exception loaderException in ex.LoaderExceptions) { if (loaderException != null) { str3 = str3 + loaderException.Message + "\r\n"; } } string str4 = str3 + "\r\n"; Tracing.Log(ExportService.sw, TraceLevel.Error, nameof(ExportService), str4 + "\r\n"); throw; } catch (Exception ex) { string msg = "Exception trying to create instance:\r\n" + ex.Message + "\r\n\r\nInnerException: \r\n" + (object)ex.InnerException; Tracing.Log(ExportService.sw, TraceLevel.Error, nameof(ExportService), msg); throw; } Tracing.Log(ExportService.sw, TraceLevel.Verbose, nameof(ExportService), "Creating Instance: " + typeName); return((IExportService)assembly1.CreateInstance(typeName)); }
protected override void OnImageFormatClick(object sender, ImageFormatEventArgs e) { Tracing.Trace("Imgur::MenuClick"); base.OnImageFormatClick(sender, e); }
public override Stream Open() { Tracing.FrameworkInformation("EmbeddedResourceVirtualFile", "Open", "_resourceName={0}", _resourceName); return(_assembly.GetManifestResourceStream(_resourceName)); }
public void CalculateServiceNameL0() { using (TestHostContext tc = CreateTestContext()) { Tracing trace = tc.GetTrace(); trace.Info("Creating service control manager"); ServiceControlManager scm = new ServiceControlManager(); scm.Initialize(tc); ServiceNameTest[] tests = new ServiceNameTest[] { new ServiceNameTest { TestName = "SystemD Test", ServiceNamePattern = "vsts.agent.{0}.{1}.{2}.service", ServiceDisplayPattern = "Azure Pipelines Agent ({0}.{1}.{2})", AgentName = "foo", PoolName = "pool1", ServerUrl = "https://dev.azure.com/bar", ExpectedServiceName = "vsts.agent.bar.pool1.foo.service", ExpectedServiceDisplayName = "Azure Pipelines Agent (bar.pool1.foo)" }, new ServiceNameTest { TestName = "Long Agent/Pool Test", ServiceNamePattern = "vsts.agent.{0}.{1}.{2}.service", ServiceDisplayPattern = "Azure Pipelines Agent ({0}.{1}.{2})", AgentName = new string('X', 40), PoolName = new string('Y', 40), ServerUrl = "https://dev.azure.com/bar", ExpectedServiceName = "vsts.agent.bar.YYYYYYYYYYYYYYYYYYYYYYYYY.XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.service", ExpectedServiceDisplayName = "Azure Pipelines Agent (bar.YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY.XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX)" }, new ServiceNameTest { TestName = "Pool With Unicode Dash Test", ServiceNamePattern = "vsts.agent.{0}.{1}.{2}.service", ServiceDisplayPattern = "Azure Pipelines Agent ({0}.{1}.{2})", AgentName = "foo", PoolName = "pool" + "\u002D" + "1", ServerUrl = "https://dev.azure.com/bar", ExpectedServiceName = "vsts.agent.bar.pool-1.foo.service", ExpectedServiceDisplayName = "Azure Pipelines Agent (bar.pool-1.foo)" }, new ServiceNameTest { TestName = "Agent For Environment Test", ServiceNamePattern = "vsts.agent.{0}.{1}.{2}.service", ServiceDisplayPattern = "Azure Pipelines Agent ({0}.{1}.{2})", AgentName = new string('X', 40), EnvironmentName = new string('Y', 40), ServerUrl = "https://dev.azure.com/bar", ExpectedServiceName = "vsts.agent.bar.YYYYYYYYYYYYYYYYYYYYYYYYY.XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.service", ExpectedServiceDisplayName = "Azure Pipelines Agent (bar.YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY.XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX)" }, }; foreach (var test in tests) { AgentSettings settings = new AgentSettings(); settings.ServerUrl = test.ServerUrl; settings.AgentName = test.AgentName; settings.PoolName = test.PoolName; settings.EnvironmentName = test.EnvironmentName; scm.CalculateServiceName(settings, test.ServiceNamePattern, test.ServiceDisplayPattern, out string serviceName, out string serviceDisplayName); Assert.True(string.Equals(serviceName, test.ExpectedServiceName), $"{test.TestName} Service Name Expected: {test.ExpectedServiceName}, Got: {serviceName}"); Assert.True(serviceName.Length <= 80, $"{test.TestName} Service Name is <= 80"); Assert.True(string.Equals(serviceDisplayName, test.ExpectedServiceDisplayName), $"{test.TestName} Service Display Name Expected: {test.ExpectedServiceDisplayName}, Got: {serviceDisplayName}"); } } }
/// <param name='resourceId'> /// The resource ID. /// </param> /// <param name='cancellationToken'> /// Cancellation token. /// </param> /// <returns> /// A standard service response including an HTTP status code and /// request ID. /// </returns> public async System.Threading.Tasks.Task <OperationResponse> DeleteAsync(string resourceId, CancellationToken cancellationToken) { // Validate if (resourceId == null) { throw new ArgumentNullException("resourceId"); } // Tracing bool shouldTrace = CloudContext.Configuration.Tracing.IsEnabled; string invocationId = null; if (shouldTrace) { invocationId = Tracing.NextInvocationId.ToString(); Dictionary <string, object> tracingParameters = new Dictionary <string, object>(); tracingParameters.Add("resourceId", resourceId); Tracing.Enter(invocationId, this, "DeleteAsync", tracingParameters); } // Construct URL string url = new Uri(this.Client.BaseUri, "/").ToString() + this.Client.Credentials.SubscriptionId + "/services/monitoring/autoscalesettings?"; url = url + "resourceId=" + Uri.EscapeUriString(resourceId); // Create HTTP transport objects HttpRequestMessage httpRequest = null; try { httpRequest = new HttpRequestMessage(); httpRequest.Method = HttpMethod.Delete; httpRequest.RequestUri = new Uri(url); // Set Headers httpRequest.Headers.Add("Accept", "application/json"); httpRequest.Headers.Add("x-ms-version", "2013-10-01"); // Set Credentials cancellationToken.ThrowIfCancellationRequested(); await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false); // Send Request HttpResponseMessage httpResponse = null; try { if (shouldTrace) { Tracing.SendRequest(invocationId, httpRequest); } cancellationToken.ThrowIfCancellationRequested(); httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false); if (shouldTrace) { Tracing.ReceiveResponse(invocationId, httpResponse); } HttpStatusCode statusCode = httpResponse.StatusCode; if (statusCode != HttpStatusCode.OK) { cancellationToken.ThrowIfCancellationRequested(); CloudException ex = CloudException.Create(httpRequest, null, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false), CloudExceptionType.Json); if (shouldTrace) { Tracing.Error(invocationId, ex); } throw ex; } // Create Result OperationResponse result = null; result = new OperationResponse(); result.StatusCode = statusCode; if (httpResponse.Headers.Contains("x-ms-request-id")) { result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault(); } if (shouldTrace) { Tracing.Exit(invocationId, result); } return(result); } finally { if (httpResponse != null) { httpResponse.Dispose(); } } } finally { if (httpRequest != null) { httpRequest.Dispose(); } } }
/// <summary> /// Get a list of deployments operations. /// </summary> /// <param name='resourceGroupName'> /// Required. The name of the resource group. The name is case /// insensitive. /// </param> /// <param name='deploymentName'> /// Required. The name of the deployment. /// </param> /// <param name='operationId'> /// Required. Operation Id. /// </param> /// <param name='cancellationToken'> /// Cancellation token. /// </param> /// <returns> /// Deployment operation. /// </returns> public async Task <DeploymentOperationsGetResult> GetAsync(string resourceGroupName, string deploymentName, string operationId, CancellationToken cancellationToken) { // Validate if (resourceGroupName == null) { throw new ArgumentNullException("resourceGroupName"); } if (resourceGroupName != null && resourceGroupName.Length > 1000) { throw new ArgumentOutOfRangeException("resourceGroupName"); } if (Regex.IsMatch(resourceGroupName, "^[-\\w\\._]+$") == false) { throw new ArgumentOutOfRangeException("resourceGroupName"); } if (deploymentName == null) { throw new ArgumentNullException("deploymentName"); } if (operationId == null) { throw new ArgumentNullException("operationId"); } // Tracing bool shouldTrace = CloudContext.Configuration.Tracing.IsEnabled; string invocationId = null; if (shouldTrace) { invocationId = Tracing.NextInvocationId.ToString(); Dictionary <string, object> tracingParameters = new Dictionary <string, object>(); tracingParameters.Add("resourceGroupName", resourceGroupName); tracingParameters.Add("deploymentName", deploymentName); tracingParameters.Add("operationId", operationId); Tracing.Enter(invocationId, this, "GetAsync", tracingParameters); } // Construct URL string baseUrl = this.Client.BaseUri.AbsoluteUri; string url = "/subscriptions/" + this.Client.Credentials.SubscriptionId.Trim() + "/resourcegroups/" + resourceGroupName.Trim() + "/deployments/" + deploymentName.Trim() + "/operations/" + operationId.Trim() + "?"; url = url + "api-version=2014-04-01-preview"; // Trim '/' character from the end of baseUrl and beginning of url. if (baseUrl[baseUrl.Length - 1] == '/') { baseUrl = baseUrl.Substring(0, baseUrl.Length - 1); } if (url[0] == '/') { url = url.Substring(1); } url = baseUrl + "/" + url; // Create HTTP transport objects HttpRequestMessage httpRequest = null; try { httpRequest = new HttpRequestMessage(); httpRequest.Method = HttpMethod.Get; httpRequest.RequestUri = new Uri(url); // Set Headers // Set Credentials cancellationToken.ThrowIfCancellationRequested(); await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false); // Send Request HttpResponseMessage httpResponse = null; try { if (shouldTrace) { Tracing.SendRequest(invocationId, httpRequest); } cancellationToken.ThrowIfCancellationRequested(); httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false); if (shouldTrace) { Tracing.ReceiveResponse(invocationId, httpResponse); } HttpStatusCode statusCode = httpResponse.StatusCode; if (statusCode != HttpStatusCode.OK) { cancellationToken.ThrowIfCancellationRequested(); CloudException ex = CloudException.Create(httpRequest, null, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false), CloudExceptionType.Json); if (shouldTrace) { Tracing.Error(invocationId, ex); } throw ex; } // Create Result DeploymentOperationsGetResult result = null; // Deserialize Response cancellationToken.ThrowIfCancellationRequested(); string responseContent = await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); result = new DeploymentOperationsGetResult(); JToken responseDoc = null; if (string.IsNullOrEmpty(responseContent) == false) { responseDoc = JToken.Parse(responseContent); } if (responseDoc != null && responseDoc.Type != JTokenType.Null) { DeploymentOperation operationInstance = new DeploymentOperation(); result.Operation = operationInstance; JToken operationIdValue = responseDoc["operationId"]; if (operationIdValue != null && operationIdValue.Type != JTokenType.Null) { string operationIdInstance = ((string)operationIdValue); operationInstance.OperationId = operationIdInstance; } JToken propertiesValue = responseDoc["properties"]; if (propertiesValue != null && propertiesValue.Type != JTokenType.Null) { DeploymentOperationProperties propertiesInstance = new DeploymentOperationProperties(); operationInstance.Properties = propertiesInstance; JToken provisioningStateValue = propertiesValue["provisioningState"]; if (provisioningStateValue != null && provisioningStateValue.Type != JTokenType.Null) { string provisioningStateInstance = ((string)provisioningStateValue); propertiesInstance.ProvisioningState = provisioningStateInstance; } JToken timestampValue = propertiesValue["timestamp"]; if (timestampValue != null && timestampValue.Type != JTokenType.Null) { DateTime timestampInstance = ((DateTime)timestampValue); propertiesInstance.Timestamp = timestampInstance; } JToken statusCodeValue = propertiesValue["statusCode"]; if (statusCodeValue != null && statusCodeValue.Type != JTokenType.Null) { string statusCodeInstance = ((string)statusCodeValue); propertiesInstance.StatusCode = statusCodeInstance; } JToken statusMessageValue = propertiesValue["statusMessage"]; if (statusMessageValue != null && statusMessageValue.Type != JTokenType.Null) { string statusMessageInstance = statusMessageValue.ToString(Formatting.Indented); propertiesInstance.StatusMessage = statusMessageInstance; } JToken targetResourceValue = propertiesValue["targetResource"]; if (targetResourceValue != null && targetResourceValue.Type != JTokenType.Null) { TargetResource targetResourceInstance = new TargetResource(); propertiesInstance.TargetResource = targetResourceInstance; JToken idValue = targetResourceValue["id"]; if (idValue != null && idValue.Type != JTokenType.Null) { string idInstance = ((string)idValue); targetResourceInstance.Id = idInstance; } JToken resourceNameValue = targetResourceValue["resourceName"]; if (resourceNameValue != null && resourceNameValue.Type != JTokenType.Null) { string resourceNameInstance = ((string)resourceNameValue); targetResourceInstance.ResourceName = resourceNameInstance; } JToken resourceTypeValue = targetResourceValue["resourceType"]; if (resourceTypeValue != null && resourceTypeValue.Type != JTokenType.Null) { string resourceTypeInstance = ((string)resourceTypeValue); targetResourceInstance.ResourceType = resourceTypeInstance; } } } } result.StatusCode = statusCode; if (httpResponse.Headers.Contains("x-ms-request-id")) { result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault(); } if (shouldTrace) { Tracing.Exit(invocationId, result); } return(result); } finally { if (httpResponse != null) { httpResponse.Dispose(); } } } finally { if (httpRequest != null) { httpRequest.Dispose(); } } }
/// <param name='resourceId'> /// The resource ID. /// </param> /// <param name='cancellationToken'> /// Cancellation token. /// </param> /// <returns> /// A standard service response including an HTTP status code and /// request ID. /// </returns> public async System.Threading.Tasks.Task <Microsoft.WindowsAzure.Management.Monitoring.Autoscale.Models.AutoscaleSettingGetResponse> GetAsync(string resourceId, CancellationToken cancellationToken) { // Validate if (resourceId == null) { throw new ArgumentNullException("resourceId"); } // Tracing bool shouldTrace = CloudContext.Configuration.Tracing.IsEnabled; string invocationId = null; if (shouldTrace) { invocationId = Tracing.NextInvocationId.ToString(); Dictionary <string, object> tracingParameters = new Dictionary <string, object>(); tracingParameters.Add("resourceId", resourceId); Tracing.Enter(invocationId, this, "GetAsync", tracingParameters); } // Construct URL string url = new Uri(this.Client.BaseUri, "/").ToString() + this.Client.Credentials.SubscriptionId + "/services/monitoring/autoscalesettings?"; url = url + "resourceId=" + Uri.EscapeUriString(resourceId); // Create HTTP transport objects HttpRequestMessage httpRequest = null; try { httpRequest = new HttpRequestMessage(); httpRequest.Method = HttpMethod.Get; httpRequest.RequestUri = new Uri(url); // Set Headers httpRequest.Headers.Add("Accept", "application/json"); httpRequest.Headers.Add("x-ms-version", "2013-10-01"); // Set Credentials cancellationToken.ThrowIfCancellationRequested(); await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false); // Send Request HttpResponseMessage httpResponse = null; try { if (shouldTrace) { Tracing.SendRequest(invocationId, httpRequest); } cancellationToken.ThrowIfCancellationRequested(); httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false); if (shouldTrace) { Tracing.ReceiveResponse(invocationId, httpResponse); } HttpStatusCode statusCode = httpResponse.StatusCode; if (statusCode != HttpStatusCode.OK) { cancellationToken.ThrowIfCancellationRequested(); CloudException ex = CloudException.Create(httpRequest, null, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false), CloudExceptionType.Json); if (shouldTrace) { Tracing.Error(invocationId, ex); } throw ex; } // Create Result AutoscaleSettingGetResponse result = null; // Deserialize Response cancellationToken.ThrowIfCancellationRequested(); string responseContent = await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); result = new AutoscaleSettingGetResponse(); JToken responseDoc = JToken.Parse(responseContent); if (responseDoc != null && responseDoc.Type != JTokenType.Null) { AutoscaleSetting settingInstance = new AutoscaleSetting(); result.Setting = settingInstance; JToken profilesArray = responseDoc["Profiles"]; if (profilesArray != null && profilesArray.Type != JTokenType.Null) { foreach (JToken profilesValue in (JArray)profilesArray) { AutoscaleProfile autoscaleProfileInstance = new AutoscaleProfile(); settingInstance.Profiles.Add(autoscaleProfileInstance); JToken nameValue = profilesValue["Name"]; if (nameValue != null && nameValue.Type != JTokenType.Null) { string nameInstance = (string)nameValue; autoscaleProfileInstance.Name = nameInstance; } JToken capacityValue = profilesValue["Capacity"]; if (capacityValue != null && capacityValue.Type != JTokenType.Null) { ScaleCapacity capacityInstance = new ScaleCapacity(); autoscaleProfileInstance.Capacity = capacityInstance; JToken minimumValue = capacityValue["Minimum"]; if (minimumValue != null && minimumValue.Type != JTokenType.Null) { string minimumInstance = (string)minimumValue; capacityInstance.Minimum = minimumInstance; } JToken maximumValue = capacityValue["Maximum"]; if (maximumValue != null && maximumValue.Type != JTokenType.Null) { string maximumInstance = (string)maximumValue; capacityInstance.Maximum = maximumInstance; } JToken defaultValue = capacityValue["Default"]; if (defaultValue != null && defaultValue.Type != JTokenType.Null) { string defaultInstance = (string)defaultValue; capacityInstance.Default = defaultInstance; } } JToken rulesArray = profilesValue["Rules"]; if (rulesArray != null && rulesArray.Type != JTokenType.Null) { foreach (JToken rulesValue in (JArray)rulesArray) { ScaleRule scaleRuleInstance = new ScaleRule(); autoscaleProfileInstance.Rules.Add(scaleRuleInstance); JToken metricTriggerValue = rulesValue["MetricTrigger"]; if (metricTriggerValue != null && metricTriggerValue.Type != JTokenType.Null) { MetricTrigger metricTriggerInstance = new MetricTrigger(); scaleRuleInstance.MetricTrigger = metricTriggerInstance; JToken metricNameValue = metricTriggerValue["MetricName"]; if (metricNameValue != null && metricNameValue.Type != JTokenType.Null) { string metricNameInstance = (string)metricNameValue; metricTriggerInstance.MetricName = metricNameInstance; } JToken metricNamespaceValue = metricTriggerValue["MetricNamespace"]; if (metricNamespaceValue != null && metricNamespaceValue.Type != JTokenType.Null) { string metricNamespaceInstance = (string)metricNamespaceValue; metricTriggerInstance.MetricNamespace = metricNamespaceInstance; } JToken metricSourceValue = metricTriggerValue["MetricSource"]; if (metricSourceValue != null && metricSourceValue.Type != JTokenType.Null) { string metricSourceInstance = (string)metricSourceValue; metricTriggerInstance.MetricSource = metricSourceInstance; } JToken timeGrainValue = metricTriggerValue["TimeGrain"]; if (timeGrainValue != null && timeGrainValue.Type != JTokenType.Null) { TimeSpan timeGrainInstance = TypeConversion.From8601TimeSpan((string)timeGrainValue); metricTriggerInstance.TimeGrain = timeGrainInstance; } JToken statisticValue = metricTriggerValue["Statistic"]; if (statisticValue != null && statisticValue.Type != JTokenType.Null) { MetricStatisticType statisticInstance = (MetricStatisticType)Enum.Parse(typeof(MetricStatisticType), (string)statisticValue, false); metricTriggerInstance.Statistic = statisticInstance; } JToken timeWindowValue = metricTriggerValue["TimeWindow"]; if (timeWindowValue != null && timeWindowValue.Type != JTokenType.Null) { TimeSpan timeWindowInstance = TypeConversion.From8601TimeSpan((string)timeWindowValue); metricTriggerInstance.TimeWindow = timeWindowInstance; } JToken timeAggregationValue = metricTriggerValue["TimeAggregation"]; if (timeAggregationValue != null && timeAggregationValue.Type != JTokenType.Null) { TimeAggregationType timeAggregationInstance = (TimeAggregationType)Enum.Parse(typeof(TimeAggregationType), (string)timeAggregationValue, false); metricTriggerInstance.TimeAggregation = timeAggregationInstance; } JToken operatorValue = metricTriggerValue["Operator"]; if (operatorValue != null && operatorValue.Type != JTokenType.Null) { ComparisonOperationType operatorInstance = (ComparisonOperationType)Enum.Parse(typeof(ComparisonOperationType), (string)operatorValue, false); metricTriggerInstance.Operator = operatorInstance; } JToken thresholdValue = metricTriggerValue["Threshold"]; if (thresholdValue != null && thresholdValue.Type != JTokenType.Null) { double thresholdInstance = (double)thresholdValue; metricTriggerInstance.Threshold = thresholdInstance; } } JToken scaleActionValue = rulesValue["ScaleAction"]; if (scaleActionValue != null && scaleActionValue.Type != JTokenType.Null) { ScaleAction scaleActionInstance = new ScaleAction(); scaleRuleInstance.ScaleAction = scaleActionInstance; JToken directionValue = scaleActionValue["Direction"]; if (directionValue != null && directionValue.Type != JTokenType.Null) { ScaleDirection directionInstance = (ScaleDirection)Enum.Parse(typeof(ScaleDirection), (string)directionValue, false); scaleActionInstance.Direction = directionInstance; } JToken typeValue = scaleActionValue["Type"]; if (typeValue != null && typeValue.Type != JTokenType.Null) { ScaleType typeInstance = (ScaleType)Enum.Parse(typeof(ScaleType), (string)typeValue, false); scaleActionInstance.Type = typeInstance; } JToken valueValue = scaleActionValue["Value"]; if (valueValue != null && valueValue.Type != JTokenType.Null) { string valueInstance = (string)valueValue; scaleActionInstance.Value = valueInstance; } JToken cooldownValue = scaleActionValue["Cooldown"]; if (cooldownValue != null && cooldownValue.Type != JTokenType.Null) { TimeSpan cooldownInstance = TypeConversion.From8601TimeSpan((string)cooldownValue); scaleActionInstance.Cooldown = cooldownInstance; } } } } JToken fixedDateValue = profilesValue["FixedDate"]; if (fixedDateValue != null && fixedDateValue.Type != JTokenType.Null) { TimeWindow fixedDateInstance = new TimeWindow(); autoscaleProfileInstance.FixedDate = fixedDateInstance; JToken timeZoneValue = fixedDateValue["TimeZone"]; if (timeZoneValue != null && timeZoneValue.Type != JTokenType.Null) { string timeZoneInstance = (string)timeZoneValue; fixedDateInstance.TimeZone = timeZoneInstance; } JToken startValue = fixedDateValue["Start"]; if (startValue != null && startValue.Type != JTokenType.Null) { DateTime startInstance = (DateTime)startValue; fixedDateInstance.Start = startInstance; } JToken endValue = fixedDateValue["End"]; if (endValue != null && endValue.Type != JTokenType.Null) { DateTime endInstance = (DateTime)endValue; fixedDateInstance.End = endInstance; } } JToken recurrenceValue = profilesValue["Recurrence"]; if (recurrenceValue != null && recurrenceValue.Type != JTokenType.Null) { Recurrence recurrenceInstance = new Recurrence(); autoscaleProfileInstance.Recurrence = recurrenceInstance; JToken frequencyValue = recurrenceValue["Frequency"]; if (frequencyValue != null && frequencyValue.Type != JTokenType.Null) { RecurrenceFrequency frequencyInstance = (RecurrenceFrequency)Enum.Parse(typeof(RecurrenceFrequency), (string)frequencyValue, false); recurrenceInstance.Frequency = frequencyInstance; } JToken scheduleValue = recurrenceValue["Schedule"]; if (scheduleValue != null && scheduleValue.Type != JTokenType.Null) { RecurrentSchedule scheduleInstance = new RecurrentSchedule(); recurrenceInstance.Schedule = scheduleInstance; JToken timeZoneValue2 = scheduleValue["TimeZone"]; if (timeZoneValue2 != null && timeZoneValue2.Type != JTokenType.Null) { string timeZoneInstance2 = (string)timeZoneValue2; scheduleInstance.TimeZone = timeZoneInstance2; } JToken daysArray = scheduleValue["Days"]; if (daysArray != null && daysArray.Type != JTokenType.Null) { foreach (JToken daysValue in (JArray)daysArray) { scheduleInstance.Days.Add((string)daysValue); } } JToken hoursArray = scheduleValue["Hours"]; if (hoursArray != null && hoursArray.Type != JTokenType.Null) { foreach (JToken hoursValue in (JArray)hoursArray) { scheduleInstance.Hours.Add((int)hoursValue); } } JToken minutesArray = scheduleValue["Minutes"]; if (minutesArray != null && minutesArray.Type != JTokenType.Null) { foreach (JToken minutesValue in (JArray)minutesArray) { scheduleInstance.Minutes.Add((int)minutesValue); } } } } } } JToken enabledValue = responseDoc["Enabled"]; if (enabledValue != null && enabledValue.Type != JTokenType.Null) { bool enabledInstance = (bool)enabledValue; settingInstance.Enabled = enabledInstance; } } result.StatusCode = statusCode; if (httpResponse.Headers.Contains("x-ms-request-id")) { result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault(); } if (shouldTrace) { Tracing.Exit(invocationId, result); } return(result); } finally { if (httpResponse != null) { httpResponse.Dispose(); } } } finally { if (httpRequest != null) { httpRequest.Dispose(); } } }
/// <summary> /// The Delete Service Certificate operation deletes a service /// certificate from the certificate store of a hosted service. The /// Delete Service Certificate operation is an asynchronous operation. /// To determine whether the management service has finished /// processing the request, call Get Operation Status. (see /// http://msdn.microsoft.com/en-us/library/windowsazure/ee460803.aspx /// for more information) /// </summary> /// <param name='parameters'> /// Parameters supplied to the Delete Service Certificate operation. /// </param> /// <param name='cancellationToken'> /// Cancellation token. /// </param> /// <returns> /// A standard service response including an HTTP status code and /// request ID. /// </returns> public async System.Threading.Tasks.Task <OperationResponse> BeginDeletingAsync(ServiceCertificateDeleteParameters parameters, CancellationToken cancellationToken) { // Validate if (parameters == null) { throw new ArgumentNullException("parameters"); } if (parameters.ServiceName == null) { throw new ArgumentNullException("parameters.ServiceName"); } // TODO: Validate parameters.ServiceName is a valid DNS name. if (parameters.Thumbprint == null) { throw new ArgumentNullException("parameters.Thumbprint"); } if (parameters.ThumbprintAlgorithm == null) { throw new ArgumentNullException("parameters.ThumbprintAlgorithm"); } // Tracing bool shouldTrace = CloudContext.Configuration.Tracing.IsEnabled; string invocationId = null; if (shouldTrace) { invocationId = Tracing.NextInvocationId.ToString(); Dictionary <string, object> tracingParameters = new Dictionary <string, object>(); tracingParameters.Add("parameters", parameters); Tracing.Enter(invocationId, this, "BeginDeletingAsync", tracingParameters); } // Construct URL string url = new Uri(this.Client.BaseUri, "/").AbsoluteUri + this.Client.Credentials.SubscriptionId + "/services/hostedservices/" + parameters.ServiceName + "/certificates/" + parameters.ThumbprintAlgorithm + "-" + parameters.Thumbprint; // Create HTTP transport objects HttpRequestMessage httpRequest = null; try { httpRequest = new HttpRequestMessage(); httpRequest.Method = HttpMethod.Delete; httpRequest.RequestUri = new Uri(url); // Set Headers httpRequest.Headers.Add("x-ms-version", "2013-11-01"); // Set Credentials cancellationToken.ThrowIfCancellationRequested(); await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false); // Send Request HttpResponseMessage httpResponse = null; try { if (shouldTrace) { Tracing.SendRequest(invocationId, httpRequest); } cancellationToken.ThrowIfCancellationRequested(); httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false); if (shouldTrace) { Tracing.ReceiveResponse(invocationId, httpResponse); } HttpStatusCode statusCode = httpResponse.StatusCode; if (statusCode != HttpStatusCode.Accepted) { cancellationToken.ThrowIfCancellationRequested(); CloudException ex = CloudException.Create(httpRequest, null, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false), CloudExceptionType.Xml); if (shouldTrace) { Tracing.Error(invocationId, ex); } throw ex; } // Create Result OperationResponse result = null; result = new OperationResponse(); result.StatusCode = statusCode; if (httpResponse.Headers.Contains("x-ms-request-id")) { result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault(); } if (shouldTrace) { Tracing.Exit(invocationId, result); } return(result); } finally { if (httpResponse != null) { httpResponse.Dispose(); } } } finally { if (httpRequest != null) { httpRequest.Dispose(); } } }
/// <param name='resourceId'> /// The resource ID. /// </param> /// <param name='parameters'> /// Parameters supplied to the operation. /// </param> /// <param name='cancellationToken'> /// Cancellation token. /// </param> /// <returns> /// A standard service response including an HTTP status code and /// request ID. /// </returns> public async System.Threading.Tasks.Task <OperationResponse> CreateOrUpdateAsync(string resourceId, AutoscaleSettingCreateOrUpdateParameters parameters, CancellationToken cancellationToken) { // Validate if (resourceId == null) { throw new ArgumentNullException("resourceId"); } if (parameters == null) { throw new ArgumentNullException("parameters"); } // Tracing bool shouldTrace = CloudContext.Configuration.Tracing.IsEnabled; string invocationId = null; if (shouldTrace) { invocationId = Tracing.NextInvocationId.ToString(); Dictionary <string, object> tracingParameters = new Dictionary <string, object>(); tracingParameters.Add("resourceId", resourceId); tracingParameters.Add("parameters", parameters); Tracing.Enter(invocationId, this, "CreateOrUpdateAsync", tracingParameters); } // Construct URL string url = new Uri(this.Client.BaseUri, "/").ToString() + this.Client.Credentials.SubscriptionId + "/services/monitoring/autoscalesettings?"; url = url + "resourceId=" + Uri.EscapeUriString(resourceId); // Create HTTP transport objects HttpRequestMessage httpRequest = null; try { httpRequest = new HttpRequestMessage(); httpRequest.Method = HttpMethod.Put; httpRequest.RequestUri = new Uri(url); // Set Headers httpRequest.Headers.Add("Accept", "application/json"); httpRequest.Headers.Add("x-ms-version", "2013-10-01"); // Set Credentials cancellationToken.ThrowIfCancellationRequested(); await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false); // Serialize Request string requestContent = null; JToken requestDoc = null; if (parameters.Setting != null) { JObject settingValue = new JObject(); requestDoc = new JObject(); requestDoc["Setting"] = settingValue; if (parameters.Setting.Profiles != null) { JArray profilesArray = new JArray(); foreach (AutoscaleProfile profilesItem in parameters.Setting.Profiles) { JObject autoscaleProfileValue = new JObject(); profilesArray.Add(autoscaleProfileValue); if (profilesItem.Name != null) { autoscaleProfileValue["Name"] = profilesItem.Name; } if (profilesItem.Capacity != null) { JObject capacityValue = new JObject(); autoscaleProfileValue["Capacity"] = capacityValue; if (profilesItem.Capacity.Minimum != null) { capacityValue["Minimum"] = profilesItem.Capacity.Minimum; } if (profilesItem.Capacity.Maximum != null) { capacityValue["Maximum"] = profilesItem.Capacity.Maximum; } if (profilesItem.Capacity.Default != null) { capacityValue["Default"] = profilesItem.Capacity.Default; } } if (profilesItem.Rules != null) { JArray rulesArray = new JArray(); foreach (ScaleRule rulesItem in profilesItem.Rules) { JObject scaleRuleValue = new JObject(); rulesArray.Add(scaleRuleValue); if (rulesItem.MetricTrigger != null) { JObject metricTriggerValue = new JObject(); scaleRuleValue["MetricTrigger"] = metricTriggerValue; if (rulesItem.MetricTrigger.MetricName != null) { metricTriggerValue["MetricName"] = rulesItem.MetricTrigger.MetricName; } if (rulesItem.MetricTrigger.MetricNamespace != null) { metricTriggerValue["MetricNamespace"] = rulesItem.MetricTrigger.MetricNamespace; } if (rulesItem.MetricTrigger.MetricSource != null) { metricTriggerValue["MetricSource"] = rulesItem.MetricTrigger.MetricSource; } metricTriggerValue["TimeGrain"] = TypeConversion.To8601String(rulesItem.MetricTrigger.TimeGrain); metricTriggerValue["Statistic"] = rulesItem.MetricTrigger.Statistic.ToString(); metricTriggerValue["TimeWindow"] = TypeConversion.To8601String(rulesItem.MetricTrigger.TimeWindow); metricTriggerValue["TimeAggregation"] = rulesItem.MetricTrigger.TimeAggregation.ToString(); metricTriggerValue["Operator"] = rulesItem.MetricTrigger.Operator.ToString(); metricTriggerValue["Threshold"] = rulesItem.MetricTrigger.Threshold; } if (rulesItem.ScaleAction != null) { JObject scaleActionValue = new JObject(); scaleRuleValue["ScaleAction"] = scaleActionValue; scaleActionValue["Direction"] = rulesItem.ScaleAction.Direction.ToString(); scaleActionValue["Type"] = rulesItem.ScaleAction.Type.ToString(); if (rulesItem.ScaleAction.Value != null) { scaleActionValue["Value"] = rulesItem.ScaleAction.Value; } scaleActionValue["Cooldown"] = TypeConversion.To8601String(rulesItem.ScaleAction.Cooldown); } } autoscaleProfileValue["Rules"] = rulesArray; } if (profilesItem.FixedDate != null) { JObject fixedDateValue = new JObject(); autoscaleProfileValue["FixedDate"] = fixedDateValue; if (profilesItem.FixedDate.TimeZone != null) { fixedDateValue["TimeZone"] = profilesItem.FixedDate.TimeZone; } fixedDateValue["Start"] = profilesItem.FixedDate.Start; fixedDateValue["End"] = profilesItem.FixedDate.End; } if (profilesItem.Recurrence != null) { JObject recurrenceValue = new JObject(); autoscaleProfileValue["Recurrence"] = recurrenceValue; recurrenceValue["Frequency"] = profilesItem.Recurrence.Frequency.ToString(); if (profilesItem.Recurrence.Schedule != null) { JObject scheduleValue = new JObject(); recurrenceValue["Schedule"] = scheduleValue; if (profilesItem.Recurrence.Schedule.TimeZone != null) { scheduleValue["TimeZone"] = profilesItem.Recurrence.Schedule.TimeZone; } if (profilesItem.Recurrence.Schedule.Days != null) { JArray daysArray = new JArray(); foreach (string daysItem in profilesItem.Recurrence.Schedule.Days) { daysArray.Add(daysItem); } scheduleValue["Days"] = daysArray; } if (profilesItem.Recurrence.Schedule.Hours != null) { JArray hoursArray = new JArray(); foreach (int hoursItem in profilesItem.Recurrence.Schedule.Hours) { hoursArray.Add(hoursItem); } scheduleValue["Hours"] = hoursArray; } if (profilesItem.Recurrence.Schedule.Minutes != null) { JArray minutesArray = new JArray(); foreach (int minutesItem in profilesItem.Recurrence.Schedule.Minutes) { minutesArray.Add(minutesItem); } scheduleValue["Minutes"] = minutesArray; } } } } settingValue["Profiles"] = profilesArray; } settingValue["Enabled"] = parameters.Setting.Enabled; } requestContent = requestDoc.ToString(Formatting.Indented); httpRequest.Content = new StringContent(requestContent, Encoding.UTF8); httpRequest.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); // Send Request HttpResponseMessage httpResponse = null; try { if (shouldTrace) { Tracing.SendRequest(invocationId, httpRequest); } cancellationToken.ThrowIfCancellationRequested(); httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false); if (shouldTrace) { Tracing.ReceiveResponse(invocationId, httpResponse); } HttpStatusCode statusCode = httpResponse.StatusCode; if (statusCode != HttpStatusCode.OK && statusCode != HttpStatusCode.Created) { cancellationToken.ThrowIfCancellationRequested(); CloudException ex = CloudException.Create(httpRequest, requestContent, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false), CloudExceptionType.Json); if (shouldTrace) { Tracing.Error(invocationId, ex); } throw ex; } // Create Result OperationResponse result = null; result = new OperationResponse(); result.StatusCode = statusCode; if (httpResponse.Headers.Contains("x-ms-request-id")) { result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault(); } if (shouldTrace) { Tracing.Exit(invocationId, result); } return(result); } finally { if (httpResponse != null) { httpResponse.Dispose(); } } } finally { if (httpRequest != null) { httpRequest.Dispose(); } } }
/// <summary> /// The List Service Certificates operation lists all of the service /// certificates associated with the specified hosted service. (see /// http://msdn.microsoft.com/en-us/library/windowsazure/jj154105.aspx /// for more information) /// </summary> /// <param name='serviceName'> /// The DNS prefix name of your hosted service. /// </param> /// <param name='cancellationToken'> /// Cancellation token. /// </param> /// <returns> /// The List Service Certificates operation response. /// </returns> public async System.Threading.Tasks.Task <Microsoft.WindowsAzure.Management.Compute.Models.ServiceCertificateListResponse> ListAsync(string serviceName, CancellationToken cancellationToken) { // Validate if (serviceName == null) { throw new ArgumentNullException("serviceName"); } // TODO: Validate serviceName is a valid DNS name. // Tracing bool shouldTrace = CloudContext.Configuration.Tracing.IsEnabled; string invocationId = null; if (shouldTrace) { invocationId = Tracing.NextInvocationId.ToString(); Dictionary <string, object> tracingParameters = new Dictionary <string, object>(); tracingParameters.Add("serviceName", serviceName); Tracing.Enter(invocationId, this, "ListAsync", tracingParameters); } // Construct URL string url = new Uri(this.Client.BaseUri, "/").AbsoluteUri + this.Client.Credentials.SubscriptionId + "/services/hostedservices/" + serviceName + "/certificates"; // Create HTTP transport objects HttpRequestMessage httpRequest = null; try { httpRequest = new HttpRequestMessage(); httpRequest.Method = HttpMethod.Get; httpRequest.RequestUri = new Uri(url); // Set Headers httpRequest.Headers.Add("x-ms-version", "2013-11-01"); // Set Credentials cancellationToken.ThrowIfCancellationRequested(); await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false); // Send Request HttpResponseMessage httpResponse = null; try { if (shouldTrace) { Tracing.SendRequest(invocationId, httpRequest); } cancellationToken.ThrowIfCancellationRequested(); httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false); if (shouldTrace) { Tracing.ReceiveResponse(invocationId, httpResponse); } HttpStatusCode statusCode = httpResponse.StatusCode; if (statusCode != HttpStatusCode.OK) { cancellationToken.ThrowIfCancellationRequested(); CloudException ex = CloudException.Create(httpRequest, null, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false), CloudExceptionType.Xml); if (shouldTrace) { Tracing.Error(invocationId, ex); } throw ex; } // Create Result ServiceCertificateListResponse result = null; // Deserialize Response cancellationToken.ThrowIfCancellationRequested(); string responseContent = await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); result = new ServiceCertificateListResponse(); XDocument responseDoc = XDocument.Parse(responseContent); XElement certificatesSequenceElement = responseDoc.Element(XName.Get("Certificates", "http://schemas.microsoft.com/windowsazure")); if (certificatesSequenceElement != null) { foreach (XElement certificatesElement in certificatesSequenceElement.Elements(XName.Get("Certificate", "http://schemas.microsoft.com/windowsazure"))) { ServiceCertificateListResponse.Certificate certificateInstance = new ServiceCertificateListResponse.Certificate(); result.Certificates.Add(certificateInstance); XElement certificateUrlElement = certificatesElement.Element(XName.Get("CertificateUrl", "http://schemas.microsoft.com/windowsazure")); if (certificateUrlElement != null) { Uri certificateUrlInstance = TypeConversion.TryParseUri(certificateUrlElement.Value); certificateInstance.CertificateUri = certificateUrlInstance; } XElement thumbprintElement = certificatesElement.Element(XName.Get("Thumbprint", "http://schemas.microsoft.com/windowsazure")); if (thumbprintElement != null) { string thumbprintInstance = thumbprintElement.Value; certificateInstance.Thumbprint = thumbprintInstance; } XElement thumbprintAlgorithmElement = certificatesElement.Element(XName.Get("ThumbprintAlgorithm", "http://schemas.microsoft.com/windowsazure")); if (thumbprintAlgorithmElement != null) { string thumbprintAlgorithmInstance = thumbprintAlgorithmElement.Value; certificateInstance.ThumbprintAlgorithm = thumbprintAlgorithmInstance; } XElement dataElement = certificatesElement.Element(XName.Get("Data", "http://schemas.microsoft.com/windowsazure")); if (dataElement != null) { byte[] dataInstance = Convert.FromBase64String(dataElement.Value); certificateInstance.Data = dataInstance; } } } result.StatusCode = statusCode; if (httpResponse.Headers.Contains("x-ms-request-id")) { result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault(); } if (shouldTrace) { Tracing.Exit(invocationId, result); } return(result); } finally { if (httpResponse != null) { httpResponse.Dispose(); } } } finally { if (httpRequest != null) { httpRequest.Dispose(); } } }
/// <summary> /// returns a new entry for this feed /// </summary> /// <returns>AtomEntry</returns> public override AtomEntry CreateFeedEntry() { Tracing.TraceMsg("Construcing new AclEntry"); return(new AclEntry()); }
/// <summary> /// Deletes a server-level Firewall Rule from an Azure SQL Database /// Server. /// </summary> /// <param name='serverName'> /// Required. The name of the Azure SQL Database Server that will have /// the Firewall Fule removed from it. /// </param> /// <param name='ruleName'> /// Required. The name of the Firewall Fule to delete. /// </param> /// <param name='cancellationToken'> /// Cancellation token. /// </param> /// <returns> /// A standard service response including an HTTP status code and /// request ID. /// </returns> public async System.Threading.Tasks.Task<OperationResponse> DeleteAsync(string serverName, string ruleName, CancellationToken cancellationToken) { // Validate if (serverName == null) { throw new ArgumentNullException("serverName"); } if (ruleName == null) { throw new ArgumentNullException("ruleName"); } // Tracing bool shouldTrace = CloudContext.Configuration.Tracing.IsEnabled; string invocationId = null; if (shouldTrace) { invocationId = Tracing.NextInvocationId.ToString(); Dictionary<string, object> tracingParameters = new Dictionary<string, object>(); tracingParameters.Add("serverName", serverName); tracingParameters.Add("ruleName", ruleName); Tracing.Enter(invocationId, this, "DeleteAsync", tracingParameters); } // Construct URL string url = "/" + (this.Client.Credentials.SubscriptionId != null ? this.Client.Credentials.SubscriptionId.Trim() : "") + "/services/sqlservers/servers/" + serverName.Trim() + "/firewallrules/" + ruleName.Trim(); string baseUrl = this.Client.BaseUri.AbsoluteUri; // Trim '/' character from the end of baseUrl and beginning of url. if (baseUrl[baseUrl.Length - 1] == '/') { baseUrl = baseUrl.Substring(0, baseUrl.Length - 1); } if (url[0] == '/') { url = url.Substring(1); } url = baseUrl + "/" + url; url = url.Replace(" ", "%20"); // Create HTTP transport objects HttpRequestMessage httpRequest = null; try { httpRequest = new HttpRequestMessage(); httpRequest.Method = HttpMethod.Delete; httpRequest.RequestUri = new Uri(url); // Set Headers httpRequest.Headers.Add("x-ms-version", "2012-03-01"); // Set Credentials cancellationToken.ThrowIfCancellationRequested(); await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false); // Send Request HttpResponseMessage httpResponse = null; try { if (shouldTrace) { Tracing.SendRequest(invocationId, httpRequest); } cancellationToken.ThrowIfCancellationRequested(); httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false); if (shouldTrace) { Tracing.ReceiveResponse(invocationId, httpResponse); } HttpStatusCode statusCode = httpResponse.StatusCode; if (statusCode != HttpStatusCode.OK) { cancellationToken.ThrowIfCancellationRequested(); CloudException ex = CloudException.Create(httpRequest, null, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false)); if (shouldTrace) { Tracing.Error(invocationId, ex); } throw ex; } // Create Result OperationResponse result = null; result = new OperationResponse(); result.StatusCode = statusCode; if (httpResponse.Headers.Contains("x-ms-request-id")) { result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault(); } if (shouldTrace) { Tracing.Exit(invocationId, result); } return result; } finally { if (httpResponse != null) { httpResponse.Dispose(); } } } finally { if (httpRequest != null) { httpRequest.Dispose(); } } }
/// <summary> /// gets called after we already handled the custom entry, to handle all /// other potential parsing tasks /// </summary> /// <param name="e">the Event arguments</param> /// <param name="parser">the atom feed parser used</param> protected override void HandleExtensionElements(ExtensionElementEventArgs e, AtomFeedParser parser) { Tracing.TraceMsg("\t HandleExtensionElements for Access Control feed called"); }
public CapabilitiesBuilder(IHostContext hostContext, CancellationToken cancellationToken) { ArgUtil.NotNull(hostContext, nameof(hostContext)); _hostContext = hostContext; _cancellationToken = cancellationToken; _trace = _hostContext.GetTrace(this.GetType().Name); _whichUtil = _hostContext.GetService<IWhichUtil>(); }
/// <summary> /// This does the real work of the plugin - uploading to imgur.com. /// </summary> /// /// <remarks> /// First upload the main image, and then place the raw /// image URL onto the clipboard for easy reference/paste. /// </remarks> private void UploadImage() { Tracing.Trace("Imgur::UploadImage"); if (!VerifyBasicSettings()) { return; } Hacks.BootstrapSettings(PluginSettings); try { var http = new HttpClient(Plugin._baseUri); var form = new HttpMultipartMimeForm(); using (var fs = File.Open(this._fileName, FileMode.Open, FileAccess.Read)) { form.Add("key", PluginSettings.Key); form.Add("image", this._fileName, HttpContent.Create(fs, "application/octet-stream", fs.Length)); form.Add("type", "file"); form.Add("title", "uploaded by Cropper SendToImgur plugin"); // optional form.Add("caption", "http://cropper.codeplex.com"); // optional var response = http.Post("upload.xml", form.CreateHttpContent()); response.EnsureStatusIsSuccessful(); var foo = response.Content.ReadAsXmlSerializable <UploadResponse>(); if (foo.links == null) { throw new InvalidOperationException("Successful response, but link is empty."); } string rawImageUri = foo.links.original; if (PluginSettings.PopBrowser) { System.Diagnostics.Process.Start(rawImageUri); } Clipboard.SetDataObject(rawImageUri, true); if (this._logger != null) { try { this._logger.Log(rawImageUri); } catch (Exception ex2) { MessageBox.Show("There's been an exception writing the ImgUr log?" + Environment.NewLine + ex2.Message + Environment.NewLine, "This isn't serious", MessageBoxButtons.OK, MessageBoxIcon.Information); } } } } catch (Exception exception2) { Tracing.Trace("Exception: {0}", exception2.StackTrace); Tracing.Trace("---------------------------------"); MessageBox.Show("There's been an exception uploading your image:" + Environment.NewLine + exception2.Message + Environment.NewLine + Environment.NewLine + "You will have to upload this file manually: " + Environment.NewLine + this._fileName, "Upload to Imgur failed", MessageBoxButtons.OK, MessageBoxIcon.Error); } return; }
public DiagnosticsTraceListener(Tracing.Trace trace) { _trace = trace; }
// Return code definition: (this will be used by service host to determine whether it will re-launch agent.listener) // 0: Agent exit // 1: Terminate failure // 2: Retriable failure // 3: Exit for self update public async static Task<int> MainAsync(string[] args) { using (HostContext context = new HostContext("Agent")) { s_trace = context.GetTrace("AgentProcess"); s_trace.Info($"Agent is built for {Constants.Agent.Platform} - {BuildConstants.AgentPackage.PackageName}."); s_trace.Info($"RuntimeInformation: {RuntimeInformation.OSDescription}."); // Validate the binaries intended for one OS are not running on a different OS. switch (Constants.Agent.Platform) { case Constants.OSPlatform.Linux: if (!RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) { Console.WriteLine(StringUtil.Loc("NotLinux")); return Constants.Agent.ReturnCode.TerminatedError; } break; case Constants.OSPlatform.OSX: if (!RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) { Console.WriteLine(StringUtil.Loc("NotOSX")); return Constants.Agent.ReturnCode.TerminatedError; } break; case Constants.OSPlatform.Windows: if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { Console.WriteLine(StringUtil.Loc("NotWindows")); return Constants.Agent.ReturnCode.TerminatedError; } break; default: Console.WriteLine(StringUtil.Loc("PlatformNotSupport", RuntimeInformation.OSDescription, Constants.Agent.Platform.ToString())); return Constants.Agent.ReturnCode.TerminatedError; } int rc = Constants.Agent.ReturnCode.Success; try { s_trace.Info($"Version: {Constants.Agent.Version}"); s_trace.Info($"Commit: {BuildConstants.Source.CommitHash}"); s_trace.Info($"Culture: {CultureInfo.CurrentCulture.Name}"); s_trace.Info($"UI Culture: {CultureInfo.CurrentUICulture.Name}"); // // TODO (bryanmac): Need VsoAgent.exe compat shim for SCM // That shim will also provide a compat arg parse // and translate / to -- etc... // // Parse the command line args. var command = new CommandSettings(context, args); s_trace.Info("Arguments parsed"); // Defer to the Agent class to execute the command. IAgent agent = context.GetService<IAgent>(); using (agent.TokenSource = new CancellationTokenSource()) { try { rc = await agent.ExecuteCommand(command); } catch (OperationCanceledException) when (agent.TokenSource.IsCancellationRequested) { s_trace.Info("Agent execution been cancelled."); } } } catch (Exception e) { Console.Error.WriteLine(StringUtil.Format("An error occured. {0}", e.Message)); s_trace.Error(e); rc = Constants.Agent.ReturnCode.RetryableError; } return rc; } }