public TransactionPool(Logging.ILogger logger)
{
this.transactionHashIndex = transactions.get <TransactionHashTag>();
this.transactionCostIndex = transactions.get <TransactionCostTag>();
this.paymentIdIndex = transactions.get <PaymentIdTag>();
this.logger = new Logging.LoggerRef(logger, "TransactionPool");
}
internal ServerPackageRepository(
IFileSystem fileSystem,
bool runBackgroundTasks,
ExpandedPackageRepository innerRepository,
Logging.ILogger logger = null,
Func <string, bool, bool> getSetting = null)
{
if (fileSystem == null)
{
throw new ArgumentNullException("fileSystem");
}
if (innerRepository == null)
{
throw new ArgumentNullException("innerRepository");
}
_fileSystem = fileSystem;
_runBackgroundTasks = runBackgroundTasks;
_expandedPackageRepository = innerRepository;
_logger = logger ?? new TraceLogger();
_serverPackageStore = new ServerPackageStore(_fileSystem, Environment.MachineName.ToLowerInvariant() + ".cache.bin");
_getSetting = getSetting ?? GetBooleanAppSetting;
}
public DefragService(Logging.ILogger logger, string connectionString, int reorganizeFragmentationThreshold = 3, int rebuildFragmentationThreshold = 30)
{
_connectionString = connectionString;
_reorganizeFragmentationThreshold = reorganizeFragmentationThreshold;
_rebuildFragmentationThreshold = rebuildFragmentationThreshold;
_logger = logger;
}
/// <summary>
/// The logger must be set up as late as possible (since the logsystem uses US), so
/// </summary>
public void SetupLogger()
{
if (Logger == null)
{
Logger = Logging.LogServices.CreateLoggerFromDefault(this.GetType());
}
}
/// <summary>
/// Initializes a new instance of the <see cref="T:ReactiveUIAroundMe.Portable.ViewModels.ViewModelBase"/> class.
/// </summary>
/// <param name="signalRClient">Signal RC lient.</param>
public ViewModelBase(ISQLiteStorage storage, IScheduler scheduler, Logging.ILogger log,
ApplicationStateHandler applicationStateHandler, WebServiceController webServiceController,
GoogleMapsWebServiceController googleMapsWebServiceController, IPathLocator pathLocator, IScreen hostScreen,
ILocationManager locationManager)
{
HostScreen = hostScreen;
Locations = new ObservableCollection <Location>();
CurrentLocation = new Location();
LocationManager = locationManager;
ConnectedStatusMessage = Labels.ConnectedTitle.ToUpper();
Storage = storage;
scheduler.Schedule((arg1) => Storage.CreateSQLiteConnection());
WebServiceController = webServiceController;
GoogleMapsWebServiceController = googleMapsWebServiceController;
PathLocator = pathLocator;
Subscriptions = new CompositeDisposable();
Scheduler = scheduler;
ApplicationStateHandler = applicationStateHandler;
Log = log;
Tag = $"{GetType()} ";
}
public Miner(System.Dispatcher dispatcher, Logging.ILogger logger)
{
this.m_dispatcher = dispatcher;
this.m_miningStopped = dispatcher;
this.m_state = MiningState.MINING_STOPPED;
this.m_logger = new Logging.LoggerRef(logger, "Miner");
}
internal ServerPackageRepository(
IFileSystem fileSystem,
bool runBackgroundTasks,
ExpandedPackageRepository innerRepository,
ISettingsProvider settingsProvider = null,
Logging.ILogger logger = null)
{
if (fileSystem == null)
{
throw new ArgumentNullException(nameof(fileSystem));
}
if (innerRepository == null)
{
throw new ArgumentNullException(nameof(innerRepository));
}
_fileSystem = fileSystem;
_runBackgroundTasks = runBackgroundTasks;
_settingsProvider = settingsProvider ?? new DefaultSettingsProvider();
_logger = logger ?? new TraceLogger();
_serverPackageCache = InitializeServerPackageStore();
_serverPackageStore = new ServerPackageStore(
_fileSystem,
innerRepository,
_logger);
}
public ServerPackageRepository(
string path,
IHashProvider hashProvider,
ISettingsProvider settingsProvider = null,
Logging.ILogger logger = null)
{
if (string.IsNullOrEmpty(path))
{
throw new ArgumentNullException(nameof(path));
}
if (hashProvider == null)
{
throw new ArgumentNullException(nameof(hashProvider));
}
_fileSystem = new PhysicalFileSystem(path);
_runBackgroundTasks = true;
_settingsProvider = settingsProvider ?? new DefaultSettingsProvider();
_logger = logger ?? new TraceLogger();
_serverPackageCache = InitializeServerPackageStore();
_serverPackageStore = new ServerPackageStore(
_fileSystem,
new ExpandedPackageRepository(_fileSystem, hashProvider),
_logger);
}
public TextServiceProcessor(string requestPath,
Func <IDictionary <String, String>, String> function,
Logging.ILogger logger) : base(logger)
{
this.RequestPath = requestPath;
this.Function = function;
}
public CircuitBreak(int exceptionsAllowedBeforeBreaking, TimeSpan durationOfBreak, int reTries, Func <Exception, bool> exceptionPredicate)
{
logger = ObjectContainer.Resolve <Logging.ILogger>();
circuitBreakerPolicy = Policy
.Handle(exceptionPredicate)
.CircuitBreaker(
exceptionsAllowedBeforeBreaking: exceptionsAllowedBeforeBreaking,
durationOfBreak: durationOfBreak,
onBreak: (ex, breakDelay) =>
{
logger.LogError(".Breaker logging: Breaking the circuit for " + breakDelay.TotalMilliseconds + "ms!", ex);
},
onReset: () =>
{
logger.LogDebug(".Breaker logging: Call ok! Closed the circuit again.");
},
onHalfOpen: () =>
{
logger.LogDebug(".Breaker logging: Half-open; next call is a trial.");
});
retryPolicy = Policy
.Handle(exceptionPredicate)
.Retry(reTries);
}
/// <summary>
/// Construtor padrão.
/// </summary>
/// <param name="properties2"></param>
/// <param name="cache"></param>
/// <param name="logger"></param>
public CacheStartupLoader(IDictionary properties2, Cache cache, Logging.ILogger logger)
{
properties2.Require("properties2").NotNull();
logger.Require("logger").NotNull();
if (properties2.Contains("retries"))
{
_noOfRetries = Convert.ToInt32(properties2["retries"]);
}
else
{
_noOfRetries = 0;
}
if (properties2.Contains("retry-interval"))
{
_retryInterval = Convert.ToInt32(properties2["retry-interval"]);
}
else
{
_retryInterval = 0;
}
if (properties2.Contains("enabled"))
{
_enabled = Convert.ToBoolean(properties2["enabled"]);
}
_cache = cache;
_properties = properties2;
_logger = logger;
}
/// <summary>
/// Logs a message to indicate that the app was Deactivated using the AppEventMesgType message type (which defaults to MesgType.Signif)
/// </summary>
public static void HandleOnDeactivated(Logging.ILogger appLogger)
{
appLogger.Emitter(AppEventMesgType).EmitWith("App Deactivated", nvs: new NamedValueSet()
{
{ "AppEvent", "OnDeactivated" }
});
}
public EncounterPlayerStatistics(ILogger logger, IEncounterRepository encounterRepository, IScheduledTaskRepository taskRepository, IBossFightSingleTargetDetail bossFightSingleTargetDetailRepository, IDiscordService discord)
{
_logger = logger;
_encounterRepository = encounterRepository;
_taskRepository = taskRepository;
_bossFightSingleTargetDetailRepository = bossFightSingleTargetDetailRepository;
_discord = discord;
}
public TransfersSyncronizer(CryptoNote.Currency currency, Logging.ILogger logger, IBlockchainSynchronizer sync, INodeOriginal node)
{
//C++ TO C# CONVERTER TODO TASK: The following line could not be converted:
this.m_currency = new CryptoNote.Currency(currency);
this.m_logger = new Logging.LoggerRef(logger, "TransfersSyncronizer");
this.m_sync = new CryptoNote.IBlockchainSynchronizer(sync);
this.m_node = new CryptoNote.INodeOriginal(node);
}
public PipMod()
{
Version = GetType().Assembly.GetName().Version;
Logger = Logging.GlobalLogger.Get().Fork(Prefix ?? Name ?? GetType().Name);
if (Prefix == null)
{
Prefix = Name;
}
}
/// <summary>
/// Logs a message to indicate that the app is Stopping using the AppEventMesgType message type (which defaults to MesgType.Signif)
/// Then runs Logging.ShutdownLogging().
/// </summary>
public static void HandleOnExit(Logging.ILogger appLogger)
{
appLogger.Emitter(AppEventMesgType).EmitWith("App Stopping", nvs: new NamedValueSet()
{
{ "AppEvent", "OnExit" }
});
Logging.ShutdownLogging();
}
public Server(String port, Logging.ILogger logger)
{
this.logger = logger;
this.Port = port;
listener = new HttpListener();
listener.Prefixes.Add("http://*:" + port + "/");
listenerThread = new Thread(Listen);
}
public ServerPackageStore(
IFileSystem fileSystem,
ExpandedPackageRepository repository,
Logging.ILogger logger)
{
_fileSystem = fileSystem;
_repository = repository;
_logger = logger;
}
/// <summary>
/// Construtor padrão.
/// </summary>
/// <param name="name">Nome do processador.</param>
/// <param name="logger">Logger associado com a instancia.</param>
public AsyncProcessor(string name, Logging.ILogger logger)
{
name.Require("name").NotNull().NotEmpty();
_name = name;
_worker = null;
_eventsHi = new Queue <IAsyncTask>(256);
_eventsLow = new Queue <IAsyncTask>(256);
_logger = logger;
}
internal StreamStoreConnectionSettings(
UserCredentials userCredentials,
IPEndPoint singleServerIpEndPoint,
string clusterDns,
IReadOnlyList <IPEndPoint> ipEndPoints,
int networkIpPort,
Logging.ILogger log,
bool useTlsConnection,
string targetHost,
bool validateServer,
bool verboseLogging = false)
{
Ensure.NotNull(log, nameof(log));
Ensure.NotNull(userCredentials, nameof(userCredentials));
if (useTlsConnection)
{
Ensure.NotNullOrEmpty(targetHost, nameof(targetHost));
}
if (singleServerIpEndPoint != null && !string.IsNullOrWhiteSpace(clusterDns) ||
singleServerIpEndPoint != null && ipEndPoints != null && ipEndPoints.Count > 0 ||
!string.IsNullOrWhiteSpace(clusterDns) && ipEndPoints != null && ipEndPoints.Count > 0)
{
throw new StreamStoreConnectionException("Conflicting server or cluster input passed.");
}
if (singleServerIpEndPoint != null)
{
Ensure.Between(1024, 65535, singleServerIpEndPoint.Port, nameof(singleServerIpEndPoint.Port));
_connectionType = ConnectionType.SingleNode;
}
else if (!string.IsNullOrWhiteSpace(clusterDns))
{
Ensure.Between(1024, 65535, networkIpPort, nameof(networkIpPort));
_connectionType = ConnectionType.DnsCluster;
}
else if (ipEndPoints != null && ipEndPoints.Count > 0)
{
foreach (var endPoint in ipEndPoints)
{
Ensure.Between(1024, 65535, endPoint.Port, nameof(endPoint.Port));
}
_connectionType = ConnectionType.GossipSeedsCluster;
GossipSeeds = ipEndPoints.Select(x => new GossipSeed(x)).ToArray();
}
UserCredentials = userCredentials;
SingleServerIpEndPoint = singleServerIpEndPoint;
ClusterDns = clusterDns;
NetworkIpPort = networkIpPort;
Log = log;
UseTlsConnection = useTlsConnection;
ValidateServer = validateServer;
TargetHost = targetHost;
VerboseLogging = verboseLogging;
}
public SVNWrapper(Tiveria.Common.Logging.ILogManager logManager)
{
_Logger = logManager.GetLogger("SVNWrapper");
_Logger.Info("Creating instance");
_Username = "";
_Password = "";
_RepositoryRevision = -1;
_SvnClient = new SvnClient();
_SvnClient.Conflict += new EventHandler <SvnConflictEventArgs>(ConflictHandler);
}
public SearchProvider(ISessionProvider sessionProvider,
[KeyFilter("SearchRestHelper")] IRestHelper restHelper,
Logging.ILogger logger,
IEventSearchResultBuilder searchResultBuilder,
IQuerySender querySender)
{
_restHelper = restHelper;
_sessionProvider = sessionProvider;
_logger = logger;
_searchResultBuilder = searchResultBuilder;
_querySender = querySender;
}
public SearchController(IQuerySender querySender,
ISiteIdProvider siteIdProvider,
ISearchProvider searchProvider,
IEventSearchResultBuilder eventSearchResultBuilder,
FIL.Logging.ILogger logger)
{
_searchProvider = searchProvider;
_querySender = querySender;
_siteIdProvider = siteIdProvider;
_eventSearchResultBuilder = eventSearchResultBuilder;
_logger = logger;
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, IHostApplicationLifetime appLifetime)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseAuthentication();
app.UseMiddleware <CachingMiddleware>();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "api/{controller}/{action}/{id?}");
}).UseResponseCaching().UseResponseCompression();
app.UseSwagger();
app.UseSwaggerUI(c =>
{
c.SwaggerEndpoint("/swagger/v1/swagger.json", "SmartGrocery API V1");
c.EnableValidator();
c.DisplayRequestDuration();
c.EnableFilter();
});
ApplicationLogger = app.ApplicationServices.GetService <Logging.ILogger <Startup> >();
appLifetime.ApplicationStopped.Register(() =>
{
ApplicationLogger.Debug("Application ending");
});
appLifetime.ApplicationStarted.Register(async() =>
{
ApplicationLogger.Debug("Application starting");
var indexManager = app.ApplicationServices.GetService <IndexesManager>();
await indexManager.UpdateIndexes().ConfigureAwait(false);
var blobs = app.ApplicationServices.GetService <BlobsInitializator>();
await blobs.Init().ConfigureAwait(false);
var queues = app.ApplicationServices.GetService <ChannelsInitializator>();
await queues.Init().ConfigureAwait(false);
});
}
public StaticResourceRequestProcessor(string rootPath,
Logging.ILogger logger) : base(logger)
{
if (string.IsNullOrEmpty(rootPath))
{
throw new ArgumentNullException(nameof(rootPath));
}
if (!Directory.Exists(rootPath))
{
throw new DirectoryNotFoundException(rootPath);
}
this.RootPath = rootPath;
}
public ActuatorBase(ActuatorConfig config, ActuatorState state)
{
Config = config;
PrivateState = state;
logger = new Logging.Logger(config.Name, Logging.LogGate.All);
PrivateState.TargetPos = PrivateState.PosState = config.InitialPos;
PrivateState.TargetPosStr = PrivateState.PosStateStr = config.ToString(config.InitialPos);
PrivateState.TimeStamp = QpcTimeStamp.Now;
logger.Info.Emit("Initial state is:{0} [{1}]", PrivateState.PosStateStr, PrivateState.PosState);
PublishState();
}
static Logging.ILogger GetLogger(Type type)
{
if (type == null)
{
return(nullLogger);
}
Logging.ILoggerManager manager = logManager;
if (manager != null)
{
Logging.ILogger logger = manager[type];
return(logger != null ? logger : nullLogger);
}
return(nullLogger);
}
public override async Task <IEnumerable <IPackageSearchMetadata> > GetMetadataAsync(
string packageId,
bool includePrerelease,
bool includeUnlisted,
Logging.ILogger log,
CancellationToken token)
{
return(await Task.Run(() =>
{
return V2Client.FindPackagesById(packageId)
.Where(p => includeUnlisted || !p.Published.HasValue || p.Published.Value.Year > 1901)
.Where(p => includePrerelease || String.IsNullOrEmpty(p.Version.SpecialVersion))
.Select(GetPackageMetadata);
},
token));
}
/// <summary> This is the inner-most implementation method for the Assert helper class. It implements all of the assertType specific behavior for all assertions that get triggered.</summary>
private static void AssertCommon(string mesg, AssertType assertType, System.Diagnostics.StackFrame sourceFrame)
{
// always log all triggered asserts to the BasicFallbackLog
string logStr = Fcns.CheckedFormat("{0} at file:'{1}', line:{2}", mesg, sourceFrame.GetFileName(), sourceFrame.GetFileLineNumber());
if (assertType != AssertType.Log)
{
if (EnableBasicFallbackLogging)
Logging.BasicFallbackLogging.LogError(logStr);
if (queuedAssertLogger == null) // in an MT world we might create a few of these simultaneously. This is not a problem as the distribution engine supports such a construct so locking is not required here in order to get valid behavior.
queuedAssertLogger = new Logging.QueuedLogger("MosaicLib.Utils.Assert");
queuedAssertLogger.Emitter(DefaultAssertLoggingMesgType).Emit(logStr);
}
bool ignoreFault = false; // intended to be used by debug user to ignore such asserts on a case by case basis
if (assertType == AssertType.Log)
{
if (assertLogger == null) // in an MT world we might create a few of these simultaneously. This is not a problem as the distribution engine supports such a construct so locking is not required here in order to get valid behavior.
assertLogger = new Logging.Logger("MosaicLib.Utils.Assert");
assertLogger.Emitter(DefaultAssertLoggingMesgType).Emit(logStr);
return;
}
else if (assertType == AssertType.LogFallback)
{
return; // already done
}
else if (assertType == AssertType.ThrowException)
{
if (!ignoreFault)
throw new AssertException(mesg, sourceFrame);
return;
}
if (!ignoreFault)
{
// the remaining types always trigger a breakpoint if a debugger is attached and the hosting environment has set the EnabledAssertDebugBreakpoints flag
if (System.Diagnostics.Debugger.IsAttached && EnableAssertDebugBreakpoints)
System.Diagnostics.Debugger.Break();
}
}
public CreateBookingCommandHandler(IEventDetailRepository eventDetailRepository,
ITransactionRepository transactionRepository,
ITransactionDetailRepository transactionDetailRepository,
ITransactionSeatDetailRepository transactionSeatDetailRepository,
IFeelBarcodeMappingRepository feelBarcodeMappingRepository,
IEventTicketDetailRepository eventTicketDetailRepository,
IEventTicketAttributeRepository eventTicketAttributeRepository,
ITicketCategoryRepository ticketCategoryRepository,
IEventAttributeRepository eventAttributeRepository,
IEventRepository eventRepository,
IVenueRepository venueRepository,
ICityRepository cityRepository,
IStateRepository stateRepository,
ICountryRepository countryRepository,
ICurrencyTypeRepository currencyTypeRepository,
ICitySightSeeingTicketDetailRepository citySightSeeingTicketDetailRepository,
ICitySightSeeingTicketRepository citySightSeeingTicketRepository,
ICitySightSeeingEventDetailMappingRepository citySightSeeingEventDetailMappingRepository,
Logging.ILogger logger,
IMatchLayoutSectionRepository matchLayoutSectionRepository, ISettings settings, ICitySightSeeingTransactionDetailRepository citySightSeeingTransactionDetailRepository, IGoogleMapApi googleMapApi, ICitySightSeeingLocationRepository citySightSeeingLocationRepository,
IMediator mediator) : base(mediator)
{
_eventDetailRepository = eventDetailRepository;
_transactionRepository = transactionRepository;
_transactionDetailRepository = transactionDetailRepository;
_feelBarcodeMappingRepository = feelBarcodeMappingRepository;
_eventTicketDetailRepository = eventTicketDetailRepository;
_eventTicketAttributeRepository = eventTicketAttributeRepository;
_ticketCategoryRepository = ticketCategoryRepository;
_eventAttributeRepository = eventAttributeRepository;
_eventRepository = eventRepository;
_venueRepository = venueRepository;
_cityRepository = cityRepository;
_stateRepository = stateRepository;
_countryRepository = countryRepository;
_currencyTypeRepository = currencyTypeRepository;
_citySightSeeingTicketDetailRepository = citySightSeeingTicketDetailRepository;
_citySightSeeingTicketRepository = citySightSeeingTicketRepository;
_citySightSeeingEventDetailMappingRepository = citySightSeeingEventDetailMappingRepository;
_logger = logger;
_settings = settings;
_citySightSeeingTransactionDetailRepository = citySightSeeingTransactionDetailRepository;
_googleMapApi = googleMapApi;
_citySightSeeingLocationRepository = citySightSeeingLocationRepository;
}
static public T Parse <T>(Logging.ILogger logging, string[] arguments) where T : CoreCommandlineOptions
{
var parser = new CommandLine.Parser(config => config.HelpWriter = Console.Out);
T options = null;
IEnumerable <Error> errors = null;
var result = parser.ParseArguments <T>(arguments)
.WithParsed <T>(opts => options = opts)
.WithNotParsed <T>(errs => errors = errs);
if (errors != null)
{
options = System.Activator.CreateInstance <T>();
options.ParsingErrors = errors;
}
return(options);
}
public ServerPackageRepository(string path, IHashProvider hashProvider, Logging.ILogger logger)
{
if (string.IsNullOrEmpty(path))
{
throw new ArgumentNullException("path");
}
if (hashProvider == null)
{
throw new ArgumentNullException("hashProvider");
}
_fileSystem = new PhysicalFileSystem(path);
_runBackgroundTasks = true;
_logger = logger ?? new TraceLogger();
_expandedPackageRepository = new ExpandedPackageRepository(_fileSystem, hashProvider);
_serverPackageStore = new ServerPackageStore(_fileSystem, Environment.MachineName.ToLowerInvariant() + ".cache.bin");
_getSetting = GetBooleanAppSetting;
}
internal ServerPackageRepository(IFileSystem fileSystem, bool runBackgroundTasks, ExpandedPackageRepository innerRepository, Logging.ILogger logger = null, Func<string, bool, bool> getSetting = null)
{
if (fileSystem == null)
{
throw new ArgumentNullException("fileSystem");
}
if (innerRepository == null)
{
throw new ArgumentNullException("innerRepository");
}
_fileSystem = fileSystem;
_runBackgroundTasks = runBackgroundTasks;
_expandedPackageRepository = innerRepository;
_logger = logger ?? new TraceLogger();
_serverPackageStore = new ServerPackageStore(_fileSystem, Environment.MachineName.ToLowerInvariant() + ".cache.bin");
_getSetting = getSetting ?? GetBooleanAppSetting;
}
public MultiSourcePackageMetadataProvider(
IEnumerable<SourceRepository> sourceRepositories,
SourceRepository optionalLocalRepository,
SourceRepository optionalGlobalLocalRepository,
Logging.ILogger logger)
{
if (sourceRepositories == null)
{
throw new ArgumentNullException(nameof(sourceRepositories));
}
_sourceRepositories = sourceRepositories;
_localRepository = optionalLocalRepository;
_globalLocalRepository = optionalGlobalLocalRepository;
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
_logger = logger;
}
private void Initialize(System.Web.HttpContext ctx)
{
m_Host = ctx.Request.Url.Host;
var contextBase = new System.Web.HttpContextWrapper(ctx);
var container = new UnityContainer();
container.AddNewExtension<Interception>();
// Enregistrement des repositories
container.RegisterType<Repositories.ICouponRepository, Repositories.NullCouponRepository>(new ContainerControlledLifetimeManager());
container.RegisterType<Repositories.ICartRepository, Repositories.HttpContextCartRepository>(new ContainerControlledLifetimeManager());
container.RegisterType<Repositories.IRegistrationRepository, Repositories.SessionRegistrationRepository>(new ContainerControlledLifetimeManager());
container.RegisterType<Repositories.ILocalizationRepository, Repositories.VoidLocalizationRepository>(new ContainerControlledLifetimeManager());
container.RegisterType<Repositories.ICommentRepository, Repositories.VoidCommentRepository>(new ContainerControlledLifetimeManager());
// Enregistrement des services
container.RegisterType<Services.ICacheService, Services.SimpleCacheService>(new ContainerControlledLifetimeManager());
container.RegisterType<Services.ICartService, Services.CartService>(new ContainerControlledLifetimeManager());
container.RegisterType<Services.IScheduledTaskService, Services.ScheduledTaskService>(new ContainerControlledLifetimeManager());
container.RegisterType<Services.IEmailerService, Services.EmailerService>(new ContainerControlledLifetimeManager());
container.RegisterType<Services.IIncentiveService, Services.IncentiveService>(new ContainerControlledLifetimeManager());
container.RegisterType<Services.ILocalizationService, Services.VoidLocalizationService>(new ContainerControlledLifetimeManager());
container.RegisterType<Services.ISearchOptimizationService, Services.VoidSearchOptimizationService>(new ContainerControlledLifetimeManager());
var pluginEnumeratorInjectionMembers = new InjectionMember[]
{
new InjectionConstructor(
ctx.Server.MapPath("/plugins.config")
, ctx.Server.MapPath("/bin")
)
};
container.RegisterType<Extensibility.IPluginEnumerator, Extensibility.XmlConfigPluginEnumerator>(new ContainerControlledLifetimeManager(), pluginEnumeratorInjectionMembers);
container.RegisterType<Extensibility.IPluginLoaderService, Extensibility.PluginLoaderService>(new ContainerControlledLifetimeManager());
container.RegisterType<Services.IEventSubscriptionService, Services.EventSubscriptionService>(new ContainerControlledLifetimeManager());
container.RegisterType<Services.IEventPublisher, Services.EventPublisher>(new ContainerControlledLifetimeManager());
container.RegisterType<Services.ISettingsService, Services.SettingsService>(new ContainerControlledLifetimeManager());
container.RegisterType<Services.ISalesService, Services.SalesService>(new ContainerControlledLifetimeManager());
// Configuration des routes
container.RegisterType<Services.IRoutesRegistrationService, ERPStoreRoutes>(new ContainerControlledLifetimeManager());
// Enregistrement des modes de reglement par defaut
container.RegisterType<Services.IPaymentService, Services.PaymentByCheckService>("check",new ContainerControlledLifetimeManager());
container.RegisterType<Services.IPaymentService, Services.PaymentByWireTransferService>("wiretransfer",new ContainerControlledLifetimeManager());
// Global Event Consumer
container.RegisterType<Services.UserLoggedEventMessage>("userLoggedEventMessage", new ContainerControlledLifetimeManager());
// Logger par defaut
container.RegisterType<Logging.ILogger, Logging.ConsoleLogger>(new PerThreadLifetimeManager());
// Chargement des services et overriding a partir du fichier
// de configuration unity.config
var map = new ExeConfigurationFileMap();
var unityConfigFileName = ERPStore.Configuration.ConfigurationSettings.AppSettings["unityConfigFileName"] ?? "unity.config";
map.ExeConfigFilename = System.IO.Path.Combine(System.Web.HttpContext.Current.Server.MapPath(@"\"), unityConfigFileName);
var config = ConfigurationManager.OpenMappedExeConfiguration(map, ConfigurationUserLevel.None);
var section = (UnityConfigurationSection)config.GetSection("unity");
if (section == null)
{
throw new Exception(string.Format("unity section in {0} does not exists", unityConfigFileName));
}
section.Configure(container);
RegisterGlobalFilters(GlobalFilters.Filters);
container.RegisterInstance<IControllerFactory>(System.Web.Mvc.ControllerBuilder.Current.GetControllerFactory());
container.RegisterType<IControllerActivator, UnityControllerActivator>();
container.RegisterType<IViewPageActivator, UnityViewPageActivator>();
var filterProvider = new UnityFilterProvider(container);
container.RegisterInstance<IFilterProvider>("attributes", filterProvider);
container.RegisterType<ModelMetadataProvider, DataAnnotationsModelMetadataProvider>();
var resolver = new UnityDependencyResolver(container);
System.Web.Mvc.DependencyResolver.SetResolver(resolver);
m_Logger = container.Resolve<Logging.ILogger>();
// Resolution et chargement des paramètres de configuration du site
m_Logger.Info("Loading site configuration");
var settingsService = container.Resolve<Services.ISettingsService>();
m_WebSiteSettings = settingsService.GetWebSiteSettings(m_Host);
m_WebSiteSettings.PhysicalPath = ctx.Server.MapPath("/");
var injectionMembers = new InjectionMember[]
{
new InjectionConstructor(m_WebSiteSettings.CryptoKey, m_WebSiteSettings.CryptoIV) ,
};
container.RegisterType<Services.CryptoService>(new ContainerControlledLifetimeManager(), injectionMembers);
m_Logger.Info("Loading plugins");
// Chargement des plugins
var pluginLoaderService = container.Resolve<Extensibility.IPluginLoaderService>();
var pluginEnumeratorService = container.Resolve<Extensibility.IPluginEnumerator>();
var plugins = pluginEnumeratorService.EnumeratePlugins();
pluginLoaderService.Load(plugins, (System.Web.HttpContextBase)contextBase, m_WebSiteSettings);
m_Logger.Info("Plugins loaded");
// Configuration des routes
var erpStoreRoutes = container.Resolve<Services.IRoutesRegistrationService>();
erpStoreRoutes.Register();
// Enregistrement des routes par defaut
RouteTable.Routes.MapERPStoreRoute(
"Admin"
, "admin/{action}/{id}"
, new { controller = "Admin", action = "Index", id = string.Empty }
);
RouteTable.Routes.MapERPStoreRoute(
"CatchAll"
, "{*catchall}"
, new { controller = "Home", action = "CatchAll" }
);
// Ne pas supprimer cette route
RouteTable.Routes.MapERPStoreRoute(
"Default",
"{controller}/{action}/{id}",
new { controller = "Home", action = "Index", id = string.Empty }
);
var eventPublisherService = container.Resolve<Services.IEventPublisher>();
eventPublisherService.Publish(new Models.Events.RegisteredRoutesEvent());
m_Logger.Info("Routes configured");
// Demarrage du planificateur de taches
var taskService = container.Resolve<Services.IScheduledTaskService>();
taskService.Start();
m_Logger.Info("Scheduler started");
}
public LoggerTrackingService(Logging.ILogger logger)
{
m_Logger = logger;
}
/// <summary> This is the inner-most implementation method for the Assert helper class. It implements all of the assertType specific behavior for all assertions that get triggered.</summary>
private static void AssertCommon(string mesg, AssertType assertType, System.Diagnostics.StackFrame sourceFrame)
{
// always log all triggered asserts to the BasicFallbackLog
string logStr = Fcns.CheckedFormat("{0} at file:'{1}', line:{2}", mesg, sourceFrame.GetFileName(), sourceFrame.GetFileLineNumber());
if (assertType != AssertType.Log)
Logging.BasicFallbackLogging.LogError(logStr);
bool ignoreFault = false; // intended to be used by debug user to ignore such asserts on a case by case basis
if (assertType == AssertType.Log)
{
if (assertLogger == null) // in an MT world we might create a few of these simultaneously. This is not a problem as the distribution engine supports such a construct so locking is not required here in order to get valid behavior.
assertLogger = new Logging.Logger("MosaicLib.Utils.Assert");
assertLogger.Warning.Emit(mesg);
return;
}
else if (assertType == AssertType.LogFallback)
{
return; // already done
}
else if (assertType == AssertType.ThrowException)
{
if (!ignoreFault)
throw new AssertException(mesg, sourceFrame);
return;
}
if (!ignoreFault)
{
// the remaining types always trigger a breakpoint
if (System.Diagnostics.Debugger.IsAttached)
System.Diagnostics.Debugger.Break();
// finally if the type is a FatalExit then call the Kernel32.dll FatalExit entry point
if (assertType == AssertType.FatalExit)
FatalExit(-1);
}
}
public LoggerTrackingChannel(TrackingParameters parameters, Logging.ILogger logger)
{
m_Logger = logger;
m_Parameters = parameters;
}
