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;
 }

 public LibGit2SharpRepository(IEnvironment environment, IDeploymentSettingsManager settings, ITraceFactory tracerFactory)
 {
     _tracerFactory = tracerFactory;
     _settings = settings;
     RepositoryPath = environment.RepositoryPath;
     _legacyGitExeRepository = new GitExeRepository(environment, settings, tracerFactory);
 }

 public BasicBuilder(string sourcePath, string scriptPath, string homePath, IDeploymentSettingsManager settings)
 {
     _sourcePath = sourcePath;
     _scriptPath = scriptPath;
     _homePath = homePath;
     _settings = settings;
 }

 public WapBuilder(IDeploymentSettingsManager settings, IBuildPropertyProvider propertyProvider, string sourcePath, string projectPath, string tempPath, string solutionPath)
     : base(settings, propertyProvider, sourcePath, tempPath)
 {
     _projectPath = projectPath;
     _tempPath = tempPath;
     _solutionPath = solutionPath;
 }

        public SiteBuilderFactoryDispatcher(IDeploymentSettingsManager settingsManager, IBuildPropertyProvider propertyProvider, IEnvironment environment)
        {
            _settingsManager = settingsManager;

            _originalSiteBuilderFactory = new SiteBuilderFactory(settingsManager, propertyProvider, environment);
            _generatorSiteBuilderFactory = new Generator.SiteBuilderFactory(settingsManager, propertyProvider, environment);
        }

 public RepositoryFactory(IEnvironment environment, IDeploymentSettingsManager settings, ITraceFactory traceFactory, HttpContextBase httpContext)
 {
     _environment = environment;
     _settings = settings;
     _traceFactory = traceFactory;
     _httpContext = httpContext;
 }

        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 static void Chmod(string permission, string filePath, IEnvironment environment, IDeploymentSettingsManager deploymentSettingManager, ILogger logger)
 {
     var folder = Path.GetDirectoryName(filePath);
     var exeFactory = new ExternalCommandFactory(environment, deploymentSettingManager, null);
     Executable exe = exeFactory.BuildCommandExecutable("/bin/chmod", folder, deploymentSettingManager.GetCommandIdleTimeout(), logger);
     exe.Execute("{0} {1}", permission, filePath);
 }

 private InfoRefsController CreateController(IGitServer gitServer = null,
                                             IDeploymentManager deploymentManager = null,
                                             IDeploymentSettingsManager settings = null,
                                             IRepositoryFactory repositoryFactory = null)
 {
     return new InfoRefsController(Mock.Of<ITracer>(), gitServer ?? Mock.Of<IGitServer>(), repositoryFactory ?? Mock.Of<IRepositoryFactory>());
 }

        public ExternalCommandFactory(IEnvironment environment, IDeploymentSettingsManager settings, string repositoryPath)
        {
            _environment = environment;

            _deploymentSettings = settings;
            _repositoryPath = repositoryPath;
        }

 public AutoSwapHandler(IDeploymentStatusManager deploymentStatusManager, IEnvironment environment, IDeploymentSettingsManager settings, ITraceFactory traceFactory)
 {
     _deploymentStatusManager = deploymentStatusManager;
     _traceFactory = traceFactory;
     _autoSwapSlotName = settings.GetValue("WEBSITE_SWAP_SLOTNAME");
     _autoSwapLockFilePath = Path.Combine(environment.LocksPath, AutoSwapLockFile);
 }

 public AspNet5Builder(IEnvironment environment, IDeploymentSettingsManager settings, IBuildPropertyProvider propertyProvider, string sourcePath, string projectPath)
     : base(environment, settings, propertyProvider, sourcePath)
 {
     _projectPath = projectPath;
     var properties = propertyProvider.GetProperties();
     properties[WellKnownEnvironmentVariables.DnxVersion] = AspNet5Helper.GetAspNet5RuntimeVersion(sourcePath);
 }

        public SiteExtensionManager(IEnvironment environment, IDeploymentSettingsManager settings, ITraceFactory traceFactory)
        {
            _localRepository = new LocalPackageRepository(environment.RootPath + "\\SiteExtensions");
            _traceFactory = traceFactory;

            var remoteSource = new Uri(settings.GetSiteExtensionRemoteUrl());
            _remoteRepository = new DataServicePackageRepository(remoteSource);
        }

 public NodeSiteEnabler(IFileSystem fileSystem, string repoFolder, string siteFolder, string scriptPath, IDeploymentSettingsManager settings)
 {
     _fileSystem = fileSystem;
     _repoFolder = repoFolder;
     _siteFolder = siteFolder;
     _scriptPath = scriptPath;
     _settings = settings;
 }

        public static IDeploymentSettingsManager BuildPerDeploymentSettingsManager(string path, IDeploymentSettingsManager deploymentSettingsManager)
        {
            var combinedSettingsProviders = new List<ISettingsProvider>(deploymentSettingsManager.SettingsProviders);
            combinedSettingsProviders.Add(new DeploymentSettingsProvider(path));

            PerSiteSettingsProvider perSiteSettings = null;
            return new DeploymentSettingsManager(perSiteSettings, combinedSettingsProviders.ToArray());
        }

 public UploadPackHandler(ITracer tracer,
                           IGitServer gitServer,
                           IOperationLock deploymentLock,
                           IDeploymentManager deploymentManager,
                           IDeploymentSettingsManager settings)
     : base(tracer, gitServer, deploymentLock, deploymentManager, settings)
 {
 }

 public DropboxHandler(ITracer tracer,
                       IServerRepository repository,
                       IDeploymentSettingsManager settings,
                       IEnvironment environment)
 {
     _tracer = tracer;
     _helper = new DropboxHelper(tracer, repository, settings, environment);
 }

 public CommandExecutor(string repositoryPath, IEnvironment environment, IDeploymentSettingsManager settings, ITracer tracer)
 {
     _rootDirectory = repositoryPath;
     _environment = environment;
     _externalCommandFactory = new ExternalCommandFactory(environment, settings, repositoryPath);
     _settings = settings;
     _tracer = tracer;
 }

 public static void AddDeploymentSettingsAsEnvironmentVariables(this Executable exe, IDeploymentSettingsManager deploymentSettingsManager)
 {
     IEnumerable<KeyValuePair<string, string>> deploymentSettings = deploymentSettingsManager.GetValues();
     foreach (var keyValuePair in deploymentSettings)
     {
         exe.EnvironmentVariables[keyValuePair.Key] = keyValuePair.Value;
     }
 }

        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");
        }