public IoTHubSink(SubscriptionMetadata metadata, ILog logger = null) : base(metadata, logger) { auditor = AuditFactory.CreateSingleton().GetAuditor(AuditType.Message); uri = new Uri(metadata.NotifyAddress); NameValueCollection nvc = HttpUtility.ParseQueryString(uri.Query); string keyName = nvc["keyname"]; deviceId = nvc["deviceid"]; methodName = nvc["method"]; propertyName = nvc["propname"]; propertyValue = nvc["propvalue"]; if (string.IsNullOrEmpty(methodName)) { deviceClient = DeviceClient.CreateFromConnectionString(string.Format( "HostName={0};DeviceId={1};SharedAccessKey={2}", uri.Authority, deviceId, metadata.SymmetricKey)); } else { serviceClient = ServiceClient.CreateFromConnectionString(string.Format( "HostName={0};SharedAccessKeyName={1};SharedAccessKey={2}", uri.Authority, keyName, metadata.SymmetricKey)); } }
public override void Init() { Trace.TraceInformation("{0} - MQTT Protocol Adapter intialization on Channel '{1}'.", DateTime.UtcNow.ToString("yyyy-MM-ddTHH-MM-ss.fffff"), Channel.Id); auditFactory = AuditFactory.CreateSingleton(); if (config.AuditConnectionString != null && config.AuditConnectionString.Contains("DefaultEndpointsProtocol")) { auditFactory.Add(new AzureTableAuditor(config.AuditConnectionString, "messageaudit"), AuditType.Message); auditFactory.Add(new AzureTableAuditor(config.AuditConnectionString, "useraudit"), AuditType.User); } else if (config.AuditConnectionString != null) { auditFactory.Add(new FileAuditor(config.AuditConnectionString), AuditType.Message); auditFactory.Add(new FileAuditor(config.AuditConnectionString), AuditType.User); } messageAuditor = auditFactory.GetAuditor(AuditType.Message); userAuditor = auditFactory.GetAuditor(AuditType.User); forcePerReceiveAuthn = Channel as UdpChannel != null; session.OnPublish += Session_OnPublish; session.OnSubscribe += Session_OnSubscribe; session.OnUnsubscribe += Session_OnUnsubscribe; session.OnDisconnect += Session_OnDisconnect;; session.OnConnect += Session_OnConnect; logger?.LogInformation($"MQTT adpater on channel '{Channel.Id}' is initialized."); }
public EventGridSink(SubscriptionMetadata metadata) : base(metadata) { auditor = AuditFactory.CreateSingleton().GetAuditor(AuditType.Message); uri = new Uri(metadata.NotifyAddress); NameValueCollection nvc = HttpUtility.ParseQueryString(uri.Query); topicHostname = uri.Authority; topicKey = metadata.SymmetricKey; string uriString = new Uri(metadata.SubscriptionUriString).ToString(); resourceUriString = uriString.Replace("/" + uri.Segments[uri.Segments.Length - 1], ""); if (!int.TryParse(nvc["clients"], out clientCount)) { clientCount = 1; } ServiceClientCredentials credentials = new TopicCredentials(topicKey); clients = new EventGridClient[clientCount]; for (int i = 0; i < clientCount; i++) { clients[i] = new EventGridClient(credentials); } }
public override void Init() { auditFactory = AuditFactory.CreateSingleton(); if (config.AuditConnectionString != null && config.AuditConnectionString.Contains("DefaultEndpointsProtocol")) { auditFactory.Add(new AzureTableAuditor(config.AuditConnectionString, "messageaudit"), AuditType.Message); auditFactory.Add(new AzureTableAuditor(config.AuditConnectionString, "useraudit"), AuditType.User); } else if (config.AuditConnectionString != null) { auditFactory.Add(new FileAuditor(config.AuditConnectionString), AuditType.Message); auditFactory.Add(new FileAuditor(config.AuditConnectionString), AuditType.User); } messageAuditor = auditFactory.GetAuditor(AuditType.Message); userAuditor = auditFactory.GetAuditor(AuditType.User); logger?.LogDebugAsync("MQTT adapter audit factory added.").GetAwaiter(); forcePerReceiveAuthn = Channel as UdpChannel != null; session.OnPublish += Session_OnPublish; session.OnSubscribe += Session_OnSubscribe; session.OnUnsubscribe += Session_OnUnsubscribe; session.OnDisconnect += Session_OnDisconnect; ; session.OnConnect += Session_OnConnect; logger?.LogInformationAsync($"MQTT adpater on channel '{Channel.Id}' is initialized.").GetAwaiter(); }
public static ClientConnection Connection(MetlConfiguration config,Credentials creds,IAuditor auditor) { return auditor.wrapFunction(((auditAction) => { var webCreds = new NetworkCredential(creds.name, creds.password); auditAction(GaugeStatus.InProgress,7); //var jabberCreds = new Credentials(config.xmppUsername, config.xmppPassword,new List<AuthorizedGroup>(),""); var wcf = new WebClientFactory(webCreds,auditor,creds); auditAction(GaugeStatus.InProgress,14); var receiveEvents = new ProductionReceiveEvents(auditor); auditAction(GaugeStatus.InProgress,21); var authProvider = new AuthorisationProvider(wcf, config,auditor); auditAction(GaugeStatus.InProgress,28); var httpProvider = new HttpResourceProvider(wcf,auditor); auditAction(GaugeStatus.InProgress,35); var resourceUploaderFactory = new ProductionResourceUploaderFactory(config, httpProvider,auditor); auditAction(GaugeStatus.InProgress,42); var resourceUploader = resourceUploaderFactory.get(); auditAction(GaugeStatus.InProgress,49); var resourceCache = new ResourceCache(); auditAction(GaugeStatus.InProgress,56); var configurationProvider = new ConfigurationProvider(wcf,auditor); auditAction(GaugeStatus.InProgress,63); auditAction(GaugeStatus.InProgress,70); var jabberWireFactory = new JabberWireFactory(config, creds, configurationProvider,resourceUploader,resourceCache, receiveEvents, wcf, httpProvider,auditor); auditAction(GaugeStatus.InProgress,77); var userOptionsProvider = new UserOptionsProvider(config, httpProvider, resourceUploader); auditAction(GaugeStatus.InProgress,84); var cc = new ClientConnection(config, receiveEvents, authProvider, resourceUploader, jabberWireFactory.conversationDetailsProvider, resourceCache, jabberWireFactory, wcf, userOptionsProvider, httpProvider,auditor); auditAction(GaugeStatus.InProgress, 91); return cc; }), "create client connection", "backend"); }
public XmlSnippetsRedeployer(IAuditor auditor, Directories directories, FileInfo snippets, FileInfo script) { this.Auditor = auditor; this.Directories = directories; this.Snippets = snippets; this.Script = script; }
public RedisSink(SubscriptionMetadata metadata, ILog logger = null) : base(metadata, logger) { tqueue = new TaskQueue(); cqm = new ConcurrentQueueManager(); auditor = AuditFactory.CreateSingleton().GetAuditor(AuditType.Message); uri = new Uri(metadata.NotifyAddress); connectionString = $"{uri.Authority}:6380,password={metadata.SymmetricKey},ssl=True,abortConnect=False"; NameValueCollection nvc = HttpUtility.ParseQueryString(uri.Query); if (!int.TryParse(nvc["db"], out dbNumber)) { dbNumber = -1; } if (TimeSpan.TryParse(nvc["expiry"], out TimeSpan expiration)) { expiry = expiration; } if (string.IsNullOrEmpty(metadata.ClaimKey)) { cacheClaimType = metadata.ClaimKey; } connection = ConnectionMultiplexer.ConnectAsync(connectionString).GetAwaiter().GetResult(); database = connection.GetDatabase(dbNumber); }
public void Initialize(IAuditor auditor) { var assemblies = AppDomain.CurrentDomain.GetAssemblies(); m_Assemblies.Add(assemblies.First(a => a.Location.Contains("UnityEngine.dll"))); m_Assemblies.Add(assemblies.First(a => a.Location.Contains("UnityEditor.dll"))); // UnityEditor m_ProjectSettingsMapping.Add(new KeyValuePair <string, string>("UnityEditor.PlayerSettings", "Project/Player")); m_ProjectSettingsMapping.Add( new KeyValuePair <string, string>("UnityEditor.Rendering.EditorGraphicsSettings", "Project/Graphics")); // UnityEngine m_ProjectSettingsMapping.Add(new KeyValuePair <string, string>("UnityEngine.Physics", "Project/Physics")); m_ProjectSettingsMapping.Add( new KeyValuePair <string, string>("UnityEngine.Physics2D", "Project/Physics 2D")); m_ProjectSettingsMapping.Add(new KeyValuePair <string, string>("UnityEngine.Time", "Project/Time")); m_ProjectSettingsMapping.Add(new KeyValuePair <string, string>("UnityEngine.QualitySettings", "Project/Quality")); m_ProblemDescriptors = ProblemDescriptorLoader.LoadFromJson(ProjectAuditor.DataPath, "ProjectSettings"); foreach (var descriptor in m_ProblemDescriptors) { auditor.RegisterDescriptor(descriptor); } }
public AzureQueueStorageSink(SubscriptionMetadata metadata, ILog logger = null) : base(metadata, logger) { loadQueue = new ConcurrentQueue <EventMessage>(); auditor = AuditFactory.CreateSingleton().GetAuditor(AuditType.Message); uri = new Uri(metadata.NotifyAddress); NameValueCollection nvc = HttpUtility.ParseQueryString(uri.Query); queue = nvc["queue"]; string ttlString = nvc["ttl"]; if (!string.IsNullOrEmpty(ttlString)) { ttl = TimeSpan.Parse(ttlString); } Uri.TryCreate(metadata.SymmetricKey, UriKind.Absolute, out Uri sasUri); if (sasUri == null) { storage = QueueStorage.New( $"DefaultEndpointsProtocol=https;AccountName={uri.Authority.Split(new[] { '.' })[0]};AccountKey={metadata.SymmetricKey};", 10000, 1000); } else { string connectionString = $"BlobEndpoint={queue};SharedAccessSignature={metadata.SymmetricKey}"; storage = QueueStorage.New(connectionString, 1000, 5120000); } }
/// <summary> /// Invokes a given function and provides error handling and auditing in case the method causes /// an exception. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="auditor"></param> /// <param name="context"></param> /// <param name="func"></param> /// <param name="errorMessage"></param> /// <returns></returns> public static T SecureFunc <T>(IAuditor auditor, FileSystemTask context, Func <T> func, Func <string> errorMessage) { try { return(func()); } // catch (FaultException<ResourceFault> e) // { // throw; //TODO provide implementation // } // catch (FaultException e) // { // //unwrap exception details // throw; //TODO provide implementation // } // catch (CommunicationException e) // { // throw; //TODO provide implementation // } catch (VfsException e) { //just audit and rethrow VFS exceptions auditor.AuditException(e, context); throw; } catch (Exception e) { //wrap unhandled exception into VFS exception var exception = new ResourceAccessException(errorMessage(), e); auditor.AuditException(exception, context); throw exception; } }
/// <summary> /// Invokes a given function and provides error handling and auditing in case the method causes /// an exception. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="auditor"></param> /// <param name="context"></param> /// <param name="func"></param> /// <param name="errorMessage"></param> /// <returns></returns> public static T SecureFunc <T>(IAuditor auditor, FileSystemTask context, Func <T> func, Func <string> errorMessage) { try { return(func()); } catch (VfsFaultException e) { //audit as warning - the error has been properly handled by the service VfsFault fault = e.Fault; auditor.AuditException(e, AuditLevel.Warning, context, AuditEvent.Unknown, fault.CreateFaultMessage()); //create a matching exception based on the fault type throw fault.ToException(); } catch (VfsException e) { //just audit and rethrow VFS exceptions auditor.AuditException(e, context); throw; } catch (Exception e) { //wrap unhandled exception into VFS exception var exception = new ResourceAccessException(errorMessage(), e); auditor.AuditException(exception, context); throw exception; } }
public static Option <Directories> TryCreateDestinationIn(IAuditor auditor, DirectoryInfo destination, DirectoryInfo source) { int repeats = 10; int pauseMsec = 100; while (repeats > 0) { try { if (TryCreate(destination) is Some <DirectoryInfo> created) { Empty(created); return(new Directories(source, created)); } repeats -= 1; Thread.Sleep(pauseMsec); } catch (Exception ex) { auditor.FailedToCreateDestination(ex.Message); return(None.Value); } } return(None.Value); }
public ClientController(IEligibilityService eligibilityService, IQuestionRepository questionRepository, IEmailService emailService, IAuditor auditor, IUser currentUser) { this._eligibilityService = eligibilityService; this._questionRepository = questionRepository; _emailService = emailService; _auditor = auditor; _currentUser = currentUser; }
public IndexModel(tt_apps_srs_db_context db, IClientProvider clientProvider, IAuditor auditor) { _db = db; _clientProvider = clientProvider; _auditor = auditor; }
public AttorneyController(IEmailService emailService, ISecurityService security, IRepositoryFactory repositories, IUser currentUser, IAuditor auditor) { _emailService = emailService; _security = security; _repositories = repositories; _currentUser = currentUser; _auditor = auditor; }
public WebHookSink(SubscriptionMetadata metadata, ILog logger) : base(metadata, logger) { this.logger = logger; auditor = AuditFactory.CreateSingleton().GetAuditor(AuditType.Message); address = new Uri(metadata.NotifyAddress).ToString(); }
/// <summary> /// Initialize Objects /// </summary> private void InitializeObjects() { IConfiguration configuration = (AzureConfig)Utils.Configuration; this.DbSyncManager = configuration.CurrentContainer.Resolve <IDBSyncManager>(); this.Logger = configuration.CurrentContainer.Resolve <ILogger>(); this.Auditor = configuration.CurrentContainer.Resolve <IAuditor>(); }
/// <summary> /// Initializes a new instance of the <see cref="PipelineArgument"/> class. /// </summary> public PipelineArgument(IReadOnlyDictionary <string, string> propertyBag, IDocument document, IRuleSet rules, IPipelineMember successor, IAuditor auditor) { PropertyBag = propertyBag; Document = document; Rules = rules; Successor = successor; Auditor = auditor; }
public void Initialize(LunaSettingsProvider settingsProvider) { MembershipProvider = new MembershipProvider(); DatabaseProvider = new DatabaseProvider(); SettingsProvider = settingsProvider; Auditor = new Auditor(); base.Initialize(null, new CacheProvider(), DatabaseProvider, null, null); }
public static void WriteSuccess(IAuditor auditor, ApiOperationContext context) { auditor.Write(new AuditItem( Activity.Current?.Id ?? "no-activity-id", true, "Success", GetUserId(context), context.Operation)); }
/// <summary> /// Unregisters a specific auditor. /// <para /> /// If the auditor is not registered, nothing happens. /// </summary> /// <exception cref="ArgumentNullException">The <paramref name="auditor"/> is <c>null</c>.</exception> public static void UnregisterAuditor(IAuditor auditor) { Argument.IsNotNull("auditor", auditor); lock (_instance._auditors) { _instance._auditors.Remove(auditor); } }
/// <summary> /// Initializes a new instance of the <see cref="Migration"/> class. /// </summary> /// <param name="connectionFactory">The connection factory.</param> /// <param name="scriptExecutor">The script executor.</param> /// <param name="auditLog">The audit log.</param> /// <param name="batchManager">The script batch manager.</param> /// <param name="initializationScriptProvider">The script provider for scripts to run when initializing the database.</param> /// <param name="migrationScriptProvider">The script provider for scripts to run during migrations.</param> internal Migration(IConnectionFactory connectionFactory, IScriptExecutor scriptExecutor, IAuditor auditLog, IBatchManager batchManager, IScriptProvider initializationScriptProvider, IScriptProvider migrationScriptProvider) { this.connectionFactory = connectionFactory ?? throw new ArgumentNullException(nameof(connectionFactory)); this.scriptExecutor = scriptExecutor ?? throw new ArgumentNullException(nameof(scriptExecutor)); this.auditLog = auditLog ?? throw new ArgumentNullException(nameof(auditLog)); this.batchManager = batchManager ?? throw new ArgumentNullException(nameof(batchManager)); this.initializationScriptProvider = initializationScriptProvider ?? throw new ArgumentNullException(nameof(initializationScriptProvider)); this.migrationScriptProvider = migrationScriptProvider ?? throw new ArgumentNullException(nameof(migrationScriptProvider)); }
public static void WriteFailure(IAuditor auditor, ApiOperationContext context, Exception e) { auditor.Write(new AuditItem( Activity.Current?.Id ?? "no-activity-id", false, e.Message, GetUserId(context), context.Operation)); }
public override void Run() { // This is a sample worker implementation. Replace with your logic. Trace.TraceInformation("NotificationWorker entry point called"); try { IUnityContainer container = Utils.Configuration.CurrentContainer; //TODO container.LoadConfiguration(); container.RegisterType <IHttpClientManager, HttpClientManager>( new PerThreadLifetimeManager(), new InjectionConstructor(RoleEnvironment.GetConfigurationSettingValue("AuthorizationSchema"))); container.RegisterType <IWhitespacesDataClient, WhitespacesDataClient>( new InjectionConstructor(new ResolvedParameter <IHttpClientManager>())); this.auditNotificationSystem = container.Resolve <NotificationSystem>("auditTracker"); this.userRequestsNotificationSystem = container.Resolve <NotificationSystem>("userAccessRequestTracker"); this.whitespacesManager = container.Resolve <WhitespacesManager>(); this.notificationAuditor = container.Resolve <AzureAuditor>(); this.notificationLogger = container.Resolve <Logger>(); while (true) { if (!this.auditNotificationSystem.Enabled) { this.auditNotificationSystem.StartTracking(); } if (!this.userRequestsNotificationSystem.Enabled) { this.userRequestsNotificationSystem.StartTracking(); } this.MonitorGetChannelList(); Thread.Sleep(TimeSpan.FromMinutes(10)); } } catch (Exception ex) { System.Diagnostics.Trace.TraceError(ex.ToString()); if (this.auditNotificationSystem.Enabled) { this.auditNotificationSystem.StopTracking(); } if (!this.userRequestsNotificationSystem.Enabled) { this.userRequestsNotificationSystem.StopTracking(); } } }
protected BaseGateway(IAuditor auditor, string connectionString) { if (string.IsNullOrWhiteSpace(connectionString)) { throw new ArgumentNullException(nameof(connectionString)); } Auditor = auditor ?? throw new ArgumentNullException(nameof(auditor)); ConnectionString = connectionString; }
/// <summary> /// Audits a request for a given file's meta data (e.g. through <see cref="IFileSystemProvider.GetFileInfo"/>. /// Be aware that this might cause verbose audit trails. /// </summary> public static void AuditFileInfoRequest(IAuditor auditor, FileSystemTask context, IVirtualFileItem file) { if (!AuditHelper.IsInfoEnabledFor(auditor, context)) { return; } string msg = String.Format("File information requested:\n{0}", AuditHelper.CreateResourceInfoString(file)); auditor.Audit(AuditLevel.Info, context, AuditEvent.FileInfoRequested, msg); }
public static void AuditDeniedFolderCreation(IAuditor auditor, AuditEvent eventId, IVirtualFolderItem folder) { if (!AuditHelper.IsWarnEnabledFor(auditor, FileSystemTask.FolderCreateRequest)) { return; } string msg = String.Format("Blocked attempt to create folder on file system. Folder information:\n{0}", AuditHelper.CreateResourceInfoString(folder)); auditor.Audit(AuditLevel.Warning, FileSystemTask.FolderCreateRequest, eventId, msg); }
/// <summary> /// Audits an attempt to delete the root folder. /// </summary> public static void AuditDeleteRootAttempt(IAuditor auditor, IVirtualFolderItem folder) { if (!AuditHelper.IsWarnEnabledFor(auditor, FileSystemTask.FolderDeleteRequest)) { return; } string msg = String.Format("Blocked attempt to delete root folder.\n\n{0}", AuditHelper.CreateResourceInfoString(folder)); auditor.Audit(AuditLevel.Warning, FileSystemTask.FolderDeleteRequest, AuditEvent.DeleteFileSystemRoot, msg); }
/// <summary> /// Audits a request for an unknown transfer. /// </summary> public static void AuditUnknownTransferRequest(IAuditor auditor, FileSystemTask context, string transferId) { if (!AuditHelper.IsWarnEnabledFor(auditor, context)) { return; } string msg = String.Format("Request for unknown transfer [{0}] received.", transferId); auditor.Audit(AuditLevel.Warning, context, AuditEvent.UnknownTransferRequest, msg); }
/// <summary> /// Audits a request for the file system's root folder. /// </summary> public static void AuditRootFolderRequest(IAuditor auditor, IVirtualFolderItem rootFolder) { if (!AuditHelper.IsInfoEnabledFor(auditor, FileSystemTask.RootFolderInfoRequest)) { return; } const string msg = "File system root requested."; auditor.Audit(AuditLevel.Info, FileSystemTask.RootFolderInfoRequest, AuditEvent.FolderInfoRequested, msg); }
private Option <Artifact> DeployNonEmpty(IAuditor auditor, Directories directories, FileInfo source, List <XmlSnippet> snippets, FileInfo destination) { if (!new SnippetsScriptWriter(destination).WriteIfModified(snippets)) { return(None.Value); } XmlSnippetsRedeployer redeployer = new XmlSnippetsRedeployer(auditor, directories, source, destination); return(new TranslatedSnippetsScript(redeployer, source, destination)); }
public static void SecureAction(IAuditor auditor, FileSystemTask context, Action action, Func <string> errorMessage) { //TODO replace wrapper once SecureFunc is properly implemented Func <bool> func = () => { action(); return(true); }; SecureFunc(auditor, context, func, errorMessage); }
/// <summary> /// Registers a specific auditor. /// </summary> /// <param name="auditor">The auditor.</param> /// <exception cref="ArgumentNullException">The <paramref name="auditor"/> is <c>null</c>.</exception> public static void RegisterAuditor(IAuditor auditor) { Argument.IsNotNull("auditor", auditor); lock (_instance._auditors) { if (!_instance._auditors.Contains(auditor)) { _instance._auditors.Add(auditor); } } }
public ProductionProviderMonitor( MetlConfiguration _metlServerAddress, ITimerFactory _timerFactory, IReceiveEvents _receiveEvents, IWebClient _webCleint, IAuditor _auditor ) { auditor = _auditor; metlServerAddress = _metlServerAddress; timerFactory = _timerFactory; client = _webCleint; }
public PrintParser( Credentials credentials, int room, MeTLLib.Providers.Structure.IConversationDetailsProvider conversationDetailsProvider, HttpHistoryProvider historyProvider, CachedHistoryProvider cachedHistoryProvider, MetlConfiguration metlServerAddress, ResourceCache cache, IReceiveEvents receiveEvents, IWebClientFactory webClientFactory, HttpResourceProvider httpResourceProvider, IAuditor _auditor) : base(credentials, room, conversationDetailsProvider, historyProvider, cachedHistoryProvider, metlServerAddress, cache, receiveEvents, webClientFactory, httpResourceProvider,_auditor) { }
public AuditingProductRepository( ProductRepository repository, IAuditor auditor) { if (repository == null) { throw new ArgumentNullException("repository"); } if (auditor == null) { throw new ArgumentNullException("auditor"); } this.innerRepository = repository; this.auditor = auditor; }
public MeTLXmppClientConnection(string domain, string server,IAuditor _auditor) : base() { auditor = _auditor; this.Server = domain; this.ConnectServer = server; this.SocketConnectionType = agsXMPP.Net.SocketConnectionType.Direct; this.UseStartTLS = true; this.UseSSL = false; // this should be set to false when UseStartTLS is set to true. UseStartTLS should deprecate useSSL. this.AutoAgents = false; this.AutoResolveConnectServer = false; this.UseCompression = false; ClientSocket.OnError += (s, e) => { auditor.error("ClientSocket Error","MeTLXmppClientConnection",e); }; }
public AuthorisationProvider(IWebClientFactory factory, MetlConfiguration server, IAuditor auditor) : base(factory,auditor) { this.webclientFactory = factory; this.server = server; }
public ConfigurationProvider(IWebClientFactory factory,IAuditor auditor) : base(factory,auditor) {}
public AuditManager(IAuditor defaultAuditor, params INamespaceAuditor[] namespaceAuditors) { this.defaultAuditor = defaultAuditor; this.namespaceAuditors = namespaceAuditors; }
//--------------------------------------------------- // // Agent Initialization // //--------------------------------------------------- void Init(SmtpAgentSettings settings) { m_settings = settings; m_settings.Validate(); m_auditor = IoC.Resolve<IAuditor>(); m_logger = Log.For(this); m_diagnostics = new AgentDiagnostics(this); m_configService = new ConfigService(m_settings); m_monitorService = new MonitorService(m_settings); using (new MethodTracer(Logger)) { try { // // First, setup defaults using Xml Config // this.InitDomains(); this.InitFolders(); this.InitRoutes(); this.InitNotifications(); // // Call config service, if any was configured // this.InitDomainsFromConfigService(); // // Finally, we can agent... // this.InitAgent(); this.SubscribeToAgentEvents(); this.ConfigureServicePoints(); } catch (Exception ex) { Logger.Error("While initializing {0}", ex.ToString()); throw; } } }
public AuditInstaller(IAuditor defaultAuditor) { auditManager = new AuditManager(defaultAuditor); }
public CustomerFinderImpl(IRepository repository, IAuditor auditor, IAuthorization authorization) { this.repository = repository; this.auditor = auditor; this.authorization = authorization; }
/// <summary> /// </summary> /// <param name="defaultAuditor">This will be used unless the object is recognised by one of the namespaceAuthorizers</param> /// <param name="namespaceAuditors"></param> public AuditInstaller(IAuditor defaultAuditor, params INamespaceAuditor[] namespaceAuditors) { auditManager = new AuditManager(defaultAuditor, namespaceAuditors); }
public ProductionResourceUploader(MetlConfiguration _metlServerAddress, HttpResourceProvider provider, IAuditor _auditor) { auditor = _auditor; metlServerAddress = _metlServerAddress; _httpResourceProvider = provider; }
public AuditingProductRepository(ProductRepository repository, IAuditor auditor) { innerRepository = repository; this.auditor = auditor; }
public MetlConfigurationManager(IAuditor _auditor) { auditor = _auditor; reload(); }
public RemoteAppMeTLConfigurationManager(IAuditor auditor) : base(auditor) { }
public LocalAppMeTLConfigurationManager(IAuditor auditor) : base(auditor) { }
public MeTLConfiguration(IAuditor _auditor) { auditor = _auditor; }
public ProductionResourceUploaderFactory(MetlConfiguration _config, HttpResourceProvider _provider, IAuditor _auditor) { auditor = _auditor; provider = _provider; config = _config; }
public ProductionReceiveEvents(IAuditor _auditor) { auditor = _auditor; this.PresenceAvailable += (sender, args) => { } ; this.SlideCollectionUpdated += (sender, args) => { }; this.ChatAvailable += (sender, args) => { }; this.CommandAvailable += (sender, args) => { }; this.ConversationDetailsAvailable += (sender, args) => { }; this.DirtyAutoShapeAvailable += (sender, args) => { }; this.DirtyImageAvailable += (sender, args) => { }; this.DirtyLiveWindowAvailable += (sender, args) => { }; this.DirtyStrokeAvailable += (sender, args) => { }; this.DirtyTextBoxAvailable += (sender, args) => { }; this.DirtyVideoAvailable += (sender, args) => { }; this.DiscoAvailable += (sender, args) => { }; this.FileAvailable += (sender, args) => { }; this.ImageAvailable += (sender, args) => { }; this.MoveDeltaAvailable += (sender, args) => { }; this.LiveWindowAvailable += (sender, args) => { }; this.PreParserAvailable += (sender, args) => { }; this.QuizAnswerAvailable += (sender, args) => { }; this.QuizQuestionAvailable += (sender, args) => { }; this.StatusChanged += (sender,args) =>{ }; this.StrokeAvailable += (sender, args) => { }; this.SubmissionAvailable += (sender, args) => { }; this.TextBoxAvailable += (sender, args) => { }; this.TeacherStatusRequest += (sender, args) => { }; this.TeacherStatusReceived += (sender, args)=> { }; this.SyncMoveRequested += (sender, SyncMoveRequestedEventArgs) => { }; this.AttendanceAvailable += (sender, args) => { }; this.ServersDown += (sender, args) => { }; }