/// <summary>
/// Stops the data package service.
/// </summary>
protected void StopDataPackageService()
{
if (_datapackageServiceStub != null)
{
_datapackageServiceStub.Dispose();
_datapackageServiceStub = null;
}
if (_requestManager != null)
{
_requestManager.Dispose();
_requestManager = null;
}
DataPackageService.Uninitialize();
if (_baselineStatusUpdater != null)
{
_baselineStatusUpdater.Dispose();
_baselineStatusUpdater = null;
}
if (_t2gManager != null)
{
_t2gManager.Dispose();
_t2gManager = null;
}
T2GManagerContainer.T2GManager = null;
_sessionManager = null;
_requestFactory = null;
}
private async Task HandleOutputAsync(IPartner partner, ResourceCollection <ServiceRequest> requests, ServiceRequestSeverity?severity, ServiceRequestStatus?status)
{
IResourceCollectionEnumerator <ResourceCollection <ServiceRequest> > enumerator;
List <ServiceRequest> serviceRequests;
enumerator = partner.Enumerators.ServiceRequests.Create(requests);
serviceRequests = new List <ServiceRequest>();
while (enumerator.HasValue)
{
serviceRequests.AddRange(enumerator.Current.Items);
await enumerator.NextAsync(RequestContextFactory.Create(CorrelationId), CancellationToken).ConfigureAwait(false);
}
if (severity.HasValue && status.HasValue)
{
WriteObject(serviceRequests.Where(r => r.Severity == severity && r.Status == status).Select(r => new PSServiceRequest(r)), true);
}
else if (severity.HasValue)
{
WriteObject(serviceRequests.Where(r => r.Severity == severity).Select(r => new PSServiceRequest(r)), true);
}
else if (status.HasValue)
{
WriteObject(serviceRequests.Where(r => r.Status == status).Select(r => new PSServiceRequest(r)), true);
}
else
{
WriteObject(serviceRequests.Select(r => new PSServiceRequest(r)), true);
}
}
/// <summary>
/// Initializes the data package service.
/// </summary>
/// <param name="isRestart">Parameter that indicates if it is a restart simulation of the services.</param>
protected void InitializeDataPackageService(bool isRestart)
{
Assert.IsTrue(HistoryLoggerConfiguration.Used, "The test application is misconfigured. HistoryLoggerConfiguration.Used is not set to proper value");
Assert.IsTrue(HistoryLoggerConfiguration.Valid, "The test application is misconfigured. HistoryLoggerConfiguration.Valid is not set to proper value");
// Create a complete T2G Manager
_t2gManager = T2GManagerContainer.T2GManager;
_sessionManager = new SessionManager();
_baselineStatusUpdater = new BaselineStatusUpdater();
if (!isRestart)
{
Assert.IsEmpty(_sessionManager.RemoveAllSessions(), "Cannot empty the session database");
}
_requestFactory = new RequestContextFactory(_t2gManager, _remoteDataStoreFactoryMock.Object, _baselineStatusUpdater);
_requestManager = new RequestManager();
_datapackageServiceStub = new DataPackageServiceStub(_sessionManager,
_notificationsSender,
_t2gManager,
_requestFactory,
_remoteDataStoreFactoryMock.Object,
_requestManager,
_baselineStatusUpdater
);
}
/// <summary>
/// Executes the operations associated with the cmdlet.
/// </summary>
public override void ExecuteCmdlet()
{
Scheduler.RunTask(async() =>
{
IPartner partner = await PartnerSession.Instance.ClientFactory.CreatePartnerOperationsAsync(CorrelationId, CancellationToken).ConfigureAwait(false);
DateTime endDate;
IResourceCollectionEnumerator <SeekBasedResourceCollection <AuditRecord> > enumerator;
List <PSAuditRecord> records;
SeekBasedResourceCollection <AuditRecord> auditRecords;
endDate = EndDate ?? DateTime.Now;
if ((endDate - StartDate).Days >= 90)
{
throw new PSInvalidOperationException(Resources.AuditRecordDateError);
}
records = new List <PSAuditRecord>();
foreach (DateTime date in ChunkDate(StartDate, endDate, 30))
{
auditRecords = await partner.AuditRecords.QueryAsync(date, null, null, CancellationToken).ConfigureAwait(false);
enumerator = partner.Enumerators.AuditRecords.Create(auditRecords);
while (enumerator.HasValue)
{
records.AddRange(enumerator.Current.Items.Select(r => new PSAuditRecord(r)));
await enumerator.NextAsync(RequestContextFactory.Create(CorrelationId), CancellationToken).ConfigureAwait(false);
}
}
WriteObject(records, true);
}, true);
}
/// <summary>
/// Executes the operations associated with the cmdlet.
/// </summary>
public override void ExecuteCmdlet()
{
Scheduler.RunTask(async() =>
{
IPartner partner = await PartnerSession.Instance.ClientFactory.CreatePartnerOperationsAsync(CorrelationId, CancellationToken).ConfigureAwait(false);
if (string.IsNullOrEmpty(InvoiceId))
{
IResourceCollectionEnumerator <ResourceCollection <Invoice> > enumerator;
List <PSInvoice> invoices;
ResourceCollection <Invoice> resources;
resources = await partner.Invoices.GetAsync(CancellationToken).ConfigureAwait(false);
enumerator = partner.Enumerators.Invoices.Create(resources);
invoices = new List <PSInvoice>();
while (enumerator.HasValue)
{
invoices.AddRange(enumerator.Current.Items.Select(i => new PSInvoice(i)));
await enumerator.NextAsync(RequestContextFactory.Create(CorrelationId), CancellationToken).ConfigureAwait(false);
}
WriteObject(invoices, true);
}
else
{
WriteObject(new PSInvoice(await partner.Invoices[InvoiceId].GetAsync(CancellationToken).ConfigureAwait(false)));
}
}, true);
}
/// <summary>
/// Executes the operations associated with the cmdlet.
/// </summary>
public override void ExecuteCmdlet()
{
Scheduler.RunTask(async() =>
{
IPartner partner = await PartnerSession.Instance.ClientFactory.CreatePartnerOperationsAsync().ConfigureAwait(false);
IResourceCollectionEnumerator <ResourceCollection <InvoiceLineItem> > enumerator;
List <InvoiceLineItem> items;
ResourceCollection <InvoiceLineItem> lineItems;
if (BillingProvider == BillingProvider.OneTime || BillingProvider == BillingProvider.Marketplace)
{
lineItems = await partner.Invoices[InvoiceId].By(BillingProvider, LineItemType, CurrencyCode, BillingPeriod.Current).GetAsync(CancellationToken).ConfigureAwait(false);
}
else
{
lineItems = await partner.Invoices[InvoiceId].By(BillingProvider, LineItemType).GetAsync(CancellationToken).ConfigureAwait(false);
}
enumerator = partner.Enumerators.InvoiceLineItems.Create(lineItems);
items = new List <InvoiceLineItem>();
while (enumerator.HasValue)
{
items.AddRange(enumerator.Current.Items);
await enumerator.NextAsync(RequestContextFactory.Create(CorrelationId), CancellationToken).ConfigureAwait(false);
}
if (LineItemType == InvoiceLineItemType.BillingLineItems)
{
if (BillingProvider == BillingProvider.Azure)
{
WriteObject(items.Select(i => new PSUsageBasedLineItem((UsageBasedLineItem)i)), true);
}
else if (BillingProvider == BillingProvider.Office)
{
WriteObject(items.Select(i => new PSLicenseBasedLineItem((LicenseBasedLineItem)i)), true);
}
else if (BillingProvider == BillingProvider.OneTime)
{
WriteObject(items.Select(i => new PSOneTimeInvoiceLineItem((OneTimeInvoiceLineItem)i)), true);
}
else if (BillingProvider == BillingProvider.Marketplace)
{
WriteObject(items.Select(i => new PSDailyRatedUsageLineItem((DailyRatedUsageLineItem)i)), true);
}
}
else
{
if (BillingProvider == BillingProvider.Azure)
{
WriteObject(items.Select(i => new PSDailyUsageLineItem((DailyUsageLineItem)i)), true);
}
else
{
WriteObject(items.Select(i => new PSDailyRatedUsageLineItem((DailyRatedUsageLineItem)i)), true);
}
}
}, true);
}
internal SlaveIdGenerator(IdType idType, long highId, Master master, Log log, RequestContextFactory requestContextFactory)
{
this.IdType = idType;
this.HighestIdInUse = highId;
this.Master = master;
this.Log = log;
this.RequestContextFactory = requestContextFactory;
IdQueue = EMPTY_ID_RANGE_ITERATOR;
}
public SlaveTokenCreatorTest(string name, SlaveTokenCreatorFixture fixture)
{
this._fixture = fixture;
_master = mock(typeof(Master));
_requestContext = new RequestContext(1, 2, 3, 4, 5);
this._name = "Poke";
_requestContextFactory = new ConstantRequestContextFactory(_requestContext);
_tokenCreator = fixture.Build(_master, _requestContextFactory);
}
public HaIdGeneratorFactory(DelegateInvocationHandler <Master> master, LogProvider logProvider, RequestContextFactory requestContextFactory, FileSystemAbstraction fs, IdTypeConfigurationProvider idTypeConfigurationProvider)
{
this._fs = fs;
this._idTypeConfigurationProvider = idTypeConfigurationProvider;
this._localFactory = new DefaultIdGeneratorFactory(fs, idTypeConfigurationProvider);
this._master = master;
this._log = logProvider.getLog(this.GetType());
this._requestContextFactory = requestContextFactory;
}
internal SlaveLocksClient(Master master, Org.Neo4j.Kernel.impl.locking.Locks_Client local, Locks localLockManager, RequestContextFactory requestContextFactory, AvailabilityGuard availabilityGuard, LogProvider logProvider)
{
this._master = master;
this._client = local;
this._localLockManager = localLockManager;
this._requestContextFactory = requestContextFactory;
this._availabilityGuard = availabilityGuard;
this._log = logProvider.getLog(this.GetType());
}
/// <summary>
/// Adds the headers to the request.
/// </summary>
/// <param name="request">The HTTP request being made.</param>
/// <param name="additionalHeaders">Additional headers to be added.</param>
private async Task AddRequestHeadersAsync(HttpRequestMessage request, IDictionary <string, string> additionalHeaders = null)
{
if (rootPartnerOperations.RequestContext.RequestId == Guid.Empty)
{
requestContext = RequestContextFactory.Create(
rootPartnerOperations.RequestContext.CorrelationId,
Guid.NewGuid(),
rootPartnerOperations.RequestContext.Locale);
}
else
{
requestContext = rootPartnerOperations.RequestContext;
}
if (!string.IsNullOrEmpty(PartnerService.Instance.ApplicationName))
{
request.Headers.Add(ApplicationNameHeader, PartnerService.Instance.ApplicationName);
}
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(MediaType));
request.Headers.Add(ClientHeader, PartnerService.Instance.Configuration.PartnerCenterClient);
request.Headers.Add(CorrelationIdHeaderName, requestContext.CorrelationId.ToString());
request.Headers.Add(LocaleHeaderName, requestContext.Locale);
request.Headers.Add(RequestIdHeaderName, requestContext.RequestId.ToString());
request.Headers.Add(SdkVersionHeader, PartnerService.Instance.AssemblyVersion);
if (rootPartnerOperations.Credentials.IsExpired())
{
if (PartnerService.Instance.RefreshCredentials != null)
{
await PartnerService.Instance.RefreshCredentials(
rootPartnerOperations.Credentials,
requestContext).ConfigureAwait(false);
}
else
{
throw new PartnerException(
"The partner credentials have expired. Please provide updated credentials.",
requestContext,
PartnerErrorCategory.Unauthorized);
}
}
request.Headers.Authorization = new AuthenticationHeaderValue(
AuthorizationScheme,
rootPartnerOperations.Credentials.PartnerServiceToken);
if (additionalHeaders != null)
{
foreach (KeyValuePair <string, string> header in additionalHeaders)
{
request.Headers.Add(header.Key, header.Value);
}
}
}
/// <summary>
/// Adds the headers to the request.
/// </summary>
/// <param name="rootPartnerOperations">The root partner operations instance.</param>
/// <param name="request">The HTTP request being made.</param>
/// <param name="additionalHeaders">Additional headers to be added.</param>
private void AddRequestHeaders(HttpRequestMessage request, IDictionary <string, string> additionalHeaders = null)
{
IRequestContext context;
if (rootPartnerOperations.RequestContext.RequestId == default)
{
context = RequestContextFactory.Create(
rootPartnerOperations.RequestContext.CorrelationId,
Guid.NewGuid(),
rootPartnerOperations.RequestContext.Locale);
}
else
{
context = rootPartnerOperations.RequestContext;
}
if (!string.IsNullOrEmpty(PartnerService.Instance.ApplicationName))
{
request.Headers.Add(ApplicationNameHeader, PartnerService.Instance.ApplicationName);
}
if (PartnerService.Instance.EnforceMfa)
{
request.Headers.Add(EnforceMfaHeader, true.ToString(CultureInfo.InvariantCulture));
}
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(MediaType));
request.Headers.Add(ClientHeader, PartnerService.Instance.Configuration.PartnerCenterClient);
request.Headers.Add(CorrelationIdHeaderName, context.CorrelationId.ToString());
request.Headers.Add(LocaleHeaderName, context.Locale);
request.Headers.Add(RequestIdHeaderName, context.RequestId.ToString());
request.Headers.Add(SdkVersionHeader, PartnerService.Instance.AssemblyVersion);
if (rootPartnerOperations.Credentials.IsExpired())
{
throw new PartnerException(
"The credential refresh mechanism provided expired credentials.",
rootPartnerOperations.RequestContext,
PartnerErrorCategory.Unauthorized);
}
request.Headers.Authorization = new AuthenticationHeaderValue(
AuthorizationScheme,
rootPartnerOperations.Credentials.PartnerServiceToken);
if (additionalHeaders != null)
{
foreach (KeyValuePair <string, string> header in additionalHeaders)
{
request.Headers.Add(header.Key, header.Value);
}
}
}
/// <summary>
/// Executes the operations associated with the cmdlet.
/// </summary>
public override void ExecuteCmdlet()
{
Scheduler.RunTask(async() =>
{
string value = string.IsNullOrEmpty(UserId) ? UserPrincipalName : UserId;
if (ShouldProcess(string.Format(CultureInfo.CurrentCulture, Resources.RestorePartnerCustomerUserWhatIf, value)))
{
IPartner partner = await PartnerSession.Instance.ClientFactory.CreatePartnerOperationsAsync(CorrelationId, CancellationToken).ConfigureAwait(false);
string userId;
if (ParameterSetName.Equals("ByUpn", StringComparison.InvariantCultureIgnoreCase))
{
SimpleFieldFilter filter = new SimpleFieldFilter("UserState", FieldFilterOperation.Equals, "Inactive");
IQuery simpleQueryWithFilter = QueryFactory.BuildSimpleQuery(filter);
IResourceCollectionEnumerator <SeekBasedResourceCollection <CustomerUser> > usersEnumerator;
List <CustomerUser> users = new List <CustomerUser>();
SeekBasedResourceCollection <CustomerUser> seekUsers;
seekUsers = await partner.Customers[CustomerId].Users.QueryAsync(simpleQueryWithFilter, CancellationToken).ConfigureAwait(false);
usersEnumerator = partner.Enumerators.CustomerUsers.Create(seekUsers);
while (usersEnumerator.HasValue)
{
users.AddRange(usersEnumerator.Current.Items);
await usersEnumerator.NextAsync(RequestContextFactory.Create(CorrelationId), CancellationToken).ConfigureAwait(false);
}
CustomerUser user = users.SingleOrDefault(u => string.Equals(u.UserPrincipalName, UserPrincipalName, StringComparison.CurrentCultureIgnoreCase));
if (user == null)
{
throw new PSInvalidOperationException($"Unable to locate {UserPrincipalName}");
}
userId = user.Id;
}
else
{
userId = UserId;
}
CustomerUser updatedCustomerUser = new CustomerUser
{
State = UserState.Active
};
await partner.Customers.ById(CustomerId).Users.ById(userId).PatchAsync(updatedCustomerUser, CancellationToken).ConfigureAwait(false);
}
}, true);
}
private volatile BinaryLatch _shutdownLatch; // Store under synchronised(this), load in update puller thread
internal SlaveUpdatePuller(RequestContextFactory requestContextFactory, Master master, LastUpdateTime lastUpdateTime, LogProvider logging, InstanceId instanceId, AvailabilityGuard availabilityGuard, InvalidEpochExceptionHandler invalidEpochHandler, JobScheduler jobScheduler, Monitor monitor)
{
this._requestContextFactory = requestContextFactory;
this._master = master;
this._lastUpdateTime = lastUpdateTime;
this._instanceId = instanceId;
this._availabilityGuard = availabilityGuard;
this._invalidEpochHandler = invalidEpochHandler;
this._jobScheduler = jobScheduler;
this._monitor = monitor;
this._logger = logging.getLog(this.GetType());
this._invalidEpochCappedLogger = (new CappedLogger(_logger)).setCountLimit(LogCap);
this._comExceptionCappedLogger = (new CappedLogger(_logger)).setCountLimit(LogCap);
}
private static void OnGetDataMessage(object processingContext)
{
var context = (ProcessingContext)processingContext;
RequestContextFactory.Create(context.Message);
var messageString = Encoding.UTF8.GetString(context.Message.Body);
Thread.Sleep(500);
Console.WriteLine($"Thread: {Thread.CurrentThread.ManagedThreadId}");
Console.WriteLine($"Message: {messageString}");
new Other().Foo();
Console.WriteLine();
context.Channel.BasicAck(context.Message.DeliveryTag, false);
}
internal SwitchToSlave(HaIdGeneratorFactory idGeneratorFactory, Monitors monitors, RequestContextFactory requestContextFactory, DelegateInvocationHandler <Master> masterDelegateHandler, ClusterMemberAvailability clusterMemberAvailability, MasterClientResolver masterClientResolver, Monitor monitor, PullerFactory pullerFactory, UpdatePuller updatePuller, System.Func <Slave, SlaveServer> slaveServerFactory, Config config, LogService logService, PageCache pageCache, DatabaseLayout databaseLayout, System.Func <TransactionIdStore> transactionIdStoreSupplier, System.Func <DatabaseTransactionStats> transactionStatsSupplier, System.Func <NeoStoreDataSource> neoDataSourceSupplier, StoreCopyClient storeCopyClient)
{
this._idGeneratorFactory = idGeneratorFactory;
this.Monitors = monitors;
this.RequestContextFactory = requestContextFactory;
this._masterDelegateHandler = masterDelegateHandler;
this._clusterMemberAvailability = clusterMemberAvailability;
this._masterClientResolver = masterClientResolver;
this.UserLog = logService.GetUserLog(this.GetType());
this.MsgLog = logService.GetInternalLog(this.GetType());
this.Monitor = monitor;
this._updatePullerFactory = pullerFactory;
this.UpdatePuller = updatePuller;
this._slaveServerFactory = slaveServerFactory;
this.Config = config;
this.PageCache = pageCache;
this.DatabaseLayout = databaseLayout;
this._transactionIdStoreSupplier = transactionIdStoreSupplier;
this._transactionStatsSupplier = transactionStatsSupplier;
this._neoDataSourceSupplier = neoDataSourceSupplier;
this._storeCopyClient = storeCopyClient;
}
public AbstractTokenCreator build(Master master, RequestContextFactory requestContextFactory)
{
return(new SlaveRelationshipTypeCreator(master, requestContextFactory));
}
public void TearDown()
{
if (_datapackageServiceStub != null)
{
_datapackageServiceStub.Dispose();
_datapackageServiceStub = null;
}
if (_requestManager != null)
{
_requestManager.Dispose();
_requestManager = null;
}
foreach (ServiceHost service in new ServiceHost[] { _hostVehicleInfoService, _hostFileTransferService, _hostIdentificationService, _hostNotificationService, _hostTrainDataPackageService })
{
if (service == null)
{
continue;
}
if (service.State == CommunicationState.Faulted)
{
service.Abort();
}
service.Close();
}
if (_vehicleInfoServiceStub != null)
{
_vehicleInfoServiceStub.Dispose();
}
if (_baselineStatusUpdater != null)
{
_baselineStatusUpdater.Dispose();
}
_hostIdentificationService = null;
_hostFileTransferService = null;
_hostVehicleInfoService = null;
_hostNotificationService = null;
_hostTrainDataPackageService = null;
_fileTransferServiceStub = null;
_identificationServiceStub = null;
_vehicleInfoServiceStub = null;
_notificationServiceStub = null;
_trainDataPackageServiceStub = null;
_baselineStatusUpdater = null;
DataPackageService.Uninitialize();
T2GManagerContainer.T2GManager = null;
_t2gManager = null;
_sessionManager = null;
_requestFactory = null;
if (_dataStoreServiceStub != null)
{
_dataStoreServiceStub.Dispose();
_dataStoreServiceStub = null;
}
_remoteDataStoreFactoryMock = null;
TestContext currentContext = TestContext.CurrentContext;
Console.Out.WriteLine("===================================");
Console.Out.WriteLine("END TEST {0}", currentContext.Test.Name);
Console.Out.WriteLine("===================================");
}
/// <summary>
/// Executes the operations associated with the cmdlet.
/// </summary>
public override void ExecuteCmdlet()
{
Scheduler.RunTask(async() =>
{
IPartner partner = await PartnerSession.Instance.ClientFactory.CreatePartnerOperationsAsync(CorrelationId, CancellationToken).ConfigureAwait(false);
if (ParameterSetName.Equals("ByUserId", StringComparison.InvariantCultureIgnoreCase))
{
CustomerUser customerUser = await partner.Customers[CustomerId].Users[UserId].GetAsync(CancellationToken).ConfigureAwait(false);
WriteObject(new PSCustomerUser(customerUser));
}
else if (ParameterSetName.Equals("ByUserState", StringComparison.InvariantCultureIgnoreCase) && ReturnDeletedUsers.ToBool())
{
SimpleFieldFilter filter = new SimpleFieldFilter("UserState", FieldFilterOperation.Equals, "Inactive");
IQuery simpleQueryWithFilter = QueryFactory.BuildSimpleQuery(filter);
IResourceCollectionEnumerator <SeekBasedResourceCollection <CustomerUser> > usersEnumerator;
List <CustomerUser> users;
SeekBasedResourceCollection <CustomerUser> seekUsers;
users = new List <CustomerUser>();
seekUsers = await partner.Customers[CustomerId].Users.QueryAsync(simpleQueryWithFilter, CancellationToken).ConfigureAwait(false);
usersEnumerator = partner.Enumerators.CustomerUsers.Create(seekUsers);
while (usersEnumerator.HasValue)
{
users.AddRange(usersEnumerator.Current.Items);
await usersEnumerator.NextAsync(RequestContextFactory.Create(CorrelationId), CancellationToken).ConfigureAwait(false);
}
WriteObject(users.Select(u => new PSCustomerUser(u)), true);
}
else if (ParameterSetName.Equals("ByUpn", StringComparison.InvariantCultureIgnoreCase))
{
GraphServiceClient client = PartnerSession.Instance.ClientFactory.CreateGraphServiceClient() as GraphServiceClient;
client.AuthenticationProvider = new GraphAuthenticationProvider(CustomerId);
Graph.User user = await client.Users[UserPrincipalName].Request().GetAsync(CancellationToken).ConfigureAwait(false);
CustomerUser customerUser = await partner.Customers[CustomerId].Users[user.Id].GetAsync(CancellationToken).ConfigureAwait(false);
WriteObject(customerUser);
}
else
{
IResourceCollectionEnumerator <SeekBasedResourceCollection <CustomerUser> > usersEnumerator;
List <CustomerUser> users;
SeekBasedResourceCollection <CustomerUser> seekUsers;
users = new List <CustomerUser>();
seekUsers = await partner.Customers[CustomerId].Users.GetAsync(CancellationToken).ConfigureAwait(false);
usersEnumerator = partner.Enumerators.CustomerUsers.Create(seekUsers);
while (usersEnumerator.HasValue)
{
users.AddRange(usersEnumerator.Current.Items);
await usersEnumerator.NextAsync(RequestContextFactory.Create(CorrelationId), CancellationToken).ConfigureAwait(false);
}
WriteObject(users.Select(u => new PSCustomerUser(u)), true);
}
}, true);
}
public AbstractTokenCreatorAnonymousInnerClass(Master master, RequestContextFactory requestContextFactory) : base(master, requestContextFactory)
{
}
/// <summary>
/// Builds a <see cref="IPartner" /> instance and configures it using the provided partner credentials.
/// </summary>
/// <param name="credentials">The partner credentials. Use the extensions to obtain these.</param>
/// <param name="httpClient">The client used to perform HTTP operations.</param>
/// <returns>A configured partner object.</returns>
public IPartner Build(IPartnerCredentials credentials, HttpClient httpClient)
{
return(new PartnerOperations(credentials, RequestContextFactory.Create(), httpClient));
}
public AbstractTokenCreator build(Master master, RequestContextFactory requestContextFactory)
{
return(new SlavePropertyTokenCreator(master, requestContextFactory));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Before public void setUp()
public virtual void SetUp()
{
_requestContextFactory = new RequestContextFactory(1, singleton(mock(typeof(TransactionIdStore))));
_master = mock(typeof(Master));
_databaseAvailabilityGuard = new DatabaseAvailabilityGuard(DEFAULT_DATABASE_NAME, Clocks.systemClock(), Instance);
}
/// <summary>
/// Builds a <see cref="IPartner" /> instance and configures it using the provided partner credentials.
/// </summary>
/// <param name="credentials">The partner credentials. Use the extensions to obtain these.</param>
/// <param name="handlers">List of handlers from top to bottom (outer handler is the first in the list).</param>
/// <returns>A configured partner object.</returns>
public IPartner Build(IPartnerCredentials credentials, params DelegatingHandler[] handlers)
{
return(new PartnerOperations(credentials, RequestContextFactory.Create(), handlers));
}