public WebDeployWindow (AspNetAppProject project, IList<WebDeployTarget> targets)
{
this.Build();
this.targets = targets;
this.project = project;
deployFiles = project.GetDeployFiles ();
}
public override void CopyFiles (IProgressMonitor monitor, IFileReplacePolicy replacePolicy, FileCopyConfiguration copyConfig, DeployFileCollection deployFiles, DeployContext context)
{
DirectoryInfo tempDir = null;
try {
tempDir = CreateTempDir ();
} catch (Exception e) {
monitor.ReportError (GettextCatalog.GetString ("Could not create temporary directory."), e);
return;
}
try {
MountTempDirectory (copyConfig, tempDir.FullName);
} catch (Exception e) {
monitor.ReportError (GettextCatalog.GetString ("Could not mount FUSE filesystem."), e);
RemoveTempDirIfEmpty (tempDir);
return;
}
try {
base.InternalCopyFiles (monitor, replacePolicy, copyConfig, deployFiles, context, tempDir.FullName);
} finally {
try {
//unmount the fuse directory
RunFuseCommand ("fusermount", string.Format ("-u \"{0}\"", tempDir.FullName));
} catch (Exception e) {
monitor.ReportError (GettextCatalog.GetString ("Could not unmount FUSE filesystem."), e);
}
RemoveTempDirIfEmpty (tempDir);
}
}
public override DeployFileCollection GetProjectDeployFiles (DeployContext ctx, Project project, ConfigurationSelector configuration)
{
DeployFileCollection deployFiles = new DeployFileCollection ();
base.GetProjectDeployFiles (ctx, project, configuration);
// Add the compiled output file
string outputFile = project.GetOutputFileName (configuration);
if (!string.IsNullOrEmpty (outputFile))
deployFiles.Add (new DeployFile (project, outputFile, Path.GetFileName (outputFile), TargetDirectory.ProgramFiles));
// Collect deployable files
foreach (ProjectFile file in project.Files) {
// skip CopyToOutputDirectory files when it's just a project build, because
// MonoDevelop.Project.Projects already copies these files using more subtle overwriting
// semantics
if (file.CopyToOutputDirectory != FileCopyMode.None)
continue;
DeployProperties props = new DeployProperties (file);
if (props.ShouldDeploy) {
DeployFile dp = new DeployFile (file);
deployFiles.Add (dp);
if (string.Compare (Path.GetFileName (dp.SourcePath), "app.config", true)==0 && string.Compare (Path.GetFileName (dp.RelativeTargetPath), "app.config", true)==0) {
string newName = Path.GetFileName (outputFile) + ".config";
dp.RelativeTargetPath = Path.Combine (Path.GetDirectoryName (dp.RelativeTargetPath), newName);
}
}
}
foreach (FileCopySet.Item item in project.GetSupportFileList (configuration)) {
deployFiles.Add (new DeployFile (project, item.Src, item.Target, TargetDirectory.ProgramFiles));
}
DotNetProject netProject = project as DotNetProject;
if (netProject != null) {
DotNetProjectConfiguration conf = (DotNetProjectConfiguration) project.GetConfiguration (configuration);
if (conf.DebugMode) {
string mdbFile = netProject.TargetRuntime.GetAssemblyDebugInfoFile (conf.CompiledOutputName);
deployFiles.Add (new DeployFile (project, mdbFile, Path.GetFileName (mdbFile), TargetDirectory.ProgramFiles));
}
}
return deployFiles;
}
public override void CopyFiles (IProgressMonitor monitor, IFileReplacePolicy replacePolicy, FileCopyConfiguration copyConfig, DeployFileCollection deployFiles, DeployContext context)
{
DirectoryInfo tempDir = null;
try {
tempDir = CreateTempDir ();
} catch (Exception e) {
monitor.ReportError (GettextCatalog.GetString ("Could not create temporary directory."), e);
return;
}
try {
MountTempDirectory (monitor, copyConfig, tempDir.FullName);
} catch (Exception e) {
monitor.ReportError (GettextCatalog.GetString ("Could not mount FUSE filesystem."), e);
RemoveTempDirIfEmpty (tempDir);
return;
}
try {
base.InternalCopyFiles (monitor, replacePolicy, copyConfig, deployFiles, context, tempDir.FullName);
} finally {
//unmount the filesystem
try {
string escapedDir = tempDir.FullName.Replace ("\"", "\\\"");
string cmd, args;
if (PropertyService.IsMac) {
cmd = "umount";
args = string.Format ("\"{0}\"", escapedDir);
} else {
cmd = "fusermount";
args = string.Format ("-u \"{0}\"", escapedDir);
}
RunFuseCommand (monitor, cmd, args);
} catch (Exception e) {
LoggingService.LogError (GettextCatalog.GetString ("Could not unmount FUSE filesystem."), e);
monitor.ReportError (GettextCatalog.GetString ("Could not unmount FUSE filesystem."), e);
}
RemoveTempDirIfEmpty (tempDir);
}
}
public override DeployFileCollection GetProjectDeployFiles (DeployContext ctx, Project project, ConfigurationSelector configuration)
{
DeployFileCollection deployFiles = new DeployFileCollection ();
base.GetProjectDeployFiles (ctx, project, configuration);
// Add the compiled output files
ProjectConfiguration pconf = (ProjectConfiguration) project.GetConfiguration (configuration);
FilePath outDir = pconf.OutputDirectory;
foreach (FilePath file in project.GetOutputFiles (configuration)) {
deployFiles.Add (new DeployFile (project, file, file.ToRelative (outDir), TargetDirectory.ProgramFiles));
}
FilePath outputFile = project.GetOutputFileName (configuration);
// Collect deployable files
foreach (ProjectFile file in project.Files) {
// skip CopyToOutputDirectory files when it's just a project build, because
// MonoDevelop.Project.Projects already copies these files using more subtle overwriting
// semantics
if (file.CopyToOutputDirectory != FileCopyMode.None)
continue;
DeployProperties props = new DeployProperties (file);
if (props.ShouldDeploy) {
DeployFile dp = new DeployFile (file);
deployFiles.Add (dp);
if (string.Compare (Path.GetFileName (dp.SourcePath), "app.config", true)==0 && string.Compare (Path.GetFileName (dp.RelativeTargetPath), "app.config", true)==0) {
string newName = Path.GetFileName (outputFile) + ".config";
dp.RelativeTargetPath = Path.Combine (Path.GetDirectoryName (dp.RelativeTargetPath), newName);
}
}
}
foreach (FileCopySet.Item item in project.GetSupportFileList (configuration)) {
deployFiles.Add (new DeployFile (project, item.Src, item.Target, TargetDirectory.ProgramFiles));
}
return deployFiles;
}
public virtual void CopyFiles(IProgressMonitor monitor, IFileReplacePolicy replacePolicy, FileCopyConfiguration copyConfig, DeployFileCollection deployFiles, DeployContext context)
{
InternalCopyFiles(monitor, replacePolicy, copyConfig, deployFiles, context, null);
}
public Makefile Deploy(AutotoolsContext ctx, SolutionFolderItem entry, ProgressMonitor monitor)
{
generateAutotools = ctx.MakefileType == MakefileType.AutotoolsMakefile;
monitor.BeginTask(GettextCatalog.GetString(
"Creating {0} for Project {1}",
generateAutotools ? "Makefile.am" : "Makefile", entry.Name), 1);
Makefile makefile = new Makefile();
try
{
if (!CanDeploy(entry, generateAutotools ? MakefileType.AutotoolsMakefile : MakefileType.SimpleMakefile))
{
throw new Exception(GettextCatalog.GetString("Not a deployable project."));
}
Project project = entry as Project;
TemplateEngine templateEngine = new TemplateEngine();
ISimpleAutotoolsSetup setup = FindSetupForProject(project);
// Handle files to be deployed
deployDirs = new Dictionary <string, StringBuilder> ();
deployFileVars = new Dictionary <string, string> ();
builtFiles = new List <string> ();
deployFileCopyVars = new StringBuilder();
deployFileCopyTargets = new StringBuilder();
//used only for simple makefile generation
templateFilesTargets = null;
installTarget = null;
installDeps = null;
installDirs = null;
uninstallTarget = null;
// handle configuration specific variables
conf_vars = new StringBuilder();
// grab all project files
files = new StringBuilder();
res_files = new StringBuilder();
extras = new StringBuilder();
datafiles = new StringBuilder();
Set <string> extraFiles = new Set <string> ();
string includes = String.Empty;
string references, dllReferences;
DotNetProject netProject = project as DotNetProject;
ProcessProjectReferences(netProject, out references, out dllReferences, ctx);
templateEngine.Variables["REFERENCES"] = references;
templateEngine.Variables["DLL_REFERENCES"] = dllReferences;
templateEngine.Variables["WARNING"] = "Warning: This is an automatically generated file, do not edit!";
if (entry is DotNetProject dotnetProject)
{
templateEngine.Variables ["RESGEN"] = "resgen";
}
string pfpath = null;
foreach (ProjectFile projectFile in project.Files)
{
pfpath = FileService.NormalizeRelativePath(projectFile.FilePath.ToRelative(project.BaseDirectory));
switch (projectFile.BuildAction)
{
case BuildAction.Compile:
if (projectFile.Subtype != Subtype.Code)
{
continue;
}
files.AppendFormat("\\\n\t{0} ", MakefileData.ToMakefilePath(pfpath));
break;
case BuildAction.Content:
case BuildAction.None:
extraFiles.Add(MakefileData.ToMakefilePath(pfpath));
break;
case BuildAction.EmbeddedResource:
if (!projectFile.FilePath.IsChildPathOf(ctx.BaseDirectory))
{
// file is not within directory hierarchy, copy it in
string rdir = Path.Combine(Path.GetDirectoryName(project.FileName), resourcedir);
if (!Directory.Exists(rdir))
{
Directory.CreateDirectory(rdir);
}
string newPath = Path.Combine(rdir, Path.GetFileName(projectFile.FilePath));
FileService.CopyFile(projectFile.FilePath, newPath);
pfpath = project.GetRelativeChildPath(newPath);
pfpath = FileService.NormalizeRelativePath(pfpath);
}
if (!String.IsNullOrEmpty(projectFile.ResourceId) && projectFile.ResourceId != Path.GetFileName(pfpath))
{
res_files.AppendFormat("\\\n\t{0},{1} ", MakefileData.ToMakefilePath(pfpath), MakefileData.EscapeString(projectFile.ResourceId));
}
else
{
res_files.AppendFormat("\\\n\t{0} ", MakefileData.ToMakefilePath(pfpath));
}
break;
case "FileCopy":
datafiles.AppendFormat("\\\n\t{0} ", MakefileData.ToMakefilePath(pfpath));
break;
}
}
if (!generateAutotools)
{
templateFilesTargets = new StringBuilder();
installTarget = new StringBuilder();
uninstallTarget = new StringBuilder();
installDeps = new StringBuilder();
installDirs = new List <string> ();
customCommands = new StringBuilder();
string programFilesDir = ctx.DeployContext.GetDirectory(TargetDirectory.ProgramFiles);
//FIXME:temp
programFilesDir = TranslateDir(programFilesDir);
installDirs.Add(programFilesDir);
installTarget.Append("\tmake pre-install-local-hook prefix=$(prefix)\n");
installTarget.Append("\tmake install-satellite-assemblies prefix=$(prefix)\n");
installTarget.AppendFormat("\tmkdir -p '$(DESTDIR){0}'\n", programFilesDir);
installTarget.AppendFormat("\t$(call cp,$(ASSEMBLY),$(DESTDIR){0})\n", programFilesDir);
installTarget.AppendFormat("\t$(call cp,$(ASSEMBLY_MDB),$(DESTDIR){0})\n", programFilesDir);
//remove dir?
uninstallTarget.Append("\tmake pre-uninstall-local-hook prefix=$(prefix)\n");
uninstallTarget.Append("\tmake uninstall-satellite-assemblies prefix=$(prefix)\n");
uninstallTarget.AppendFormat("\t$(call rm,$(ASSEMBLY),$(DESTDIR){0})\n", programFilesDir);
uninstallTarget.AppendFormat("\t$(call rm,$(ASSEMBLY_MDB),$(DESTDIR){0})\n", programFilesDir);
installDeps.Append(" $(ASSEMBLY) $(ASSEMBLY_MDB)");
conf_vars.AppendFormat("srcdir=.\n");
conf_vars.AppendFormat("top_srcdir={0}\n\n",
FileService.AbsoluteToRelativePath(project.BaseDirectory, ctx.TargetSolution.BaseDirectory));
conf_vars.AppendFormat("include $(top_srcdir)/config.make\n\n");
// Don't emit for top level project makefile(eg. pdn.make), as it would be
// included by top level solution makefile
if (ctx.TargetSolution.BaseDirectory != project.BaseDirectory)
{
string customhooks = Path.Combine(project.BaseDirectory, "custom-hooks.make");
bool include = File.Exists(customhooks);
includes = "include $(top_srcdir)/Makefile.include\n";
includes += String.Format("{0}include $(srcdir)/custom-hooks.make\n\n", include ? "" : "#");
if (include)
{
makefile.SetVariable("EXTRA_DIST", "$(srcdir)/custom-hooks.make");
}
}
}
bool buildEnabled;
List <ConfigSection> configSections = new List <ConfigSection> ();
allDeployVars = new Dictionary <string, DeployFileData> ();
foreach (SolutionConfiguration combineConfig in ctx.TargetSolution.Configurations)
{
DotNetProjectConfiguration config = GetProjectConfig(combineConfig.Id, project, out buildEnabled) as DotNetProjectConfiguration;
if (config == null)
{
continue;
}
ConfigSection configSection = new ConfigSection(combineConfig.Id);
string assembly = MakefileData.GetUnixPath(project.GetRelativeChildPath(config.CompiledOutputName));
configSection.BuildVariablesBuilder.AppendFormat("ASSEMBLY_COMPILER_COMMAND = {0}\n",
setup.GetCompilerCommand(project, config.Id));
configSection.BuildVariablesBuilder.AppendFormat("ASSEMBLY_COMPILER_FLAGS = {0}\n",
setup.GetCompilerFlags(project, config.Id));
// add check for compiler command in configure.ac
ctx.AddCommandCheck(setup.GetCompilerCommand(project, config.Id));
configSection.BuildVariablesBuilder.AppendFormat("ASSEMBLY = {0}\n",
AutotoolsContext.EscapeStringForAutomake(assembly));
configSection.BuildVariablesBuilder.AppendFormat("ASSEMBLY_MDB = {0}\n",
config.DebugSymbols ? "$(ASSEMBLY).mdb" : String.Empty);
string target;
switch (config.CompileTarget)
{
case CompileTarget.Exe:
target = "exe";
break;
case CompileTarget.Library:
target = "library";
break;
case CompileTarget.WinExe:
target = "winexe";
break;
case CompileTarget.Module:
target = "module";
break;
default:
throw new Exception(GettextCatalog.GetString("Unknown target {0}", config.CompileTarget));
}
configSection.BuildVariablesBuilder.AppendFormat("COMPILE_TARGET = {0}\n", target);
// for project references, we need a ref to the dll for the current configuration
StringWriter projectReferences = new StringWriter();
string pref = null;
foreach (ProjectReference reference in netProject.References)
{
if (reference.ReferenceType != ReferenceType.Project)
{
continue;
}
Project refp = reference.ResolveProject(ctx.TargetSolution);
if (refp == null)
{
throw new Exception(GettextCatalog.GetString("Couldn't find referenced project '{0}'", reference.Reference));
}
if (!(refp is DotNetProject))
{
continue;
}
DotNetProjectConfiguration dnpc = GetProjectConfig(combineConfig.Id, refp, out buildEnabled) as DotNetProjectConfiguration;
if (dnpc == null)
{
throw new Exception(GettextCatalog.GetString
("Could not add reference to project '{0}'", refp.Name));
}
projectReferences.WriteLine(" \\");
projectReferences.Write("\t");
pref = project.GetRelativeChildPath(dnpc.CompiledOutputName);
projectReferences.Write(MakefileData.ToMakefilePath(pref));
}
configSection.BuildVariablesBuilder.AppendFormat("PROJECT_REFERENCES = {0}\n", projectReferences.ToString());
string buildDir = project.GetRelativeChildPath(config.OutputDirectory);
configSection.BuildVariablesBuilder.AppendFormat("BUILD_DIR = {0}\n", MakefileData.ToMakefilePath(buildDir));
// Register files built by this configuration.
// Built files won't be distributed.
foreach (string bfile in builtFiles)
{
ctx.AddBuiltFile(Path.Combine(config.OutputDirectory, bfile));
}
DeployFileCollection deployFiles = DeployService.GetDeployFiles(
ctx.DeployContext, new SolutionFolderItem[] { project }, config.Selector);
ProcessDeployFilesForConfig(deployFiles, project, configSection, ctx, config);
configSections.Add(configSection);
if (!generateAutotools)
{
EmitCustomCommandTargets(config.CustomCommands, project, customCommands, combineConfig.Id,
new CustomCommandType [] {
CustomCommandType.BeforeBuild,
CustomCommandType.AfterBuild,
CustomCommandType.BeforeClean,
CustomCommandType.AfterClean
}, monitor);
}
else
{
if (config.CustomCommands.Count > 0)
{
monitor.ReportWarning(GettextCatalog.GetString("Custom commands are not supported for autotools based makefiles. Ignoring."));
}
}
// Register files generated by the compiler
ctx.AddBuiltFile(project.GetOutputFileName(combineConfig.Selector));
if (config.DebugSymbols)
{
ctx.AddBuiltFile(project.GetOutputFileName(combineConfig.Selector) + ".mdb");
}
if (config.SignAssembly)
{
string spath = project.GetRelativeChildPath(config.AssemblyKeyFile);
spath = FileService.NormalizeRelativePath(spath);
extraFiles.Add(MakefileData.ToMakefilePath(spath));
}
if (buildEnabled && pkgs.Count > 0)
{
ctx.AddRequiredPackages(combineConfig.Id, pkgs);
}
}
foreach (string ef in extraFiles)
{
extras.AppendFormat("\\\n\t{0} ", ef);
}
Dictionary <string, DeployFileData> commonDeployVars = new Dictionary <string, DeployFileData> (allDeployVars);
foreach (ConfigSection configSection in configSections)
{
List <string> toRemove = new List <string> ();
foreach (KeyValuePair <string, DeployFileData> pair in commonDeployVars)
{
if (!configSection.DeployFileVars.ContainsKey(pair.Key))
{
toRemove.Add(pair.Key);
}
}
foreach (string s in toRemove)
{
commonDeployVars.Remove(s);
}
}
//emit the config sections here.. to conf_vars
foreach (ConfigSection configSection in configSections)
{
conf_vars.AppendFormat(generateAutotools ? "if ENABLE_{0}\n" : "ifeq ($(CONFIG),{0})\n",
ctx.EscapeAndUpperConfigName(configSection.Name));
conf_vars.Append(configSection.BuildVariablesBuilder.ToString());
conf_vars.Append("\n");
if (ctx.Switches != null)
{
foreach (Switch s in ctx.Switches)
{
conf_vars.AppendLine(string.Format(@"if ENABLE_{0}
ASSEMBLY_COMPILER_FLAGS += -define:{1}
endif", s.SwitchName.Replace('-', '_').ToUpperInvariant(), s.Define));
}
}
foreach (KeyValuePair <string, DeployFileData> pair in allDeployVars)
{
string targetDeployVar = pair.Key;
if (pair.Value.File.ContainsPathReferences)
{
//Template files are not handled per-config
continue;
}
if (configSection.DeployFileVars.ContainsKey(targetDeployVar))
{
//use the dfile from the config section
DeployFile dfile = configSection.DeployFileVars [targetDeployVar];
string fname = MakefileData.ToMakefilePath(
FileService.AbsoluteToRelativePath(
Path.GetFullPath(project.BaseDirectory),
Path.GetFullPath(dfile.SourcePath)));
conf_vars.AppendFormat("{0}_SOURCE={1}\n", targetDeployVar, fname);
if (!commonDeployVars.ContainsKey(targetDeployVar))
{
//FOO_DLL=$(BUILD_DIR)/foo.dll
conf_vars.AppendFormat("{0}=$(BUILD_DIR)/{1}\n",
targetDeployVar,
MakefileData.ToMakefilePath(dfile.RelativeTargetPath));
}
}
else
{
// not common and not part of @configSection
conf_vars.AppendFormat("{0}=\n", pair.Key);
}
}
conf_vars.Append("\nendif\n\n");
}
conf_vars.AppendFormat("AL=al\n");
conf_vars.AppendFormat("SATELLITE_ASSEMBLY_NAME=$(notdir $(basename $(ASSEMBLY))).resources.dll\n");
foreach (KeyValuePair <string, DeployFileData> pair in allDeployVars)
{
HandleDeployFile(pair.Value, pair.Key, project, ctx);
if (commonDeployVars.ContainsKey(pair.Key))
{
//FOO_DLL=$(BUILD_DIR)/foo.dll
deployFileCopyVars.AppendFormat("{0} = $(BUILD_DIR)/{1}\n",
pair.Key,
MakefileData.ToMakefilePath(pair.Value.File.RelativeTargetPath));
}
}
conf_vars.Append('\n');
StringBuilder vars = new StringBuilder();
foreach (KeyValuePair <string, StringBuilder> pair in deployDirs)
{
//PROGRAM_FILES= .. etc
conf_vars.AppendFormat("{0} = {1} \n\n", pair.Key, pair.Value.ToString());
//Build list of deploy dir variables
vars.AppendFormat("$({0}) ", pair.Key);
}
if (!generateAutotools)
{
installTarget.Insert(0, String.Format("install-local:{0}\n", installDeps.ToString()));
installTarget.Append("\tmake post-install-local-hook prefix=$(prefix)\n");
uninstallTarget.Insert(0, String.Format("uninstall-local:{0}\n", installDeps.ToString()));
uninstallTarget.Append("\tmake post-uninstall-local-hook prefix=$(prefix)\n");
}
if (!generateAutotools && customCommands.Length > 0)
{
customCommands.Insert(0, "# Targets for Custom commands\n");
}
templateEngine.Variables["CONFIG_VARS"] = conf_vars.ToString();
templateEngine.Variables["DEPLOY_FILE_VARS"] = vars.ToString();
templateEngine.Variables["COPY_DEPLOY_FILES_VARS"] = deployFileCopyVars.ToString();
templateEngine.Variables["COPY_DEPLOY_FILES_TARGETS"] = deployFileCopyTargets.ToString();
templateEngine.Variables["ALL_TARGET"] = (ctx.TargetSolution.BaseDirectory == project.BaseDirectory) ? "all-local" : "all";
templateEngine.Variables["INCLUDES"] = includes;
templateEngine.Variables["FILES"] = files.ToString();
templateEngine.Variables["RESOURCES"] = res_files.ToString();
templateEngine.Variables["EXTRAS"] = extras.ToString();
templateEngine.Variables["DATA_FILES"] = datafiles.ToString();
templateEngine.Variables["CLEANFILES"] = vars.ToString();
if (!generateAutotools)
{
templateEngine.Variables["TEMPLATE_FILES_TARGETS"] = templateFilesTargets.ToString();
templateEngine.Variables["INSTALL_TARGET"] = installTarget.ToString();
templateEngine.Variables["UNINSTALL_TARGET"] = uninstallTarget.ToString();
templateEngine.Variables["CUSTOM_COMMAND_TARGETS"] = customCommands.ToString();
}
// Create project specific makefile
Stream stream = ctx.GetTemplateStream(
generateAutotools ? "Makefile.am.project.template" : "Makefile.noauto.project.template");
StreamReader reader = new StreamReader(stream);
string txt = templateEngine.Process(reader);
reader.Close();
makefile.Append(txt);
monitor.Step(1);
}
finally { monitor.EndTask(); }
return(makefile);
}
public DeployFileCollection GetDeployFiles (ConfigurationSelector configuration)
{
DeployFileCollection deployFiles = new DeployFileCollection ();
CProjectConfiguration conf = (CProjectConfiguration) GetConfiguration (configuration);
CompileTarget target = conf.CompileTarget;
// Headers and resources
foreach (ProjectFile f in Files) {
if (f.BuildAction == BuildAction.Content) {
string targetDirectory =
(IsHeaderFile (f.Name) ? TargetDirectory.Include : TargetDirectory.ProgramFiles);
deployFiles.Add (new DeployFile (this, f.FilePath, f.ProjectVirtualPath, targetDirectory));
}
}
// Output
string output = GetOutputFileName (configuration);
if (!string.IsNullOrEmpty (output)) {
string targetDirectory = string.Empty;
switch (target) {
case CompileTarget.Bin:
targetDirectory = TargetDirectory.ProgramFiles;
break;
case CompileTarget.SharedLibrary:
targetDirectory = TargetDirectory.ProgramFiles;
break;
case CompileTarget.StaticLibrary:
targetDirectory = TargetDirectory.ProgramFiles;
break;
}
deployFiles.Add (new DeployFile (this, output, Path.GetFileName (output), targetDirectory));
}
// PkgPackage
if (target != CompileTarget.Bin) {
string pkgfile = WriteDeployablePgkPackage (this, conf);
deployFiles.Add (new DeployFile (this, Path.Combine (BaseDirectory, pkgfile), pkgfile, LinuxTargetDirectory.PkgConfig));
}
return deployFiles;
}
public override void CopyFiles(IProgressMonitor monitor, IFileReplacePolicy replacePolicy, FileCopyConfiguration copyConfig, DeployFileCollection deployFiles, DeployContext context)
{
DirectoryInfo tempDir = null;
try {
tempDir = CreateTempDir();
} catch (Exception e) {
monitor.ReportError(GettextCatalog.GetString("Could not create temporary directory."), e);
return;
}
try {
MountTempDirectory(copyConfig, tempDir.FullName);
} catch (Exception e) {
monitor.ReportError(GettextCatalog.GetString("Could not mount FUSE filesystem."), e);
RemoveTempDirIfEmpty(tempDir);
return;
}
try {
base.InternalCopyFiles(monitor, replacePolicy, copyConfig, deployFiles, context, tempDir.FullName);
} finally {
try {
//unmount the fuse directory
RunFuseCommand("fusermount", string.Format("-u \"{0}\"", tempDir.FullName));
} catch (Exception e) {
monitor.ReportError(GettextCatalog.GetString("Could not unmount FUSE filesystem."), e);
}
RemoveTempDirIfEmpty(tempDir);
}
}
public DeployFileCollection GetDeployFiles (ConfigurationSelector configuration)
{
DeployFileCollection result = new DeployFileCollection ();
foreach (Translation translation in this.Translations) {
if (OutputType == TranslationOutputType.SystemPath) {
string moDirectory = Path.Combine ("locale", translation.IsoCode);
moDirectory = Path.Combine (moDirectory, "LC_MESSAGES");
string moFileName = Path.Combine (moDirectory, PackageName + ".mo");
result.Add (new DeployFile (this, translation.GetOutFile (configuration), moFileName, TargetDirectory.CommonApplicationDataRoot));
} else {
string moDirectory = Path.Combine (RelPath, translation.IsoCode);
moDirectory = Path.Combine (moDirectory, "LC_MESSAGES");
string moFileName = Path.Combine (moDirectory, PackageName + ".mo");
result.Add (new DeployFile (this, translation.GetOutFile (configuration), moFileName, TargetDirectory.ProgramFiles));
}
}
return result;
}
protected override bool OnBuild(IProgressMonitor monitor, DeployContext ctx)
{
string tmpFolder = null;
try {
SolutionConfigurationSelector conf = (SolutionConfigurationSelector)configuration;
BuildResult res = RootSolutionItem.Build(monitor, conf);
if (res.ErrorCount > 0)
{
foreach (BuildError e in res.Errors)
{
monitor.ReportError(e.ToString(), null);
}
monitor.ReportError(GettextCatalog.GetString("The source project failed to build."), null);
return(false);
}
tmpFolder = FileService.CreateTempDirectory();
string tf = Path.GetFileNameWithoutExtension(targetFile);
if (tf.EndsWith(".tar"))
{
tf = Path.GetFileNameWithoutExtension(tf);
}
string folder = FileService.GetFullPath(Path.Combine(tmpFolder, tf));
// Export the binary files
DeployFileCollection deployFiles = GetDeployFiles(ctx, conf);
foreach (DeployFile file in deployFiles)
{
string tfile = Path.Combine(folder, file.ResolvedTargetFile);
string tdir = FileService.GetFullPath(Path.GetDirectoryName(tfile));
if (!Directory.Exists(tdir))
{
Directory.CreateDirectory(tdir);
}
File.Copy(file.SourcePath, tfile, true);
}
// Create the archive
string td = Path.GetDirectoryName(targetFile);
if (!Directory.Exists(td))
{
Directory.CreateDirectory(td);
}
DeployService.CreateArchive(monitor, tmpFolder, targetFile);
}
catch (Exception ex) {
monitor.ReportError("Package creation failed", ex);
LoggingService.LogError("Package creation failed", ex);
return(false);
}
finally {
if (tmpFolder != null)
{
Directory.Delete(tmpFolder, true);
}
}
if (monitor.AsyncOperation.Success)
{
monitor.Log.WriteLine(GettextCatalog.GetString("Created file: {0}", targetFile));
}
return(true);
}
internal void InternalCopyFiles(ProgressMonitor monitor, IFileReplacePolicy replacePolicy, FileCopyConfiguration copyConfig, DeployFileCollection deployFiles, DeployContext context, string realPrefix)
{
string targetDirectory = ((LocalFileCopyConfiguration)copyConfig).TargetDirectory;
if (string.IsNullOrEmpty(copyConfig.FriendlyLocation) || string.IsNullOrEmpty(targetDirectory))
{
throw new InvalidOperationException("Cannot deploy to unconfigured location.");
}
List <DeployFileConf> files = new List <DeployFileConf> ();
long totalFileSize = 0;
//pre-scan: ask all copy/replace questions first so user doesn't have to wait, and get
foreach (DeployFile df in deployFiles)
{
if (!context.IncludeFile(df))
{
continue;
}
DeployFileConf dfc = new DeployFileConf();
files.Add(dfc);
dfc.SourceFile = df.SourcePath;
dfc.FileSize = FileSize(dfc.SourceFile);
totalFileSize += dfc.FileSize;
string relativeTarget = context.GetResolvedPath(df.TargetDirectoryID, df.RelativeTargetPath);
if (relativeTarget == null)
{
throw new InvalidOperationException(GettextCatalog.GetString("Could not resolve target directory ID \"{0}\"", df.TargetDirectoryID));
}
dfc.TargetFile = Path.Combine(targetDirectory, relativeTarget);
//this is a bit hacky; it's an internal hook to the BaseFuseFileCopyHandler implementation a level up the inheritance heirarchy
//Essentailly we are aliasing the path so that BaseFuseFileCopyHandler can use LocalFileCopyHandler to do the local copying
//after the temp FUSE directory is mounted
if (!string.IsNullOrEmpty(realPrefix))
{
dfc.InternalTargetFile = Path.Combine(realPrefix, context.GetResolvedPath(df.TargetDirectoryID, df.RelativeTargetPath));
}
else
{
dfc.InternalTargetFile = dfc.TargetFile;
}
if (FileExists(dfc.InternalTargetFile))
{
dfc.SourceModified = File.GetLastWriteTime(dfc.SourceFile);
dfc.TargetModified = GetTargetModificationTime(dfc.InternalTargetFile);
dfc.ReplaceMode = replacePolicy.GetReplaceAction(dfc.SourceFile, dfc.SourceModified, dfc.TargetFile, dfc.TargetModified);
if (dfc.ReplaceMode == FileReplaceMode.Abort)
{
monitor.Log.WriteLine(GettextCatalog.GetString("Deployment aborted: target file {0} already exists.", dfc.TargetFile));
throw new OperationCanceledException();
}
}
}
//PROBLEM: monitor takes ints, file sizes are longs
//HOWEVER: longs are excessively long for a progress bar
//SOLUTION: assume total task has a length of 1000 (longer than this is probably unnecessary for a progress bar),
// and set up a callback system for translating the actual long number of bytes into a portion of this
const int progressBarLength = 1000;
long stepSize = totalFileSize / progressBarLength;
long carry = 0;
monitor.BeginTask(copyConfig.FriendlyLocation, progressBarLength);
CopyReportCallback copyCallback = delegate(long bytes) {
if (monitor.CancellationToken.IsCancellationRequested)
{
return(false);
}
int steps = (int)(bytes / stepSize);
carry += bytes % stepSize;
if (carry > stepSize)
{
steps += 1;
carry -= stepSize;
}
if (steps > 0)
{
monitor.Step(steps);
}
return(true);
};
//now the actual copy
foreach (DeployFileConf file in files)
{
//abort the copy if cancelling
if (monitor.CancellationToken.IsCancellationRequested)
{
break;
}
EnsureDirectoryExists(Path.GetDirectoryName(file.InternalTargetFile));
if (file.ReplaceMode != FileReplaceMode.NotSet)
{
switch (file.ReplaceMode)
{
case FileReplaceMode.Skip:
monitor.Log.WriteLine(GettextCatalog.GetString("Skipped {0}: file exists.", file.TargetFile));
copyCallback(file.FileSize);
continue; //next file
case FileReplaceMode.Replace:
monitor.Log.WriteLine(GettextCatalog.GetString("Replaced {0}.", file.TargetFile));
break;
case FileReplaceMode.ReplaceOlder:
if (file.SourceModified > file.TargetModified)
{
monitor.Log.WriteLine(GettextCatalog.GetString("Replacing {0}: existing file is older.", file.TargetFile));
}
else
{
if (file.SourceModified == file.TargetModified)
{
monitor.Log.WriteLine(GettextCatalog.GetString("Skipped {0}: existing file is the same age.", file.TargetFile));
}
else
{
monitor.Log.WriteLine(GettextCatalog.GetString("Skipped {0}: existing file is newer.", file.TargetFile));
}
copyCallback(file.FileSize);
continue; //next file
}
break;
}
}
else
{
monitor.Log.WriteLine(GettextCatalog.GetString("Deployed file {0}.", file.TargetFile));
}
CopyFile(file.SourceFile, file.InternalTargetFile, copyCallback);
}
monitor.EndTask();
}
// Populates configSection.DeployFileVars with unique DeployFiles for a particular config
void ProcessDeployFilesForConfig (DeployFileCollection deployFiles, Project project, ConfigSection configSection, AutotoolsContext ctx, DotNetProjectConfiguration config)
{
//@deployFiles can have duplicates
Dictionary<string, DeployFile> uniqueDeployFiles = new Dictionary<string, DeployFile> ();
foreach (DeployFile dfile in deployFiles) {
if (dfile.SourcePath == project.GetOutputFileName (configSection.Selector))
continue;
// DeployFileCollection can have duplicates, ignore them
string key = dfile.RelativeTargetPath;
if (!dfile.ContainsPathReferences)
key += dfile.SourcePath;
if (uniqueDeployFiles.ContainsKey (key))
continue;
uniqueDeployFiles [key] = dfile;
string targetDeployVar = GetDeployVar (deployFileVars, dfile.RelativeTargetPath);
configSection.DeployFileVars [targetDeployVar] = dfile;
DeployFileData data = new DeployFileData ();
data.File = dfile;
data.Configuration = config;
allDeployVars [targetDeployVar] = data;
}
}
public void CopyFiles (ProgressMonitor monitor, IFileReplacePolicy replacePolicy, DeployFileCollection files, DeployContext context)
{
Handler.CopyFiles (monitor, replacePolicy, this, files, context);
}
public virtual void CopyFiles (IProgressMonitor monitor, IFileReplacePolicy replacePolicy, FileCopyConfiguration copyConfig, DeployFileCollection deployFiles, DeployContext context)
{
InternalCopyFiles (monitor, replacePolicy, copyConfig, deployFiles, context, null);
}
internal void CopyFiles (ProgressMonitor monitor, IFileReplacePolicy replacePolicy, FileCopyConfiguration copyConfig, DeployFileCollection files, DeployContext context)
{
handler.CopyFiles (monitor, replacePolicy, copyConfig, files, context);
}
internal void InternalCopyFiles (IProgressMonitor monitor, IFileReplacePolicy replacePolicy, FileCopyConfiguration copyConfig, DeployFileCollection deployFiles, DeployContext context, string realPrefix)
{
string targetDirectory = ((LocalFileCopyConfiguration) copyConfig).TargetDirectory;
if (string.IsNullOrEmpty (copyConfig.FriendlyLocation) || string.IsNullOrEmpty (targetDirectory))
throw new InvalidOperationException ("Cannot deploy to unconfigured location.");
List<DeployFileConf> files = new List<DeployFileConf> ();
long totalFileSize = 0;
//pre-scan: ask all copy/replace questions first so user doesn't have to wait, and get
foreach (DeployFile df in deployFiles) {
if (!context.IncludeFile (df))
continue;
DeployFileConf dfc = new DeployFileConf ();
files.Add (dfc);
dfc.SourceFile = df.SourcePath;
dfc.FileSize = FileSize (dfc.SourceFile);
totalFileSize += dfc.FileSize;
string relativeTarget = context.GetResolvedPath (df.TargetDirectoryID, df.RelativeTargetPath);
if (relativeTarget == null)
throw new InvalidOperationException (GettextCatalog.GetString ("Could not resolve target directory ID \"{0}\"", df.TargetDirectoryID));
dfc.TargetFile = Path.Combine (targetDirectory, relativeTarget);
//this is a bit hacky; it's an internal hook to the BaseFuseFileCopyHandler implementation a level up the inheritance heirarchy
//Essentailly we are aliasing the path so that BaseFuseFileCopyHandler can use LocalFileCopyHandler to do the local copying
//after the temp FUSE directory is mounted
if (!string.IsNullOrEmpty (realPrefix)) {
dfc.InternalTargetFile = Path.Combine (realPrefix, context.GetResolvedPath (df.TargetDirectoryID, df.RelativeTargetPath));
} else {
dfc.InternalTargetFile = dfc.TargetFile;
}
if (FileExists (dfc.InternalTargetFile)) {
dfc.SourceModified = File.GetLastWriteTime (dfc.SourceFile);
dfc.TargetModified = GetTargetModificationTime (dfc.InternalTargetFile);
dfc.ReplaceMode = replacePolicy.GetReplaceAction (dfc.SourceFile, dfc.SourceModified, dfc.TargetFile, dfc.TargetModified);
if (dfc.ReplaceMode == FileReplaceMode.Abort) {
monitor.Log.WriteLine (GettextCatalog.GetString ("Deployment aborted: target file {0} already exists.", dfc.TargetFile));
throw new OperationCanceledException ();
}
}
}
//PROBLEM: monitor takes ints, file sizes are longs
//HOWEVER: longs are excessively long for a progress bar
//SOLUTION: assume total task has a length of 1000 (longer than this is probably unnecessary for a progress bar),
// and set up a callback system for translating the actual long number of bytes into a portion of this
const int progressBarLength = 1000;
long stepSize = totalFileSize / progressBarLength;
long carry = 0;
monitor.BeginTask (copyConfig.FriendlyLocation, progressBarLength);
CopyReportCallback copyCallback = delegate (long bytes) {
if (monitor.IsCancelRequested)
return false;
int steps = (int) (bytes / stepSize);
carry += bytes % stepSize;
if (carry > stepSize) {
steps += 1;
carry -= stepSize;
}
if (steps > 0)
monitor.Step (steps);
return true;
};
//now the actual copy
foreach (DeployFileConf file in files) {
//abort the copy if cancelling
if (monitor.IsCancelRequested)
break;
EnsureDirectoryExists (Path.GetDirectoryName (file.InternalTargetFile));
if (file.ReplaceMode != FileReplaceMode.NotSet) {
switch (file.ReplaceMode) {
case FileReplaceMode.Skip:
monitor.Log.WriteLine (GettextCatalog.GetString ("Skipped {0}: file exists.", file.TargetFile));
copyCallback (file.FileSize);
continue; //next file
case FileReplaceMode.Replace:
monitor.Log.WriteLine (GettextCatalog.GetString ("Replaced {0}.", file.TargetFile));
break;
case FileReplaceMode.ReplaceOlder:
if (file.SourceModified > file.TargetModified) {
monitor.Log.WriteLine (GettextCatalog.GetString ("Replacing {0}: existing file is older.", file.TargetFile));
} else {
if (file.SourceModified == file.TargetModified)
monitor.Log.WriteLine (GettextCatalog.GetString ("Skipped {0}: existing file is the same age.", file.TargetFile));
else
monitor.Log.WriteLine (GettextCatalog.GetString ("Skipped {0}: existing file is newer.", file.TargetFile));
copyCallback (file.FileSize);
continue; //next file
}
break;
}
}
else {
monitor.Log.WriteLine (GettextCatalog.GetString ("Deployed file {0}.", file.TargetFile));
}
CopyFile (file.SourceFile, file.InternalTargetFile, copyCallback);
}
monitor.EndTask ();
}
public override void CopyFiles(IProgressMonitor monitor, IFileReplacePolicy replacePolicy, FileCopyConfiguration copyConfig, DeployFileCollection deployFiles, DeployContext context)
{
DirectoryInfo tempDir = null;
try {
tempDir = CreateTempDir();
} catch (Exception e) {
monitor.ReportError(GettextCatalog.GetString("Could not create temporary directory."), e);
return;
}
try {
MountTempDirectory(monitor, copyConfig, tempDir.FullName);
} catch (Exception e) {
monitor.ReportError(GettextCatalog.GetString("Could not mount FUSE filesystem."), e);
RemoveTempDirIfEmpty(tempDir);
return;
}
try {
base.InternalCopyFiles(monitor, replacePolicy, copyConfig, deployFiles, context, tempDir.FullName);
} finally {
//unmount the filesystem
try {
string escapedDir = tempDir.FullName.Replace("\"", "\\\"");
string cmd, args;
if (Platform.IsMac)
{
cmd = "umount";
args = string.Format("\"{0}\"", escapedDir);
}
else
{
cmd = "fusermount";
args = string.Format("-u \"{0}\"", escapedDir);
}
RunFuseCommand(monitor, cmd, args);
} catch (Exception e) {
LoggingService.LogError(GettextCatalog.GetString("Could not unmount FUSE filesystem."), e);
monitor.ReportError(GettextCatalog.GetString("Could not unmount FUSE filesystem."), e);
}
RemoveTempDirIfEmpty(tempDir);
}
}
public static DeployFileCollection GetDeployFiles (DeployContext ctx, SolutionFolderItem[] entries, ConfigurationSelector configuration)
{
DeployFileCollection col = new DeployFileCollection ();
foreach (SolutionFolderItem e in entries) {
col.AddRange (GetDeployFiles (ctx, e, configuration));
}
return col;
}
void FillFiles ()
{
store.Clear ();
if (comboConfigs.Active == -1)
return;
files = builder.GetDeployFiles (context, (SolutionConfigurationSelector) comboConfigs.ActiveText);
foreach (DeployFile file in files) {
string desc = GetDirectoryName (file.TargetDirectoryID);
store.AppendValues (file, file.DisplayName, desc, file.RelativeTargetPath.ToString (), file.SourceSolutionItem.Name, builder.IsFileIncluded (file));
}
}
