protected virtual IInjectorService CreateInjectorClient(DirectoryServer server, IDirectoryProvider directory)
{
IInjectorService result;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
InjectorClient injectorClient = InjectorClient.Create(server.Fqdn, directory, this.logger);
disposeGuard.Add <InjectorClient>(injectorClient);
bool flag = true;
IInjectorService injectorService = injectorClient;
if (!injectorClient.ServerVersion[1])
{
flag = false;
injectorService = this.CreateCompatibilityInjectorClient(server);
}
if (!injectorClient.ServerVersion[2])
{
injectorService = new ConsumerMetricsInjectorCapabilityDecorator(injectorService);
}
if (flag)
{
disposeGuard.Success();
}
result = injectorService;
}
return(result);
}
public RemoteInterfaceProtocolActor(ILogService logService, IRIPService rip, IInjectorService injector)
{
_log = logService.GetContextLogger <RemoteInterfaceProtocolActor>();
_rip = rip;
_injector = injector;
RegisterReceivers();
}
public ConfigActor(IInjectorService injector)
{
_log = injector.GetService <ILogService>()
.GetContextLogger <ConfigActor>();
_config = injector.GetService <IConfigService>();
ReceiveAsync <DirectoryWatchConfig>(OnConfig);
}
public ScanActor(IInjectorService injector)
{
_log = injector.GetService <ILogService>()
.GetContextLogger <ScanActor>();
_eventService = injector.GetService <IEventService>();
Receive <ScanDirectory>(OnScanDirectory);
}
public WatchActor(IInjectorService injector, FolderToWatch folder)
{
_log = injector.GetService <ILogService>()
.GetContextLogger <WatchActor>();
_eventService = injector.GetService <IEventService>();
_folder = folder;
StartWatcher(folder.FolderPath);
}
public PluginService(IInjectorService injector, ILogService logService)
{
_injector = injector;
_loader = new AssemblyLoader(logService);
_pending = new SynchronizedCollection <Type>();
_ready = new List <IPlugin>();
_failed = new List <IPlugin>();
_folders = new List <DirectoryInfo>();
}
public BasePlugin(IInjectorService injector)
{
Info = BuildPluginInfo();
FullName = $"{Info.Name}[{Info.Id}]";
Injector = injector;
Logger = Injector
.GetService <ILogService>()
.GetContextLogger <T>();
EventService = Injector.GetService <IEventService>();
_subscriptions = new List <IDisposable>();
}
protected override void ProcessRequest()
{
using (OperationTracker.Create(this.logger, "Rebalancing {0} from {1} to {2}.", new object[]
{
this.rebalanceData.RebalanceInformation,
this.rebalanceData.SourceDatabase,
this.rebalanceData.TargetDatabase
}))
{
this.logger.Log(MigrationEventType.Information, "MOVE: Moving {0} from {1} to {2}.", new object[]
{
this.rebalanceData.RebalanceInformation,
this.rebalanceData.SourceDatabase,
this.rebalanceData.TargetDatabase
});
Band[] bands = this.rebalanceData.RebalanceInformation.Metrics.OfType <Band>().ToArray <Band>();
TopologyExtractorFactory entitySelectorFactory = this.serviceContext.TopologyExtractorFactoryContextPool.GetContext(this.clientFactory, bands, this.nonMovableOrgs, this.logger).GetEntitySelectorFactory();
DirectoryDatabase database = this.directoryProvider.GetDatabase(this.rebalanceData.SourceDatabase.Guid);
LoadContainer container = entitySelectorFactory.GetExtractor(database).ExtractTopology();
IOperationRetryManager operationRetryManager = LoadBalanceOperationRetryManager.Create(this.logger);
foreach (LoadMetric loadMetric in this.rebalanceData.RebalanceInformation.Metrics)
{
EntitySelector selector = loadMetric.GetSelector(container, this.rebalanceData.ConstraintSetIdentity, this.rebalanceData.RebalanceInformation[loadMetric]);
if (selector.IsEmpty)
{
this.logger.Log(MigrationEventType.Information, "Could not find any mailbox for metric {0} in database {1}.", new object[]
{
loadMetric,
this.rebalanceData.SourceDatabase
});
}
else
{
this.logger.Log(MigrationEventType.Information, "Found mailboxes matching the metric {0} in database {1}. Requesting the injections.", new object[]
{
loadMetric,
this.rebalanceData.SourceDatabase
});
operationRetryManager.TryRun(delegate
{
DirectoryDatabase database2 = (DirectoryDatabase)this.directoryProvider.GetDirectoryObject(this.rebalanceData.TargetDatabase.DirectoryObjectIdentity);
using (IInjectorService injectorClientForDatabase = this.clientFactory.GetInjectorClientForDatabase(database2))
{
injectorClientForDatabase.InjectMoves(this.rebalanceData.TargetDatabase.Guid, this.rebalanceData.RebalanceBatchName, selector.GetEntities(this.rebalanceData.TargetDatabase));
}
});
}
}
}
}
public MopHost(HostProperties p, MopLifeService life, IInjectorService injector)
{
if (p.DataDirectory is null)
{
throw new ArgumentNullException("Data directory is null");
}
if (p.TempDirectory is null)
{
throw new ArgumentNullException("Temp directory is null");
}
Info = BuildHostInfo(p.Id, p.Name);
DataDirectory = new DirectoryInfo(p.DataDirectory);
TempDirectory = new DirectoryInfo(p.TempDirectory);
_lifeHandler = life;
_injector = injector;
}
public virtual void InjectMoveForMailbox(DirectoryMailbox mailbox, BatchName batchName)
{
if (LoadBalanceADSettings.Instance.Value.UseDatabaseSelectorForMoveInjection)
{
LoadEntity loadEntity = this.serviceContext.GetTopologyExtractorFactoryContext().GetEntitySelectorFactory().GetExtractor(mailbox).ExtractEntity();
MailboxProvisioningResult database = this.databaseSelector.GetDatabase(new MailboxProvisioningData(mailbox.PhysicalSize, mailbox.MailboxProvisioningConstraints, loadEntity.ConsumedLoad));
database.ValidateSelection();
DirectoryIdentity database2 = database.Database;
DirectoryDatabase database3 = (DirectoryDatabase)this.directoryProvider.GetDirectoryObject(database2);
using (IInjectorService injectorClientForDatabase = this.clientFactory.GetInjectorClientForDatabase(database3))
{
injectorClientForDatabase.InjectSingleMove(database2.Guid, batchName.ToString(), new LoadEntity(mailbox));
return;
}
}
IRequest request = mailbox.CreateRequestToMove(null, batchName.ToString(), this.logger);
this.queueManager.MainProcessingQueue.EnqueueRequest(request);
}
public SupervisorActor(IInjectorService injector, DirectoryWatchConfig config)
{
_injector = injector;
_config = config;
_watchActors = new();
_configActor = CreateConfigActor();
_scanActor = CreateScanActor();
_supportedTypes = new string[]
{ AddWatchDirectory, RemoveWatchDirectory, DirectoryScan };
_log = injector.GetService <ILogService>()
.GetContextLogger <SupervisorActor>();
foreach (var d in config.Directories)
{
StartWatchActor(d);
}
Receive <IEvent>(OnEvent);
}
protected MissingCapabilityInjectorClientDecorator(IInjectorService service)
{
this.service = service;
}
public BaseActorPlugin(IInjectorService injector) : base(injector)
{
}
public RemoteInterfaceProtocolPlugin(IInjectorService injector) : base(injector)
{
_rip = Injector.GetService <IRIPService>();
Injector.RegisterService <HelperService>(LifeCycle.Singleton);
_rip.Register <HelperService>();
}
public DirectoryWatchPlugin(IInjectorService injector) : base(injector)
{
}
public CachedInjectorClient(IInjectorService client) : base(client as IWcfClient)
{
this.client = client;
}
public AssemblyResolver(IPluginService pluginService, IInjectorService injector)
{
_pluginService = pluginService;
_injector = injector;
}
public PingPlugin(IInjectorService injector) : base(injector)
{
_log = injector.GetService <ILogService>();
RegisterRoles("ping");
}
public ConsumerMetricsInjectorCapabilityDecorator(IInjectorService service) : base(service)
{
}
