public XcodeSyncBackContext GetChanges(IProgressMonitor monitor, NSObjectInfoService infoService, DotNetProject project)
{
var ctx = new XcodeSyncBackContext(projectDir, syncTimeCache, infoService, project);
var needsSync = new List <XcodeSyncedItem> (items.Where(i => i.NeedsSyncBack(monitor, ctx)));
var knownFiles = GetKnownFiles();
if (Directory.Exists(projectDir))
{
monitor.BeginTask("Scanning for newly-added files in the Xcode project...", 0);
ScanForAddedFiles(monitor, ctx, knownFiles, projectDir, null);
monitor.EndTask();
}
if (needsSync.Count > 0)
{
monitor.BeginStepTask(GettextCatalog.GetString("Synchronizing changes made to known files in Xcode back to MonoDevelop..."), needsSync.Count, 1);
for (int i = 0; i < needsSync.Count; i++)
{
var item = needsSync [i];
item.SyncBack(monitor, ctx);
monitor.Step(1);
}
monitor.EndTask();
}
return(ctx);
}
public void BeginStepTask(string name, int totalWork, int stepSize)
{
lock (monitor.SyncRoot)
{
monitor.BeginStepTask(name, totalWork, stepSize);
}
}
public IAsyncOperation Update(IProgressMonitor monitor)
{
System.Threading.ThreadPool.QueueUserWorkItem(delegate {
string[] statuses;
if (InitialUpdate)
{
statuses = new string [] { "NEW", "ASSIGNED", "NEEDINFO" }
}
;
else
{
statuses = new string [] { "NEW", "ASSIGNED", "NEEDINFO", "RESOLVED", "CLOSED", "VERIFIED" }
};
string[] severities = new string [] { "Critical", "Major", "Normal", "Minor", "Enhancement" };
DateTime t = DateTime.Now;
monitor.BeginTask("Updating from bugzilla server", 3);
try {
Connect();
int nb, mb;
// Bugs
int lastWork = -1;
Bug[] data = server.GetBugsForProduct(Product, statuses, severities, lastUpdate, delegate(int total, int current) {
if (lastWork == -1)
{
monitor.BeginStepTask("Getting bug data", total, 2);
lastWork = 0;
}
monitor.Step(current - lastWork);
lastWork = current;
});
monitor.EndTask();
UpdateBugData(data, out nb, out mb);
lastUpdate = t;
monitor.Step(1);
Save();
monitor.Step(1);
monitor.ReportSuccess(string.Format("Bug list updated ({0} added, {1} modified)", nb, mb));
} catch (Exception ex) {
monitor.ReportError("Update failed", ex);
} finally {
monitor.Dispose();
}
});
/// <summary>
/// Copies resource files from the Xcode project (back) to the MonoDevelop project directory.
/// </summary>
/// <param name='monitor'>
/// A progress monitor.
/// </param>
/// <param name='context'>
/// The sync context.
/// </param>
void CopyFilesToMD(IProgressMonitor monitor, XcodeSyncBackContext context)
{
if (context.FileSyncJobs.Count == 0)
{
return;
}
monitor.BeginStepTask("Copying files from Xcode back to MonoDevelop...", context.FileSyncJobs.Count, 1);
foreach (var file in context.FileSyncJobs)
{
monitor.Log.WriteLine("Copying {0} file from Xcode: {1}", file.IsFreshlyAdded ? "new" : "changed", file.SyncedRelative);
if (!Directory.Exists(file.Original.ParentDirectory))
{
Directory.CreateDirectory(file.Original.ParentDirectory);
}
var tempFile = file.Original.ParentDirectory.Combine(".#" + file.Original.ParentDirectory.FileName);
FilePath path = context.ProjectDir.Combine(file.SyncedRelative);
if (File.Exists(path))
{
File.Copy(path, tempFile);
FileService.SystemRename(tempFile, file.Original);
DateTime mtime = File.GetLastWriteTime(file.Original);
context.SetSyncTime(file.SyncedRelative, mtime);
}
else
{
monitor.ReportWarning(string.Format("'{0}' does not exist.", file.SyncedRelative));
}
monitor.Step(1);
}
monitor.EndTask();
}
public XcodeSyncBackContext GetChanges(IProgressMonitor monitor, NSObjectInfoService infoService, DotNetProject project)
{
var ctx = new XcodeSyncBackContext(projectDir, syncTimeCache, infoService, project);
var needsSync = new List <XcodeSyncedItem> (items.Where(i => i.NeedsSyncBack(ctx)));
var knownFiles = GetKnownFiles();
ScanForAddedFiles(ctx, knownFiles, projectDir, null);
if (needsSync.Count > 0)
{
monitor.BeginStepTask(GettextCatalog.GetString("Synchronizing Xcode project changes"), needsSync.Count, 1);
for (int i = 0; i < needsSync.Count; i++)
{
var item = needsSync [i];
item.SyncBack(ctx);
monitor.Step(1);
}
monitor.Log.WriteLine(GettextCatalog.GetPluralString("Synchronized {0} file", "Synchronized {0} files", needsSync.Count), needsSync.Count);
monitor.EndTask();
}
return(ctx);
}
public XcodeSyncBackContext GetChanges (IProgressMonitor monitor, NSObjectInfoService infoService, DotNetProject project)
{
var ctx = new XcodeSyncBackContext (projectDir, syncTimeCache, infoService, project);
var needsSync = new List<XcodeSyncedItem> (items.Where (i => i.NeedsSyncBack (monitor, ctx)));
var knownFiles = GetKnownFiles ();
if (Directory.Exists (projectDir)) {
monitor.BeginTask ("Scanning for newly-added files in the Xcode project...", 0);
ScanForAddedFiles (monitor, ctx, knownFiles, projectDir, null);
monitor.EndTask ();
}
if (needsSync.Count > 0) {
monitor.BeginStepTask (GettextCatalog.GetString ("Synchronizing changes made to known files in Xcode back to MonoDevelop..."), needsSync.Count, 1);
for (int i = 0; i < needsSync.Count; i++) {
var item = needsSync [i];
item.SyncBack (monitor, ctx);
monitor.Step (1);
}
monitor.EndTask ();
}
return ctx;
}
public override void Revert (FilePath[] localPaths, bool recurse, IProgressMonitor monitor)
{
foreach (var group in localPaths.GroupBy (f => GetRepository (f))) {
var repository = group.Key;
var files = group.ToArray ();
var c = GetHeadCommit (repository);
RevTree tree = c != null ? c.Tree : null;
List<FilePath> changedFiles = new List<FilePath> ();
List<FilePath> removedFiles = new List<FilePath> ();
monitor.BeginTask (GettextCatalog.GetString ("Reverting files"), 3);
monitor.BeginStepTask (GettextCatalog.GetString ("Reverting files"), files.Length, 2);
DirCache dc = repository.LockDirCache ();
DirCacheBuilder builder = dc.Builder ();
try {
HashSet<string> entriesToRemove = new HashSet<string> ();
HashSet<string> foldersToRemove = new HashSet<string> ();
// Add the new entries
foreach (FilePath fp in files) {
string p = repository.ToGitPath (fp);
// Register entries to be removed from the index
if (Directory.Exists (fp))
foldersToRemove.Add (p);
else
entriesToRemove.Add (p);
TreeWalk tw = tree != null ? TreeWalk.ForPath (repository, p, tree) : null;
if (tw == null) {
// Removed from the index
}
else {
// Add new entries
TreeWalk r;
if (tw.IsSubtree) {
// It's a directory. Make sure we remove existing index entries of this directory
foldersToRemove.Add (p);
// We have to iterate through all folder files. We need a new iterator since the
// existing rw is not recursive
r = new NGit.Treewalk.TreeWalk(repository);
r.Reset (tree);
r.Filter = PathFilterGroup.CreateFromStrings(new string[]{p});
r.Recursive = true;
r.Next ();
} else {
r = tw;
}
do {
// There can be more than one entry if reverting a whole directory
string rpath = repository.FromGitPath (r.PathString);
DirCacheEntry e = new DirCacheEntry (r.PathString);
e.SetObjectId (r.GetObjectId (0));
e.FileMode = r.GetFileMode (0);
if (!Directory.Exists (Path.GetDirectoryName (rpath)))
Directory.CreateDirectory (rpath);
DirCacheCheckout.CheckoutEntry (repository, rpath, e);
builder.Add (e);
changedFiles.Add (rpath);
} while (r.Next ());
}
monitor.Step (1);
}
// Add entries we want to keep
int count = dc.GetEntryCount ();
for (int n=0; n<count; n++) {
DirCacheEntry e = dc.GetEntry (n);
string path = e.PathString;
if (!entriesToRemove.Contains (path) && !foldersToRemove.Any (f => IsSubpath (f,path)))
builder.Add (e);
}
builder.Commit ();
}
catch {
dc.Unlock ();
throw;
}
monitor.EndTask ();
monitor.BeginTask (null, files.Length);
foreach (FilePath p in changedFiles) {
FileService.NotifyFileChanged (p);
monitor.Step (1);
}
foreach (FilePath p in removedFiles) {
FileService.NotifyFileRemoved (p);
monitor.Step (1);
}
monitor.EndTask ();
}
}
public XcodeSyncBackContext GetChanges (IProgressMonitor monitor, NSObjectInfoService infoService, DotNetProject project)
{
var ctx = new XcodeSyncBackContext (projectDir, syncTimeCache, infoService, project);
var needsSync = new List<XcodeSyncedItem> (items.Where (i => i.NeedsSyncBack (ctx)));
var knownFiles = GetKnownFiles ();
ScanForAddedFiles (ctx, knownFiles, projectDir, null);
if (needsSync.Count > 0) {
monitor.BeginStepTask (GettextCatalog.GetString ("Synchronizing Xcode project changes"), needsSync.Count, 1);
for (int i = 0; i < needsSync.Count; i++) {
var item = needsSync [i];
item.SyncBack (ctx);
monitor.Step (1);
}
monitor.Log.WriteLine (GettextCatalog.GetPluralString ("Synchronized {0} file", "Synchronized {0} files", needsSync.Count), needsSync.Count);
monitor.EndTask ();
}
return ctx;
}
public override void BeginStepTask(string name, int totalWork, int stepSize)
{
base.BeginStepTask(name, totalWork, stepSize);
statusMonitor.BeginStepTask(name, totalWork, stepSize);
}
void WriteProjects (SolutionFolder folder, string baseDirectory, StreamWriter writer, bool saveProjects, IProgressMonitor monitor)
{
monitor.BeginStepTask (GettextCatalog.GetString ("Saving projects"), folder.Items.Count, 1);
foreach (SolutionItem ce in folder.Items.ToArray ())
{
string[] l = null;
if (ce is SolutionEntityItem) {
SolutionEntityItem item = (SolutionEntityItem) ce;
MSBuildHandler handler = MSBuildProjectService.GetItemHandler (item);
if (saveProjects) {
try {
handler.SavingSolution = true;
item.Save (monitor);
} finally {
handler.SavingSolution = false;
}
}
l = handler.SlnProjectContent;
writer.WriteLine (@"Project(""{0}"") = ""{1}"", ""{2}"", ""{3}""",
handler.TypeGuid,
item.Name,
FileService.NormalizeRelativePath (FileService.AbsoluteToRelativePath (
baseDirectory, item.FileName)).Replace ('/', '\\'),
ce.ItemId);
DataItem data = handler.WriteSlnData ();
if (data != null && data.HasItemData) {
writer.WriteLine ("\tProjectSection(MonoDevelopProperties) = preProject");
WriteDataItem (writer, data);
writer.WriteLine ("\tEndProjectSection");
}
if (item.ItemDependencies.Count > 0 || handler.UnresolvedProjectDependencies != null) {
writer.WriteLine ("\tProjectSection(ProjectDependencies) = postProject");
foreach (var dep in item.ItemDependencies)
writer.WriteLine ("\t\t{0} = {0}", dep.ItemId);
if (handler.UnresolvedProjectDependencies != null) {
foreach (var dep in handler.UnresolvedProjectDependencies)
writer.WriteLine ("\t\t{0} = {0}", dep);
}
writer.WriteLine ("\tEndProjectSection");
}
} else if (ce is SolutionFolder) {
//Solution
SlnData slnData = GetSlnData (ce);
if (slnData == null) {
// Solution folder
slnData = new SlnData ();
ce.ExtendedProperties [typeof (SlnFileFormat)] = slnData;
}
l = slnData.Extra;
writer.WriteLine (@"Project(""{0}"") = ""{1}"", ""{2}"", ""{3}""",
MSBuildProjectService.FolderTypeGuid,
ce.Name,
ce.Name,
ce.ItemId);
// Folder files
WriteFolderFiles (writer, (SolutionFolder) ce);
//Write custom properties
MSBuildSerializer ser = new MSBuildSerializer (folder.ParentSolution.FileName);
DataItem data = (DataItem) ser.Serialize (ce, typeof(SolutionFolder));
if (data.HasItemData) {
writer.WriteLine ("\tProjectSection(MonoDevelopProperties) = preProject");
WriteDataItem (writer, data);
writer.WriteLine ("\tEndProjectSection");
}
}
if (l != null) {
foreach (string s in l)
writer.WriteLine (s);
}
writer.WriteLine ("EndProject");
if (ce is SolutionFolder)
WriteProjects (ce as SolutionFolder, baseDirectory, writer, saveProjects, monitor);
monitor.Step (1);
}
monitor.EndTask ();
}
/// <summary>
/// Copies resource files from the Xcode project (back) to the MonoDevelop project directory.
/// </summary>
/// <param name='monitor'>
/// A progress monitor.
/// </param>
/// <param name='context'>
/// The sync context.
/// </param>
void CopyFilesToMD (IProgressMonitor monitor, XcodeSyncBackContext context)
{
if (context.FileSyncJobs.Count == 0)
return;
monitor.BeginStepTask ("Copying files from Xcode back to MonoDevelop...", context.FileSyncJobs.Count, 1);
foreach (var file in context.FileSyncJobs) {
monitor.Log.WriteLine ("Copying {0} file from Xcode: {1}", file.IsFreshlyAdded ? "new" : "changed", file.SyncedRelative);
if (!Directory.Exists (file.Original.ParentDirectory))
Directory.CreateDirectory (file.Original.ParentDirectory);
var tempFile = file.Original.ParentDirectory.Combine (".#" + file.Original.ParentDirectory.FileName);
FilePath path = context.ProjectDir.Combine (file.SyncedRelative);
if (File.Exists (path)) {
File.Copy (path, tempFile);
FileService.SystemRename (tempFile, file.Original);
DateTime mtime = File.GetLastWriteTime (file.Original);
context.SetSyncTime (file.SyncedRelative, mtime);
} else {
monitor.ReportWarning (string.Format ("'{0}' does not exist.", file.SyncedRelative));
}
monitor.Step (1);
}
monitor.EndTask ();
}
internal bool Install(IProgressStatus statusMonitor, PackageCollection packs)
{
// Make sure the registry is up to date
service.Registry.Update(statusMonitor);
IProgressMonitor monitor = ProgressStatusMonitor.GetProgressMonitor(statusMonitor);
PackageCollection toUninstall;
DependencyCollection unresolved;
if (!ResolveDependencies(monitor, packs, out toUninstall, out unresolved))
{
monitor.ReportError("Not all dependencies could be resolved.", null);
return(false);
}
ArrayList prepared = new ArrayList();
ArrayList uninstallPrepared = new ArrayList();
bool rollback = false;
monitor.BeginTask("Installing add-ins...", 100);
// Prepare install
monitor.BeginStepTask("Initializing installation", toUninstall.Count + packs.Count + 1, 75);
foreach (Package mpack in toUninstall)
{
try
{
mpack.PrepareUninstall(monitor, this);
uninstallPrepared.Add(mpack);
if (monitor.IsCancelRequested)
{
throw new InstallException("Installation cancelled.");
}
monitor.Step(1);
}
catch (Exception ex)
{
ReportException(monitor, ex);
rollback = true;
break;
}
}
monitor.Step(1);
foreach (Package mpack in packs)
{
try
{
mpack.PrepareInstall(monitor, this);
if (monitor.IsCancelRequested)
{
throw new InstallException("Installation cancelled.");
}
prepared.Add(mpack);
monitor.Step(1);
}
catch (Exception ex)
{
ReportException(monitor, ex);
rollback = true;
break;
}
}
monitor.EndTask();
monitor.BeginStepTask("Installing", toUninstall.Count + packs.Count + 1, 20);
// Commit install
if (!rollback)
{
foreach (Package mpack in toUninstall)
{
try
{
mpack.CommitUninstall(monitor, this);
if (monitor.IsCancelRequested)
{
throw new InstallException("Installation cancelled.");
}
monitor.Step(1);
}
catch (Exception ex)
{
ReportException(monitor, ex);
rollback = true;
break;
}
}
}
monitor.Step(1);
if (!rollback)
{
foreach (Package mpack in packs)
{
try
{
mpack.CommitInstall(monitor, this);
if (monitor.IsCancelRequested)
{
throw new InstallException("Installation cancelled.");
}
monitor.Step(1);
}
catch (Exception ex)
{
ReportException(monitor, ex);
rollback = true;
break;
}
}
}
monitor.EndTask();
// Rollback if failed
if (monitor.IsCancelRequested)
{
monitor = new NullProgressMonitor();
}
if (rollback)
{
monitor.BeginStepTask("Finishing installation", (prepared.Count + uninstallPrepared.Count) * 2 + 1, 5);
foreach (Package mpack in prepared)
{
try
{
mpack.RollbackInstall(monitor, this);
monitor.Step(1);
}
catch (Exception ex)
{
ReportException(monitor, ex);
}
}
foreach (Package mpack in uninstallPrepared)
{
try
{
mpack.RollbackUninstall(monitor, this);
monitor.Step(1);
}
catch (Exception ex)
{
ReportException(monitor, ex);
}
}
}
else
{
monitor.BeginStepTask("Finishing installation", prepared.Count + uninstallPrepared.Count + 1, 5);
}
// Cleanup
foreach (Package mpack in prepared)
{
try
{
mpack.EndInstall(monitor, this);
monitor.Step(1);
}
catch (Exception ex)
{
monitor.Log.WriteLine(ex);
}
}
monitor.Step(1);
foreach (Package mpack in uninstallPrepared)
{
try
{
mpack.EndUninstall(monitor, this);
monitor.Step(1);
}
catch (Exception ex)
{
monitor.Log.WriteLine(ex);
}
}
// Update the extension maps
service.Registry.Update(statusMonitor);
monitor.EndTask();
monitor.EndTask();
service.SaveConfiguration();
ResetCachedData();
return(!rollback);
}
/// <summary>
/// Removes any deleted files from the DotNetProject.
/// </summary>
/// <param name='monitor'>
/// A progress monitor.
/// </param>
/// <param name='context'>
/// The sync context.
/// </param>
/// <returns>
/// Returns whether or not any files were removed from the project.
/// </returns>
bool RemoveDeletedFilesFromProject (IProgressMonitor monitor, XcodeSyncBackContext context)
{
if (context.FileSyncJobs.Count == 0)
return false;
var removed = new List<XcodeSyncFileBackJob> (context.FileSyncJobs.Where (job => job.Status == XcodeSyncFileStatus.Removed));
if (removed.Count == 0)
return false;
monitor.BeginStepTask (string.Format ("Removing deleted files from {0}...", dnp.Name), removed.Count, 1);
foreach (var file in removed) {
monitor.Log.WriteLine ("Removing '{0}'", file.SyncedRelative);
context.Project.Files.Remove (file.Original);
monitor.Step (1);
}
monitor.EndTask ();
return true;
}
/// <summary>
/// Adds any newly created content files to MonoDevelop's DotNetProject.
/// </summary>
/// <param name='monitor'>
/// A progress monitor.
/// </param>
/// <param name='context'>
/// The sync context.
/// </param>
/// <returns>
/// Returns whether or not new files were added to the project.
/// </returns>
bool AddNewFilesToProject (IProgressMonitor monitor, XcodeSyncBackContext context)
{
if (context.FileSyncJobs.Count == 0)
return false;
var added = new List<XcodeSyncFileBackJob> (context.FileSyncJobs.Where (job => job.Status == XcodeSyncFileStatus.Added));
if (added.Count == 0)
return false;
monitor.BeginStepTask (string.Format ("Adding new files to {0}...", dnp.Name), added.Count, 1);
foreach (var file in added) {
if (File.Exists (file.Original)) {
monitor.Log.WriteLine ("Adding '{0}'", file.SyncedRelative);
string buildAction = BuildAction.Content;
if (HasInterfaceDefinitionExtension (file.Original))
buildAction = BuildAction.InterfaceDefinition;
context.Project.AddFile (file.Original, buildAction);
}
monitor.Step (1);
}
monitor.EndTask ();
return true;
}
/// <summary>
/// Syncs modified resource files from the Xcode project (back) to the MonoDevelop project directory.
/// </summary>
/// <param name='monitor'>
/// A progress monitor.
/// </param>
/// <param name='context'>
/// The sync context.
/// </param>
void CopyNewAndModifiedFiles (IProgressMonitor monitor, XcodeSyncBackContext context)
{
if (context.FileSyncJobs.Count == 0)
return;
var modified = new List<XcodeSyncFileBackJob> (context.FileSyncJobs.Where (job => job.IsNewOrModified));
if (modified.Count == 0)
return;
monitor.BeginStepTask (string.Format ("Copying new and modified files from Xcode back to {0}...", dnp.Name), modified.Count, 1);
foreach (var file in modified) {
if (file.Status == XcodeSyncFileStatus.Modified)
monitor.Log.WriteLine ("Copying modified file '{0}'", file.SyncedRelative);
else
monitor.Log.WriteLine ("Copying new file '{0}'", file.SyncedRelative);
SyncFile (monitor, context, file);
monitor.Step (1);
}
monitor.EndTask ();
}
public void BeginStepTask(string name, int totalWork, int stepSize)
{
statusMonitor.BeginStepTask(name, totalWork, stepSize);
}