public LinkedServiceArm(string factoryName, LinkedService linkedService) { Name = linkedService.Name; Properties = linkedService.Properties; Type = Constants.LinkedServiceType; ApiVersion = Constants.DataFactoryApiVersion; switch (linkedService.Properties.TypeProperties) { case AzureBatchTypeProperties batch: DependsOn = new string[2] { factoryName, batch.LinkedServiceName }; break; case HDInsightTypeProperties insights: DependsOn = new string[2] { factoryName, insights.LinkedServiceName }; break; default: DependsOn = new string[1] { factoryName }; break; } }
private LinkedService ConvertAndTestJson(string json, bool customTest = false, HashSet <string> propertyBagKeys = null) { LinkedService linkedService = this.ConvertToWrapper(json); CoreModel.LinkedService actual = this.Operations.Converter.ToCoreType(linkedService); // after converting to intermediate object, ensure that ServiceExtraProperties is still set if (customTest) { IGenericTypeProperties typeProperties = linkedService.Properties.TypeProperties as IGenericTypeProperties; Assert.NotNull(typeProperties); } string actualJson = Core.DataFactoryManagementClient.SerializeInternalLinkedServiceToJson(actual); JsonComparer.ValidateAreSame(json, actualJson, ignoreDefaultValues: true); Assert.DoesNotContain("ServiceExtraProperties", actualJson); JObject actualJObject = JObject.Parse(actualJson); JsonComparer.ValidatePropertyNameCasing(actualJObject, true, string.Empty, propertyBagKeys); return(linkedService); }
private Instance GetInstance(IEnumerable <LinkedService> linkedServices, IDictionary <string, string> extendedProperties) { // Valiate input linkedServices.ThrowIfNull(); // Get the details on the datastore-sqldw instance LinkedService linkedService = linkedServices .Where(ls => ls.Name == "datastore-sqldw") .First(); // Get the extended properties for the data store var properties = linkedService.Properties.TypeProperties as AzureSqlDataWarehouseLinkedService; // Get the connection string SqlConnectionStringBuilder scsb = new SqlConnectionStringBuilder(properties.ConnectionString); var instance = new Instance(); // Get the server and database instance.Server = scsb.DataSource; instance.Database = scsb.InitialCatalog; instance.Location = extendedProperties[EXTENDED_PROPERTY_LOCATION]; instance.ResourceGroup = extendedProperties[EXTENDED_PROPERTY_RESOURCE_GROUP]; instance.SubscriptionId = new Guid(extendedProperties[EXTENDED_PROPERTY_SUBSCRIPTION_ID]); return(instance); }
public LinkedServiceResource ToSdkObject() { LinkedService linkedService = this.Properties?.ToSdkObject(); LinkedServiceResource linkedServiceResource = new LinkedServiceResource(linkedService); return(linkedServiceResource); }
public virtual LinkedService ToSdkObject() { LinkedService linkedService = new LinkedService(); SetProperties(linkedService); return(linkedService); }
public string GetSqlConnectionString(string datasetName) { Dataset dataset = Datasets.Single(x => x.Name == datasetName); LinkedService linkedService = LinkedServices.First(x => x.Name == dataset.Properties.LinkedServiceName); if (linkedService.Properties.Type != "AzureSqlDatabase") { throw new Exception($"The linked service is of type '{linkedService.Properties.Type}'. It should be of type 'AzureSqlDatabase'."); } AzureSqlDatabaseLinkedService sqlLinkedService = linkedService.Properties.TypeProperties as AzureSqlDatabaseLinkedService; if (sqlLinkedService == null) { throw new Exception($"Unable to find data set name '{datasetName}'."); } string connectionString = sqlLinkedService.ConnectionString; if (string.IsNullOrEmpty(connectionString)) { throw new Exception($"Connection string for '{linkedService.Name}' linked service is empty."); } return(connectionString); }
private JObject GetARMResourceFromJson(JObject jsonObject, string resourceType, object resource) { if (jsonObject["$schema"] != null) { jsonObject["$schema"].Parent.Remove(); // remove the schema } jsonObject.Add("type", resourceType.ToLower()); jsonObject.Add("apiVersion", ARM_API_VERSION); // need to escape square brackets in Values as they are a special place-holder in ADF // jsonObject = jsonObject.ReplaceInValues("[", "[[").ReplaceInValues("]", "]]"); JArray dependsOn = new JArray(); dependsOn.Add("[parameters('" + ARM_PROJECT_PARAMETER_NAME + "')]"); switch (resourceType.ToLower()) { case "datapipelines": // for pipelines also add dependencies to all Input and Output-Datasets foreach (Activity act in ((Pipeline)resource).Properties.Activities) { foreach (ActivityInput actInput in act.Inputs) { dependsOn.Add(actInput.Name); } foreach (ActivityOutput actOutput in act.Outputs) { dependsOn.Add(actOutput.Name); } } break; case "datasets": // for Datasets also add a dependency to the LinkedService Dataset ds = (Dataset)resource; dependsOn.Add(ds.Properties.LinkedServiceName); break; case "linkedservices": // LinkedServices like Batch or HDInsight might depend on other LinkedServices LinkedService ls = (LinkedService)resource; Regex regex = new Regex(@"""linkedservicename""\s*:\s*""([^""]+)""", RegexOptions.IgnoreCase); Match m = regex.Match(jsonObject.ToString()); if (m.Success) { dependsOn.Add(m.Groups[1].Value); } break; default: Console.WriteLine("ResourceType {0} is not supporeted!", resourceType); break; } jsonObject.Add("dependsOn", dependsOn); return(jsonObject); }
/// <summary> /// Validates a linked service matches the expected properties. Throws assertion exceptions if validation fails. /// </summary> /// <param name="expected">Expected linked service</param> /// <param name="actual">Actual linked service</param> internal static void ValidateLinkedService(LinkedService expected, LinkedService actual) { Assert.NotNull(actual); Assert.NotNull(actual.Id); Assert.Equal(LinkedServiceResourceType.ToLower(), actual.Type.ToLower()); Assert.Equal(expected.ResourceId.ToLower(), actual.ResourceId.ToLower()); }
public void LinkedServiceUnregisteredTypeTest(string unregisteredTypeJson) { // If a linked service type has not been locally registered, // typeProperties should be deserialized to a GenericLinkedServiceInstance LinkedService linkedService = this.ConvertToWrapper(unregisteredTypeJson); Assert.IsType <GenericLinkedService>(linkedService.Properties.TypeProperties); }
public PSLinkedService(LinkedService linkedService) { if (linkedService == null) { throw new ArgumentNullException("linkedService"); } this.linkedService = linkedService; }
public BlobLocation(LinkedService linkedService, Dataset dataset, string sliceYear, string sliceMonth, string sliceDay) { _linkedService = linkedService; _dataset = dataset; _sliceYear = sliceYear; _sliceMonth = sliceMonth; _sliceDay = sliceDay; }
internal LinkedServiceGetResponse( Core.Models.LinkedServiceGetResponse internalResponse, DataFactoryManagementClient client) : this() { Ensure.IsNotNull(internalResponse, "internalResponse"); Ensure.IsNotNull(internalResponse.LinkedService, "internalResponse.LinkedService"); DataFactoryOperationUtilities.CopyRuntimeProperties(internalResponse, this); this.LinkedService = ((LinkedServiceOperations)client.LinkedServices).Converter.ToWrapperType(internalResponse.LinkedService); }
public void CanCreateLinkedService() { // Arrange LinkedService expected = new LinkedService() { Name = linkedServiceName, Properties = new HDInsightBYOCLinkedService() { ProvisioningState = "Succeeded" } }; dataFactoriesClientMock.Setup(c => c.ReadJsonFileContent(It.IsAny <string>())) .Returns(rawJsonContent) .Verifiable(); dataFactoriesClientMock.Setup( c => c.CreatePSLinkedService( It.Is <CreatePSLinkedServiceParameters>( parameters => parameters.Name == linkedServiceName && parameters.ResourceGroupName == ResourceGroupName && parameters.DataFactoryName == DataFactoryName))) .CallBase() .Verifiable(); dataFactoriesClientMock.Setup( c => c.CreateOrUpdateLinkedService(ResourceGroupName, DataFactoryName, linkedServiceName, rawJsonContent)) .Returns(expected) .Verifiable(); // Action cmdlet.File = filePath; cmdlet.Force = true; cmdlet.ExecuteCmdlet(); // Assert dataFactoriesClientMock.VerifyAll(); commandRuntimeMock.Verify( f => f.WriteObject( It.Is <PSLinkedService>( ls => ResourceGroupName == ls.ResourceGroupName && DataFactoryName == ls.DataFactoryName && expected.Name == ls.LinkedServiceName && expected.Properties == ls.Properties)), Times.Once()); }
public PSLinkedService(LinkedService service) { if (service != null) { this.Id = service.Id; this.Name = service.Name; this.Type = service.Type; this.ResourceId = service.ResourceId; this.WriteAccessResourceId = service.WriteAccessResourceId; this.ProvisioningState = service.ProvisioningState; this.Tags = service.Tags; } }
public static void SetLinkedServiceProperties(LinkedService linkedService, LinkedServiceJson linkedServiceJson) { if (linkedService.LinkedServiceProperties != null) { LinkedServiceProperty linkedServiceProperty = linkedService.LinkedServiceProperties; LinkedServicePropertyJson linkedServicePropertyJson = new(); linkedServicePropertyJson.Type = linkedService.Type.ToString(); SetLinkedServiceTypeProperties(linkedServiceProperty, linkedServicePropertyJson); linkedServiceJson.Properties = linkedServicePropertyJson; } }
/// <summary> /// Serializes the given LinkedService into JSON, by mocking a create request to /// exercise the client's serialization logic. /// </summary> /// <param name="item"></param> /// <returns></returns> public static string SerializeLinkedServiceToJson(LinkedService item) { var createParams = new LinkedServiceCreateOrUpdateParameters() { LinkedService = item }; var handler = new MockResourceProviderDelegatingHandler(); var client = DataPipelineManagementClient.GetFakeClient(handler); string resourceGroupName = Guid.NewGuid().ToString("D"); string dataFactoryName = Guid.NewGuid().ToString("D"); client.LinkedServices.BeginCreateOrUpdate(resourceGroupName, dataFactoryName, createParams); return(handler.Json); }
// Get Linked Service Connection String private static string GetConnectionString(LinkedService asset) { if (asset == null) { return(null); } AzureStorageLinkedService storageAsset = asset.Properties as AzureStorageLinkedService; if (storageAsset == null) { return(null); } return(storageAsset.ConnectionString); }
private AdlsInfo GetAdlsInfo(LinkedService outputLinkedService) { var azureDataLakeStoreLinkedService = (AzureDataLakeStoreLinkedService)outputLinkedService.Properties.TypeProperties; return(new AdlsInfo() { AzureSubscriptionId = azureDataLakeStoreLinkedService.SubscriptionId, AadDomain = azureDataLakeStoreLinkedService.Tenant, AadClient = azureDataLakeStoreLinkedService.ServicePrincipalId, AadClientSecret = azureDataLakeStoreLinkedService.ServicePrincipalKey, AdlsUri = azureDataLakeStoreLinkedService.DataLakeStoreUri, AdlsName = azureDataLakeStoreLinkedService.AccountName, AdlsResourceGroupName = azureDataLakeStoreLinkedService.ResourceGroupName, AdlsAuthorization = azureDataLakeStoreLinkedService.Authorization, AdlsSessionId = azureDataLakeStoreLinkedService.SessionId }); }
protected void SetProperties(LinkedService linkedService) { linkedService.ConnectVia = this.ConnectVia?.ToSdkObject(); linkedService.Description = this.Description; this.Annotations?.ForEach(item => linkedService.Annotations.Add(item)); this.Parameters?.ForEach(item => linkedService.Parameters.Add(item.Key, item.Value?.ToSdkObject())); if (this.AdditionalProperties != null) { foreach (var item in this.AdditionalProperties) { if (item.Key != "typeProperties") { linkedService.Add(item.Key, item.Value); } } } }
protected override MyDotNetActivityContext PreExecute(IEnumerable <LinkedService> linkedServices, IEnumerable <Dataset> datasets, Activity activity, IActivityLogger logger) { WriteGreeting(logger); // Process ADF artifacts up front as these objects are not serializable across app domain boundaries. Dataset dataset = datasets.First(ds => ds.Name == activity.Inputs.Single().Name); var blobProperties = (AzureBlobDataset)dataset.Properties.TypeProperties; LinkedService linkedService = linkedServices.First(ls => ls.Name == dataset.Properties.LinkedServiceName); var storageProperties = (AzureStorageLinkedService)linkedService.Properties.TypeProperties; return(new MyDotNetActivityContext { ConnectionString = storageProperties.ConnectionString, FolderPath = blobProperties.FolderPath, FileName = blobProperties.FileName }); }
public PSLinkedService(LinkedService linkedService) { this.ConnectVia = new PSIntegrationRuntimeReference(linkedService?.ConnectVia); this.Description = linkedService?.Description; this.Parameters = linkedService?.Parameters? .Select(element => new KeyValuePair <string, PSParameterSpecification>(element.Key, new PSParameterSpecification(element.Value))) .ToDictionary(kvp => kvp.Key, kvp => kvp.Value); this.Annotations = linkedService?.Annotations; var propertiesEnum = linkedService?.GetEnumerator(); if (propertiesEnum != null) { this.AdditionalProperties = new Dictionary <string, object>(); while (propertiesEnum.MoveNext()) { this.AdditionalProperties.Add(propertiesEnum.Current); } } }
public void CanCreateUpdateDeleteLinkedService() { using (MockContext context = MockContext.Start(this.GetType())) { var client = TestHelper.GetOperationalInsightsManagementClient(this, context); var subId = client.SubscriptionId; var linkedServiceName = "Automation"; var accountResourceIdFromat = "/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.Automation/automationAccounts/{2}"; var accountResourceId = string.Format(accountResourceIdFromat, subId, resourceGroupName, automationAccountName); // Create a linked service var createParameters = new LinkedService { ResourceId = accountResourceId }; var createResponse = client.LinkedServices.CreateOrUpdate(resourceGroupName, workspaceName, linkedServiceName, createParameters); TestHelper.ValidateLinkedService(createParameters, createResponse); // Get the linked service var getResponse = client.LinkedServices.Get(resourceGroupName, workspaceName, linkedServiceName); TestHelper.ValidateLinkedService(createParameters, getResponse); // List the linked services in the workspace var listResponse = client.LinkedServices.ListByWorkspace(resourceGroupName, workspaceName); Assert.Single(listResponse); Assert.Single(listResponse.Where(w => w.ResourceId.Equals(accountResourceId, StringComparison.OrdinalIgnoreCase))); var accountResourceId2 = string.Format(accountResourceIdFromat, subId, resourceGroupName, automationAccountName2); var updateParameters = new LinkedService { ResourceId = accountResourceId2 }; // Perform an update on one of the linked service var updateResponse = client.LinkedServices.CreateOrUpdate(resourceGroupName, workspaceName, linkedServiceName, updateParameters); TestHelper.ValidateLinkedService(updateParameters, updateResponse); // Delete a linked service client.LinkedServices.Delete(resourceGroupName, workspaceName, linkedServiceName); } }
protected override GeoCodeContext PreExecute(IEnumerable <LinkedService> linkedServices, IEnumerable <Dataset> datasets, Activity activity, IActivityLogger logger) { // Process ADF artifacts up front as these objects are not serializable across app domain boundaries. Dataset dataset = datasets.First(ds => ds.Name == activity.Inputs.Single().Name); var blobProperties = (AzureBlobDataset)dataset.Properties.TypeProperties; LinkedService linkedService = linkedServices.First(ls => ls.Name == dataset.Properties.LinkedServiceName); var storageProperties = (AzureStorageLinkedService)linkedService.Properties.TypeProperties; // to get extended properties (for example: SliceStart) DotNetActivity dotNetActivity = (DotNetActivity)activity.TypeProperties; return(new GeoCodeContext { ConnectionString = storageProperties.ConnectionString, FolderPath = blobProperties.FolderPath, FileName = blobProperties.FileName, OutputFolder = dotNetActivity.ExtendedProperties["OutputFolder"], MapsAPIKey = dotNetActivity.ExtendedProperties["MapsAPIKey"] }); }
public void CanThrowIfLinkedServiceProvisioningFailed() { // Arrange LinkedService expected = new LinkedService() { Name = linkedServiceName, Properties = new HDInsightBYOCLinkedService() { ProvisioningState = "Failed" } }; dataFactoriesClientMock.Setup(c => c.ReadJsonFileContent(It.IsAny <string>())) .Returns(rawJsonContent) .Verifiable(); dataFactoriesClientMock.Setup( c => c.CreatePSLinkedService( It.Is <CreatePSLinkedServiceParameters>( parameters => parameters.Name == linkedServiceName && parameters.ResourceGroupName == ResourceGroupName && parameters.DataFactoryName == DataFactoryName))) .CallBase() .Verifiable(); dataFactoriesClientMock.Setup( c => c.CreateOrUpdateLinkedService(ResourceGroupName, DataFactoryName, linkedServiceName, rawJsonContent)) .Returns(expected) .Verifiable(); // Action cmdlet.File = filePath; cmdlet.Force = true; // Assert Assert.Throws <ProvisioningFailedException>(() => cmdlet.ExecuteCmdlet()); }
public void LinkedServiceCreateFailsWithoutWorkspace() { using (MockContext context = MockContext.Start(this.GetType())) { var client = TestHelper.GetOperationalInsightsManagementClient(this, context); var subId = client.SubscriptionId; string linkedServiceName = "Automation"; string workspaceName = TestUtilities.GenerateName("AzSDKTest"); var accountResourceIdFromat = "/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.Automation/automationAccounts/{2}"; var accountResourceId = string.Format(accountResourceIdFromat, subId, resourceGroupName, "testAccount"); var createParameters = new LinkedService { ResourceId = accountResourceId }; // Create a linked service on a non-existent workspace TestHelper.VerifyCloudException(HttpStatusCode.NotFound, () => client.LinkedServices.CreateOrUpdate(resourceGroupName, workspaceName, linkedServiceName, createParameters)); } }
public LinkedService ADFLinkedServiceFromJson(JObject jsonObject) { Type dynClass; MethodInfo dynMethod; string objectType = "LinkedService"; MapConfigElements(ref jsonObject); MapSlices(ref jsonObject); dynClass = new Core.DataFactoryManagementClient().GetType(); dynMethod = dynClass.GetMethod("DeserializeInternal" + objectType + "Json", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static); CoreModels.LinkedService internalObject = (CoreModels.LinkedService)dynMethod.Invoke(this, new object[] { jsonObject.ToString() }); dynClass = Type.GetType(dynClass.AssemblyQualifiedName.Replace("Core.DataFactoryManagementClient", "Conversion." + objectType + "Converter")); ConstructorInfo constructor = dynClass.GetConstructor(Type.EmptyTypes); object classObject = constructor.Invoke(new object[] { }); dynMethod = dynClass.GetMethod("ToWrapperType", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public); LinkedService ret = (LinkedService)dynMethod.Invoke(classObject, new object[] { internalObject }); return(ret); }
/// <summary> /// Create or update a linked service. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='resourceGroupName'> /// The name of the resource group to get. The name is case insensitive. /// </param> /// <param name='workspaceName'> /// Name of the Log Analytics Workspace that will contain the linkedServices /// resource /// </param> /// <param name='linkedServiceName'> /// Name of the linkedServices resource /// </param> /// <param name='parameters'> /// The parameters required to create or update a linked service. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async System.Threading.Tasks.Task <LinkedService> CreateOrUpdateAsync(this ILinkedServicesOperations operations, string resourceGroupName, string workspaceName, string linkedServiceName, LinkedService parameters, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { using (var _result = await operations.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, workspaceName, linkedServiceName, parameters, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
/// <summary> /// Create or update a linked service. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='resourceGroupName'> /// The name of the resource group to get. The name is case insensitive. /// </param> /// <param name='workspaceName'> /// Name of the Log Analytics Workspace that will contain the linkedServices /// resource /// </param> /// <param name='linkedServiceName'> /// Name of the linkedServices resource /// </param> /// <param name='parameters'> /// The parameters required to create or update a linked service. /// </param> public static LinkedService CreateOrUpdate(this ILinkedServicesOperations operations, string resourceGroupName, string workspaceName, string linkedServiceName, LinkedService parameters) { return(System.Threading.Tasks.Task.Factory.StartNew(s => ((ILinkedServicesOperations)s).CreateOrUpdateAsync(resourceGroupName, workspaceName, linkedServiceName, parameters), operations, System.Threading.CancellationToken.None, System.Threading.Tasks.TaskCreationOptions.None, System.Threading.Tasks.TaskScheduler.Default).Unwrap().GetAwaiter().GetResult()); }
/// <summary> /// Create or update a linked service. /// </summary> /// <param name='resourceGroupName'> /// The name of the resource group. The name is case insensitive. /// </param> /// <param name='workspaceName'> /// The name of the workspace. /// </param> /// <param name='linkedServiceName'> /// Name of the linkedServices resource /// </param> /// <param name='parameters'> /// The parameters required to create or update a linked service. /// </param> /// <param name='customHeaders'> /// The headers that will be added to request. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public async Task <AzureOperationResponse <LinkedService> > CreateOrUpdateWithHttpMessagesAsync(string resourceGroupName, string workspaceName, string linkedServiceName, LinkedService parameters, Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken)) { // Send Request AzureOperationResponse <LinkedService> _response = await BeginCreateOrUpdateWithHttpMessagesAsync(resourceGroupName, workspaceName, linkedServiceName, parameters, customHeaders, cancellationToken).ConfigureAwait(false); return(await Client.GetPutOrPatchOperationResultAsync(_response, customHeaders, cancellationToken).ConfigureAwait(false)); }
/// <summary> /// Create or update a linked service. /// </summary> /// <param name='resourceGroupName'> /// The name of the resource group. The name is case insensitive. /// </param> /// <param name='workspaceName'> /// The name of the workspace. /// </param> /// <param name='linkedServiceName'> /// Name of the linkedServices resource /// </param> /// <param name='parameters'> /// The parameters required to create or update a linked service. /// </param> /// <param name='customHeaders'> /// Headers that will be added to request. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> /// <exception cref="CloudException"> /// Thrown when the operation returned an invalid status code /// </exception> /// <exception cref="SerializationException"> /// Thrown when unable to deserialize the response /// </exception> /// <exception cref="ValidationException"> /// Thrown when a required parameter is null /// </exception> /// <exception cref="System.ArgumentNullException"> /// Thrown when a required parameter is null /// </exception> /// <return> /// A response object containing the response body and response headers. /// </return> public async Task <AzureOperationResponse <LinkedService> > BeginCreateOrUpdateWithHttpMessagesAsync(string resourceGroupName, string workspaceName, string linkedServiceName, LinkedService parameters, Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken)) { if (resourceGroupName == null) { throw new ValidationException(ValidationRules.CannotBeNull, "resourceGroupName"); } if (resourceGroupName != null) { if (resourceGroupName.Length > 90) { throw new ValidationException(ValidationRules.MaxLength, "resourceGroupName", 90); } if (resourceGroupName.Length < 1) { throw new ValidationException(ValidationRules.MinLength, "resourceGroupName", 1); } } if (workspaceName == null) { throw new ValidationException(ValidationRules.CannotBeNull, "workspaceName"); } if (workspaceName != null) { if (workspaceName.Length > 63) { throw new ValidationException(ValidationRules.MaxLength, "workspaceName", 63); } if (workspaceName.Length < 4) { throw new ValidationException(ValidationRules.MinLength, "workspaceName", 4); } if (!System.Text.RegularExpressions.Regex.IsMatch(workspaceName, "^[A-Za-z0-9][A-Za-z0-9-]+[A-Za-z0-9]$")) { throw new ValidationException(ValidationRules.Pattern, "workspaceName", "^[A-Za-z0-9][A-Za-z0-9-]+[A-Za-z0-9]$"); } } if (linkedServiceName == null) { throw new ValidationException(ValidationRules.CannotBeNull, "linkedServiceName"); } if (parameters == null) { throw new ValidationException(ValidationRules.CannotBeNull, "parameters"); } if (Client.SubscriptionId == null) { throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.SubscriptionId"); } if (Client.SubscriptionId != null) { if (Client.SubscriptionId.Length < 1) { throw new ValidationException(ValidationRules.MinLength, "Client.SubscriptionId", 1); } } string apiVersion = "2020-08-01"; // Tracing bool _shouldTrace = ServiceClientTracing.IsEnabled; string _invocationId = null; if (_shouldTrace) { _invocationId = ServiceClientTracing.NextInvocationId.ToString(); Dictionary <string, object> tracingParameters = new Dictionary <string, object>(); tracingParameters.Add("resourceGroupName", resourceGroupName); tracingParameters.Add("workspaceName", workspaceName); tracingParameters.Add("linkedServiceName", linkedServiceName); tracingParameters.Add("parameters", parameters); tracingParameters.Add("apiVersion", apiVersion); tracingParameters.Add("cancellationToken", cancellationToken); ServiceClientTracing.Enter(_invocationId, this, "BeginCreateOrUpdate", tracingParameters); } // Construct URL var _baseUrl = Client.BaseUri.AbsoluteUri; var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}/providers/Microsoft.OperationalInsights/workspaces/{workspaceName}/linkedServices/{linkedServiceName}").ToString(); _url = _url.Replace("{resourceGroupName}", System.Uri.EscapeDataString(resourceGroupName)); _url = _url.Replace("{workspaceName}", System.Uri.EscapeDataString(workspaceName)); _url = _url.Replace("{linkedServiceName}", System.Uri.EscapeDataString(linkedServiceName)); _url = _url.Replace("{subscriptionId}", System.Uri.EscapeDataString(Client.SubscriptionId)); List <string> _queryParameters = new List <string>(); if (apiVersion != null) { _queryParameters.Add(string.Format("api-version={0}", System.Uri.EscapeDataString(apiVersion))); } if (_queryParameters.Count > 0) { _url += (_url.Contains("?") ? "&" : "?") + string.Join("&", _queryParameters); } // Create HTTP transport objects var _httpRequest = new HttpRequestMessage(); HttpResponseMessage _httpResponse = null; _httpRequest.Method = new HttpMethod("PUT"); _httpRequest.RequestUri = new System.Uri(_url); // Set Headers if (Client.GenerateClientRequestId != null && Client.GenerateClientRequestId.Value) { _httpRequest.Headers.TryAddWithoutValidation("x-ms-client-request-id", System.Guid.NewGuid().ToString()); } if (Client.AcceptLanguage != null) { if (_httpRequest.Headers.Contains("accept-language")) { _httpRequest.Headers.Remove("accept-language"); } _httpRequest.Headers.TryAddWithoutValidation("accept-language", Client.AcceptLanguage); } if (customHeaders != null) { foreach (var _header in customHeaders) { if (_httpRequest.Headers.Contains(_header.Key)) { _httpRequest.Headers.Remove(_header.Key); } _httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value); } } // Serialize Request string _requestContent = null; if (parameters != null) { _requestContent = Rest.Serialization.SafeJsonConvert.SerializeObject(parameters, Client.SerializationSettings); _httpRequest.Content = new StringContent(_requestContent, System.Text.Encoding.UTF8); _httpRequest.Content.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json; charset=utf-8"); } // Set Credentials if (Client.Credentials != null) { cancellationToken.ThrowIfCancellationRequested(); await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false); } // Send Request if (_shouldTrace) { ServiceClientTracing.SendRequest(_invocationId, _httpRequest); } cancellationToken.ThrowIfCancellationRequested(); _httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false); if (_shouldTrace) { ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse); } HttpStatusCode _statusCode = _httpResponse.StatusCode; cancellationToken.ThrowIfCancellationRequested(); string _responseContent = null; if ((int)_statusCode != 200 && (int)_statusCode != 201 && (int)_statusCode != 202) { var ex = new CloudException(string.Format("Operation returned an invalid status code '{0}'", _statusCode)); try { _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); CloudError _errorBody = Rest.Serialization.SafeJsonConvert.DeserializeObject <CloudError>(_responseContent, Client.DeserializationSettings); if (_errorBody != null) { ex = new CloudException(_errorBody.Message); ex.Body = _errorBody; } } catch (JsonException) { // Ignore the exception } ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent); ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent); if (_httpResponse.Headers.Contains("x-ms-request-id")) { ex.RequestId = _httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault(); } if (_shouldTrace) { ServiceClientTracing.Error(_invocationId, ex); } _httpRequest.Dispose(); if (_httpResponse != null) { _httpResponse.Dispose(); } throw ex; } // Create Result var _result = new AzureOperationResponse <LinkedService>(); _result.Request = _httpRequest; _result.Response = _httpResponse; if (_httpResponse.Headers.Contains("x-ms-request-id")) { _result.RequestId = _httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault(); } // Deserialize Response if ((int)_statusCode == 200) { _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); try { _result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject <LinkedService>(_responseContent, Client.DeserializationSettings); } catch (JsonException ex) { _httpRequest.Dispose(); if (_httpResponse != null) { _httpResponse.Dispose(); } throw new SerializationException("Unable to deserialize the response.", _responseContent, ex); } } // Deserialize Response if ((int)_statusCode == 201) { _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); try { _result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject <LinkedService>(_responseContent, Client.DeserializationSettings); } catch (JsonException ex) { _httpRequest.Dispose(); if (_httpResponse != null) { _httpResponse.Dispose(); } throw new SerializationException("Unable to deserialize the response.", _responseContent, ex); } } if (_shouldTrace) { ServiceClientTracing.Exit(_invocationId, _result); } return(_result); }
public LinkedServiceCreateOrUpdateParameters(LinkedService linkedService) : this() { Ensure.IsNotNull(linkedService, "linkedService"); this.LinkedService = linkedService; }