public static DeploymentStatusFile Open(string id, IEnvironment environment, IAnalytics analytics, IOperationLock statusLock)
{
return statusLock.LockOperation(() =>
{
string path = Path.Combine(environment.DeploymentsPath, id, StatusFile);
if (!FileSystemHelpers.FileExists(path))
{
return null;
}
try
{
XDocument document = null;
using (var stream = FileSystemHelpers.OpenRead(path))
{
document = XDocument.Load(stream);
}
return new DeploymentStatusFile(id, environment, statusLock, document);
}
catch (Exception ex)
{
// in the scenario where w3wp is abruptly terminated while xml is being written,
// we may end up with corrupted xml. we will handle the error and remove the problematic directory.
analytics.UnexpectedException(ex);
FileSystemHelpers.DeleteDirectorySafe(Path.GetDirectoryName(path), ignoreErrors: true);
// it is ok to return null as callers already handle null.
return null;
}
}, DeploymentStatusManager.LockTimeout);
}
public StructuredTextLogger(string path, IAnalytics analytics)
{
_depth = 0;
_path = path;
_analytics = analytics;
_structuredTextDocument = new StructuredTextDocument<LogEntry>(path,
// DateTime.ToString("o") => "2015-08-04T00:08:38.5489308Z"
e => string.Join(LogEntrySeparator, e.LogTime.ToString("o"), e.Message, e.Id, (int)e.Type),
str =>
{
var splitted = str.Split(new[] { LogEntrySeparator }, StringSplitOptions.None);
if (splitted.Length == 4)
{
var time = DateTime.Parse(splitted[0]).ToUniversalTime();
var message = UnsanitizeValue(splitted[1]);
var id = splitted[2];
var type = (LogEntryType)Int32.Parse(splitted[3]);
return new LogEntry(time, id, message, type);
}
else
{
throw new FormatException(string.Format("the log line \"{0}\" is in an invalid format", str));
}
});
}
public ContinuousJobRunner(string jobName, IEnvironment environment, IFileSystem fileSystem, IDeploymentSettingsManager settings, ITraceFactory traceFactory, IAnalytics analytics)
: base(jobName, Constants.ContinuousPath, environment, fileSystem, settings, traceFactory, analytics)
{
_continuousJobLogger = new ContinuousJobLogger(jobName, Environment, FileSystem, TraceFactory);
_disableFilePath = Path.Combine(JobBinariesPath, "disable.job");
_singletonFilePath = Path.Combine(JobBinariesPath, "singleton.job");
}
public TriggeredJobsScheduler(ITriggeredJobsManager triggeredJobsManager, ITraceFactory traceFactory, IAnalytics analytics, IEnvironment environment)
{
_triggeredJobsManager = triggeredJobsManager;
_traceFactory = traceFactory;
_environment = environment;
_jobsFileWatcher = new JobsFileWatcher(triggeredJobsManager.JobsBinariesPath, OnJobChanged, JobSettings.JobSettingsFileName, ListJobNames, traceFactory, analytics);
}
public DynamicsCrmConnector(ICrmServiceWrapper crmService, ILogger logger, IAnalytics analytics)
{
_crmService = crmService;
_logger = logger;
_analytics = analytics;
DynamicsMapper.Configure();
}
public SiteExtensionController(ISiteExtensionManager manager, IEnvironment environment, ITraceFactory traceFactory, IAnalytics analytics)
{
_manager = manager;
_environment = environment;
_traceFactory = traceFactory;
_analytics = analytics;
_siteExtensionRoot = Path.Combine(_environment.RootPath, "SiteExtensions");
}
public TriggeredJobsScheduler(ITriggeredJobsManager triggeredJobsManager, ITraceFactory traceFactory, IEnvironment environment, IAnalytics analytics)
{
_triggeredJobsManager = triggeredJobsManager;
_traceFactory = traceFactory;
_environment = environment;
_analytics = analytics;
_triggeredJobsManager.RegisterExtraEventHandlerForFileChange(OnJobChanged);
}
public TriggeredJobSchedule(TriggeredJob triggeredJob, Action<TriggeredJobSchedule> onSchedule, TriggeredJobSchedulerLogger logger, IAnalytics analytics)
{
TriggeredJob = triggeredJob;
_onSchedule = onSchedule;
Logger = logger;
_analytics = analytics;
_timer = new Timer(OnTimer, triggeredJob, Timeout.Infinite, Timeout.Infinite);
}
public ContinuousJobRunner(ContinuousJob continuousJob, IEnvironment environment, IDeploymentSettingsManager settings, ITraceFactory traceFactory, IAnalytics analytics)
: base(continuousJob.Name, Constants.ContinuousPath, environment, settings, traceFactory, analytics)
{
_continuousJobLogger = new ContinuousJobLogger(continuousJob.Name, Environment, TraceFactory);
_disableFilePath = Path.Combine(continuousJob.JobBinariesRootPath, "disable.job");
_singletonLock = new LockFile(Path.Combine(JobDataPath, "singleton.job.lock"), TraceFactory);
}
public DeploymentStatusManager(IEnvironment environment,
IAnalytics analytics,
IOperationLock statusLock)
{
_environment = environment;
_analytics = analytics;
_statusLock = statusLock;
_activeFile = Path.Combine(environment.DeploymentsPath, Constants.ActiveDeploymentFile);
}
public SiteExtensionManager(IContinuousJobsManager continuousJobManager, ITriggeredJobsManager triggeredJobManager, IEnvironment environment, IDeploymentSettingsManager settings, ITraceFactory traceFactory, HttpContextBase context, IAnalytics analytics)
{
_rootPath = Path.Combine(environment.RootPath, "SiteExtensions");
_baseUrl = context.Request.Url == null ? String.Empty : context.Request.Url.GetLeftPart(UriPartial.Authority).TrimEnd('/');
_localRepository = GetSourceRepository(_rootPath);
_continuousJobManager = continuousJobManager;
_triggeredJobManager = triggeredJobManager;
_environment = environment;
_settings = settings;
_traceFactory = traceFactory;
_analytics = analytics;
}
protected BaseJobRunner(string jobName, string jobsTypePath, IEnvironment environment,
IDeploymentSettingsManager settings, ITraceFactory traceFactory, IAnalytics analytics)
{
TraceFactory = traceFactory;
Environment = environment;
Settings = settings;
JobName = jobName;
_analytics = analytics;
JobBinariesPath = Path.Combine(Environment.JobsBinariesPath, jobsTypePath, jobName);
JobTempPath = Path.Combine(Environment.TempPath, Constants.JobsPath, jobsTypePath, jobName);
JobDataPath = Path.Combine(Environment.DataPath, Constants.JobsPath, jobsTypePath, jobName);
_externalCommandFactory = new ExternalCommandFactory(Environment, Settings, Environment.RepositoryPath);
}
public AnalyticsTests()
{
Scheduler.Shutdown();
Scheduler.Initialize((config =>
{
config.EnableWebApiSelfHost = false;
config.EnableAuditHistory = false;
config.PersistanceStoreType = PersistanceStoreType.InMemory;
config.AutoStart = false;
}));
IPersistanceStore persistanceStore = new InMemoryStore();
_analytics = new Analytics(Scheduler.Instance(), persistanceStore);
_schedulerCore = new SchedulerCore(Scheduler.Instance(), persistanceStore);
}
/// <summary>
/// Get Analytics Instance
/// </summary>
/// <param name="accountId">accountId, when you setup your app this would be generated for you.</param>
/// <param name="applicationId">applicationId, when you setup your app this would be generated for you</param>
/// <param name="applicationVersion"> applicationVersion, specify version of your app here, make sure you don't forget to update this</param>
/// <param name="uploadType">uploadType how data is going to be uploaded, UploadType.WhileUsingAsync | UploadType.Manual</param>
/// <returns>iAnalytics new or cached instance</returns>
/// <see cref="Integration Guidelines SDK Document"/>
public static IAnalytics GetInstance()
{
lock (objectToLock)
{
if (iAnalytics == null)
{
#if DEBUG
System.Diagnostics.Debug.WriteLine("created new analytics instance");
#endif
iAnalytics = new Analytics();
}
}
return iAnalytics;
}
public DeploymentController(ITracer tracer,
IEnvironment environment,
IAnalytics analytics,
IDeploymentManager deploymentManager,
IDeploymentStatusManager status,
IOperationLock deploymentLock,
IRepositoryFactory repositoryFactory,
IAutoSwapHandler autoSwapHandler)
{
_tracer = tracer;
_environment = environment;
_analytics = analytics;
_deploymentManager = deploymentManager;
_status = status;
_deploymentLock = deploymentLock;
_repositoryFactory = repositoryFactory;
_autoSwapHandler = autoSwapHandler;
}
public DeploymentManager(ISiteBuilderFactory builderFactory,
IEnvironment environment,
ITraceFactory traceFactory,
IAnalytics analytics,
IDeploymentSettingsManager settings,
IDeploymentStatusManager status,
IOperationLock deploymentLock,
ILogger globalLogger,
IWebHooksManager hooksManager)
{
_builderFactory = builderFactory;
_environment = environment;
_traceFactory = traceFactory;
_analytics = analytics;
_deploymentLock = deploymentLock;
_globalLogger = globalLogger ?? NullLogger.Instance;
_settings = settings;
_status = status;
_hooksManager = hooksManager;
}
public JobsFileWatcher(
string watchedDirectoryPath,
Action<string> onJobChanged,
string filter,
Func<IEnumerable<string>> listJobNames,
ITraceFactory traceFactory,
IAnalytics analytics)
{
_traceFactory = traceFactory;
_analytics = analytics;
_watchedDirectoryPath = watchedDirectoryPath;
_onJobChanged = onJobChanged;
_filter = filter;
_listJobNames = listJobNames;
_makeChangesTimer = new Timer(OnMakeChanges);
_startFileWatcherTimer = new Timer(StartWatcher);
_startFileWatcherTimer.Change(0, Timeout.Infinite);
FirstTimeMakingChanges = true;
}
public static void TrackPage(this IAnalytics target, Type screenType)
{
target.TrackPage(screenType.FullName);
}
public TriggeredJobsScheduler(ITriggeredJobsManager triggeredJobsManager, ITraceFactory traceFactory, IAnalytics analytics, IEnvironment environment)
{
_triggeredJobsManager = triggeredJobsManager;
_traceFactory = traceFactory;
_environment = environment;
_jobsFileWatcher = new JobsFileWatcher(triggeredJobsManager.JobsBinariesPath, OnJobChanged, JobSettings.JobSettingsFileName, ListJobNames, traceFactory, analytics);
}
/// <summary>
/// Updates the app.config using XML directly for injecting trace providers.
/// </summary>
internal static void UpdateAppConfigAddTraceListeners(string configFilePath, IAnalytics analytics)
{
try
{
var xmlConfig = XDocument.Load(configFilePath);
// save the LastWriteTime before our modification, so we can restore
// it below
FileInfo fileInfo = new FileInfo(configFilePath);
DateTime lastWriteTime = fileInfo.LastWriteTimeUtc;
// Make sure the trace listeners section available otherwise create it
var configurationElement = GetOrCreateElement(xmlConfig, "configuration");
var systemDiagnosticsElement = GetOrCreateElement(configurationElement, "system.diagnostics");
var traceElement = GetOrCreateElement(systemDiagnosticsElement, "trace");
var listenersElement = GetOrCreateElement(traceElement, "listeners");
// Inject existing trace providers to the target app.config
foreach (TraceListener listener in Trace.Listeners)
{
// Ignore the default trace provider
if (String.Equals(listener.Name, "default", StringComparison.OrdinalIgnoreCase))
{
continue;
}
// Do not add a trace provider if it already exists (by name)
XElement listenerElement = listenersElement.Elements().FirstOrDefault(xElement =>
{
XAttribute nameAttribute = xElement.Attribute("name");
return nameAttribute != null && String.Equals(nameAttribute.Value, listener.Name, StringComparison.OrdinalIgnoreCase);
});
if (listenerElement == null)
{
var addElement = new XElement("add");
addElement.Add(new XAttribute("name", listener.Name));
addElement.Add(new XAttribute("type", listener.GetType().AssemblyQualifiedName));
listenersElement.AddFirst(addElement);
}
}
FileSystemHelpers.WriteAllText(configFilePath, xmlConfig.ToString());
// we need to restore the previous last update time so our file write
// doesn't cause the job directory to be considered dirty
fileInfo.LastWriteTimeUtc = lastWriteTime;
}
catch (Exception ex)
{
analytics.UnexpectedException(ex);
}
}
public OnboardingWhatViewModel(INavigationService nav, IAnalytics analytics) : base(nav, analytics)
{
}
public OnboardingAuthViewModel(INavigationService nav, AuthorizeHealthCommand authorizer, IAnalytics analytics) : base(nav, analytics)
{
AuthorizeHealthCommand = authorizer.GetCommand();
}
public TriggeredJobRunner(string jobName, IEnvironment environment, IDeploymentSettingsManager settings, ITraceFactory traceFactory, IAnalytics analytics)
: base(jobName, Constants.TriggeredPath, environment, settings, traceFactory, analytics)
{
_lockFile = BuildTriggeredJobRunnerLockFile(JobDataPath, TraceFactory);
}
public XmlLogger(IFileSystem fileSystem, string path, IAnalytics analytics)
{
_fileSystem = fileSystem;
_path = path;
_analytics = analytics;
}
public XmlLogger(string path, IAnalytics analytics)
{
_path = path;
_analytics = analytics;
}
public GithubDataStore(HttpClient httpClient, IConnectivity connectivity, IBarrel barrel, ILogger <GithubDataStore> logger, IAnalytics analytics)
{
_httpClient = httpClient;
_connectivity = connectivity;
_barrel = barrel;
_logger = logger;
_analytics = analytics;
httpClient.BaseAddress = new Uri(baseUrl);
}
public SystemStatusModule(ISettingsService <PlexRequestSettings> settingsService, ICacheProvider cache, ISettingsService <SystemSettings> ss, ISecurityExtensions security, IAnalytics a) : base("admin", settingsService, security)
{
Cache = cache;
SystemSettings = ss;
Analytics = a;
Before += (ctx) => Security.AdminLoginRedirect(Permissions.Administrator, ctx);
Get["/status", true] = async(x, ct) => await Status();
Post["/save", true] = async(x, ct) => await Save();
Post["/autoupdate"] = x => AutoUpdate();
}
public static string GetAnalyticsCode(IAnalytics that) => that.Value <string>("analyticsCode");
public CultureModule(ISettingsService <PlexRequestSettings> pr, IAnalytics a, ISecurityExtensions security) : base("culture", pr, security)
{
Analytics = a;
Get["/"] = x => SetCulture();
}
public void Init()
{
_uiHelper = new TestUiHelper();
_analytics = Substitute.For<IAnalytics>();
_asyncAnalytics = new AsyncAnalytics(_analytics, _uiHelper);
}
public UserLoginModule(ISettingsService <AuthenticationSettings> auth, IPlexApi api, ISettingsService <PlexSettings> plexSettings, ISettingsService <PlexRequestSettings> pr,
ISettingsService <LandingPageSettings> lp, IAnalytics a, IResourceLinker linker, IRepository <UserLogins> userLogins, IExternalUserRepository <PlexUsers> plexUsers, ICustomUserMapper custom,
ISecurityExtensions security, ISettingsService <UserManagementSettings> userManagementSettings, IEmbyApi embyApi, ISettingsService <EmbySettings> emby, IExternalUserRepository <EmbyUsers> embyU,
IUserHelper userHelper)
: base("userlogin", pr, security)
{
AuthService = auth;
LandingPageSettings = lp;
Analytics = a;
PlexApi = api;
PlexSettings = plexSettings;
Linker = linker;
UserLogins = userLogins;
PlexUserRepository = plexUsers;
CustomUserMapper = custom;
UserManagementSettings = userManagementSettings;
EmbySettings = emby;
EmbyApi = embyApi;
EmbyUserRepository = embyU;
UserHelper = userHelper;
Post["/", true] = async(x, ct) => await LoginUser();
Get["/logout"] = x => Logout();
Get["UserLoginIndex", "/", true] = async(x, ct) =>
{
if (Request.Query["landing"] == null)
{
var s = await LandingPageSettings.GetSettingsAsync();
if (s.Enabled)
{
if (s.BeforeLogin) // Before login
{
if (string.IsNullOrEmpty(Username))
{
// They are not logged in
return
(Context.GetRedirect(Linker.BuildRelativeUri(Context, "LandingPageIndex").ToString()));
}
return(Context.GetRedirect(Linker.BuildRelativeUri(Context, "SearchIndex").ToString()));
}
// After login
if (string.IsNullOrEmpty(Username))
{
// Not logged in yet
return(Context.GetRedirect(Linker.BuildRelativeUri(Context, "UserLoginIndex").ToString() + "?landing"));
}
// Send them to landing
var landingUrl = Linker.BuildRelativeUri(Context, "LandingPageIndex").ToString();
return(Context.GetRedirect(landingUrl));
}
}
if (!string.IsNullOrEmpty(Username) || IsAdmin)
{
var url = Linker.BuildRelativeUri(Context, "SearchIndex").ToString();
return(Response.AsRedirect(url));
}
var settings = await AuthService.GetSettingsAsync();
return(View["Username", settings]);
};
Post["/login", true] = async(x, ct) => await UsernameLogin();
Post["/password", true] = async(x, ct) => await PasswordLogin();
}
public ContinuousJobsManager(ITraceFactory traceFactory, IEnvironment environment, IDeploymentSettingsManager settings, IAnalytics analytics)
: base(traceFactory, environment, settings, analytics, Constants.ContinuousPath)
{
_makeChangesTimer = new Timer(OnMakeChanges);
_startFileWatcherTimer = new Timer(StartWatcher);
_startFileWatcherTimer.Change(0, Timeout.Infinite);
}
public UserWizardModule(ISettingsService <PlexRequestSettings> pr, ISettingsService <PlexSettings> plex, IPlexApi plexApi,
ISettingsService <AuthenticationSettings> auth, ICustomUserMapper m, IAnalytics a) : base("wizard", pr)
{
PlexSettings = plex;
PlexApi = plexApi;
PlexRequestSettings = pr;
Auth = auth;
Mapper = m;
Analytics = a;
Get["/", true] = async(x, ct) =>
{
a.TrackEventAsync(Category.Wizard, Action.Start, "Started the wizard", Username, CookieHelper.GetAnalyticClientId(Cookies));
var settings = await PlexRequestSettings.GetSettingsAsync();
if (settings.Wizard)
{
return(Context.GetRedirect("~/search"));
}
return(View["Index"]);
};
Post["/plexAuth"] = x => PlexAuth();
Post["/plex", true] = async(x, ct) => await Plex();
Post["/plexrequest", true] = async(x, ct) => await PlexRequest();
Post["/auth", true] = async(x, ct) => await Authentication();
Post["/createuser", true] = async(x, ct) => await CreateUser();
}
public XmlLogger(string path, IAnalytics analytics)
{
_path = path;
_analytics = analytics;
}
/// <summary>
/// <para>Scan every site extensions, check if there is any successful installation</para>
/// <para>Looking for below cases:</para>
/// <para>if not install to webroot, trigger restart; if install to webroot and with applicationHost.xdt file, trigger restart.</para>
/// </summary>
/// <param name="siteExtensionStatusRoot">should be $ROOT\site\siteextensions</param>
/// <param name="siteExtensionRoot">should be $ROOT\SiteExtensions</param>
public static bool IsAnyInstallationRequireRestart(string siteExtensionStatusRoot, string siteExtensionRoot, ITracer tracer, IAnalytics analytics)
{
try
{
using (tracer.Step("Checking if there is any installation require site restart ..."))
{
string[] packageDirs = FileSystemHelpers.GetDirectories(siteExtensionStatusRoot);
// folder name is the package id
foreach (var dir in packageDirs)
{
try
{
DirectoryInfo dirInfo = new DirectoryInfo(dir);
var statusSettings = new SiteExtensionStatus(siteExtensionStatusRoot, dirInfo.Name, tracer);
if (statusSettings.IsSiteExtensionRequireRestart(siteExtensionRoot))
{
return true;
}
}
catch (Exception ex)
{
analytics.UnexpectedException(ex, trace: false);
tracer.TraceError(ex, "Failed to query {0} under {1}, continus to check others ...", _statusSettingsFileName, dir);
}
}
}
}
catch (Exception ex)
{
analytics.UnexpectedException(ex, trace: false);
tracer.TraceError(ex, "Not able to query directory under {0}", siteExtensionStatusRoot);
}
return false;
}
private static DeploymentManager CreateDeploymentManager(
ISiteBuilderFactory builderFactory = null,
IEnvironment environment = null,
IFileSystem fileSystem = null,
ITraceFactory traceFactory = null,
IAnalytics analytics = null,
IDeploymentSettingsManager settings = null,
IDeploymentStatusManager status = null,
IOperationLock deploymentLock = null,
ILogger globalLogger = null,
IWebHooksManager hooksManager = null)
{
builderFactory = builderFactory ?? Mock.Of<ISiteBuilderFactory>();
environment = environment ?? Mock.Of<IEnvironment>();
FileSystemHelpers.Instance = fileSystem ?? Mock.Of<IFileSystem>();
traceFactory = traceFactory ?? Mock.Of<ITraceFactory>();
analytics = analytics ?? Mock.Of<IAnalytics>();
settings = settings ?? Mock.Of<IDeploymentSettingsManager>();
status = status ?? Mock.Of<IDeploymentStatusManager>();
deploymentLock = deploymentLock ?? Mock.Of<IOperationLock>();
globalLogger = globalLogger ?? Mock.Of<ILogger>();
return new DeploymentManager(builderFactory, environment, traceFactory, analytics, settings, status, deploymentLock, globalLogger, hooksManager);
}
/// <summary>
/// Creates an instance of AppCenterTraceListener
/// </summary>
/// <param name="analytics">Keep this as NULL to use the default implementation. This is only exposed for unit testing purposes</param>
/// <param name="crashes">Keep this as NULL to use the default implementation. This is only exposed for unit testing purposes</param>
public AppCenterTraceListener(IAnalytics analytics = null, ICrashes crashes = null)
{
Analytics = analytics ?? AppCenterAnalytics.Instance;
Crashes = crashes ?? AppCenterCrashes.Instance;
}
public UserManagementModule(ISettingsService <PlexRequestSettings> pr, ICustomUserMapper m, IPlexApi plexApi, ISettingsService <PlexSettings> plex, IRepository <UserLogins> userLogins, IExternalUserRepository <PlexUsers> plexRepo
, ISecurityExtensions security, IRequestService req, IAnalytics ana, ISettingsService <EmbySettings> embyService, IEmbyApi embyApi, IExternalUserRepository <EmbyUsers> embyRepo) : base("usermanagement", pr, security)
{
#if !DEBUG
Before += (ctx) => Security.AdminLoginRedirect(Permissions.Administrator, ctx);
#endif
UserMapper = m;
PlexApi = plexApi;
PlexSettings = plex;
UserLoginsRepo = userLogins;
PlexUsersRepository = plexRepo;
PlexRequestSettings = pr;
RequestService = req;
Analytics = ana;
EmbySettings = embyService;
EmbyApi = embyApi;
EmbyRepository = embyRepo;
Get["/"] = x => Load();
Get["/users", true] = async(x, ct) => await LoadUsers();
Post["/createuser", true] = async(x, ct) => await CreateUser();
Get["/local/{id}"] = x => LocalDetails((Guid)x.id);
Get["/plex/{id}", true] = async(x, ct) => await PlexDetails(x.id);
Get["/permissions"] = x => GetEnum <Permissions>();
Get["/features"] = x => GetEnum <Features>();
Post["/updateuser", true] = async(x, ct) => await UpdateUser();
Post["/deleteuser"] = x => DeleteUser();
}
public AggregateTriggeredJobsManager(ITraceFactory traceFactory, IEnvironment environment, IDeploymentSettingsManager settings, IAnalytics analytics, IWebHooksManager hooksManager, IHttpContextAccessor httpContextAccessor)
: base(new TriggeredJobsManager(environment.JobsBinariesPath, traceFactory, environment, settings, analytics, hooksManager, httpContextAccessor),
excludedList => new TriggeredJobsManager(environment.SecondaryJobsBinariesPath, traceFactory, environment, settings, analytics, hooksManager, httpContextAccessor, excludedList),
settings, environment, traceFactory, Constants.TriggeredPath)
{
}
internal TraceDeprecatedActionAttribute(IAnalytics analytics, ITraceFactory traceFactory)
{
_analytics = analytics;
_traceFactory = traceFactory;
}
protected BaseJobRunner(string jobName, string jobsTypePath, IEnvironment environment,
IDeploymentSettingsManager settings, ITraceFactory traceFactory, IAnalytics analytics)
{
TraceFactory = traceFactory;
Environment = environment;
Settings = settings;
JobName = jobName;
_analytics = analytics;
JobBinariesPath = Path.Combine(Environment.JobsBinariesPath, jobsTypePath, jobName);
JobTempPath = Path.Combine(Environment.TempPath, Constants.JobsPath, jobsTypePath, jobName);
JobDataPath = Path.Combine(Environment.DataPath, Constants.JobsPath, jobsTypePath, jobName);
_externalCommandFactory = new ExternalCommandFactory(Environment, Settings, Environment.RepositoryPath);
}
internal static void UpdateAppConfigs(string tempJobInstancePath, IAnalytics analytics)
{
IEnumerable<string> configFilePaths = FileSystemHelpers.ListFiles(tempJobInstancePath, SearchOption.AllDirectories, AppConfigFilesLookupList);
foreach (string configFilePath in configFilePaths)
{
UpdateAppConfig(configFilePath, analytics);
UpdateAppConfigAddTraceListeners(configFilePath, analytics);
}
}
public TriggeredJobRunner(string jobName, IEnvironment environment, IFileSystem fileSystem, IDeploymentSettingsManager settings, ITraceFactory traceFactory, IAnalytics analytics)
: base(jobName, Constants.TriggeredPath, environment, fileSystem, settings, traceFactory, analytics)
{
_lockFile = new LockFile(Path.Combine(JobDataPath, "triggeredJob.lock"), TraceFactory, FileSystem);
}
internal static void UpdateAppConfig(string configFilePath, IAnalytics analytics)
{
try
{
var settings = SettingsProcessor.Instance;
bool updateXml = false;
// Read app.config
string exeFilePath = configFilePath.Substring(0, configFilePath.Length - ".config".Length);
// Only continue to update config file if the corresponding exe file exists
if (!FileSystemHelpers.FileExists(exeFilePath))
{
return;
}
// save the LastWriteTime before our modification, so we can restore
// it below
FileInfo fileInfo = new FileInfo(configFilePath);
DateTime lastWriteTime = fileInfo.LastWriteTimeUtc;
Configuration config = ConfigurationManager.OpenExeConfiguration(exeFilePath);
foreach (var appSetting in settings.AppSettings)
{
config.AppSettings.Settings.Remove(appSetting.Key);
config.AppSettings.Settings.Add(appSetting.Key, appSetting.Value);
updateXml = true;
}
foreach (ConnectionStringSettings connectionString in settings.ConnectionStrings)
{
ConnectionStringSettings currentConnectionString = config.ConnectionStrings.ConnectionStrings[connectionString.Name];
if (currentConnectionString != null)
{
// Update provider name if connection string already exists and provider name is null (custom type)
connectionString.ProviderName = connectionString.ProviderName ?? currentConnectionString.ProviderName;
}
config.ConnectionStrings.ConnectionStrings.Remove(connectionString.Name);
config.ConnectionStrings.ConnectionStrings.Add(connectionString);
updateXml = true;
}
if (updateXml)
{
// Write updated app.config
config.Save();
}
// we need to restore the previous last update time so our file write
// doesn't cause the job directory to be considered dirty
fileInfo.LastWriteTimeUtc = lastWriteTime;
}
catch (Exception ex)
{
analytics.UnexpectedException(ex);
}
}
private void InitWithMocks()
{
_uiHelper = Substitute.For<IUiHelper>();
_analytics = Substitute.For<IAnalytics>();
_asyncAnalytics = new AsyncAnalytics(_analytics, _uiHelper);
}
public JobStartedReporter(IAnalytics analytics, JobBase job, string trigger, string siteMode, string jobDataPath)
{
_analytics = analytics;
_job = job;
_trigger = trigger;
_siteMode = siteMode;
_jobDataPath = jobDataPath;
_timer = new Timer(Report, null, ReportTimeoutInMilliseconds, Timeout.Infinite);
}
public static void LogEvent(this IAnalytics target, string eventId)
{
target.LogEvent(eventId, (IDictionary <string, string>)null);
}
public DeploymentAnalytics(IAnalytics analytics, IDeploymentSettingsManager settings)
{
_analytics = analytics;
_siteMode = settings.GetWebSiteSku();
}
public AggregateContinuousJobsManager(ITraceFactory traceFactory, IEnvironment environment, IDeploymentSettingsManager settings, IAnalytics analytics)
: base(new ContinuousJobsManager(environment.JobsBinariesPath, traceFactory, environment, settings, analytics),
excludedList => new ContinuousJobsManager(environment.SecondaryJobsBinariesPath, traceFactory, environment, settings, analytics, excludedList),
settings, environment, traceFactory, Constants.ContinuousPath)
{
}
