public LibGit2SharpRepository(IEnvironment environment, IDeploymentSettingsManager settings, ITraceFactory tracerFactory)
{
_tracerFactory = tracerFactory;
_settings = settings;
RepositoryPath = environment.RepositoryPath;
_legacyGitExeRepository = new GitExeRepository(environment, settings, tracerFactory);
}
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 ExternalCommandFactory(IEnvironment environment, IDeploymentSettingsManager settings, string repositoryPath)
{
_environment = environment;
_deploymentSettings = settings;
_repositoryPath = repositoryPath;
}
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 AspNet5Builder(IEnvironment environment, IDeploymentSettingsManager settings, IBuildPropertyProvider propertyProvider, string sourcePath, string projectPath, bool isConsoleApp)
: base(environment, settings, propertyProvider, sourcePath)
{
_projectPath = projectPath;
_sourcePath = sourcePath;
_isConsoleApp = isConsoleApp;
}
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 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 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);
}
public BasicBuilder(string sourcePath, string scriptPath, string homePath, IDeploymentSettingsManager settings)
{
_sourcePath = sourcePath;
_scriptPath = scriptPath;
_homePath = homePath;
_settings = settings;
}
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 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 NodeSiteEnabler(IFileSystem fileSystem, string repoFolder, string siteFolder, string scriptPath, IDeploymentSettingsManager settings)
{
_fileSystem = fileSystem;
_repoFolder = repoFolder;
_siteFolder = siteFolder;
_scriptPath = scriptPath;
_settings = settings;
}
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 UploadPackHandler(ITracer tracer,
IGitServer gitServer,
IOperationLock deploymentLock,
IDeploymentManager deploymentManager,
IDeploymentSettingsManager settings)
: base(tracer, gitServer, deploymentLock, deploymentManager, settings)
{
}
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 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 CommandExecutor(string repositoryPath, IEnvironment environment, IDeploymentSettingsManager settings, ITracer tracer)
{
_rootDirectory = repositoryPath;
_environment = environment;
_externalCommandFactory = new ExternalCommandFactory(environment, settings, repositoryPath);
_settings = settings;
_tracer = tracer;
}
public DropboxHandler(ITracer tracer,
IServerRepository repository,
IDeploymentSettingsManager settings,
IEnvironment environment)
{
_tracer = tracer;
_helper = new DropboxHelper(tracer, repository, settings, environment);
}
public CustomBuilder(string repositoryPath, string tempPath, string command, IBuildPropertyProvider propertyProvider, string homePath, IDeploymentSettingsManager settings)
{
_repositoryPath = repositoryPath;
_tempPath = tempPath;
_command = command;
_propertyProvider = propertyProvider;
_homePath = homePath;
_settings = settings;
}
protected MsBuildSiteBuilder(IDeploymentSettingsManager settings, IBuildPropertyProvider propertyProvider, string workingDirectory)
{
_settings = settings;
_propertyProvider = propertyProvider;
_msbuildExe = new Executable(PathUtility.ResolveMSBuildPath(), workingDirectory, settings.GetCommandIdleTimeout());
// NuGet.exe 1.8 will require an environment variable to make package restore work
_msbuildExe.EnvironmentVariables[WellKnownEnvironmentVariables.NuGetPackageRestoreKey] = "true";
}
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 ExternalCommandBuilder(IEnvironment environment, IDeploymentSettingsManager settings, IBuildPropertyProvider propertyProvider, string repositoryPath)
{
Environment = environment;
DeploymentSettings = settings;
RepositoryPath = repositoryPath;
PropertyProvider = propertyProvider;
HomePath = environment.SiteRootPath;
}
public TriggeredJobsScheduler(ITriggeredJobsManager triggeredJobsManager, ITraceFactory traceFactory, IAnalytics analytics, IEnvironment environment, IDeploymentSettingsManager settings)
{
_triggeredJobsManager = triggeredJobsManager;
_traceFactory = traceFactory;
_environment = environment;
_settings = settings;
_jobsFileWatcher = new JobsFileWatcher(triggeredJobsManager.JobsBinariesPath, OnJobChanged, JobSettings.JobSettingsFileName, ListJobNames, traceFactory, analytics);
}
public DropboxHelper(ITracer tracer,
IServerRepository repository,
IDeploymentSettingsManager settings,
IEnvironment environment)
{
_tracer = tracer;
_repository = repository;
_settings = settings;
_environment = environment;
}
protected ExternalCommandBuilder(IEnvironment environment, IDeploymentSettingsManager settings, IBuildPropertyProvider propertyProvider, string repositoryPath)
{
Environment = environment;
DeploymentSettings = settings;
RepositoryPath = repositoryPath;
PropertyProvider = propertyProvider;
ExternalCommandFactory = new ExternalCommandFactory(environment, settings, repositoryPath);
}
public static bool IsNullRepository(this IDeploymentSettingsManager settings)
{
return(settings.GetValue(SettingsKeys.NoRepository) == "1");
}
public static bool RunFromZip(this IDeploymentSettingsManager settings) => settings.RunFromLocalZip() || settings.RunFromRemoteZip();
public static TimeSpan GetWebJobsRestartTime(this IDeploymentSettingsManager settings)
{
return(GetTimeSpan(settings, SettingsKeys.WebJobsRestartTime, DefaultWebJobsRestartTime));
}
public Analytics(IDeploymentSettingsManager settings, IServerConfiguration serverConfiguration, ITraceFactory traceFactory)
{
_settings = settings;
_serverConfiguration = serverConfiguration;
_traceFactory = traceFactory;
}
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 PersistentCommandController(IEnvironment environment, IDeploymentSettingsManager settings, ITracer tracer)
{
_environment = environment;
_tracer = tracer;
_settings = settings;
}
public ISiteBuilder CreateBuilder(ITracer tracer, ILogger logger, IDeploymentSettingsManager settings, IRepository repository, DeploymentInfoBase deploymentInfo)
{
string repositoryRoot = repository.RepositoryPath;
// Use the cached vs projects file finder for: a. better performance, b. ignoring solutions/projects under node_modules
var fileFinder = new CachedVsProjectsFileFinder(repository);
// If there's a custom deployment file then let that take over.
var command = settings.GetValue(SettingsKeys.Command);
if (!String.IsNullOrEmpty(command))
{
return(new CustomBuilder(_environment, settings, _propertyProvider, repositoryRoot, command));
}
// If the user provided specific generator arguments, that overrides any detection logic
string scriptGeneratorArgs = settings.GetValue(SettingsKeys.ScriptGeneratorArgs);
if (!String.IsNullOrEmpty(scriptGeneratorArgs))
{
return(new CustomGeneratorCommandSiteBuilder(_environment, settings, _propertyProvider, repositoryRoot, scriptGeneratorArgs));
}
// If the repository has an explicit pointer to a project path to be deployed
// then use it.
string targetProjectPath = settings.GetValue(SettingsKeys.Project);
if (!String.IsNullOrEmpty(targetProjectPath))
{
tracer.Trace("Specific project was specified: " + targetProjectPath);
targetProjectPath = Path.GetFullPath(Path.Combine(repositoryRoot, targetProjectPath.TrimStart('/', '\\')));
}
if (deploymentInfo != null && deploymentInfo.Deployer == Constants.OneDeploy)
{
var projectPath = !String.IsNullOrEmpty(targetProjectPath) ? targetProjectPath : repositoryRoot;
return(new OneDeployBuilder(_environment, settings, _propertyProvider, repositoryRoot, projectPath, deploymentInfo));
}
if (settings.RunFromLocalZip())
{
return(new RunFromZipSiteBuilder());
}
if (!settings.DoBuildDuringDeployment())
{
var projectPath = !String.IsNullOrEmpty(targetProjectPath) ? targetProjectPath : repositoryRoot;
return(new BasicBuilder(_environment, settings, _propertyProvider, repositoryRoot, projectPath));
}
string msbuild16Log = String.Format("UseMSBuild16: {0}", VsHelper.UseMSBuild16().ToString());
tracer.Trace(msbuild16Log);
KuduEventSource.Log.GenericEvent(
ServerConfiguration.GetApplicationName(),
msbuild16Log,
string.Empty,
string.Empty,
string.Empty,
string.Empty
);
if (!String.IsNullOrEmpty(targetProjectPath))
{
// Try to resolve the project
return(ResolveProject(repositoryRoot,
targetProjectPath,
settings,
fileFinder,
tryWebSiteProject: true,
searchOption: SearchOption.TopDirectoryOnly));
}
// Get all solutions in the current repository path
var solutions = VsHelper.GetSolutions(repositoryRoot, fileFinder).ToList();
if (!solutions.Any())
{
return(ResolveProject(repositoryRoot,
settings,
fileFinder,
searchOption: SearchOption.AllDirectories));
}
// More than one solution is ambiguous
if (solutions.Count > 1)
{
// TODO: Show relative paths in error messages
ThrowAmbiguousSolutionsError(solutions);
}
// We have a solution
VsSolution solution = solutions[0];
return(DetermineProjectFromSolution(logger, settings, repository, solution));
}
public static string GetPostDeploymentActionsDir(this IDeploymentSettingsManager settings, string defaultPath)
{
string value = settings.GetValue(SettingsKeys.PostDeploymentActionsDirectory);
return(!String.IsNullOrEmpty(value) ? value : defaultPath);
}
public static TimeSpan GetLogStreamTimeout(this IDeploymentSettingsManager settings)
{
return(GetTimeSpan(settings, SettingsKeys.LogStreamTimeout, DefaultLogStreamTimeout));
}
public static void SetBranch(this IDeploymentSettingsManager settings, string branchName)
{
// If we're updating branch, clear out the legacy value first
settings.DeleteValue(SettingsKeys.Branch);
settings.SetValue(SettingsKeys.DeploymentBranch, branchName);
}
/// <summary>
/// Determines if Kudu should perform shallow clones (--depth 1) when attempting to perform the first fetch from a remote Git repository.
/// </summary>
public static bool AllowShallowClones(this IDeploymentSettingsManager settings)
{
return(StringUtils.IsTrueLike(settings.GetValue(SettingsKeys.UseShallowClone)));
}
public static string GetValue(this IDeploymentSettingsManager settings, string key)
{
return(settings.GetValue(key, onlyPerSite: false));
}
private ISiteBuilder ResolveProject(string repositoryRoot, IDeploymentSettingsManager perDeploymentSettings, IFileFinder fileFinder, bool tryWebSiteProject = false, SearchOption searchOption = SearchOption.AllDirectories)
{
return(ResolveProject(repositoryRoot, repositoryRoot, perDeploymentSettings, fileFinder, tryWebSiteProject, searchOption, specificConfiguration: false));
}
public static bool IsWebJobsStopped(this IDeploymentSettingsManager settings)
{
string value = settings.GetValue(SettingsKeys.WebJobsStopped);
return(StringUtils.IsTrueLike(value));
}
private ISiteBuilder ResolveNonAspProject(string repositoryRoot, string projectPath, IDeploymentSettingsManager perDeploymentSettings)
{
string sourceProjectPath = projectPath ?? repositoryRoot;
if (FunctionAppHelper.LooksLikeFunctionApp())
{
return(new FunctionBasicBuilder(_environment, perDeploymentSettings, _propertyProvider, repositoryRoot, projectPath));
}
else if (IsNodeSite(sourceProjectPath))
{
return(new NodeSiteBuilder(_environment, perDeploymentSettings, _propertyProvider, repositoryRoot, projectPath));
}
else if (IsPythonSite(sourceProjectPath))
{
return(new PythonSiteBuilder(_environment, perDeploymentSettings, _propertyProvider, repositoryRoot, projectPath));
}
else if (IsGoSite(sourceProjectPath))
{
return(new GoSiteBuilder(_environment, perDeploymentSettings, _propertyProvider, repositoryRoot, projectPath));
}
else if (IsRubySite(sourceProjectPath))
{
return(new RubySiteBuilder(_environment, perDeploymentSettings, _propertyProvider, repositoryRoot, projectPath));
}
else if (IsPHPSite(sourceProjectPath))
{
return(new PHPSiteBuilder(_environment, perDeploymentSettings, _propertyProvider, repositoryRoot, projectPath));
}
return(new BasicBuilder(_environment, perDeploymentSettings, _propertyProvider, repositoryRoot, projectPath));
}
public DeploymentAnalytics(IAnalytics analytics, IDeploymentSettingsManager settings)
{
_analytics = analytics;
_siteMode = settings.GetWebSiteSku();
}
private ISiteBuilder DetermineProjectFromSolution(ILogger logger, IDeploymentSettingsManager settings, IRepository repository, VsSolution solution)
{
string repositoryRoot = repository.RepositoryPath;
// We need to determine what project to deploy so get a list of all web projects and
// figure out with some heuristic, which one to deploy.
// TODO: Pick only 1 and throw if there's more than one
// shunTODO need to implement this
VsSolutionProject project = solution.Projects.Where(p => p.IsWap || p.IsWebSite || p.IsAspNetCore || p.IsFunctionApp).FirstOrDefault();
if (project == null)
{
// Try executable type project
project = solution.Projects.Where(p => p.IsExecutable).FirstOrDefault();
if (project != null)
{
if (VsHelper.UseMSBuild1607() || VsHelper.IsDotNetCore5(project.TargetFramework))
{
return(new DotNetConsoleMSBuild1607Builder(_environment,
settings,
_propertyProvider,
repositoryRoot,
project.AbsolutePath,
solution.Path));
}
else if (VsHelper.UseMSBuild16())
{
return(new DotNetCoreConsoleMSBuild16Builder(_environment,
settings,
_propertyProvider,
repositoryRoot,
project.AbsolutePath,
solution.Path));
}
else
{
return(new DotNetConsoleBuilder(_environment,
settings,
_propertyProvider,
repositoryRoot,
project.AbsolutePath,
solution.Path));
}
}
logger.Log(Resources.Log_NoDeployableProjects, solution.Path);
// we have a solution file, but no deployable project
// shunTODO how often do we run into this
return(ResolveNonAspProject(repositoryRoot, null, settings));
}
if (project.IsWap)
{
return(new WapBuilder(_environment,
settings,
_propertyProvider,
repositoryRoot,
project.AbsolutePath,
solution.Path));
}
if (project.IsAspNetCore)
{
if (VsHelper.UseMSBuild1607() || VsHelper.IsDotNetCore5(project.TargetFramework))
{
return(new AspNetCoreMSBuild1607Builder(_environment,
settings,
_propertyProvider,
repositoryRoot,
project.AbsolutePath,
solution.Path));
}
else if (VsHelper.UseMSBuild16())
{
return(new AspNetCoreMSBuild16Builder(_environment,
settings,
_propertyProvider,
repositoryRoot,
project.AbsolutePath,
solution.Path));
}
else
{
return(new AspNetCoreBuilder(_environment,
settings,
_propertyProvider,
repositoryRoot,
project.AbsolutePath,
solution.Path));
}
}
if (project.IsWebSite)
{
return(new WebSiteBuilder(_environment,
settings,
_propertyProvider,
repositoryRoot,
project.AbsolutePath,
solution.Path));
}
if (VsHelper.UseMSBuild1607() || VsHelper.IsDotNetCore5(project.TargetFramework))
{
return(new FunctionMSBuild1607Builder(_environment,
settings,
_propertyProvider,
repositoryRoot,
project.AbsolutePath,
solution.Path));
}
else if (VsHelper.UseMSBuild16())
{
return(new FunctionMSBuild16Builder(_environment,
settings,
_propertyProvider,
repositoryRoot,
project.AbsolutePath,
solution.Path));
}
else
{
return(new FunctionMsbuildBuilder(_environment,
settings,
_propertyProvider,
repositoryRoot,
project.AbsolutePath,
solution.Path));
}
}
public SiteExtensionManager(IContinuousJobsManager continuousJobManager, ITriggeredJobsManager triggeredJobManager, IEnvironment environment, IDeploymentSettingsManager settings, ITraceFactory traceFactory, HttpContextBase context)
{
_rootPath = Path.Combine(environment.RootPath, "SiteExtensions");
_baseUrl = context.Request.Url == null ? String.Empty : context.Request.Url.GetLeftPart(UriPartial.Authority).TrimEnd('/');
_localRepository = new LocalPackageRepository(_rootPath);
_continuousJobManager = continuousJobManager;
_triggeredJobManager = triggeredJobManager;
_environment = environment;
_settings = settings;
_traceFactory = traceFactory;
}
public PersistentCommandTest(IEnvironment environment, IDeploymentSettingsManager settings, ITracer tracer, IProcess process)
: base(environment, settings, tracer)
{
_process = process;
}
public ContinuousJobsManager(ITraceFactory traceFactory, IEnvironment environment, IDeploymentSettingsManager settings, IAnalytics analytics)
: base(traceFactory, environment, settings, analytics, Constants.ContinuousPath)
{
_jobsFileWatcher = new JobsFileWatcher(JobsBinariesPath, OnJobChanged, null, ListJobNames, traceFactory, analytics);
}
public DotNetCoreConsoleMSBuild16Builder(IEnvironment environment, IDeploymentSettingsManager settings, IBuildPropertyProvider propertyProvider, string sourcePath, string projectFilePath, string solutionPath)
: base(environment, settings, propertyProvider, sourcePath, projectFilePath, solutionPath, "--dotNetConsoleMSBuild16")
{
}
public ExternalCommandFactory(IEnvironment environment, IDeploymentSettingsManager settings, string repositoryPath)
{
_environment = environment;
_deploymentSettings = settings;
_repositoryPath = repositoryPath;
}
public static TimeSpan GetWebJobsIdleTimeout(this IDeploymentSettingsManager settings)
{
return(GetTimeSpan(settings, SettingsKeys.WebJobsIdleTimeoutInSeconds, DefaultJobsIdleTimeout));
}
// used when we have a project file
private ISiteBuilder DetermineProject(string repositoryRoot, string targetPath, IDeploymentSettingsManager perDeploymentSettings, IFileFinder fileFinder)
{
var solution = VsHelper.FindContainingSolution(repositoryRoot, targetPath, fileFinder);
string solutionPath = solution?.Path;
var projectTypeGuids = VsHelper.GetProjectTypeGuids(targetPath);
var targetFramework = VsHelper.GetTargetFramework(targetPath);
if (VsHelper.IsWap(projectTypeGuids))
{
return(new WapBuilder(_environment,
perDeploymentSettings,
_propertyProvider,
repositoryRoot,
targetPath,
solutionPath));
}
else if (AspNetCoreHelper.IsDotnetCoreFromProjectFile(targetPath, projectTypeGuids))
{
if (VsHelper.UseMSBuild1607() || VsHelper.IsDotNetCore5(targetFramework))
{
return(new AspNetCoreMSBuild1607Builder(_environment,
perDeploymentSettings,
_propertyProvider,
repositoryRoot,
targetPath,
solutionPath));
}
else if (VsHelper.UseMSBuild16())
{
return(new AspNetCoreMSBuild16Builder(_environment,
perDeploymentSettings,
_propertyProvider,
repositoryRoot,
targetPath,
solutionPath));
}
else
{
return(new AspNetCoreBuilder(_environment,
perDeploymentSettings,
_propertyProvider,
repositoryRoot,
targetPath,
solutionPath));
}
}
else if (VsHelper.IsExecutableProject(targetPath))
{
if (VsHelper.UseMSBuild1607() || VsHelper.IsDotNetCore5(targetFramework))
{
return(new DotNetConsoleMSBuild1607Builder(_environment,
perDeploymentSettings,
_propertyProvider,
repositoryRoot,
targetPath,
solutionPath));
}
else if (VsHelper.UseMSBuild16())
{
return(new DotNetCoreConsoleMSBuild16Builder(_environment,
perDeploymentSettings,
_propertyProvider,
repositoryRoot,
targetPath,
solutionPath));
}
else
{
// This is a console app
return(new DotNetConsoleBuilder(_environment,
perDeploymentSettings,
_propertyProvider,
repositoryRoot,
targetPath,
solutionPath));
}
}
else if (FunctionAppHelper.LooksLikeFunctionApp())
{
if (FunctionAppHelper.IsCSharpFunctionFromProjectFile(targetPath))
{
if (VsHelper.UseMSBuild1607() || VsHelper.IsDotNetCore5(targetFramework))
{
return(new FunctionMSBuild1607Builder(_environment,
perDeploymentSettings,
_propertyProvider,
repositoryRoot,
targetPath,
solutionPath));
}
else if (VsHelper.UseMSBuild16())
{
return(new FunctionMSBuild16Builder(_environment,
perDeploymentSettings,
_propertyProvider,
repositoryRoot,
targetPath,
solutionPath));
}
else
{
return(new FunctionMsbuildBuilder(_environment,
perDeploymentSettings,
_propertyProvider,
repositoryRoot,
targetPath,
solutionPath));
}
}
else
{
// csx or node function with extensions.csproj
return(new FunctionBasicBuilder(_environment,
perDeploymentSettings,
_propertyProvider,
repositoryRoot,
Path.GetDirectoryName(targetPath)));
}
}
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
Resources.Error_ProjectNotDeployable,
targetPath));
}
public static string GetGitEmail(this IDeploymentSettingsManager settings)
{
string value = settings.GetValue(SettingsKeys.GitEmail);
return(!String.IsNullOrEmpty(value) ? value : "unknown");
}
// unless user specifies which project to deploy, targetPath == repositoryRoot
private ISiteBuilder ResolveProject(string repositoryRoot, string targetPath, IDeploymentSettingsManager perDeploymentSettings, IFileFinder fileFinder, bool tryWebSiteProject, SearchOption searchOption = SearchOption.AllDirectories, bool specificConfiguration = true)
{
if (DeploymentHelper.IsMsBuildProject(targetPath))
{
// needs to check for project file existence
if (!File.Exists(targetPath))
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
Resources.Error_ProjectDoesNotExist,
targetPath));
}
return(DetermineProject(repositoryRoot, targetPath, perDeploymentSettings, fileFinder));
}
// Check for loose projects
var projects = DeploymentHelper.GetMsBuildProjects(targetPath, fileFinder, searchOption);
if (projects.Count > 1)
{
// Can't determine which project to build
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
Resources.Error_AmbiguousProjects,
String.Join(", ", projects)));
}
else if (projects.Count == 1)
{
return(DetermineProject(repositoryRoot, projects[0], perDeploymentSettings, fileFinder));
}
// Check for ASP.NET Core project without VS solution or project
// for ASP.NET Core project which only has project.json, but not xproj ie: dotnet preview2 cli project
string projectJson;
if (AspNetCoreHelper.TryAspNetCoreWebProject(targetPath, fileFinder, out projectJson))
{
string targetFramework = VsHelper.GetTargetFrameworkJson(projectJson);
if (VsHelper.UseMSBuild1607() || VsHelper.IsDotNetCore5(targetFramework))
{
return(new AspNetCoreMSBuild1607Builder(_environment,
perDeploymentSettings,
_propertyProvider,
repositoryRoot,
projectJson,
null));
}
else if (VsHelper.UseMSBuild16())
{
return(new AspNetCoreMSBuild16Builder(_environment,
perDeploymentSettings,
_propertyProvider,
repositoryRoot,
projectJson,
null));
}
else
{
return(new AspNetCoreBuilder(_environment,
perDeploymentSettings,
_propertyProvider,
repositoryRoot,
projectJson,
null));
}
}
if (tryWebSiteProject)
{
// Website projects need a solution to build so look for one in the repository path
// that has this website in it.
var solutions = VsHelper.FindContainingSolutions(repositoryRoot, targetPath, fileFinder);
// More than one solution is ambiguous
if (solutions.Count > 1)
{
ThrowAmbiguousSolutionsError(solutions);
}
else if (solutions.Count == 1)
{
// Unambiguously pick the root
return(new WebSiteBuilder(_environment,
perDeploymentSettings,
_propertyProvider,
repositoryRoot,
targetPath,
solutions[0].Path));
}
}
// This should only ever happen if the user specifies an invalid directory.
// The other case where the method is called we always resolve the path so it's a non issue there.
if (specificConfiguration && !Directory.Exists(targetPath))
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
Resources.Error_ProjectDoesNotExist,
targetPath));
}
// If there's none then use the basic builder (the site is xcopy deployable)
return(ResolveNonAspProject(repositoryRoot, targetPath, perDeploymentSettings));
}
public static bool ShouldUpdateSubmodules(this IDeploymentSettingsManager settings)
{
return(settings.GetValue(SettingsKeys.DisableSubmodules) != "1");
}
// allow /deploy endpoint
public static bool IsScmEnabled(this IDeploymentSettingsManager settings)
{
string scmType = settings.GetValue(SettingsKeys.ScmType);
return(scmType != ScmType.None && scmType != ScmType.Tfs && scmType != ScmType.TfsGit);
}
public static string GetSiteExtensionRemoteUrl(this IDeploymentSettingsManager settings)
{
string value = settings.GetValue(SettingsKeys.SiteExtensionRemoteUrl);
return(!String.IsNullOrEmpty(value) ? value : DefaultSiteExtensionRemoteUrl);
}
public static TimeSpan GetCommandIdleTimeout(this IDeploymentSettingsManager settings)
{
return(GetTimeSpan(settings, SettingsKeys.CommandIdleTimeout, DefaultCommandIdleTimeout));
}
public DropboxHandler(ITracer tracer,
IDeploymentStatusManager status,
IDeploymentSettingsManager settings,
IEnvironment environment)
{
_dropBoxHelper = new DropboxHelper(tracer, status, settings, environment);
}
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);
}
}
}
public OneDriveHandler(ITracer tracer,
IDeploymentStatusManager status,
IDeploymentSettingsManager settings,
IEnvironment environment)
{
_settings = settings;
_oneDriveHelper = new OneDriveHelper(tracer, status, settings, environment);
}
