//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @SuppressWarnings("unchecked") @Before public void setUp() public virtual void setUp() { batchConfiguration = Mockito.mock(typeof(BatchConfiguration)); engineConfiguration = Mockito.mock(typeof(ProcessEngineConfigurationImpl)); ids = Mockito.mock(typeof(System.Collections.IList)); when(batchConfiguration.Ids).thenReturn(ids); }
public AssetsController(IAssetService assetService, ILogger logger, BatchConfiguration batchConfiguration) { _assetService = assetService; _logger = logger; _batchConfiguration = batchConfiguration; }
private void ValidateBatchConfiguration(BatchConfiguration expected, BatchConfiguration actual) { Assert.Equal(expected.Name, actual.Name); Assert.Equal(expected.Properties.BatchGroupName, actual.Properties.BatchGroupName); Assert.Equal(expected.Properties.ReleaseCriteria.BatchSize, actual.Properties.ReleaseCriteria.BatchSize); Assert.NotNull(actual.Properties.CreatedTime); Assert.NotNull(actual.Properties.ChangedTime); }
protected internal virtual int CalculateSize(ProcessEngineConfigurationImpl engineConfiguration, BatchConfiguration batchConfiguration) { var invocationsPerBatchJob = engineConfiguration.InvocationsPerBatchJob; var processInstanceCount = batchConfiguration.Ids.Count; return((int)Math.Ceiling((decimal)(processInstanceCount / invocationsPerBatchJob))); }
private BatchConfiguration BuildBatchConfiguration() { var config = BuildConfig(); var batch = new BatchConfiguration(); config.GetSection("batch").Bind(batch); return(batch); }
public PSIntegrationAccountBatchConfiguration(BatchConfiguration batchConfiguration) : base(batchConfiguration.Properties, batchConfiguration.Id, batchConfiguration.Name, batchConfiguration.Type, batchConfiguration.Location, batchConfiguration.Tags) { }
public ApplicationJobs(IOptions <BatchConfiguration> batchConfig) { Batch = batchConfig.Value; _lazyBatchClient = new Lazy <BatchClient>(() => { var batchCreds = new BatchSharedKeyCredentials(Batch.Url, Batch.Account, Batch.Key); return(BatchClient.Open(batchCreds)); }, true); }
private BatchConfiguration CreateIntegrationAccountBatchConfiguration(string batchConfigurationName) { var batchConfigurationProperties = new BatchConfigurationProperties("batchGroupName", new BatchReleaseCriteria(batchSize: 10)); var batchConfiguration = new BatchConfiguration(batchConfigurationProperties, location: Constants.DefaultLocation, name: batchConfigurationName); return(batchConfiguration); }
public void refreshBatchNameAndBatchAction() { object newActionName; object newBatchName; BatchConfiguration.TryGetValue(BatchConfigurationFieldName.BatchName, out newBatchName); BatchConfiguration.TryGetValue(BatchConfigurationFieldName.BatchActionName, out newActionName); BatchName = (string)((KeyValuePair <string, object>)newBatchName).Value; ActionName = (string)((KeyValuePair <string, object>)newActionName).Value; }
public SubscriptionConfiguration( ConsumerSettings settings, BatchConfiguration batchConfiguration, IEventDeserializer serializer, HandlerConfiguration handlerConfig = default, bool skipUnknownEvents = true, int consumerInstances = 1) : this(settings, serializer, handlerConfig, skipUnknownEvents, consumerInstances) { BatchConfiguration = batchConfiguration; BatchProcessingRequired = true; }
public void should_create_deploy_runner() { var configuration = new BatchConfiguration { Id = "batch-build", Github = new Github { Branch = "master", Url = "*****@*****.**" }, Iis = new Iis { Port = 9090, SiteName = "x", DeployDirectory = "c:\\sites" }, Batch = new Batch { BuildScript = "build.bat" } }; var deployer = CreateFactory(); var deployRunner = deployer.ForConfiguration(configuration); Assert.That(deployRunner, Is.Not.Null); }
public async Task Run() { //itm production lag random generator var rnd = new Random((int)DateTime.UtcNow.Ticks); //prepare to handle Ctrl+C Console.CancelKeyPress += Console_CancelKeyPress; //batch configuration var batchConfiguration = new BatchConfiguration <int> { //Time window before the current batch chuck collected is executed AddMoreItemsTimeWindow = TimeSpan.FromSeconds(3.0) }; //Create batch var batchCollector = new Batch <int>(batchConfiguration, new BatchChunkProcessor()); //obtain a producer token that allows aggregation of items to the batch, there can be more than one concurrent aggregators. Not represented in this example //new aggregator using (var token = await batchCollector.NewBatchAggregatorToken()) { //add items until the user cancels while (!_cancellationTokenSource.Token.IsCancellationRequested) { await AddItemToBatch(token); } //notify the batch that this aggregator is done adding items await batchCollector.AddingItemsToBatchCompleted(token); } async Task AddItemToBatch(BatchAggregatorToken <int> token) { //generate and add new item to the batch var item = rnd.Next(0, 25); Console.WriteLine($"Produced {item}", Color.DarkSlateGray); await batchCollector.Add(item, token); //wait to produce next var waitMilliseconds = rnd.Next(1, 2000); Console.WriteLine($"Waiting {TimeSpan.FromMilliseconds(waitMilliseconds)}", Color.DarkGray); Thread.Sleep(waitMilliseconds); } }
public void ConfigureServices() { var services = new ServiceCollection(); services.AddMemoryCache(); services.AddOptions(); services.Configure <SearchConfiguration>(options => { Configuration.GetSection("search").Bind(options); SearchConfiguration.Validate(options); }); services.Configure <CosmosConfiguration>(options => { Configuration.GetSection("documents").Bind(options); CosmosConfiguration.Validate(options); }); services.Configure <StorageConfiguration>((config) => { Configuration.GetSection("storage").Bind(config); StorageConfiguration.Validate(config); }); services.Configure <BatchConfiguration>((config) => { Configuration.GetSection("batch").Bind(config); BatchConfiguration.Validate(config); }); var armTemplatesMap = new ArmTemplatesMap(); services.AddSingleton(armTemplatesMap); var staticAssetsMap = new StaticAssetsMap(); services.AddSingleton(staticAssetsMap); services.AddSingleton <ApplicationJobs>(); services.AddSingleton <DatasetStorageService>(); services.AddSingleton <DatasetOwnersService>(); services.AddSingleton <DatasetEditStorageService>(); services.AddSingleton <UserDataStorageService>(); services.AddSingleton <SasTokenService>(); services.AddSingleton <ValidationService>(); services.AddSingleton <DatasetSearchService>(); services.AddSingleton <FileSearchService>(); ServiceProvider = services.BuildServiceProvider(); }
protected internal virtual BatchEntity createBatch(CommandContext commandContext, ICollection <string> processInstanceIds) { ProcessEngineConfigurationImpl processEngineConfiguration = commandContext.ProcessEngineConfiguration; BatchJobHandler batchJobHandler = getBatchJobHandler(processEngineConfiguration); BatchConfiguration configuration = getAbstractIdsBatchConfiguration(new List <string>(processInstanceIds)); BatchEntity batch = new BatchEntity(); batch.Type = batchJobHandler.Type; batch.TotalJobs = BatchUtil.calculateBatchSize(processEngineConfiguration, (UpdateProcessInstancesSuspendStateBatchConfiguration)configuration); batch.BatchJobsPerSeed = processEngineConfiguration.BatchJobsPerSeed; batch.InvocationsPerBatchJob = processEngineConfiguration.InvocationsPerBatchJob; batch.ConfigurationBytes = batchJobHandler.writeConfiguration(configuration); commandContext.BatchManager.insertBatch(batch); return(batch); }
public void BatchConfigurationCanBeParsed() { var subject = new BatchConfiguration(JObject.Parse(this.TestBatchConfigPayload)); subject.ShadowFilters.Should().NotBeNull(); subject.ShadowFilters.Count().Should().Be(1); subject.ShadowFilters.First().Language.Should().Be("CSharp"); subject.ShadowFilters.First().Type.Should().Be(CodeFileFilterType.Project); subject.ShadowFilters.First().Paths.Should().NotBeNull(); subject.ShadowFilters.First().Paths.Length.Should().Be(1); subject.ShadowFilters.First().Paths[0].Should().Be("Test/Folder/*.cs"); subject.UnshadowFilters.Should().NotBeNull(); subject.UnshadowFilters.Count().Should().Be(1); subject.UnshadowFilters.First().Language.Should().Be("Glsl"); subject.UnshadowFilters.First().Type.Should().Be(CodeFileFilterType.FileSystem); subject.UnshadowFilters.First().Paths.Should().NotBeNull(); subject.UnshadowFilters.First().Paths.Length.Should().Be(1); subject.UnshadowFilters.First().Paths[0].Should().Be("Test\\Shaders\\*.glsl"); }
public EndpointConfiguration AddBatchSubscription( ConsumerSettings settings, BatchConfiguration batchConfig, IEventDeserializer serializer, HandlerConfiguration handlerConfig = default, bool skipUnknownEventTypes = true, int instances = 1, bool isLongRunning = true) { var subscription = new SubscriptionConfiguration( isLongRunning ? settings.ToLongRunning() : settings, batchConfig, serializer, handlerConfig, skipUnknownEventTypes, instances); _subscriptions.Add(subscription); return(this); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddApplicationInsightsTelemetry(); services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>(); services.AddSingleton <IConfiguration>(Configuration); services.AddOptions(); services.Configure <IdentityProviderConfiguration>(options => { Configuration.GetSection("azuread").Bind(options); IdentityProviderConfiguration.Validate(options); }); services.Configure <SearchConfiguration>(options => { Configuration.GetSection("search").Bind(options); SearchConfiguration.Validate(options); }); services.Configure <CosmosConfiguration>(options => { Configuration.GetSection("documents").Bind(options); CosmosConfiguration.Validate(options); }); services.Configure <StorageConfiguration>((config) => { Configuration.GetSection("storage").Bind(config); StorageConfiguration.Validate(config); }); services.Configure <BatchConfiguration>((config) => { Configuration.GetSection("batch").Bind(config); BatchConfiguration.Validate(config); }); services.Configure <AppInsightsConfiguration>((config) => { Configuration.GetSection("applicationinsights").Bind(config); AppInsightsConfiguration.Validate(config); }); var armTemplatesMap = new ArmTemplatesMap(); services.AddSingleton(armTemplatesMap); var staticAssetsMap = new StaticAssetsMap(); services.AddSingleton(staticAssetsMap); services.AddMemoryCache(); //services // .AddAuthentication(options => // { // options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme; // options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; // }) // .AddJwtBearer(options => // { // options.Audience = Configuration["azureADConfig:clientId"]; // options.Authority = Configuration["azureADConfig:authority"]; // options.Events = new JwtBearerEvents // { // OnMessageReceived = FetchAuthTokenFromCookie, // OnTokenValidated = async context => // { // var principal = context.Principal; // var ODREmailList = Configuration["ODRAdminList"].Split(";"); // } // }; // }); //services // .AddAuthentication(options => // { // options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme; // }) // .AddJwtBearer(options => // { // options.Audience = Configuration["azureADConfig:clientId"]; // options.Authority = Configuration["azureADConfig:authority"]; // options.TokenValidationParameters = new Microsoft.IdentityModel.Tokens.TokenValidationParameters // { // ValidAudience = Configuration["azureADConfig:clientId"], // ValidIssuer = $"https://login.microsoftonline.com/" + Configuration["azureADConfig:tenantId"] + "/v2.0" // }; // options.Events = new JwtBearerEvents // { // OnMessageReceived = FetchAuthTokenFromCookie, // //OnTokenValidated = async context => // //{ // // var principal = context.Principal; // // if (Configuration.GetChildren().Any(item => item.Key == "ODRAdminList") && principal.Claims.Any(c => c.Type == "preferred_username")) // // { // // var ODRAdminsList = Configuration["ODRAdminList"].Split(";").ToList(); // // var testSubject = principal.Claims.FirstOrDefault(c => c.Type == "preferred_username").Value; // // if (ODRAdminsList.Contains(testSubject)) // // { // // var claims = new List<Claim> // // { // // new Claim(ClaimTypes.Role, "ODRAdmin") // // }; // // var appIdentity = new ClaimsIdentity(claims); // // principal.AddIdentity(appIdentity); // // } // // } // //} // }; // }); services .AddAuthentication(options => { options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme; options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; }) .AddJwtBearer(options => { var tenantName = Configuration["AzureAD:Tenant"].Split('.').First(); var policyName = Configuration["AzureAD:Policy"]; var audience = Configuration["AzureAD:Audience"]; options.MetadataAddress = $"https://{tenantName}.b2clogin.com/{tenantName}.onmicrosoft.com/{policyName}/v2.0/.well-known/openid-configuration"; options.Audience = audience; options.Events = new JwtBearerEvents { OnMessageReceived = FetchAuthTokenFromCookie, OnAuthenticationFailed = context => { var ctx = context; return(Task.FromResult(0)); }, }; }); services.AddMvc(); services .AddAuthorization(options => { options.AddPolicy(PolicyNames.MustBeInAdminGroup, policy => { var authorizedAdminUsers = Configuration["AuthorizedAdminUsers"]; policy.Requirements.Add(new AzureActiveDirectoryGroupRequirement(authorizedAdminUsers)); }); }); services.AddSingleton <IAuthorizationHandler, AzureActiveDirectoryGroupHandler>(); //if (CurrentEnvironment.IsDevelopment()) //{ // services.AddSingleton<IAuthorizationHandler, DevelopmentOnlyNoAuthDirectoryGroupHandler>(); //} //else //{ // services.AddSingleton<IAuthorizationHandler, AzureActiveDirectoryGroupHandler>(); //} services.AddScoped <DatasetSearchService>(); services.AddScoped <UserDataSearchService>(); services.AddScoped <DatasetStorageService>(); services.AddScoped <AppInsightsService>(); services.AddScoped <UserDataStorageService>(); services.AddScoped <LicenseStorageService>(); services.AddScoped <SasTokenService>(); services.AddScoped <ValidationService>(); services.AddScoped <ApplicationJobs>(); // In production, the Angular files will be served from this directory services.AddSpaStaticFiles(configuration => { configuration.RootPath = "ui-app"; }); // Add Swagger generator if (Configuration.GetValue <bool>("Application:EnableSwagger")) { services.AddSwaggerGen(c => { c.SwaggerDoc("v1", new Swashbuckle.AspNetCore.Swagger.Info { Title = "MSR ODR Admin API", Version = "v1" }); }); } }
/// <summary> /// Adds the runtime services to the instance. /// </summary> /// <param name="services">The services.</param> public void ConfigureServices(IServiceCollection services) { services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>(); services.AddSingleton <IConfiguration>(this.Configuration); services.AddSingleton <ITelemetryInitializer, TelemetryUserAndSessionContext>(); services.AddApplicationInsightsTelemetry(); services.AddOptions(); services.Configure <IdentityProviderConfiguration>(options => { Configuration.GetSection("azuread").Bind(options); IdentityProviderConfiguration.Validate(options); }); services.Configure <SearchConfiguration>(options => { Configuration.GetSection("search").Bind(options); SearchConfiguration.Validate(options); }); services.Configure <CosmosConfiguration>(options => { Configuration.GetSection("documents").Bind(options); CosmosConfiguration.Validate(options); }); services.Configure <StorageConfiguration>((config) => { Configuration.GetSection("storage").Bind(config); StorageConfiguration.Validate(config); }); services.Configure <WebServerConfiguration>(options => { Configuration.GetSection("webserver").Bind(options); WebServerConfiguration.Validate(options); }); services.Configure <BatchConfiguration>((config) => { Configuration.GetSection("batch").Bind(config); BatchConfiguration.Validate(config); }); var armTemplatesMap = Configuration.GetSection("armTemplates").Get <ArmTemplatesMap>(); services.AddSingleton(armTemplatesMap); var staticAssetsMap = Configuration.GetSection("staticAssets").Get <StaticAssetsMap>(); services.AddSingleton(staticAssetsMap); services.AddMemoryCache(); services.AddCors(options => { options.AddPolicy("DefaultPolicy", builder => builder.AllowAnyOrigin() .WithMethods("GET", "POST", "PUT", "DELETE") .AllowAnyHeader() .AllowCredentials()); }); services.AddResponseCompression(opt => { opt.EnableForHttps = true; }); services.AddMvc() .AddMvcOptions(options => { options.Filters.Add(new TelemetryExceptionFilter(new LoggerFactory())); }) .AddJsonOptions(options => { options.SerializerSettings.Converters.Add(new StringEnumConverter { CamelCaseText = true }); }); services.AddScoped <DatasetSearchService>(); services.AddScoped <FileSearchService>(); services.AddScoped <DatasetStorageService>(); services.AddScoped <DatasetOwnersService>(); services.AddScoped <DatasetEditStorageService>(); services.AddScoped <UserDataStorageService>(); services.AddScoped <FileStorageService>(); services.AddScoped <LicenseStorageService>(); services.AddScoped <ValidationService>(); services.AddScoped <SasTokenService>(); services.AddScoped <GenerateFilePreview>(); services.AddScoped <CurrentUserService>(); services.AddScoped <ApplicationJobs>(); if (this.UseSwagger) { services.UseSwagger(this.Configuration); } services .AddAuthentication(options => { options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme; options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; }) .AddJwtBearer(options => { var tenantName = Configuration["AzureAD:Tenant"].Split('.').First(); var policyName = Configuration["AzureAD:Policy"]; var audience = Configuration["AzureAD:Audience"]; options.MetadataAddress = $"https://{tenantName}.b2clogin.com/{tenantName}.onmicrosoft.com/{policyName}/v2.0/.well-known/openid-configuration"; options.Audience = audience; options.Events = new JwtBearerEvents { OnAuthenticationFailed = context => { var ctx = context; return(Task.FromResult(0)); }, }; }); }
public BatchFactory(IMessageProcessor messageProcessor, BatchConfiguration batchConfiguration) { _messageProcessor = messageProcessor; _batchConfiguration = batchConfiguration; }
public GivenABatchConfiguration() { _mockPreferences = new Mock<IPreferences>(); BatchConfiguration = new BatchConfiguration(_mockPreferences.Object); }
/// <summary> /// Creates integration account batch configuration. /// </summary> /// <param name="resourceGroupName">The integration account resource group name.</param> /// <param name="integrationAccountName">The integration account name.</param> /// <param name="integrationAccountBatchConfigurationName">The integration account batch configuration name.</param> /// <param name="integrationAccountBatchConfiguration">The integration account batch configuration object.</param> /// <returns>Newly created integration account batch configuration object.</returns> public PSIntegrationAccountBatchConfiguration CreateIntegrationAccountBatchConfiguration(string resourceGroupName, string integrationAccountName, string integrationAccountBatchConfigurationName, BatchConfiguration integrationAccountBatchConfiguration) { if (!this.DoesIntegrationAccountBatchConfigurationExist(resourceGroupName, integrationAccountName, integrationAccountBatchConfigurationName)) { var batchConfiguration = this.LogicManagementClient.IntegrationAccountBatchConfigurations.CreateOrUpdate(resourceGroupName, integrationAccountName, integrationAccountBatchConfigurationName, integrationAccountBatchConfiguration); return(new PSIntegrationAccountBatchConfiguration(batchConfiguration)); } else { throw new PSArgumentException(string.Format(CultureInfo.InvariantCulture, Properties.Resource.ResourceAlreadyExists, integrationAccountBatchConfigurationName, resourceGroupName)); } }
private void testConfiguration(ProcessEngineConfigurationImpl engineConfiguration, BatchConfiguration batchConfiguration, int expectedResult) { assertEquals(expectedResult, BatchUtil.calculateBatchSize(engineConfiguration, batchConfiguration)); }
public void PassesValidation() { var batchConfig = BuildBatchConfiguration(); BatchConfiguration.Validate(batchConfig); }
public void should_be_configured_if_all_data_in_place() { var batch = new BatchConfiguration { Github = new Github { Branch = "xx", Url = "xx" }, Iis = new Iis { SiteName = "x", DeployDirectory = "c:\\sites" }, Batch = new Batch { BuildDirectory = "x", BuildScript = "y "}}; Assert.That(batch.IsConfigured(), Is.True); }
/// <summary> /// Executes the integration account batch configuration update command. /// </summary> public override void ExecuteCmdlet() { base.ExecuteCmdlet(); switch (this.ParameterSetName) { case ParameterSet.ByInputObjectAndJson: case ParameterSet.ByInputObjectAndFilePath: case ParameterSet.ByInputObjectAndParameters: { var parsedResourceId = new ResourceIdentifier(this.InputObject.Id); this.ResourceGroupName = parsedResourceId.ResourceGroupName; this.ParentName = parsedResourceId.ResourceName; break; } case ParameterSet.ByResourceIdAndJson: case ParameterSet.ByResourceIdAndFilePath: case ParameterSet.ByResourceIdAndParameters: { var parsedResourceId = new ResourceIdentifier(this.ResourceId); this.ResourceGroupName = parsedResourceId.ResourceGroupName; this.ParentName = parsedResourceId.ResourceName; break; } } var batchConfiguration = new BatchConfiguration(); switch (this.ParameterSetName) { case ParameterSet.ByInputObjectAndJson: case ParameterSet.ByResourceIdAndJson: case ParameterSet.ByIntegrationAccountAndJson: { batchConfiguration.Properties = CmdletHelper.ConvertToBatchConfigurationProperties(this.BatchConfigurationDefinition); break; } case ParameterSet.ByInputObjectAndFilePath: case ParameterSet.ByResourceIdAndFilePath: case ParameterSet.ByIntegrationAccountAndFilePath: { batchConfiguration.Properties = CmdletHelper.ConvertToBatchConfigurationProperties(CmdletHelper.GetStringContentFromFile(this.TryResolvePath(this.BatchConfigurationFilePath))); break; } case ParameterSet.ByInputObjectAndParameters: case ParameterSet.ByResourceIdAndParameters: case ParameterSet.ByIntegrationAccountAndParameters: { var releaseCriteria = new BatchReleaseCriteria(); if (this.MyInvocation.BoundParameters.ContainsKey("MessageCount")) { releaseCriteria.MessageCount = this.MessageCount; } if (this.MyInvocation.BoundParameters.ContainsKey("BatchSize")) { releaseCriteria.BatchSize = this.BatchSize; } if (this.MyInvocation.BoundParameters.ContainsKey("ScheduleInterval")) { releaseCriteria.Recurrence = new WorkflowTriggerRecurrence { Interval = this.ScheduleInterval, Frequency = this.ScheduleFrequency, TimeZone = !string.IsNullOrWhiteSpace(this.ScheduleTimeZone) ? this.ScheduleTimeZone : null, StartTime = this.ScheduleStartTime?.ToShortDateString() }; } batchConfiguration.Properties = new BatchConfigurationProperties { BatchGroupName = this.BatchGroupName, ReleaseCriteria = releaseCriteria }; if (!this.IsValidReleaseCriteria(releaseCriteria)) { throw new PSArgumentException(string.Format(CultureInfo.InvariantCulture, Resource.BatchConfigurationParameterNeedsToBeSpecified)); } break; } } batchConfiguration.Properties.Metadata = this.Metadata; if (this.ShouldProcess(this.Name, string.Format(CultureInfo.InvariantCulture, Resource.UpdateIntegrationAccountArtifactMessage, Resource.BatchConfiguration, this.Name, this.ResourceGroupName))) { var updatedBatchConfiguration = IntegrationAccountClient.UpdateIntegrationAccountBatchConfiguration(this.ResourceGroupName, this.ParentName, this.Name, batchConfiguration); this.WriteObject(updatedBatchConfiguration); } }
/// <summary> /// Create or update a batch configuration for an integration account. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='resourceGroupName'> /// The resource group name. /// </param> /// <param name='integrationAccountName'> /// The integration account name. /// </param> /// <param name='batchConfigurationName'> /// The batch configuration name. /// </param> /// <param name='batchConfiguration'> /// The batch configuration. /// </param> public static BatchConfiguration CreateOrUpdate(this IIntegrationAccountBatchConfigurationsOperations operations, string resourceGroupName, string integrationAccountName, string batchConfigurationName, BatchConfiguration batchConfiguration) { return(operations.CreateOrUpdateAsync(resourceGroupName, integrationAccountName, batchConfigurationName, batchConfiguration).GetAwaiter().GetResult()); }
/// <summary> /// Updates the integration account. /// </summary> /// <param name="resourceGroupName">The integration account batch configuration resource group.</param> /// <param name="integrationAccountName">The integration account name.</param> /// <param name="integrationAccountBatchConfigurationName">The integration account batch configuration name.</param> /// <param name="integrationAccountBatchConfiguration">The integration account batch configuration object.</param> /// <returns>Updated integration account batch configuration</returns> public PSIntegrationAccountBatchConfiguration UpdateIntegrationAccountBatchConfiguration(string resourceGroupName, string integrationAccountName, string integrationAccountBatchConfigurationName, BatchConfiguration integrationAccountBatchConfiguration) { var updatedBatchConfiguration = this.LogicManagementClient.IntegrationAccountBatchConfigurations.CreateOrUpdate(resourceGroupName, integrationAccountName, integrationAccountBatchConfigurationName, integrationAccountBatchConfiguration); return(new PSIntegrationAccountBatchConfiguration(updatedBatchConfiguration)); }
/// <summary> /// Create or update a batch configuration for an integration account. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='resourceGroupName'> /// The resource group name. /// </param> /// <param name='integrationAccountName'> /// The integration account name. /// </param> /// <param name='batchConfigurationName'> /// The batch configuration name. /// </param> /// <param name='batchConfiguration'> /// The batch configuration. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <BatchConfiguration> CreateOrUpdateAsync(this IIntegrationAccountBatchConfigurationsOperations operations, string resourceGroupName, string integrationAccountName, string batchConfigurationName, BatchConfiguration batchConfiguration, CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, integrationAccountName, batchConfigurationName, batchConfiguration, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
/// <summary> /// Create or update a batch configuration for an integration account. /// </summary> /// <param name='resourceGroupName'> /// The resource group name. /// </param> /// <param name='integrationAccountName'> /// The integration account name. /// </param> /// <param name='batchConfigurationName'> /// The batch configuration name. /// </param> /// <param name='batchConfiguration'> /// The batch configuration. /// </param> /// <param name='customHeaders'> /// Headers that will be added to request. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> /// <exception cref="ErrorResponseException"> /// 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 <BatchConfiguration> > CreateOrUpdateWithHttpMessagesAsync(string resourceGroupName, string integrationAccountName, string batchConfigurationName, BatchConfiguration batchConfiguration, Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken)) { if (Client.SubscriptionId == null) { throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.SubscriptionId"); } if (resourceGroupName == null) { throw new ValidationException(ValidationRules.CannotBeNull, "resourceGroupName"); } if (integrationAccountName == null) { throw new ValidationException(ValidationRules.CannotBeNull, "integrationAccountName"); } if (batchConfigurationName == null) { throw new ValidationException(ValidationRules.CannotBeNull, "batchConfigurationName"); } if (batchConfiguration == null) { throw new ValidationException(ValidationRules.CannotBeNull, "batchConfiguration"); } if (batchConfiguration != null) { batchConfiguration.Validate(); } if (Client.ApiVersion == null) { throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.ApiVersion"); } // 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("integrationAccountName", integrationAccountName); tracingParameters.Add("batchConfigurationName", batchConfigurationName); tracingParameters.Add("batchConfiguration", batchConfiguration); tracingParameters.Add("cancellationToken", cancellationToken); ServiceClientTracing.Enter(_invocationId, this, "CreateOrUpdate", 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.Logic/integrationAccounts/{integrationAccountName}/batchConfigurations/{batchConfigurationName}").ToString(); _url = _url.Replace("{subscriptionId}", System.Uri.EscapeDataString(Client.SubscriptionId)); _url = _url.Replace("{resourceGroupName}", System.Uri.EscapeDataString(resourceGroupName)); _url = _url.Replace("{integrationAccountName}", System.Uri.EscapeDataString(integrationAccountName)); _url = _url.Replace("{batchConfigurationName}", System.Uri.EscapeDataString(batchConfigurationName)); List <string> _queryParameters = new List <string>(); if (Client.ApiVersion != null) { _queryParameters.Add(string.Format("api-version={0}", System.Uri.EscapeDataString(Client.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 (batchConfiguration != null) { _requestContent = Rest.Serialization.SafeJsonConvert.SerializeObject(batchConfiguration, 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) { var ex = new ErrorResponseException(string.Format("Operation returned an invalid status code '{0}'", _statusCode)); try { _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); ErrorResponse _errorBody = Rest.Serialization.SafeJsonConvert.DeserializeObject <ErrorResponse>(_responseContent, Client.DeserializationSettings); if (_errorBody != null) { ex.Body = _errorBody; } } catch (JsonException) { // Ignore the exception } ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent); ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent); if (_shouldTrace) { ServiceClientTracing.Error(_invocationId, ex); } _httpRequest.Dispose(); if (_httpResponse != null) { _httpResponse.Dispose(); } throw ex; } // Create Result var _result = new AzureOperationResponse <BatchConfiguration>(); _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 <BatchConfiguration>(_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 <BatchConfiguration>(_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 void should_fail_if_build_script_is_missing() { var batch = new BatchConfiguration { Github = new Github { Branch = "xx", Url = "xx" }, Iis = new Iis { SiteName = "x", DeployDirectory = "c:\\sites" }, Batch = new Batch { BuildDirectory = "x" } }; Assert.That(batch.IsConfigured(), Is.False); }
public IDeployRunner ForConfiguration(BatchConfiguration config) { var bounceConfig = new BatchBounceConfigurationBuilder(config).CreateConfig(); return new DeployRunner(bounceConfig.ToBounceTargets()); }