//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());
}
