protected static async Task TearDownAsync(params PackageInfo[] packages)
{
try
{
var builder = new ServiceFabricClientBuilder();
builder.UseEndpoints(new Uri(TestInfo.Connection));
var fabricClient = await builder.BuildAsync();
foreach (var package in packages)
{
await DeleteExistingApplicationAsync(fabricClient, package.AppId);
await RemoveApplicationTypeAsync(fabricClient, package.AppTypeName);
}
}
catch (Exception)
{
// Ignore
}
finally
{
foreach (var package in packages)
{
Directory.Delete(package.TempDir, true);
}
}
}
protected override void ProcessRecord()
{
PartitionSchemeDescription partitionSchemeDescription;
ServiceDescription serviceDescription;
var client = new ServiceFabricClientBuilder().ConnectAsync(ClusterEndPoint, ThumbPrint).Result;
if (PartitionSchemeUniformInt64)
{
partitionSchemeDescription = new UniformInt64RangePartitionSchemeDescription(PartitionCount, LowKey.ToString(), HighKey.ToString());
}
else if (PartitionSchemeNamed)
{
partitionSchemeDescription = new NamedPartitionSchemeDescription(PartitionCount, PartitionNames);
}
else
{
partitionSchemeDescription = new SingletonPartitionSchemeDescription();
}
if (Stateless.IsPresent)
{
serviceDescription = new StatelessServiceDescription(new ServiceName(ServiceName), ServiceType, partitionSchemeDescription, InstanceCount, initializationData: InitializationData);
}
else
{
serviceDescription = new StatefulServiceDescription(new ServiceName(ServiceName), ServiceType, partitionSchemeDescription, TargetReplicaSetSize, MinReplicaSetSize, PersistedState, initializationData: InitializationData);
}
client.Services.CreateServiceAsync(ApplicationId, serviceDescription).Wait();
}
/// <summary>
/// Creates and initializes a new instance of the <see cref="ServiceFabricHttpClient"/> class.
/// </summary>
/// <param name="builder">Builder isntance to create ServiceFabricHttpClient from.</param>
/// <param name="cancellationToken">A cancellation token to cancel the async operation.</param>
/// <returns><see cref="ServiceFabricHttpClient"/> instance.</returns>
internal static async Task <IServiceFabricClient> CreateAsync(
ServiceFabricClientBuilder builder,
CancellationToken cancellationToken = default(CancellationToken))
{
var obj = new ServiceFabricHttpClient(builder);
await obj.InitializeAsync(cancellationToken);
return(obj);
}
public static Task <IServiceFabricClient> BuildAsyncDirect(this ServiceFabricClientBuilder serviceFabricClientBuilder)
{
object[] parameters = new object[2]
{
serviceFabricClientBuilder,
default(CancellationToken)
};
return((Task <IServiceFabricClient>) typeof(ServiceFabricHttpClient).GetMethod("CreateAsync", BindingFlags.NonPublic | BindingFlags.Static).Invoke(null, parameters));
}
private void AppendSecurity(ServiceFabricClientBuilder builder, Manifest manifest)
{
if (!string.IsNullOrWhiteSpace(manifest.ClusterDetails.FindByValue))
{
builder.UseX509Security(_ =>
{
var certificate = FindCertificate(manifest.ClusterDetails);
var remoteSettings = new RemoteX509SecuritySettings(
new List <string>(new[] { certificate.Thumbprint }));
var settings = new X509SecuritySettings(certificate, remoteSettings);
return(Task.FromResult <SecuritySettings>(settings));
});
}
}
public async Task <IServiceFabricClient> BuildAsync(Manifest manifest)
{
try
{
var builder = new ServiceFabricClientBuilder();
AppendSecurity(builder, manifest);
AppendClusterEndpoint(builder, manifest);
return(await builder.BuildAsync());
}
catch (Exception error)
{
_logger.Log(new LogMessage(StageTypes.Preparation, error.Message, LogLevelTypes.Error));
}
return(null);
}
/// <summary>
/// Configure IServiceFabricClientBuilder to create IServiceFabricClient implementation which communicates with Service Fabric cluster via the REST http gateway using the provided HttpClientHandler and DelegatingHandlers.
/// </summary>
/// <param name="builder">Builder </param>
/// <param name="innerHandler">The inner handler which is responsible for processing the HTTP response messages. When null or not provided, <see cref="System.Net.Http.HttpClientHandler"/> will be used as last handler in channel.</param>
/// <param name="delegateHandlers">An ordered list of <see cref="System.Net.Http.DelegatingHandler"/> instances to be invoked in HTTP message channel as message flows to and from the last handler in the channel.</param>
/// <returns>IServiceFabricClientBuilder instance.</returns>
public static ServiceFabricClientBuilder ConfigureHttpClientSettings(
this ServiceFabricClientBuilder builder,
HttpClientHandler innerHandler,
params DelegatingHandler[] delegateHandlers)
{
if (innerHandler == null)
{
throw new ArgumentNullException(nameof(innerHandler));
}
if (delegateHandlers.Any(handler => handler == null))
{
throw new ArgumentException(SR.ErrorNullDelegateHandler);
}
builder.Container[typeof(HttpClientHandler)] = innerHandler;
builder.Container[typeof(DelegatingHandler[])] = delegateHandlers;
return(builder);
}
/// <summary>
/// Initializes a new instance of the <see cref="ServiceFabricHttpClient"/> class.
/// </summary>
/// <param name="builder">Builder isntance to create ServiceFabricHttpClient from.</param>
private ServiceFabricHttpClient(ServiceFabricClientBuilder builder)
: base(builder.Endpoints, builder.SecuritySettings, builder.ClientSettings)
{
this.CreateManagementClients();
// Validate when Security Settings is null, url can't be https
if (this.SecuritySettingsFunc == null)
{
var scheme = Uri.UriSchemeHttp;
var invalidClusterEndpoint = this.ClusterEndpoints.FirstOrDefault(url => !string.Equals(url.Scheme, scheme, StringComparison.OrdinalIgnoreCase));
if (invalidClusterEndpoint != null)
{
throw new InvalidOperationException(string.Format(SR.ErrorUrlScheme, invalidClusterEndpoint.Scheme, scheme));
}
}
else
{
// Url validation for secured cluster will be done after SecuritySettings is invoked in Initialize, it can be https only for Claims and X509.
}
var seed = (int)DateTime.Now.Ticks;
this.randomizedEndpoints = new RandomizedList <Uri>(this.ClusterEndpoints, new Random(seed));
this.ClientId = Guid.NewGuid().ToString();
// Get information from DI container in ServiceFabricClientBuilder
this.innerHandler = new HttpClientHandler();
if (builder.Container.ContainsKey(typeof(HttpClientHandler)))
{
this.innerHandler = (HttpClientHandler)builder.Container[typeof(HttpClientHandler)];
}
if (builder.Container.ContainsKey(typeof(DelegatingHandler[])))
{
this.delegateHandlers = (DelegatingHandler[])builder.Container[typeof(DelegatingHandler[])];
}
this.refreshSecuritySettingsFunc = this.SecuritySettingsFunc;
this.httpClientHandlerWrapper = new HttpClientHandlerWrapper(this.innerHandler);
this.ClientTypeHeaderValue = Constants.ClientlibClientTypeHeaderValue;
}
public async Task Init()
{
Process.Start(new ProcessStartInfo {
FileName = "dotnet", Arguments = "publish", WorkingDirectory = basePath
}).WaitForExit();
var client = new ServiceFabricClientBuilder().UseEndpoints(new Uri("http://localhost:19080")).BuildAsync().Result;
var apps = await client.Applications.GetApplicationInfoListAsync();
foreach (var app in apps.Data)
{
await client.Applications.DeleteApplicationAsync(app.Id);
}
var apptypes = await client.ApplicationTypes.GetApplicationTypeInfoListAsync();
foreach (var type in apptypes.Data)
{
await client.ApplicationTypes.UnprovisionApplicationTypeAsync(type.Name, new UnprovisionApplicationTypeDescriptionInfo(type.Version));
}
}
public static Task <IServiceFabricClient> ConnectAsync(this ServiceFabricClientBuilder serviceFabricClientBuilder, string ClusterEndPoint, string ThumbPrint, StoreLocation storeLocation = StoreLocation.CurrentUser)
{
var builder = serviceFabricClientBuilder.UseEndpoints(new Uri(ClusterEndPoint));
if (!string.IsNullOrWhiteSpace(ThumbPrint))
{
Func <CancellationToken, Task <SecuritySettings> > GetSecurityCredentials = (ct) =>
{
var store = new X509Store(StoreName.My, storeLocation);
store.Open(OpenFlags.ReadOnly);
var clientCert = store.Certificates.Find(X509FindType.FindByThumbprint, ThumbPrint, false)[0];
var remoteSecuritySettings = new RemoteX509SecuritySettings(new List <string> {
ThumbPrint
});
return(Task.FromResult <SecuritySettings>(new X509SecuritySettings(clientCert, remoteSecuritySettings)));
};
builder = builder.UseX509Security(GetSecurityCredentials);
}
builder.ClientSettings.ClientTimeout = TimeSpan.FromMinutes(15);
return(builder.BuildAsyncDirect());
}
private static void AppendClusterEndpoint(ServiceFabricClientBuilder builder, Manifest manifest)
{
builder.UseEndpoints(new Uri(manifest.ClusterDetails.Connection));
}
internal static ServiceFabricClientBuilder AddClientTypeIdentity(
this ServiceFabricClientBuilder builder,
string clientType)
{
return(builder);
}
/// <inheritdoc />
protected override void ProcessRecordInternal()
{
if (this.ConnectionEndpoint == null)
{
if (!this.TryConfiguringDefaultConnect())
{
throw new InvalidOperationException("Cluster Connection Information is not provided. Please try connecting again with correct connection information.");
}
}
// Create Builder
var builder = new ServiceFabricClientBuilder()
.UseEndpoints(this.ConnectionEndpoint.Select(e => new Uri(e)).ToArray());
// Configure Security for builder
if (this.WindowsCredential.IsPresent)
{
builder.UseWindowsSecurity();
}
else if (this.X509Credential.IsPresent)
{
var remoteX509SecuritySettings = this.GetServerX509SecuritySettings();
Func <CancellationToken, Task <SecuritySettings> > securitySettings;
if (this.ClientCertificate == null)
{
var clientCert = CredentialsUtil.GetCertificate(this.StoreLocation, this.StoreName, this.FindValue, this.FindType);
if (clientCert == null)
{
throw new PSInvalidOperationException(Resource.ErrorLoadingClientCertificate);
}
securitySettings = (ct) => Task.FromResult <SecuritySettings>(new X509SecuritySettings(clientCert, remoteX509SecuritySettings));
}
else
{
securitySettings = (ct) => Task.FromResult <SecuritySettings>(new X509SecuritySettings(this.ClientCertificate, remoteX509SecuritySettings));
}
builder.UseX509Security(securitySettings);
}
else if (this.AzureActiveDirectory.IsPresent)
{
var remoteX509SecuritySettings = this.GetServerX509SecuritySettings();
Func <CancellationToken, Task <SecuritySettings> > securitySettings;
if (this.GetMetadata.IsPresent)
{
securitySettings = (ct) => Task.FromResult <SecuritySettings>(new AzureActiveDirectorySecuritySettings("DummyTokenToGetMetadata", remoteX509SecuritySettings));
}
else
{
if (this.SecurityToken != null)
{
securitySettings = (ct) => Task.FromResult <SecuritySettings>(new AzureActiveDirectorySecuritySettings(this.SecurityToken, remoteX509SecuritySettings));
}
else
{
securitySettings = (ct) => Task.FromResult <SecuritySettings>(new AzureActiveDirectorySecuritySettings(CredentialsUtil.GetAccessTokenAsync, remoteX509SecuritySettings));
}
}
builder.UseAzureActiveDirectorySecurity(securitySettings);
}
else if (this.DSTS.IsPresent)
{
var remoteX509SecuritySettings = this.GetServerX509SecuritySettings();
Func <CancellationToken, Task <SecuritySettings> > securitySettings =
(ct) => Task.FromResult <SecuritySettings>(new DstsClaimsSecuritySettings(CredentialsUtil.GetAccessTokenDstsAsync, remoteX509SecuritySettings));
builder.UseClaimsSecurity(securitySettings);
}
// build the client
var client = builder.BuildAsync(cancellationToken: this.CancellationToken).GetAwaiter().GetResult() as ServiceFabricHttpClient;
// set the client type for Telemetry on HttpGateway.
client.ClientTypeHeaderValue = Constants.PowershellClientTypeHeaderValue;
if (this.GetMetadata.IsPresent)
{
var aadMetadata = client.Cluster.GetAadMetadataAsync(cancellationToken: this.CancellationToken).GetAwaiter().GetResult().Metadata;
var result = new PSObject();
result.Properties.Add(new PSNoteProperty(nameof(aadMetadata.Authority), aadMetadata.Authority));
result.Properties.Add(new PSNoteProperty(nameof(aadMetadata.Client), aadMetadata.Client));
result.Properties.Add(new PSNoteProperty(nameof(aadMetadata.Cluster), aadMetadata.Cluster));
result.Properties.Add(new PSNoteProperty(nameof(aadMetadata.Login), aadMetadata.Login));
result.Properties.Add(new PSNoteProperty(nameof(aadMetadata.Redirect), aadMetadata.Redirect));
result.Properties.Add(new PSNoteProperty(nameof(aadMetadata.Tenant), aadMetadata.Tenant));
this.WriteObject(result);
}
else
{
client.Cluster.GetClusterManifestAsync(cancellationToken: this.CancellationToken).GetAwaiter().GetResult();
Console.WriteLine(Resource.MsgConnectSuccess);
this.SetClusterConnection(client);
}
}