private void WaitForGlobalReconnectTimeout()
{
var sleep = AppConfigurationProvider.Get <ManagerConfiguration>().GlobalReconnectTimeout;
_logger.Info($"{nameof(WaitForGlobalReconnectTimeout)} Sleep for [ms]: {sleep}");
Thread.Sleep(sleep);
_logger.Info($"{nameof(WaitForGlobalReconnectTimeout)} Sleep finished");
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
var dbconfig = AppConfigurationProvider.Get <DbConfiguration>();
optionsBuilder.UseMultiDb(dbconfig.ConnectionStrings[dbconfig.DbProvider]);
optionsBuilder.EnableSensitiveDataLogging();
optionsBuilder.UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking);
}
static void Main()
{
IConfigurationProvider configurationProvider = new AppConfigurationProvider();
var connectionString = configurationProvider.GetValue(ConnectionStringKey, string.Empty);
var entityPath = configurationProvider.GetValue(EntityPathKey, string.Empty);
var consumerGroup = configurationProvider.GetValue(ConsumerGroupKey, string.Empty);
var handlers = configurationProvider.GetValue(HandlersKey, string.Empty).Split(',');
IEventHubReader reader = new EventHubReader(connectionString, entityPath, consumerGroup);
SubscribeHandlers(Assembly.GetExecutingAssembly(), reader);
SubscribeExternalHandlers(reader);
reader.Read();
}
private static IWebHost PrepareHost(string[] args)
{
return(new WebHostBuilder()
.UseKestrel(
options =>
{
var config = AppConfigurationProvider.Get <ManagerConfiguration>();
options.Listen(IPAddress.Parse(config.LocalIpAddress), config.ListeningPort,
listenOptions => { });
options.Listen(IPAddress.Parse("127.0.0.1"), config.ListeningPort,
listenOptions => { });
})
.UseConfiguration(new ConfigurationBuilder().AddCommandLine(args).Build())
.UseContentRoot(Directory.GetCurrentDirectory())
.UseIISIntegration()
.UseStartup <Startup>()
.Build());
}
/// <summary>
/// Uses provider specific extension based on DB provider set in DB Config
/// </summary>
/// <param name="services">Service collection</param>
/// <returns>Returns service collection</returns>
public static IServiceCollection AddEntityFrameworkMultiDb(this IServiceCollection services)
{
var dbconfig = AppConfigurationProvider.Get <DbConfiguration>();
switch (dbconfig.DbProvider)
{
case DbProviders.MsSql:
return(services.AddEntityFrameworkSqlServer());
case DbProviders.PostgreSql:
return(services.AddEntityFrameworkNpgsql());
case DbProviders.Sqlite:
return(services.AddEntityFrameworkSqlite());
default:
throw new InvalidOperationException("Unknown DB provider setup in database configuration.");
}
}
/// <inheritdoc />
/// <summary>
/// Runs the async apply reservation task async.
/// </summary>
public async Task RunAsyncApplyReservationTaskAsync(CancellationToken cancellationToken)
{
_logger.Info("RunAsyncApplyReservationTaskAsync Thread Started.");
while (!cancellationToken.IsCancellationRequested)
{
try
{
var applied = false;
if (await RestClient.TryToConnect())
{
_logger.Info("ApplyAvailableReservations [START]");
try
{
applied = await ApplyAvailableReservations();
}
catch (Exception e)
{
_logger.Info("ApplyAvailableReservations: " + e.Message + " [ERROR]");
}
_logger.Info("ApplyAvailableReservations: " + applied + " [STOP]");
Thread.Sleep((await RestClient.GetManagerConfiguration()).ReservationServiceRefreshTime);
}
else
{
_logger.Error("ApplyAvailableReservations: Failed connecting to " + RestClient.Endpoint +
" [STOP]");
var sleep = AppConfigurationProvider.Get <ManagerConfiguration>().GlobalReconnectTimeout;
_logger.Info("ApplyAvailableReservations Sleep for [ms]: " + sleep);
Thread.Sleep(sleep);
_logger.Info("ApplyAvailableReservations Sleep finished");
}
}
catch (Exception e)
{
_logger.Error("Exception during RunAsyncApplyReservationTaskAsync.", e);
}
}
_logger.Info($"{nameof(RunAsyncApplyReservationTaskAsync)} STOP.");
}
/// <summary>
/// Uses provider specific extension based on configured provider in dbconfig.json
/// </summary>
/// <param name="builder">Context options builder</param>
/// <param name="connectionString">Connection string</param>
/// <returns>Returns Context options builder</returns>
public static DbContextOptionsBuilder UseMultiDb(this DbContextOptionsBuilder builder, string connectionString)
{
var dbconfig = AppConfigurationProvider.Get <DbConfiguration>();
switch (dbconfig.DbProvider)
{
case DbProviders.MsSql:
return(builder.UseSqlServer(connectionString));
case DbProviders.PostgreSql:
return(builder.UseNpgsql(connectionString
));
case DbProviders.Sqlite:
return(builder.UseSqlite(connectionString));
default:
throw new InvalidOperationException("Unknown DB provider setup in database configuration.");
}
}
public override void Install(IDictionary stateSaver)
{
base.Install(stateSaver);
string email = Context.Parameters["email"] ?? "",
userName = Context.Parameters["smtpusername"] ?? "",
password = Context.Parameters["smtppassword"] ?? "";
Debugger.Launch();
string path = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Tasker.Service.exe.config");
AppConfigurationProvider config = new AppConfigurationProvider(path);
config.UpdateSettings(new Dictionary <string, object>
{
{ "SmtpUsername", userName },
{ "SmtpPassword", password },
{ "EmailFromAddress", email },
});
}
/// <summary>
/// Retrieves model mapping from DB mapping files for given type
/// </summary>
/// <typeparam name="T">DB Model</typeparam>
/// <param name="builder">Model builder</param>
/// <returns>Returns model builder</returns>
public static ModelBuilder GetModelMapping <T>(this ModelBuilder builder) where T : class
{
var dbConfiguration = AppConfigurationProvider.Get <DbConfiguration>();
var mappingFileName = $"{typeof(T).Name}.json";
var mappingObject =
JsonConvert.DeserializeObject <ClassDbMapping>(
File.ReadAllText(dbConfiguration.DbMappingFilesPath + "/" + mappingFileName));
builder.HasDefaultSchema(dbConfiguration.DefaultDbSchema);
builder.Entity <T>().ToTable(mappingObject.TableNames[dbConfiguration.DbProvider]);
foreach (var propertyMapping in mappingObject.PropertyMappings)
{
builder.Entity <T>()
.Property(propertyMapping.PropertyName)
.HasColumnName(propertyMapping.Mappings[dbConfiguration.DbProvider]);
}
return(builder);
}
private static void ConfigureServices(IServiceCollection services)
{
services.AddLogging(builder => builder.AddConsole());
var environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
Configuration = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
.AddJsonFile($"appsettings.{environment}.json", optional: true, reloadOnChange: true)
.AddEnvironmentVariables()
.Build();
var ConfigurationProvider = new AppConfigurationProvider(Configuration, Directory.GetCurrentDirectory());
//Ioc.Configure(services, ConfigurationProvider);
DbContextConfiguration.UseSqlDataBase <DataBase>(services, ConfigurationProvider);
MappingConfig.RegisterMappings();
services.AddTransient <Functions, Functions>();
services.AddSingleton(Configuration);
}
/// <summary>
/// Configure the specified app, env and loggerFactory. This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
/// </summary>
/// <returns>The configure.</returns>
/// <param name="app">App.</param>
/// <param name="env">Env.</param>
/// <param name="loggerFactory">Logger factory.</param>
/// <param name="applicationLifetime">Handle application lifecycle.</param>
/// <param name="logger">Logger.</param>
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory,
IApplicationLifetime applicationLifetime, IManagerLogger logger)
{
var appconfig = AppConfigurationProvider.Get <AppConfiguration>();
applicationLifetime.ApplicationStopped.Register(OnShutdown);
loggerFactory.AddConsole((logText, logLevel) =>
{
if (Debugger.IsAttached)
{
return(true);
}
if (logLevel >= appconfig.DefaultLogLevel)
{
return(true);
}
return(false);
}, appconfig.IncludeScopes);
loggerFactory.AddFile("Logs/log-{Date}.txt", LogLevel.Trace);
app.UseExceptionHandler(
options =>
{
options.Run(
async context =>
{
context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
context.Response.ContentType = "text/html";
var ex = context.Features.Get <IExceptionHandlerFeature>();
if (ex != null)
{
var err = $"<h1>Error: {ex.Error.Message}</h1>{ex.Error.StackTrace}";
await context.Response.WriteAsync(err).ConfigureAwait(false);
logger.Error(ex.Error.Message, ex.Error);
}
});
}
);
//app.UseDeveloperExceptionPage();
app.UseStaticFiles();
app.UseMvcWithDefaultRoute();
app.UseCors("AllowAllHeaders");
// Enable middleware to serve generated Swagger as a JSON endpoint.
app.UseSwagger();
// Enable middleware to serve swagger-ui (HTML, JS, CSS etc.), specifying the Swagger JSON endpoint.
app.UseSwaggerUI(c =>
{
c.RoutePrefix = "doc";
c.SwaggerEndpoint("/swagger/v1/swagger.json", "My API V1");
});
}
public VidzyContext()
{
Configuration = AppConfigurationProvider.BuildConfigurtions();
}
public void SystemEnabledTest()
{
IToggleConfiguration provider = new AppConfigurationProvider(InitConfiguration());
Assert.IsTrue(provider.SystemEnabled);
}
/// <summary>
/// Initializes a new instance of the <see cref="T:MobileManager.Startup"/> class.
/// </summary>
/// <param name="env">Env.</param>
public Startup(IHostingEnvironment env)
{
AppConfigurationProvider.Register <DbConfiguration>(@"ConfigFiles/dbconfig.json")
.RegisterNext <ManagerConfiguration>(@"ConfigFiles/managerconfig.json")
.RegisterNext <AppConfiguration>(@"ConfigFiles/appsettings.json");
}
public IActionResult Get()
{
LogRequestToDebug();
return(JsonExtension(AppConfigurationProvider.Get <ManagerConfiguration>()));
}
public CountriesDBContext()
{
Configuration = AppConfigurationProvider.BuildConfigurtions();
}
public IWebHost Start()
{
container.Install(FromAssembly.This());
BeforeStart();
AppConfigurationProvider = container.Resolve <IAppConfigurationProvider>();
Configuration = AppConfigurationProvider.Get <WebHostConfiguration>();
Index = CreateIndex();
Storage = CreateStorage();
container
.Register(Component.For <IPathResolver>().ImplementedBy <PathResolver>())
.Register(Component.For <IJsonMergeVisitor>().ImplementedBy <JsonMergeVisitor>())
.Register(Component.For <IDiagnosticsDumpService>().ImplementedBy <DiagnosticsDumpService>())
.Register(Component.For <IJsonConverter>().ImplementedBy <DotjemJsonConverter>())
.Register(Component.For <ILazyComponentLoader>().ImplementedBy <LazyOfTComponentLoader>())
.Register(Component.For <IWindsorContainer>().Instance(container))
.Register(Component.For <IWebHost>().Instance(this))
.Register(Component.For <IStorageIndex>().Instance(Index))
.Register(Component.For <IStorageContext>().Instance(Storage))
.Register(Component.For <IWebHostConfiguration>().Instance(Configuration))
.Register(Component.For <IInitializationTracker>().Instance(Initialization));
ILogger perf = container.Resolve <ILogger>();
IPerformanceTracker startup = perf.TrackTask("Start");
DiagnosticsLogger = container.Resolve <IDiagnosticsLogger>();
perf.TrackAction(BeforeConfigure);
perf.TrackAction(() => Configure(container.Resolve <IPipeline>()), "Configure Pipeline");
perf.TrackAction(() => Configure(container), "Configure Container");
perf.TrackAction(() => Configure(Storage), "Configure Storage");
perf.TrackAction(() => Configure(Index), "Configure Index");
perf.TrackAction(() => Configure(new HttpRouterConfigurator(configuration.Routes)), "Configure Routes");
perf.TrackAction(AfterConfigure);
ResolveComponents();
Initialization.SetProgress("Bootstrapping.");
Task.Factory.StartNew(() =>
{
perf.TrackAction(BeforeInitialize);
Initialization.SetProgress("Initializing storage.");
perf.TrackAction(() => Initialize(Storage), "Initialize Storage");
Initialization.SetProgress("Initializing index.");
perf.TrackAction(() => Initialize(Index), "Initialize Index");
perf.TrackAction(AfterInitialize);
storageManager = container.Resolve <IStorageManager>();
indexManager = container.Resolve <IStorageIndexManager>();
Initialization.SetProgress("Loading index.");
perf.TrackAction(storageManager.Start);
perf.TrackAction(indexManager.Start);
perf.TrackAction(AfterStart);
Initialization.Complete();
startup.Dispose();
}).ContinueWith(async result => {
if (!result.IsFaulted)
{
return;
}
IDiagnosticsDumpService dump = Resolve <IDiagnosticsDumpService>();
Guid ticket = Guid.NewGuid();
try
{
if (result.Exception != null)
{
DiagnosticsLogger.LogException(Severity.Fatal, result.Exception, new { ticketId = ticket });
dump.Dump(ticket, result.Exception.ToString());
}
else
{
DiagnosticsLogger.LogFailure(Severity.Fatal, "Server startup failed. Unknown Error.", new { ticketId = ticket });
dump.Dump(ticket, "Server startup failed. Unknown Error.");
}
Initialization.SetProgress("Server startup failed. Please contact support. ({0})", ticket);
}
catch (Exception ex)
{
//TODO: (jmd 2015-10-01) Temporary Dumping of failure we don't know where to put.
string dumpMessage =
$"{ex}{Environment.NewLine}-----------------------------------{Environment.NewLine}{result.Exception}";
Initialization.SetProgress(dumpMessage);
dump.Dump(ticket, dumpMessage);
}
await Task.Delay(10.Minutes())
.ContinueWith(t =>
{
//NOTE: (jmd 2019-11-04) This restarts the application.
HttpRuntime.UnloadAppDomain();
});
});
return(this);
}
/// <summary>
/// Configures the services.
/// </summary>
/// <param name="services">Services.</param>
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
using (var deviceDbContext = new GeneralDbContext())
{
deviceDbContext.Database.EnsureCreated();
}
services.AddMvc()
.AddJsonOptions(
options => options.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore
).AddJsonOptions(options =>
{
options.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;
});
JsonConvert.DefaultSettings = () => new JsonSerializerSettings
{
Formatting = Formatting.Indented,
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
};
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Info {
Title = "MobileManager API", Version = "v1"
});
//Set the comments path for the swagger json and ui.
var basePath = AppContext.BaseDirectory;
var xmlPath = Path.Combine(basePath, "MobileManager.xml");
c.IncludeXmlComments(xmlPath);
});
services.AddReact();
services.AddMvc();
services.AddEntityFrameworkMultiDb()
.AddDbContext <GeneralDbContext>();
services.AddCors(options =>
{
options.AddPolicy("AllowAllHeaders",
builder =>
{
builder.AllowAnyOrigin()
.AllowAnyHeader()
.AllowAnyMethod();
});
});
services.AddTransient <IRepository <Device>, DeviceRepository>()
.AddTransient <IRepository <Reservation>, ReservationQueueRepository>()
.AddTransient <IRepository <ReservationApplied>, ReservationAppliedRepository>()
.AddTransient <IRepository <AppiumProcess>, AppiumRepository>()
.AddTransient <IRepository <LogMessage>, LoggerRepository>();
//services.AddSingleton<IManagerConfiguration, ManagerConfiguration>();
services.AddSingleton <IRestClient, RestClient>()
.AddSingleton <IAppiumService, AppiumService>()
.AddSingleton <IAdbController, AdbController>()
.AddSingleton <IHttpContextAccessor, HttpContextAccessor>()
.AddSingleton(typeof(IManagerConfiguration), AppConfigurationProvider.Get <ManagerConfiguration>())
.AddSingleton <IManagerLogger, ManagerLogger>()
.AddSingleton <IDeviceUtils, DeviceUtils>()
.AddSingleton <IScreenshotService, ScreenshotService>()
.AddSingleton <IExternalProcesses, ExternalProcesses>();
services.AddMvcCore().AddApiExplorer();
// Run hosted services
var configuration = AppConfigurationProvider.Get <ManagerConfiguration>();
if (configuration.AndroidServiceEnabled)
{
services.AddHostedService <AndroidDeviceService>();
}
if (configuration.IosServiceEnabled)
{
services.AddHostedService <IosDeviceService>();
}
services.AddHostedService <ReservationService>();
}
public PlutoDbContext()
{
Configuration = AppConfigurationProvider.BuildConfigurtions();
}
public void DefaultValueTest()
{
IToggleConfiguration provider = new AppConfigurationProvider(InitConfiguration());
Assert.IsFalse(provider.DefaultValue);
}
private async Task LoadConnectedAndroidDevicesAsync(CancellationToken cancellationToken)
{
_logger.Info($"{nameof(LoadConnectedAndroidDevicesAsync)} Thread started.");
try
{
while (!cancellationToken.IsCancellationRequested)
{
_logger.Debug($"Running {nameof(LoadConnectedAndroidDevicesAsync)}.");
if (await _restClient.TryToConnect())
{
var deviceIdAndStatus = GetAndroidDevicesFromAdbDevicesOutput();
await _deviceUtils.CheckAllDevicesInDevicePoolAreOnline(deviceIdAndStatus.Keys.ToList(),
DeviceType.Android, _restClient);
foreach (var deviceId in deviceIdAndStatus.Keys)
{
var deviceAlreadyInPool = await IsDeviceAlreadyInDevicePoolAsync(deviceId);
if (!deviceAlreadyInPool)
{
var state = deviceIdAndStatus[deviceId];
if (state != "device")
{
_logger.Error(
$"{nameof(LoadConnectedAndroidDevicesAsync)}: Device with id: [{deviceId}] is in incorrect state: [{state}]. Expected state is [device]");
continue;
}
}
else
{
continue;
}
_logger.Debug(
$"{nameof(LoadConnectedAndroidDevicesAsync)}: read device [{deviceId}] properties.");
var deviceName = GetDeviceName(deviceId);
if (string.IsNullOrWhiteSpace(deviceName))
{
_logger.Error(
$"{nameof(LoadConnectedAndroidDevicesAsync)}: Failed to get deviceName to device with id: '" +
deviceId + "'");
continue;
}
_logger.Debug(
$"{nameof(LoadConnectedAndroidDevicesAsync)}: new android device factory [{deviceId}] name [{deviceName.Trim('\n', '\r')}].");
var device = new DeviceFactory().NewDevice(deviceId, deviceName.Trim('\n', '\r'), true,
DeviceType.Android, DeviceStatus.Online);
var deviceProperties = GetDevicePropertiesById(deviceId);
var properties = new List <DeviceProperties>();
foreach (var prop in deviceProperties)
{
properties.Add(new DeviceProperties(prop.Key, prop.Value));
}
device.Properties = properties;
await TryAddNewDeviceToDevicePoolAsync(device);
_logger.Debug(
$"{nameof(LoadConnectedAndroidDevicesAsync)}: TryAddNewDeviceToDevicePoolAsync [{JsonConvert.SerializeObject(device)}].");
await TryAddNewDeviceToDevicePoolAsync(device);
}
var sleepTime = (await _restClient.GetManagerConfiguration()).AndroidDeviceServiceRefreshTime;
_logger.Debug($"{nameof(LoadConnectedAndroidDevicesAsync)}: sleep for [{sleepTime}].");
Thread.Sleep(sleepTime);
}
else
{
_logger.Error($"{nameof(LoadConnectedAndroidDevicesAsync)}: Failed connecting to " +
_restClient.Endpoint +
" [STOP]");
var sleep = AppConfigurationProvider.Get <ManagerConfiguration>().GlobalReconnectTimeout;
_logger.Info($"{nameof(LoadConnectedAndroidDevicesAsync)}: Sleep for [ms]: {sleep}");
Thread.Sleep(sleep);
_logger.Info($"{nameof(LoadConnectedAndroidDevicesAsync)}: Sleep finished");
}
}
_logger.Info($"{nameof(LoadConnectedAndroidDevicesAsync)} STOP.");
}
catch (Exception e)
{
_logger.Error($"Stopping {nameof(LoadConnectedAndroidDevicesAsync)}.", e);
}
if (cancellationToken.IsCancellationRequested)
{
var result = _externalProcesses.RunProcessAndReadOutput("adb", "kill-server");
_logger.Debug(
$"{nameof(LoadConnectedAndroidDevicesAsync)}: Stop ADB server to release ports - output:{result}");
}
}
