public SiteBuilderFactoryDispatcher(IDeploymentSettingsManager settingsManager, IBuildPropertyProvider propertyProvider, IEnvironment environment)
{
_settingsManager = settingsManager;
_originalSiteBuilderFactory = new SiteBuilderFactory(settingsManager, propertyProvider, environment);
_generatorSiteBuilderFactory = new Generator.SiteBuilderFactory(settingsManager, propertyProvider, environment);
}
public LibGit2SharpRepository(IEnvironment environment, IDeploymentSettingsManager settings, ITraceFactory tracerFactory)
{
_tracerFactory = tracerFactory;
_settings = settings;
RepositoryPath = environment.RepositoryPath;
_legacyGitExeRepository = new GitExeRepository(environment, settings, tracerFactory);
}
public virtual IDynamic Call(IEnvironment environment, IDynamic thisBinding, IArgs args)
{
var oldContext = environment.Context;
var newEnvironment = Scope.NewDeclarativeEnvironment();
using (var newContext = environment.EnterContext())
{
newContext.LexicalEnviroment = newEnvironment;
newContext.VariableEnviroment = newEnvironment;
newContext.Strict = ExecutableCode.Strict;
if (ExecutableCode.Strict)
{
newContext.ThisBinding = thisBinding;
}
else
{
switch (thisBinding.TypeCode)
{
case LanguageTypeCode.Undefined:
case LanguageTypeCode.Null:
newContext.ThisBinding = Environment.GlobalObject;
break;
default:
newContext.ThisBinding = thisBinding.ConvertToObject();
break;
}
}
BindFormalParameters(args);
Environment.BindFunctionDeclarations(ExecutableCode.FunctionDeclarations, ExecutableCode.Strict, true);
BindArgumentsObject(args);
Environment.BindVariableDeclarations(ExecutableCode.VariableDeclarations, ExecutableCode.Strict, true);
return ExecutableCode.Code(environment, args);
}
}
IHost IIsolator.Build(IEnvironment environment)
{
var domainName = _options.DomainName ?? Guid.NewGuid().ToString();
var strongName = typeof (Jail).Assembly.Evidence.GetHostEvidence<StrongName>();
var domain = System.AppDomain.CreateDomain(domainName, null, _options.Setup, _options.Permissions, strongName, typeof(object).Assembly.Evidence.GetHostEvidence<StrongName>());
var host = (AppDomainHost) Activator.CreateInstanceFrom(domain,
typeof (AppDomainHost).Assembly.CodeBase,
typeof (AppDomainHost).FullName)
.Unwrap();
host.AddAssembly(typeof (Jail).Assembly.GetName());
foreach (var registration in environment.GetRegistrations())
{
if (registration is AssemblyName)
{
host.AddAssembly((AssemblyName) registration);
}
else if (registration is InMemoryAssembly)
{
host.AddAssembly((InMemoryAssembly) registration);
}
}
return host;
}
public SessionHandler(ILogger<SessionHandler> logger,
IEnvironment environment,
IFileSystem fileSystem,
IKeyValueStore keyValueStore,
IMessageBus messageBus,
ISession session,
ITorrentInfoRepository torrentInfoRepository,
ITorrentMetadataRepository metadataRepository)
{
if (logger == null) throw new ArgumentNullException("logger");
if (environment == null) throw new ArgumentNullException("environment");
if (fileSystem == null) throw new ArgumentNullException("fileSystem");
if (keyValueStore == null) throw new ArgumentNullException("keyValueStore");
if (messageBus == null) throw new ArgumentNullException("messageBus");
if (session == null) throw new ArgumentNullException("session");
if (torrentInfoRepository == null) throw new ArgumentNullException("torrentInfoRepository");
if (metadataRepository == null) throw new ArgumentNullException("metadataRepository");
_logger = logger;
_environment = environment;
_fileSystem = fileSystem;
_keyValueStore = keyValueStore;
_messageBus = messageBus;
_session = session;
_torrentInfoRepository = torrentInfoRepository;
_metadataRepository = metadataRepository;
_muted = new List<string>();
_alertsThread = new Thread(ReadAlerts);
}
public DeploymentStatusManager(IEnvironment environment,
IFileSystem fileSystem)
{
_environment = environment;
_fileSystem = fileSystem;
_activeFile = Path.Combine(environment.DeploymentCachePath, Constants.ActiveDeploymentFile);
}
public ExternalCommandFactory(IEnvironment environment, IDeploymentSettingsManager settings, string repositoryPath)
{
_environment = environment;
_deploymentSettings = settings;
_repositoryPath = repositoryPath;
}
// Return a list of folders that need to be on the %PATH%
public virtual List<string> GetPathFolders(IEnvironment environment)
{
// Add the msbuild path and git path to the %PATH% so more tools are available
var toolsPaths = new List<string> {
environment.DeploymentToolsPath, // Add /site/deployments/tools to the path to allow users to drop tools in there
environment.ScriptPath,
Path.GetDirectoryName(ResolveMSBuildPath()),
Path.GetDirectoryName(ResolveGitPath()),
Path.GetDirectoryName(ResolveVsTestPath()),
Path.GetDirectoryName(ResolveSQLCmdPath()),
Path.GetDirectoryName(ResolveFSharpCPath())
};
toolsPaths.AddRange(ResolveGitToolPaths());
toolsPaths.AddRange(ResolveNodeNpmPaths());
toolsPaths.Add(ResolveNpmGlobalPrefix());
toolsPaths.AddRange(new[]
{
ResolveBowerPath(),
ResolveGruntPath(),
ResolveGulpPath()
}.Where(p => !String.IsNullOrEmpty(p)).Select(Path.GetDirectoryName));
return toolsPaths;
}
public HGeneratorIterator(IEnvironment environment, Generator generator, ReadOnlyList<string> variableDeclarations, ILexicalEnvironment scope)
: base(environment)
{
Generator = generator;
VariableDeclarations = variableDeclarations;
Scope = scope;
}
public override IDynamic CreateIterator(IEnvironment environment, IArgs args)
{
var scope = Scope.NewDeclarativeEnvironment();
var generator = new Generator(new GeneratorSteps(Steps));
var iterator = new HGeneratorIterator(environment, generator, VariableDeclarations, scope);
return iterator;
}
public static void MyClassInitialize(TestContext testContext)
{
ObjectFactory.Inject<IEnvironment>(new Environment());
ObjectFactory.Inject<IDatabaseConnection>(new DatabaseConnection());
_environment = ObjectFactory.GetInstance<IEnvironment>();
}
private static void OldRunsCleanup(string jobName, IFileSystem fileSystem, IEnvironment environment, ITraceFactory traceFactory, IDeploymentSettingsManager settings)
{
// if max is 5 and we have 5 we still want to remove one to make room for the next
// that's why we decrement max value by 1
int maxRuns = settings.GetMaxJobRunsHistoryCount() - 1;
string historyPath = Path.Combine(environment.JobsDataPath, Constants.TriggeredPath, jobName);
DirectoryInfoBase historyDirectory = fileSystem.DirectoryInfo.FromDirectoryName(historyPath);
if (!historyDirectory.Exists)
{
return;
}
DirectoryInfoBase[] historyRunsDirectories = historyDirectory.GetDirectories();
if (historyRunsDirectories.Length <= maxRuns)
{
return;
}
var directoriesToRemove = historyRunsDirectories.OrderByDescending(d => d.Name).Skip(maxRuns);
foreach (DirectoryInfoBase directory in directoriesToRemove)
{
try
{
directory.Delete(true);
}
catch (Exception ex)
{
traceFactory.GetTracer().TraceError(ex);
}
}
}
public HGeneratorIterable(IEnvironment environment, ReadOnlyList<GeneratorStep> steps, ReadOnlyList<string> variableDeclarations, ILexicalEnvironment scope)
: base(environment)
{
Steps = steps;
VariableDeclarations = variableDeclarations;
Scope = scope;
}
public void SetHomePath(IEnvironment environment)
{
if (!String.IsNullOrEmpty(environment.RootPath))
{
SetHomePath(environment.RootPath);
}
}
public AppVeyor(Logger logger, IEnvironment environment, IHttpClientFactory httpClientFactory)
{
_logger = logger;
_environment = environment;
_httpClientFactory = httpClientFactory;
_appVeyorApiUrl = _environment.GetEnvironmentVariable("APPVEYOR_API_URL");
}
public RepositoryFactory(IEnvironment environment, IDeploymentSettingsManager settings, ITraceFactory traceFactory, HttpContextBase httpContext)
{
_environment = environment;
_settings = settings;
_traceFactory = traceFactory;
_httpContext = httpContext;
}
// ReSharper disable MemberCanBePrivate.Global
public ResharperIntegrationService(IPackageDescriptorMonitor monitor, IEnvironment env)
// ReSharper restore MemberCanBePrivate.Global
{
_monitor = monitor;
_env = env;
_refreshTimer = new Timer(_ => Refresh(), null, Timeout.Infinite, Timeout.Infinite);
}
public InfoRefsService(ITracer tracer, IGitServer gitServer, IEnvironment environment, RepositoryConfiguration configuration)
{
_gitServer = gitServer;
_tracer = tracer;
_deploymentTargetPath = environment.DeploymentTargetPath;
_configuration = configuration;
}
public DTECheckFrm(IEnvironment env)
{
_dteo = new DTEOperation(env, vsCE.Events.SolutionEventType.General);
InitializeComponent();
Icon = Resource.Package_32;
}
internal static IDynamic IsArray(IEnvironment environment, IArgs args)
{
// 15.4.3.2 Array.isArray ( arg )
var arg = args[0] as IObject;
return environment.CreateBoolean(arg != null && arg.Class == "Array");
}
public MSBuildBuildEngine(IFileSystem fileSystem, IEnvironment environment)
: base(fileSystem,environment)
{
Profile = new List<string> { environment.ExecutionEnvironment.Profile };
Platform = new List<string> { environment.ExecutionEnvironment.Platform };
Project = new List<string>();
}
public AspNet5Builder(IEnvironment environment, IDeploymentSettingsManager settings, IBuildPropertyProvider propertyProvider, string sourcePath, string projectPath, bool isConsoleApp)
: base(environment, settings, propertyProvider, sourcePath)
{
_projectPath = projectPath;
_sourcePath = sourcePath;
_isConsoleApp = isConsoleApp;
}
/// <summary>
/// Setup constructor
/// </summary>
public CompositeEditorController(
IEnvironment env,
ICompositeEditorView view,
object composite,
IComponentUiElementFactory uiFactory,
IComponentDependencies dependencies,
IComponentAggregator aggregator
)
: base(view)
{
Arguments.CheckNotNull( env, "env" );
Arguments.CheckNotNull( uiFactory, "uiFactory" );
Arguments.CheckNotNull( dependencies, "dependencies" );
Arguments.CheckNotNull( aggregator, "aggregator" );
m_View = view;
m_Environment = env;
m_UiFactory = uiFactory;
m_Dependencies = dependencies;
m_Aggregator = aggregator;
m_View.SelectionChanged += OnSelectionChanged;
m_View.EditComponent += OnEditComponent;
m_View.RemoveSelectedComponent += OnRemoveComponent;
m_View.AddToComponent += OnAddComponent;
ResetView( composite );
}
public NullRepository(IEnvironment environment, ITraceFactory traceFactory, HttpContextBase httpContext)
{
_environment = environment;
_traceFactory = traceFactory;
_httpContext = httpContext;
_changeSetKey = Path.Combine(_environment.RepositoryPath, "changeset");
}
private static void startTheEnvironment(IList<LogEntry> list, IEnvironment environment, params Action<IInstaller, IPackageLog>[] actions)
{
var log = new PackageLog();
try
{
var installers = environment.StartUp(log);
// This needs to happen regardless, but we want these logs put in before
// logs for the installers, so we don't do it in the finally{}
AddPackagingLogEntries(list);
executeInstallers(list, installers, actions);
}
catch (Exception ex)
{
AddPackagingLogEntries(list);
log.MarkFailure(ex.ToString());
}
finally
{
list.Add(LogEntry.FromPackageLog(environment, log));
environment.SafeDispose();
}
}
public static IEnumerable<IGrouping<string, Exports.ICommand>> CommandExports(this IPackageManager manager, IEnvironment environment)
{
var projectCommands = manager.GetProjectExports<Exports.ICommand>(environment.Descriptor, environment.ProjectRepository, environment.ExecutionEnvironment).SelectMany(x=>x).GroupBy(x=>x.Package.Name);
var consumedPackages = projectCommands.Select(x => x.Key).ToList();
var systemCommands = manager.GetSystemExports<Exports.ICommand>(environment.SystemRepository, environment.ExecutionEnvironment).SelectMany(x => x).GroupBy(x => x.Package.Name);
return projectCommands.Concat(systemCommands.Where(x => consumedPackages.ContainsNoCase(x.Key) == false));
}
public static IQueryValue CClamp(IEnvironment env, IQueryValue[] args)
{
FunctionUtils.CheckArgumentCountEqual("cclamp", 1, args.Length);
Color color = args[0].Color;
color.Clamp();
return new ColorValue() {Color = color};
}
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 static string GetAvatarPreselection(this Avatar avatar, IEnvironment env)
{
if (avatar.isDefault)
return "checked=\"checked\"";
return string.Empty;
}
/// <inheritdoc />
/// <summary>
/// </summary>
/// <param name="environment"></param>
public void Register(IEnvironment environment)
{
this.Register(environment, environment.Identifier);
}
private static void RemoveTempFileFromUserDrive(IEnvironment environment)
{
FileSystemHelpers.DeleteDirectorySafe(Path.Combine(environment.RootPath, "data", "Temp"), ignoreErrors: true);
}
/// <summary>
/// Creates the new instance of <see cref="IAlpacaDataClient"/> interface
/// implementation for specific environment provided as <paramref name="environment"/> argument.
/// </summary>
/// <param name="environment">Target environment for new object.</param>
/// <param name="securityKey">Alpaca API security key.</param>
/// <returns>The new instance of <see cref="IAlpacaDataClient"/> interface implementation.</returns>
public static IAlpacaDataClient GetAlpacaDataClient(
this IEnvironment environment,
SecurityKey securityKey) =>
new AlpacaDataClient(environment.GetAlpacaDataClientConfiguration(securityKey));
public BuildServer(IEnvironment environment, ILog log) : base(environment, log)
{
}
public SearchContext(bool includeHistory, IEnvironment environment)
{
this.includeHistory = includeHistory;
Environment = environment;
}
public Environment(IEnvironment parent)
{
Parent = parent;
}
private static string GetSettingsPath(IEnvironment environment)
{
return(Path.Combine(environment.DeploymentsPath, Constants.DeploySettingsPath));
}
private static void RegisterServices(IKernel kernel)
{
var serverConfiguration = new ServerConfiguration();
// Make sure %HOME% is correctly set
EnsureHomeEnvironmentVariable();
EnsureSiteBitnessEnvironmentVariable();
IEnvironment environment = GetEnvironment();
EnsureDotNetCoreEnvironmentVariable(environment);
// Add various folders that never change to the process path. All child processes will inherit
PrependFoldersToPath(environment);
// Per request environment
kernel.Bind <IEnvironment>().ToMethod(context => GetEnvironment(context.Kernel.Get <IDeploymentSettingsManager>()))
.InRequestScope();
// General
kernel.Bind <HttpContextBase>().ToMethod(context => new HttpContextWrapper(HttpContext.Current))
.InRequestScope();
kernel.Bind <IServerConfiguration>().ToConstant(serverConfiguration);
kernel.Bind <IBuildPropertyProvider>().ToConstant(new BuildPropertyProvider());
System.Func <ITracer> createTracerThunk = () => GetTracer(environment, kernel);
System.Func <ILogger> createLoggerThunk = () => GetLogger(environment, kernel);
// First try to use the current request profiler if any, otherwise create a new one
var traceFactory = new TracerFactory(() => TraceServices.CurrentRequestTracer ?? createTracerThunk());
kernel.Bind <ITracer>().ToMethod(context => TraceServices.CurrentRequestTracer ?? NullTracer.Instance);
kernel.Bind <ITraceFactory>().ToConstant(traceFactory);
TraceServices.SetTraceFactory(createTracerThunk, createLoggerThunk);
// Setup the deployment lock
string lockPath = Path.Combine(environment.SiteRootPath, Constants.LockPath);
string deploymentLockPath = Path.Combine(lockPath, Constants.DeploymentLockFile);
string statusLockPath = Path.Combine(lockPath, Constants.StatusLockFile);
string sshKeyLockPath = Path.Combine(lockPath, Constants.SSHKeyLockFile);
string hooksLockPath = Path.Combine(lockPath, Constants.HooksLockFile);
_deploymentLock = new DeploymentLockFile(deploymentLockPath, kernel.Get <ITraceFactory>());
_deploymentLock.InitializeAsyncLocks();
var statusLock = new LockFile(statusLockPath, kernel.Get <ITraceFactory>());
var sshKeyLock = new LockFile(sshKeyLockPath, kernel.Get <ITraceFactory>());
var hooksLock = new LockFile(hooksLockPath, kernel.Get <ITraceFactory>());
kernel.Bind <IOperationLock>().ToConstant(sshKeyLock).WhenInjectedInto <SSHKeyController>();
kernel.Bind <IOperationLock>().ToConstant(statusLock).WhenInjectedInto <DeploymentStatusManager>();
kernel.Bind <IOperationLock>().ToConstant(hooksLock).WhenInjectedInto <WebHooksManager>();
kernel.Bind <IOperationLock>().ToConstant(_deploymentLock);
var shutdownDetector = new ShutdownDetector();
shutdownDetector.Initialize();
IDeploymentSettingsManager noContextDeploymentsSettingsManager =
new DeploymentSettingsManager(new XmlSettings.Settings(GetSettingsPath(environment)));
TraceServices.TraceLevel = noContextDeploymentsSettingsManager.GetTraceLevel();
var noContextTraceFactory = new TracerFactory(() => GetTracerWithoutContext(environment, noContextDeploymentsSettingsManager));
kernel.Bind <IAnalytics>().ToMethod(context => new Analytics(context.Kernel.Get <IDeploymentSettingsManager>(),
context.Kernel.Get <IServerConfiguration>(),
noContextTraceFactory));
// Trace unhandled (crash) exceptions.
AppDomain.CurrentDomain.UnhandledException += (sender, args) =>
{
var ex = args.ExceptionObject as Exception;
if (ex != null)
{
kernel.Get <IAnalytics>().UnexpectedException(ex);
}
};
// Trace shutdown event
// Cannot use shutdownDetector.Token.Register because of race condition
// with NinjectServices.Stop via WebActivator.ApplicationShutdownMethodAttribute
Shutdown += () => TraceShutdown(environment, noContextDeploymentsSettingsManager);
// LogStream service
// The hooks and log stream start endpoint are low traffic end-points. Re-using it to avoid creating another lock
var logStreamManagerLock = hooksLock;
kernel.Bind <LogStreamManager>().ToMethod(context => new LogStreamManager(Path.Combine(environment.RootPath, Constants.LogFilesPath),
context.Kernel.Get <IEnvironment>(),
context.Kernel.Get <IDeploymentSettingsManager>(),
context.Kernel.Get <ITracer>(),
shutdownDetector,
logStreamManagerLock));
kernel.Bind <InfoRefsController>().ToMethod(context => new InfoRefsController(t => context.Kernel.Get(t)))
.InRequestScope();
kernel.Bind <CustomGitRepositoryHandler>().ToMethod(context => new CustomGitRepositoryHandler(t => context.Kernel.Get(t)))
.InRequestScope();
// Deployment Service
kernel.Bind <ISettings>().ToMethod(context => new XmlSettings.Settings(GetSettingsPath(environment)))
.InRequestScope();
kernel.Bind <IDeploymentSettingsManager>().To <DeploymentSettingsManager>()
.InRequestScope();
kernel.Bind <IDeploymentStatusManager>().To <DeploymentStatusManager>()
.InRequestScope();
kernel.Bind <ISiteBuilderFactory>().To <SiteBuilderFactory>()
.InRequestScope();
kernel.Bind <IWebHooksManager>().To <WebHooksManager>()
.InRequestScope();
ITriggeredJobsManager triggeredJobsManager = new TriggeredJobsManager(
noContextTraceFactory,
kernel.Get <IEnvironment>(),
kernel.Get <IDeploymentSettingsManager>(),
kernel.Get <IAnalytics>(),
kernel.Get <IWebHooksManager>());
kernel.Bind <ITriggeredJobsManager>().ToConstant(triggeredJobsManager)
.InTransientScope();
TriggeredJobsScheduler triggeredJobsScheduler = new TriggeredJobsScheduler(
triggeredJobsManager,
noContextTraceFactory,
environment,
kernel.Get <IAnalytics>());
kernel.Bind <TriggeredJobsScheduler>().ToConstant(triggeredJobsScheduler)
.InTransientScope();
IContinuousJobsManager continuousJobManager = new ContinuousJobsManager(
noContextTraceFactory,
kernel.Get <IEnvironment>(),
kernel.Get <IDeploymentSettingsManager>(),
kernel.Get <IAnalytics>());
OperationManager.SafeExecute(triggeredJobsManager.CleanupDeletedJobs);
OperationManager.SafeExecute(continuousJobManager.CleanupDeletedJobs);
kernel.Bind <IContinuousJobsManager>().ToConstant(continuousJobManager)
.InTransientScope();
kernel.Bind <ILogger>().ToMethod(context => GetLogger(environment, context.Kernel))
.InRequestScope();
kernel.Bind <IDeploymentManager>().To <DeploymentManager>()
.InRequestScope();
kernel.Bind <IAutoSwapHandler>().To <AutoSwapHandler>()
.InRequestScope();
kernel.Bind <ISSHKeyManager>().To <SSHKeyManager>()
.InRequestScope();
kernel.Bind <IRepositoryFactory>().ToMethod(context => _deploymentLock.RepositoryFactory = new RepositoryFactory(context.Kernel.Get <IEnvironment>(),
context.Kernel.Get <IDeploymentSettingsManager>(),
context.Kernel.Get <ITraceFactory>()))
.InRequestScope();
kernel.Bind <IApplicationLogsReader>().To <ApplicationLogsReader>()
.InSingletonScope();
// Git server
kernel.Bind <IDeploymentEnvironment>().To <DeploymentEnvrionment>();
kernel.Bind <IGitServer>().ToMethod(context => new GitExeServer(context.Kernel.Get <IEnvironment>(),
_deploymentLock,
GetRequestTraceFile(context.Kernel),
context.Kernel.Get <IRepositoryFactory>(),
context.Kernel.Get <IDeploymentEnvironment>(),
context.Kernel.Get <IDeploymentSettingsManager>(),
context.Kernel.Get <ITraceFactory>()))
.InRequestScope();
// Git Servicehook parsers
kernel.Bind <IServiceHookHandler>().To <GenericHandler>().InRequestScope();
kernel.Bind <IServiceHookHandler>().To <GitHubHandler>().InRequestScope();
kernel.Bind <IServiceHookHandler>().To <BitbucketHandler>().InRequestScope();
kernel.Bind <IServiceHookHandler>().To <BitbucketHandlerV2>().InRequestScope();
kernel.Bind <IServiceHookHandler>().To <DropboxHandler>().InRequestScope();
kernel.Bind <IServiceHookHandler>().To <CodePlexHandler>().InRequestScope();
kernel.Bind <IServiceHookHandler>().To <CodebaseHqHandler>().InRequestScope();
kernel.Bind <IServiceHookHandler>().To <GitlabHqHandler>().InRequestScope();
kernel.Bind <IServiceHookHandler>().To <GitHubCompatHandler>().InRequestScope();
kernel.Bind <IServiceHookHandler>().To <KilnHgHandler>().InRequestScope();
kernel.Bind <IServiceHookHandler>().To <VSOHandler>().InRequestScope();
kernel.Bind <IServiceHookHandler>().To <OneDriveHandler>().InRequestScope();
// SiteExtensions
kernel.Bind <ISiteExtensionManager>().To <SiteExtensionManager>().InRequestScope();
// Functions
kernel.Bind <IFunctionManager>().To <FunctionManager>().InRequestScope();
// Command executor
kernel.Bind <ICommandExecutor>().To <CommandExecutor>().InRequestScope();
MigrateSite(environment, noContextDeploymentsSettingsManager);
RemoveOldTracePath(environment);
RemoveTempFileFromUserDrive(environment);
// Temporary fix for https://github.com/npm/npm/issues/5905
EnsureNpmGlobalDirectory();
EnsureUserProfileDirectory();
// Skip SSL Certificate Validate
OperationClient.SkipSslValidationIfNeeded();
// Make sure webpages:Enabled is true. Even though we set it in web.config, it could be overwritten by
// an Azure AppSetting that's supposed to be for the site only but incidently affects Kudu as well.
ConfigurationManager.AppSettings["webpages:Enabled"] = "true";
// Kudu does not rely owin:appStartup. This is to avoid Azure AppSetting if set.
if (ConfigurationManager.AppSettings["owin:appStartup"] != null)
{
// Set the appSetting to null since we cannot use AppSettings.Remove(key) (ReadOnly exception!)
ConfigurationManager.AppSettings["owin:appStartup"] = null;
}
RegisterRoutes(kernel, RouteTable.Routes);
// Register the default hubs route: ~/signalr
GlobalHost.DependencyResolver = new SignalRNinjectDependencyResolver(kernel);
GlobalConfiguration.Configuration.Filters.Add(
new TraceDeprecatedActionAttribute(
kernel.Get <IAnalytics>(),
kernel.Get <ITraceFactory>()));
GlobalConfiguration.Configuration.Filters.Add(new EnsureRequestIdHandlerAttribute());
}
/// <param name="env">Used environment</param>
/// <param name="uvariable">Instance of used user-variables</param>
public UserVariableComponent(IEnvironment env, IUserVariable uvariable)
: base(env, uvariable)
{
}
// remove old LogFiles/Git trace
private static void RemoveOldTracePath(IEnvironment environment)
{
FileSystemHelpers.DeleteDirectorySafe(Path.Combine(environment.LogFilesPath, "Git"), ignoreErrors: true);
}
public VsoAgent(IEnvironment environment) : base(environment)
{
}
public BlobStorageSecretsRepository(string secretSentinelDirectoryPath, string accountConnection, string siteSlotName, ILogger logger, IEnvironment environment, IAzureBlobStorageProvider azureBlobStorageProvider)
: base(secretSentinelDirectoryPath, logger, environment)
{
ArgumentNullException.ThrowIfNull(secretSentinelDirectoryPath);
ArgumentNullException.ThrowIfNull(accountConnection);
ArgumentNullException.ThrowIfNull(siteSlotName);
_secretsBlobPath = siteSlotName.ToLowerInvariant();
_hostSecretsBlobPath = string.Format("{0}/{1}", _secretsBlobPath, ScriptConstants.HostMetadataFileName);
_accountConnection = accountConnection;
_azureBlobStorageProvider = azureBlobStorageProvider;
}
public static void Run(Arguments arguments, IFileSystem fileSystem, IEnvironment environment)
{
Logger.WriteInfo($"Running on {(runningOnUnix ? "Unix" : "Windows")}.");
var noFetch = arguments.NoFetch;
var authentication = arguments.Authentication;
var targetPath = arguments.TargetPath;
var targetUrl = arguments.TargetUrl;
var dynamicRepositoryLocation = arguments.DynamicRepositoryLocation;
var targetBranch = arguments.TargetBranch;
var commitId = arguments.CommitId;
var overrideConfig = arguments.HasOverrideConfig ? arguments.OverrideConfig : null;
var noCache = arguments.NoCache;
var noNormalize = arguments.NoNormalize;
var executeCore = new ExecuteCore(fileSystem, environment, arguments.ConfigFileLocator);
var variables = executeCore.ExecuteGitVersion(targetUrl, dynamicRepositoryLocation, authentication, targetBranch, noFetch, targetPath, commitId, overrideConfig, noCache, noNormalize);
switch (arguments.Output)
{
case OutputType.BuildServer:
{
BuildServerList.Init(environment);
foreach (var buildServer in BuildServerList.GetApplicableBuildServers())
{
buildServer.WriteIntegration(Console.WriteLine, variables);
}
break;
}
case OutputType.Json:
switch (arguments.ShowVariable)
{
case null:
Console.WriteLine(JsonOutputFormatter.ToJson(variables));
break;
default:
if (!variables.TryGetValue(arguments.ShowVariable, out var part))
{
throw new WarningException($"'{arguments.ShowVariable}' variable does not exist");
}
Console.WriteLine(part);
break;
}
break;
default:
throw new ArgumentOutOfRangeException();
}
if (arguments.UpdateWixVersionFile)
{
using (var wixVersionFileUpdater = new WixVersionFileUpdater(targetPath, variables, fileSystem))
{
wixVersionFileUpdater.Update();
}
}
using (var assemblyInfoUpdater = new AssemblyInfoFileUpdater(arguments.UpdateAssemblyInfoFileName, targetPath, variables, fileSystem, arguments.EnsureAssemblyInfo))
{
if (arguments.UpdateAssemblyInfo)
{
assemblyInfoUpdater.Update();
}
var execRun = RunExecCommandIfNeeded(arguments, targetPath, variables);
var msbuildRun = RunMsBuildIfNeeded(arguments, targetPath, variables);
if (!execRun && !msbuildRun)
{
assemblyInfoUpdater.CommitChanges();
//TODO Put warning back
//if (!context.CurrentBuildServer.IsRunningInBuildAgent())
//{
// Console.WriteLine("WARNING: Not running in build server and /ProjectFile or /Exec arguments not passed");
// Console.WriteLine();
// Console.WriteLine("Run GitVersion.exe /? for help");
//}
}
}
}
public HostJsonFileConfigurationSource(ScriptApplicationHostOptions applicationHostOptions, IEnvironment environment, ILoggerFactory loggerFactory, IMetricsLogger metricsLogger)
{
if (loggerFactory == null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
HostOptions = applicationHostOptions;
Environment = environment;
_metricsLogger = metricsLogger;
_logger = loggerFactory.CreateLogger(LogCategories.Startup);
}
public static IEnvironment NewCachingEnvironmentFor(IEnvironment environment)
{
return(new _IEnvironment_48(environment));
}
public async Task <IAgentAction <IReadOnlyCollection <ElementData> > > GetNextAction(IEnvironment <IReadOnlyCollection <ElementData> > environment, IState <IReadOnlyCollection <ElementData> > state)
{
var actions = await environment.GetPossibleActions(state);
Debug.Assert(state.Data.Count > 0, $"A state reached {nameof(SeleniumQLearningStepPolicy)} that has no data");
// TODO: exploration mode?
var stateAndActionPairs = actions
.Select(x =>
{
var pair = new StateAndActionPair <IReadOnlyCollection <ElementData> >(state, x);
return(QualityMatrix.ContainsKey(pair)
? (Action: x, Score: QualityMatrix[pair])
: (Action: x, Score: 0D));
})
.OrderByDescending(x => x.Score)
.ToList();
// Take all the items that compete for the maximum value
var maxStateAndActionPairs = stateAndActionPairs
.Where(x => x.Score == stateAndActionPairs[0].Score)
.ToList();
return(maxStateAndActionPairs.ElementAt(random.Next(0, maxStateAndActionPairs.Count)).Action);
}
public _IEnvironment_48(IEnvironment environment)
{
this.environment = environment;
_bindings = new Hashtable();
}
public HttpOptionsSetup(IEnvironment environment)
{
_environment = environment;
}
internal static bool IsSyncTriggersEnvironment(IScriptWebHostEnvironment webHostEnvironment, IEnvironment environment)
{
if (environment.IsCoreToolsEnvironment())
{
// don't sync triggers when running locally or not running in a cloud
// hosted environment
return(false);
}
if (environment.GetEnvironmentVariable(EnvironmentSettingNames.WebSiteAuthEncryptionKey) == null)
{
// We don't have the encryption key required for SetTriggers,
// so sync calls would fail auth anyways.
// This might happen in when running locally for example.
return(false);
}
if (webHostEnvironment.InStandbyMode)
{
// don’t sync triggers when in standby mode
return(false);
}
// Windows (Dedicated/Consumption)
// Linux Consumption
if ((environment.IsAppServiceWindowsEnvironment() || environment.IsLinuxContainerEnvironment()) &&
!environment.IsContainerReady())
{
// container ready flag not set yet – site not fully specialized/initialized
return(false);
}
return(true);
}
public static void RunWith(IEnvironment environment, IRunnable runnable)
{
_current.With(environment, runnable);
}
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;
}
public FunctionsSyncManager(IConfiguration configuration, IHostIdProvider hostIdProvider, IOptionsMonitor <ScriptApplicationHostOptions> applicationHostOptions, IOptions <LanguageWorkerOptions> languageWorkerOptions, ILogger <FunctionsSyncManager> logger, HttpClient httpClient, ISecretManagerProvider secretManagerProvider, IScriptWebHostEnvironment webHostEnvironment, IEnvironment environment, HostNameProvider hostNameProvider)
{
_applicationHostOptions = applicationHostOptions;
_logger = logger;
_workerConfigs = languageWorkerOptions.Value.WorkerConfigs;
_httpClient = httpClient;
_secretManagerProvider = secretManagerProvider;
_configuration = configuration;
_hostIdProvider = hostIdProvider;
_webHostEnvironment = webHostEnvironment;
_environment = environment;
_hostNameProvider = hostNameProvider;
}
/// <summary>
/// Creates new instance of <see cref="PolygonDataClientConfiguration"/> for specific
/// environment provided as <paramref name="environment"/> argument.
/// </summary>
/// <param name="environment">Target environment for new object.</param>
/// <param name="keyId">Alpaca API key identifier.</param>
/// <returns>New instance of <see cref="PolygonDataClientConfiguration"/> object.</returns>
public static PolygonDataClientConfiguration GetPolygonDataClientConfiguration(
this IEnvironment environment,
String keyId) =>
public AppVeyor(IEnvironment environment, ILog log) : base(environment, log)
{
}
public LinuxContainerInitializationHostService(IEnvironment environment, IInstanceManager instanceManager, ILogger <LinuxContainerInitializationHostService> logger)
{
_environment = environment;
_instanceManager = instanceManager;
_logger = logger;
}
public static string GetScriptsDirectoryAbsolutePath(IEnvironment environment)
{
return(Path.Combine(environment.RootPath, ScriptsDirectoryRelativePath));
}
public static IPolygonDataClient GetPolygonDataClient(
this IEnvironment environment,
String keyId) =>
new PolygonDataClient(environment.GetPolygonDataClientConfiguration(keyId));
/// <summary>
/// </summary>
/// <param name="neodroid_environment"></param>
public void UnRegister(IEnvironment neodroid_environment)
{
this.UnRegister(neodroid_environment, neodroid_environment.Identifier);
}
public AdapterDataSetWarehouseOrderOutput(IEnvironment pEnv)
: base(pEnv)
{
lineIOCode = docIOCode = (short)ConstIOCode.outputFromWarehouse;
lineTrCode = docTrCode = (short)ConstDocTypeMaterial.marerialDefinedOutput20;
}
private async Task InitializeTestHostAsync(string testDirName, IEnvironment environment)
{
var httpConfig = new HttpConfiguration();
var uniqueTestRootPath = Path.Combine(_testRootPath, testDirName, Guid.NewGuid().ToString());
var scriptRootPath = Path.Combine(uniqueTestRootPath, "wwwroot");
FileUtility.EnsureDirectoryExists(scriptRootPath);
string proxyConfigPath = Path.Combine(scriptRootPath, "proxies.json");
File.WriteAllText(proxyConfigPath, "{}");
await TestHelpers.Await(() => File.Exists(proxyConfigPath));
_loggerProvider = new TestLoggerProvider();
if (environment.IsAppServiceEnvironment())
{
// if the test is mocking App Service environment, we need
// to also set the HOME and WEBSITE_SITE_NAME variables
environment.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebsiteHomePath, uniqueTestRootPath);
environment.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebsiteName, "test-host-name");
}
var webHostBuilder = Program.CreateWebHostBuilder()
.ConfigureAppConfiguration(c =>
{
// This source reads from AzureWebJobsScriptRoot, which does not work
// with the custom paths that these tests are using.
var source = c.Sources.OfType <WebScriptHostConfigurationSource>().SingleOrDefault();
if (source != null)
{
c.Sources.Remove(source);
}
c.AddTestSettings();
})
.ConfigureLogging(c =>
{
c.AddProvider(_loggerProvider);
})
.ConfigureServices(c =>
{
c.ConfigureAll <ScriptApplicationHostOptions>(o =>
{
o.IsSelfHost = true;
o.LogPath = Path.Combine(uniqueTestRootPath, "logs");
o.SecretsPath = Path.Combine(uniqueTestRootPath, "secrets");
o.ScriptPath = _expectedScriptPath = scriptRootPath;
});
c.AddSingleton <IEnvironment>(_ => environment);
c.AddSingleton <IConfigureBuilder <ILoggingBuilder> >(new DelegatedConfigureBuilder <ILoggingBuilder>(b => b.AddProvider(_loggerProvider)));
});
_httpServer = new TestServer(webHostBuilder);
_httpClient = _httpServer.CreateClient();
_httpClient.BaseAddress = new Uri("https://localhost/");
TestHelpers.WaitForWebHost(_httpClient);
var traces = _loggerProvider.GetAllLogMessages().ToArray();
Assert.NotNull(traces.Single(p => p.FormattedMessage.StartsWith("Host is in standby mode")));
_expectedHostId = await _httpServer.Host.Services.GetService <IHostIdProvider>().GetHostIdAsync(CancellationToken.None);
}
public FetchHandler(ITracer tracer,
IDeploymentManager deploymentManager,
IDeploymentSettingsManager settings,
IDeploymentStatusManager status,
IOperationLock deploymentLock,
IEnvironment environment,
IEnumerable<IServiceHookHandler> serviceHookHandlers,
IRepositoryFactory repositoryFactory,
IAutoSwapHandler autoSwapHandler)
{
_tracer = tracer;
_deploymentLock = deploymentLock;
_environment = environment;
_deploymentManager = deploymentManager;
_settings = settings;
_status = status;
_serviceHookHandlers = serviceHookHandlers;
_repositoryFactory = repositoryFactory;
_autoSwapHandler = autoSwapHandler;
_markerFilePath = Path.Combine(environment.DeploymentsPath, "pending");
// Prefer marker creation in ctor to delay create when needed.
// This is to keep the code simple and avoid creation synchronization.
if (!FileSystemHelpers.FileExists(_markerFilePath))
{
try
{
FileSystemHelpers.WriteAllText(_markerFilePath, String.Empty);
}
catch (Exception ex)
{
tracer.TraceError(ex);
}
}
}
