/// <summary>
/// Start the service
/// </summary>
public bool Start()
{
this.Starting?.Invoke(this, EventArgs.Empty);
// Get configuration
this.m_configuration = ApplicationContext.Current.Configuration.GetSection <SynchronizationConfigurationSection>();
this.m_threadPool = ApplicationContext.Current.GetService <IThreadPoolService>();
this.m_integrationService = ApplicationContext.Current.GetService <IClinicalIntegrationService>();
this.m_networkInfoService = ApplicationContext.Current.GetService <INetworkInformationService>();
this.m_networkInfoService.NetworkStatusChanged += (o, e) => this.Pull(SynchronizationPullTriggerType.OnNetworkChange);
this.m_tracer.TraceInfo("Performing OnStart trigger pull...");
this.Pull(SynchronizationPullTriggerType.OnStart);
// Polling
if (this.m_configuration.SynchronizationResources.Any(o => (o.Triggers & SynchronizationPullTriggerType.PeriodicPoll) != 0) &&
this.m_configuration.PollInterval != default(TimeSpan))
{
Action <Object> pollFn = null;
pollFn = _ =>
{
this.Pull(SynchronizationPullTriggerType.PeriodicPoll);
ApplicationContext.Current.GetService <IThreadPoolService>().QueueUserWorkItem(this.m_configuration.PollInterval, pollFn, null);
};
ApplicationContext.Current.GetService <IThreadPoolService>().QueueUserWorkItem(this.m_configuration.PollInterval, pollFn, null);
}
this.Started?.Invoke(this, EventArgs.Empty);
return(true);
}
/// <summary>
/// Data policy filter service with DI
/// </summary>
public DataPolicyFilterService(IConfigurationManager configurationManager, IPasswordHashingService passwordService, IPolicyDecisionService pdpService, IThreadPoolService threadPoolService,
IDataCachingService dataCachingService, ISubscriptionExecutor subscriptionExecutor = null, IAdhocCacheService adhocCache = null)
{
this.m_hasher = passwordService;
this.m_adhocCache = adhocCache;
this.m_pdpService = pdpService;
this.m_subscriptionExecutor = subscriptionExecutor;
this.m_dataCachingService = dataCachingService;
this.m_threadPool = threadPoolService;
// Configuration load
this.m_configuration = configurationManager.GetSection <DataPolicyFilterConfigurationSection>();
if (this.m_configuration == null)
{
this.m_tracer.TraceWarning("No data policy configuration exists. Setting all to HIDE");
this.m_configuration = new DataPolicyFilterConfigurationSection()
{
DefaultAction = ResourceDataPolicyActionType.Hide, Resources = new List <ResourceDataPolicyFilter>()
};
}
if (this.m_configuration.Resources != null)
{
foreach (var t in this.m_configuration.Resources)
{
if (typeof(Act).IsAssignableFrom(t.ResourceType.Type) || typeof(Entity).IsAssignableFrom(t.ResourceType.Type) || typeof(AssigningAuthority).IsAssignableFrom(t.ResourceType.Type))
{
this.m_tracer.TraceInfo("Binding privacy action {0} to {1}", t.Action, t.ResourceType.Type);
this.m_actions.TryAdd(t.ResourceType.Type, t);
}
}
}
}
/// <summary>
/// Create a new job manager service
/// </summary>
public DefaultJobManagerService(IThreadPoolService threadPool, IServiceManager serviceManager, IJobStateManagerService jobStateManager = null, IJobScheduleManager cronTabManager = null)
{
this.m_threadPool = threadPool;
this.m_jobScheduleManager = cronTabManager ?? new XmlFileJobScheduleManager();
this.m_jobStateManager = jobStateManager ?? new XmlFileJobStateManager();
this.m_serviceManager = serviceManager;
}
/// <summary>
/// Thread pool performance probe
/// </summary>
public ThreadPoolPerformanceProbe(IThreadPoolService threadPoolService)
{
this.m_performanceCounters = new IDiagnosticsProbe[]
{
new PoolConcurrencyProbe(threadPoolService),
new PooledWorkersProbe(threadPoolService),
new QueueDepthProbe(threadPoolService)
};
}
/// <summary>
/// Creates a new entity merger service
/// </summary>
public MdmEntityMerger(IDataPersistenceService <Bundle> batchService, IThreadPoolService threadPool, IPolicyEnforcementService policyEnforcement, IStoredQueryDataPersistenceService <TEntity> persistenceService, IFastQueryDataPersistenceService <EntityRelationship> relationshipPersistence)
{
this.m_dataManager = MdmDataManagerFactory.GetDataManager <TEntity>();
this.m_batchPersistence = batchService;
this.m_pepService = policyEnforcement;
this.m_entityPersistence = persistenceService;
this.m_relationshipPersistence = relationshipPersistence;
this.m_threadPool = threadPool;
if (this.m_relationshipPersistence is IReportProgressChanged irpc)
{
irpc.ProgressChanged += (o, e) => this.ProgressChanged?.Invoke(o, e); // pass through progress reports
}
}
/// <summary>
/// Start the service
/// </summary>
public bool Start()
{
this.Starting?.Invoke(this, EventArgs.Empty);
// Get configuration
this.m_configuration = ApplicationContext.Current.Configuration.GetSection <SynchronizationConfigurationSection>();
this.m_threadPool = ApplicationContext.Current.GetService <IThreadPoolService>();
this.m_integrationService = ApplicationContext.Current.GetService <IClinicalIntegrationService>();
this.m_networkInfoService = ApplicationContext.Current.GetService <INetworkInformationService>();
this.m_networkInfoService.NetworkStatusChanged += (o, e) => this.Pull(SynchronizationPullTriggerType.OnNetworkChange);
// Notification for tickles when the pull is completed
this.PullCompleted += (o, e) =>
{
if (e.Type == null) // general pull complete
{
ApplicationContext.Current.SetProgress(Strings.locale_idle, 1.0f);
var tickleService = ApplicationContext.Current.GetService <ITickleService>();
if (e.IsInitial)
{
tickleService.SendTickle(
new Tickler.Tickle(Guid.Empty, Tickler.TickleType.Task | Tickler.TickleType.Toast, Strings.locale_sync_initial, DateTime.Now.Add(this.m_configuration.PollInterval))
);
}
else
{
tickleService.SendTickle(
new Tickler.Tickle(Guid.Empty, Tickler.TickleType.Task | Tickler.TickleType.Toast, Strings.locale_sync_complete, DateTime.Now.Add(this.m_configuration.PollInterval))
);
}
}
};
ApplicationServiceContext.Current.Started += (xo, xe) =>
{
try
{
this.m_tracer.TraceInfo("Performing OnStart trigger pull...");
this.Pull(SynchronizationPullTriggerType.OnStart);
// Polling
if (this.m_configuration.SynchronizationResources.Any(o => (o.Triggers & SynchronizationPullTriggerType.PeriodicPoll) != 0) &&
this.m_configuration.PollInterval != default(TimeSpan))
{
var jms = ApplicationServiceContext.Current.GetService <IJobManagerService>();
var jsms = ApplicationServiceContext.Current.GetService <IJobStateManagerService>();
var job = new RemoteSynchronizationJob(this, jsms);
jms.AddJob(job, JobStartType.DelayStart);
jms.SetJobSchedule(job, this.m_configuration.PollInterval);
}
}
catch (Exception)
{
this.m_tracer.TraceError("Error starting remote sync service: {0}");
}
};
this.Started?.Invoke(this, EventArgs.Empty);
return(true);
}
/// <summary>
/// ADO freetext constructor
/// </summary>
public AdoFreetextSearchService(IJobManagerService jobManager, IServiceManager serviceManager, IConfigurationManager configurationManager, IThreadPoolService threadPoolService)
{
this.m_configuration = configurationManager.GetSection <AdoPersistenceConfigurationSection>();
this.m_ftiRefreshThread = new Thread(this.MonitorFreetextJob)
{
Name = "ADO.NET FullText Realtime Refresh",
IsBackground = true,
Priority = ThreadPriority.Lowest
};
this.m_ftiRefreshThread.Start();
if (this.m_configuration.Provider.GetFilterFunction("freetext") == null)
{
return; // Freetext not supported
}
var job = serviceManager.CreateInjected <AdoRebuildFreetextIndexJob>();
jobManager.AddJob(job, JobStartType.TimerOnly);
if (jobManager.GetJobSchedules(job)?.Any() != true)
{
jobManager.SetJobSchedule(job, new DayOfWeek[] { DayOfWeek.Saturday }, new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, 0, 0, 0));
}
// Subscribe to common types and events
var appServiceProvider = ApplicationServiceContext.Current;
appServiceProvider.GetService <IDataPersistenceService <Bundle> >().Inserted += (o, e) => e.Data.Item.ForEach(i => this.ReIndex(i));
appServiceProvider.GetService <IDataPersistenceService <Patient> >().Inserted += (o, e) => this.ReIndex(e.Data);
appServiceProvider.GetService <IDataPersistenceService <Provider> >().Inserted += (o, e) => this.ReIndex(e.Data);
appServiceProvider.GetService <IDataPersistenceService <Material> >().Inserted += (o, e) => this.ReIndex(e.Data);
appServiceProvider.GetService <IDataPersistenceService <ManufacturedMaterial> >().Inserted += (o, e) => this.ReIndex(e.Data);
appServiceProvider.GetService <IDataPersistenceService <Entity> >().Inserted += (o, e) => this.ReIndex(e.Data);
appServiceProvider.GetService <IDataPersistenceService <Place> >().Inserted += (o, e) => this.ReIndex(e.Data);
appServiceProvider.GetService <IDataPersistenceService <Organization> >().Inserted += (o, e) => this.ReIndex(e.Data);
appServiceProvider.GetService <IDataPersistenceService <Person> >().Inserted += (o, e) => this.ReIndex(e.Data);
appServiceProvider.GetService <IDataPersistenceService <Patient> >().Updated += (o, e) => this.ReIndex(e.Data);
appServiceProvider.GetService <IDataPersistenceService <Provider> >().Updated += (o, e) => this.ReIndex(e.Data);
appServiceProvider.GetService <IDataPersistenceService <Material> >().Updated += (o, e) => this.ReIndex(e.Data);
appServiceProvider.GetService <IDataPersistenceService <ManufacturedMaterial> >().Updated += (o, e) => this.ReIndex(e.Data);
appServiceProvider.GetService <IDataPersistenceService <Entity> >().Updated += (o, e) => this.ReIndex(e.Data);
appServiceProvider.GetService <IDataPersistenceService <Place> >().Updated += (o, e) => this.ReIndex(e.Data);
appServiceProvider.GetService <IDataPersistenceService <Organization> >().Updated += (o, e) => this.ReIndex(e.Data);
appServiceProvider.GetService <IDataPersistenceService <Person> >().Updated += (o, e) => this.ReIndex(e.Data);
appServiceProvider.Stopping += (o, e) => this.m_shutdown = true;
}
/// <summary>
/// Creates a new instance with DI
/// </summary>
public ExemptablePolicyFilterService(IConfigurationManager configManager, IPasswordHashingService passwordService, IPolicyDecisionService pdpService, IThreadPoolService threadPoolService, IDataCachingService dataCachingService, IAdhocCacheService adhocCache = null, ISubscriptionExecutor subscriptionExecutor = null)
: base(configManager, passwordService, pdpService, threadPoolService, dataCachingService, subscriptionExecutor, adhocCache)
{
}
/// <summary>
/// Starts the queue manager service.
/// </summary>
/// <returns>Returns true if the service started successfully.</returns>
public bool Start()
{
this.Starting?.Invoke(this, EventArgs.Empty);
this.m_threadPool = ApplicationContext.Current.GetService <IThreadPoolService>();
// Bind to the inbound queue
SynchronizationQueue.Inbound.Enqueued += (o, e) =>
{
// Someone already got this!
if (Monitor.IsEntered(this.m_inboundLock))
{
return;
}
Action <Object> async = (itm) =>
{
this.ExhaustInboundQueue();
};
this.m_threadPool.QueueUserWorkItem(async);
};
// Bind to outbound queue
SynchronizationQueue.Outbound.Enqueued += (o, e) =>
{
// Trigger sync?
if (e.Data.Type.StartsWith(typeof(Patch).FullName) ||
e.Data.Type.StartsWith(typeof(Bundle).FullName) ||
ApplicationContext.Current.Configuration.GetSection <SynchronizationConfigurationSection>().SynchronizationResources.
Exists(r => r.ResourceType == Type.GetType(e.Data.Type) &&
(r.Triggers & SynchronizationPullTriggerType.OnCommit) != 0))
{
Action <Object> async = (itm) =>
{
this.ExhaustOutboundQueue();
};
this.m_threadPool.QueueUserWorkItem(async);
}
};
// Bind to administration queue
SynchronizationQueue.Admin.Enqueued += (o, e) =>
{
// Admin is always pushed
this.m_threadPool.QueueUserWorkItem(a => this.ExhaustAdminQueue());
};
ApplicationContext.Current.Started += (o, e) =>
{
// startup
Action <Object> startup = (iar) =>
{
try
{
this.ExhaustOutboundQueue();
this.ExhaustInboundQueue();
this.ExhaustAdminQueue();
}
catch (Exception ex)
{
this.m_tracer.TraceError("Error executing initial queues: {0}", ex);
}
};
ApplicationContext.Current.GetService <IThreadPoolService>().QueueNonPooledWorkItem(startup, null);
};
this.Started?.Invoke(this, EventArgs.Empty);
return(true);
}
public bool Start()
{
try
{
this.Starting?.Invoke(this, EventArgs.Empty);
this.m_tracer.TraceInfo("Starting internal IMS services...");
this.m_threadPool = ApplicationContext.Current.GetService <IThreadPoolService>();
XamarinApplicationContext.Current.SetProgress("IMS Service Bus", 0);
this.m_bypassMagic = XamarinApplicationContext.Current.GetType().Name == "MiniApplicationContext";
this.m_listener = new HttpListener();
this.m_defaultViewModel = ViewModelDescription.Load(typeof(MiniImsServer).Assembly.GetManifestResourceStream("OpenIZ.Mobile.Core.Xamarin.Resources.ViewModel.xml"));
// Scan for services
try
{
foreach (var t in typeof(MiniImsServer).Assembly.DefinedTypes.Where(o => o.GetCustomAttribute <RestServiceAttribute>() != null))
{
var serviceAtt = t.GetCustomAttribute <RestServiceAttribute>();
object instance = Activator.CreateInstance(t);
foreach (var mi in t.GetRuntimeMethods().Where(o => o.GetCustomAttribute <RestOperationAttribute>() != null))
{
var operationAtt = mi.GetCustomAttribute <RestOperationAttribute>();
var faultMethod = operationAtt.FaultProvider != null?t.GetRuntimeMethod(operationAtt.FaultProvider, new Type[] { typeof(Exception) }) : null;
String pathMatch = String.Format("{0}:{1}{2}", operationAtt.Method, serviceAtt.BaseAddress, operationAtt.UriPath);
if (!this.m_services.ContainsKey(pathMatch))
{
lock (this.m_lockObject)
this.m_services.Add(pathMatch, new InvokationInformation()
{
BindObject = instance,
Method = mi,
FaultProvider = faultMethod,
Demand = (mi.GetCustomAttributes <DemandAttribute>().Union(t.GetCustomAttributes <DemandAttribute>())).Select(o => o.PolicyId).ToList(),
Anonymous = (mi.GetCustomAttribute <AnonymousAttribute>() ?? t.GetCustomAttribute <AnonymousAttribute>()) != null,
Parameters = mi.GetParameters()
});
}
}
}
}
catch (Exception e)
{
this.m_tracer.TraceWarning("Could scan for handlers : {1}", e);
}
// Get loopback
var loopback = GetLocalIpAddress();
// Core always on 9200
this.m_listener.Prefixes.Add(String.Format("http://{0}:9200/", loopback));
this.m_acceptThread = new Thread(() =>
{
// Process the request
while (this.m_listener != null)
{
try
{
//var iAsyncResult = this.m_listener.BeginGetContext(null, null);
//iAsyncResult.AsyncWaitHandle.WaitOne();
var context = this.m_listener.GetContext(); //this.m_listener.EndGetContext(iAsyncResult);
this.m_threadPool.QueueUserWorkItem(TimeSpan.MinValue, this.HandleRequest, context);
}
catch (Exception e)
{
this.m_tracer.TraceError("Listener Error: {0}", e);
}
}
});
this.m_listener.Start();
this.m_acceptThread.IsBackground = true;
this.m_acceptThread.Start();
this.m_acceptThread.Name = "MiniIMS";
this.m_tracer.TraceInfo("Started internal IMS services...");
// We have to wait for the IAppletManager service to come up or else it is pretty useless
this.Started?.Invoke(this, EventArgs.Empty);
this.m_startFinished = true;
return(true);
}
catch (Exception ex)
{
this.m_tracer.TraceError("Error starting IMS : {0}", ex);
ApplicationContext.Current.Alert(Strings.err_moreThanOneApplication);
return(false);
}
}
/// <summary>
/// Starts the queue manager service.
/// </summary>
/// <returns>Returns true if the service started successfully.</returns>
public bool Start()
{
this.Starting?.Invoke(this, EventArgs.Empty);
this.m_threadPool = ApplicationContext.Current.GetService <IThreadPoolService>();
// Bind to the inbound queue
SynchronizationQueue.Inbound.Enqueued += (o, e) =>
{
// Someone already got this!
if (Monitor.IsEntered(this.m_inboundLock))
{
return;
}
Action <Object> async = (itm) =>
{
this.ExhaustInboundQueue();
};
this.m_threadPool.QueueUserWorkItem(async);
};
// Bind to outbound queue
SynchronizationQueue.Outbound.Enqueued += (o, e) =>
{
// Trigger sync?
if (e.Data.Type.StartsWith(typeof(Patch).FullName) ||
e.Data.Type.StartsWith(typeof(Bundle).FullName) ||
ApplicationContext.Current.Configuration.GetSection <SynchronizationConfigurationSection>().SynchronizationResources.
Exists(r => r.ResourceType == Type.GetType(e.Data.Type) &&
(r.Triggers & SynchronizationPullTriggerType.OnCommit) != 0))
{
Action <Object> async = (itm) =>
{
this.ExhaustOutboundQueue();
};
this.m_threadPool.QueueUserWorkItem(async);
}
};
// Bind to administration queue
SynchronizationQueue.Admin.Enqueued += (o, e) =>
{
// Admin is always pushed
this.m_threadPool.QueueUserWorkItem(a => this.ExhaustAdminQueue());
};
ApplicationContext.Current.Started += (o, e) =>
{
// startup
Action <Object> startup = (iar) =>
{
try
{
this.ExhaustOutboundQueue();
this.ExhaustInboundQueue();
this.ExhaustAdminQueue();
}
catch (Exception ex)
{
this.m_tracer.TraceError("Error executing initial queues: {0}", ex);
}
};
ApplicationContext.Current.GetService <IThreadPoolService>().QueueNonPooledWorkItem(startup, null);
};
// Does the outbound queue have data?
int dlc = SynchronizationQueue.DeadLetter.Count();
if (dlc > 0 &&
ApplicationContext.Current.Confirm(Strings.locale_retry))
{
try
{
int i = 0;
while (SynchronizationQueue.DeadLetter.Count() > 0)
{
ApplicationContext.Current.SetProgress(Strings.locale_requeueing, ((float)i++) / (float)dlc);
var itm = SynchronizationQueue.DeadLetter.PeekRaw();
switch (itm.OriginalQueue)
{
case "inbound":
case "inbound_queue":
SynchronizationQueue.Inbound.EnqueueRaw(new InboundQueueEntry(itm));
break;
case "outbound":
case "outbound_queue":
SynchronizationQueue.Outbound.EnqueueRaw(new OutboundQueueEntry(itm));
break;
case "admin":
case "admin_queue":
SynchronizationQueue.Admin.EnqueueRaw(new OutboundAdminQueueEntry(itm));
break;
}
SynchronizationQueue.DeadLetter.Delete(itm.Id);
}
}
catch (Exception e)
{
this.m_tracer.TraceInfo("Could not re-queue items: {0}", e.Message);
}
}
this.Started?.Invoke(this, EventArgs.Empty);
return(true);
}
/// <summary>
/// Synchronized dispatch service
/// </summary>
public SynchronizedAuditDispatchService(IConfigurationManager configurationManager, IJobStateManagerService jobStateManager, IJobManagerService scheduleManager, IThreadPoolService threadPool, IQueueManagerService queueManagerService)
{
this.m_securityConfiguration = configurationManager.GetSection <SecurityConfigurationSection>();
this.m_jobStateManager = jobStateManager;
this.m_queueManagerService = queueManagerService;
if (!scheduleManager.GetJobSchedules(this).Any())
{
scheduleManager.SetJobSchedule(this, new TimeSpan(0, 5, 0));
}
threadPool.QueueUserWorkItem(_ =>
{
try
{
AuditData securityAlertData = new AuditData(DateTime.Now, ActionType.Execute, OutcomeIndicator.Success, EventIdentifierType.SecurityAlert, AuditUtil.CreateAuditActionCode(EventTypeCodes.AuditLoggingStarted));
AuditUtil.AddLocalDeviceActor(securityAlertData);
AuditUtil.SendAudit(securityAlertData);
}
catch (Exception ex)
{
this.m_tracer.TraceError("Error starting up audit repository service: {0}", ex);
}
});
}
/// <summary>
/// Non pooled workers counter
/// </summary>
public PooledWorkersProbe(IThreadPoolService threadPool) : base("Pool Use", "Shows the number of busy worker threads")
{
this.m_threadPool = threadPool;
}
/// <summary>
/// Non pooled workers counter
/// </summary>
public QueueDepthProbe(IThreadPoolService threadPool) : base("Queue Depth", "Shows the number of tasks waiting to be executed")
{
this.m_threadPool = threadPool;
}
/// <summary>
/// Non pooled workers counter
/// </summary>
public PoolConcurrencyProbe(IThreadPoolService threadPool) : base("Thread pool size", "Shows the total number of threads which are allocated to the thread pool")
{
this.m_threadPool = threadPool;
}
/// <summary>
/// Creates a new local job manager
/// </summary>
public LocalJobManagerService(IThreadPoolService threadPool, IServiceManager serviceManager, IJobStateManagerService jobStateManager = null, IJobScheduleManager cronTabManager = null) : base(threadPool, serviceManager, jobStateManager, cronTabManager)
{
}
