protected IDisposable ChangeMonitor(FileBased<IPackageDescriptor> descriptor)
{
bool packagesChanged = false;
PackageChanged change = (a, b, c, d) =>
{
packagesChanged = true;
return Enumerable.Empty<object>();
};
PackageUpdated update = (a, b, c, d, e) =>
{
packagesChanged = true;
return Enumerable.Empty<object>();
};
var listener = PackageManager.Monitor(change, change, update);
return new ActionOnDispose(()=>
{
listener.Dispose();
if (packagesChanged)
{
if (HostEnvironment.Descriptor != descriptor.Value)
{
descriptor.File.Touch();
HostEnvironment.DescriptorFile.Touch();
}
else
{
foreach (var file in HostEnvironment.ScopedDescriptors.Select(x => x.Value.File))
file.Touch();
}
}
});
}
protected IDisposable SaveDescriptorOnSuccess(FileBased <IPackageDescriptor> descriptor)
{
bool packagesChanged = false;
PackageChanged change = (a, b, c, d) =>
{
packagesChanged = true;
return(Enumerable.Empty <object>());
};
PackageUpdated update = (a, b, c, d, e) =>
{
packagesChanged = true;
return(Enumerable.Empty <object>());
};
var listener = PackageManager.Monitor(change, change, update);
return(new ActionOnDispose(() =>
{
listener.Dispose();
if (Successful && packagesChanged)
{
descriptor.Save();
if (HostEnvironment.Descriptor != descriptor.Value)
{
HostEnvironment.DescriptorFile.Touch();
}
else
{
foreach (var file in HostEnvironment.ScopedDescriptors.Select(x => x.Value.File))
{
file.Touch();
}
}
}
}));
}
public IDictionary <string, FileBased <IPackageDescriptor> > ReadAll(IDirectory directoryToReadFrom)
{
var descriptorFiles = (from dir in directoryToReadFrom.AncestorsAndSelf()
let descriptors = dir.Files("*.wrapdesc")
where descriptors.Count() > 0
select descriptors.OrderBy(x => x.Name.Length)).FirstOrDefault();
var all = new Dictionary <string, FileBased <IPackageDescriptor> >();
if (descriptorFiles == null)
{
return(all);
}
var root = descriptorFiles.First();
var rootDescriptor = root.ReadRetry(Read);
all[string.Empty] = FileBased.New(root, rootDescriptor);
foreach (var descriptor in descriptorFiles.Skip(1))
{
var regex = new Regex(string.Format("^{0}.(?<scope>.*).wrapdesc$", rootDescriptor.Name));
var scopeMatch = regex.Match(descriptor.Name);
if (scopeMatch.Success == false)
{
continue;
}
var scopedDescriptor = rootDescriptor
.CreateScoped(descriptor.Read(Read));
all[scopeMatch.Groups["scope"].Value] = FileBased.New(descriptor, scopedDescriptor);
}
return(all);
}
protected void TrySaveDescriptorFile(FileBased <IPackageDescriptor> targetDescriptor)
{
if (!Successful)
{
return;
}
using (var descriptorStream = targetDescriptor.File.OpenWrite())
new PackageDescriptorReaderWriter().Write(targetDescriptor.Value, descriptorStream);
}
ICommandOutput VerifyDescriptor(FileBased <IPackageDescriptor> descriptor)
{
if (NoDescriptorUpdate)
{
return(new GenericMessage("Descriptor file will not be updated."));
}
return(descriptor.File.Exists
? new GenericMessage(@"Using descriptor {0}.", descriptor.File.Name)
: new GenericMessage("Creating descriptor {0}.", descriptor.File.Name));
}
ICommandOutput VerifyDescriptor(FileBased <IPackageDescriptor> descriptor)
{
if (Project == false)
{
return(null);
}
if (NoDescriptorUpdate)
{
return(new Info("Descriptor file will not be updated."));
}
return(descriptor.File.Exists
? new Info(@"Using descriptor {0}.", descriptor.File.Name)
: new Info("Creating descriptor {0}.", descriptor.File.Name));
}
public InMemoryEnvironment(IDirectory currentDirectory, IDirectory configDirectory = null)
{
CurrentDirectory = currentDirectory;
SystemRepository = new InMemoryRepository("System repository");
//RemoteRepository = new InMemoryRepository("Remote repository");
CurrentDirectoryRepository = new InMemoryRepository("Current directory repository");
//RemoteRepositories = new List<InMemoryRepository> { RemoteRepository };
DescriptorFile = CurrentDirectory.GetFile("descriptor.wrapdesc").MustExist();
Descriptor = new PackageDescriptor();
ConfigurationDirectory = configDirectory;
ScopedDescriptors = new Dictionary <string, FileBased <IPackageDescriptor> >(StringComparer.OrdinalIgnoreCase);
ScopedDescriptors[string.Empty] = FileBased.New(DescriptorFile, Descriptor);
ExecutionEnvironment = new ExecutionEnvironment("AnyCPU", "net35");
}
public static FileBased <IPackageDescriptor> GetOrCreateScopedDescriptor(this IEnvironment env, string scope)
{
scope = scope ?? string.Empty;
if (env.ScopedDescriptors.ContainsKey(scope))
{
return(env.ScopedDescriptors[scope]);
}
var newDescriptorFile = env.DescriptorFile.Parent.GetFile(string.Format("{0}.{1}.wrapdesc", env.DescriptorFile.NameWithoutExtension, scope.ToLowerInvariant()));
var newDescriptor = env.Descriptor.CreateScoped(Enumerable.Empty <IPackageDescriptorEntry>());
var result = FileBased.New(newDescriptorFile, newDescriptor);
return(env.ScopedDescriptors[scope] = result);
}
IEnumerable <ICommandOutput> InProject()
{
if (!Project)
{
yield break;
}
if (HostEnvironment.ProjectRepository != null)
{
_targetDescriptor = HostEnvironment.GetOrCreateScopedDescriptor(Scope);
}
else
{
yield return(new Error("Not in a package directory."));
}
}
IEnumerable <ICommandOutput> UpdateProjectPackages()
{
yield return(new Info("Updating project packages..."));
var sourceRepos = _remoteRepositories;
var errors = new List <PackageOperationResult>();
bool updated = false;
_targetDescriptor = HostEnvironment.GetOrCreateScopedDescriptor(Scope ?? string.Empty);
var packageDescriptor = _targetDescriptor.Value.Lock(HostEnvironment.ProjectRepository);
foreach (var x in (string.IsNullOrEmpty(Name)
? PackageManager.UpdateProjectPackages(sourceRepos, HostEnvironment.ProjectRepository, packageDescriptor)
: PackageManager.UpdateProjectPackages(sourceRepos, HostEnvironment.ProjectRepository, packageDescriptor, Name)))
{
if (x is PackageMissingResult || x is PackageConflictResult)
{
errors.Add(x);
}
else
{
updated = true;
yield return(x.ToOutput());
}
}
if (updated)
{
_targetDescriptor.File.Touch();
}
foreach (var failed in errors.GetFailures())
{
var errorMessage = "{0} could not be updated\r\n{1}";
var details = failed.SelectMany(_ => new[] { " - " + _.First() }.Concat(_.Skip(1).Select(x => " " + x)));
yield return(new Error(errorMessage, failed.Key, details.JoinString(@"\r\n")));
}
}
protected void TrySaveDescriptorFile(FileBased<IPackageDescriptor> targetDescriptor)
{
if (!Successful) return;
using (var descriptorStream = targetDescriptor.File.OpenWrite())
new PackageDescriptorReaderWriter().Write(targetDescriptor.Value, descriptorStream);
}
protected override IEnumerable <ICommandOutput> ExecuteCore()
{
_targetDescriptor = HostEnvironment.GetOrCreateScopedDescriptor(Scope ?? string.Empty);
yield return(VerifyDescriptor(_targetDescriptor));
yield return(VerifyProjectRepository());
yield return(SetupEnvironmentForAdd());
var sourceRepositories = GetSourceRepositories();
var descriptor = new PackageDescriptor(_targetDescriptor.Value);
if (Project && System)
{
var sysToAdd = new List <PackageIdentifier>();
using (SaveDescriptorOnSuccess(_targetDescriptor))
{
foreach (var m in AddProjectPackage(descriptor, sourceRepositories))
{
yield return(ToOutput(m));
ParseSuccess(m, sysToAdd.Add);
}
foreach (var identifier in sysToAdd)
{
foreach (var m in PackageManager.AddSystemPackage(PackageRequest.Exact(identifier.Name, identifier.Version), sourceRepositories, HostEnvironment.SystemRepository))
{
yield return(ToOutput(m));
}
}
}
}
else if (Project)
{
using (SaveDescriptorOnSuccess(_targetDescriptor))
{
foreach (var m in AddProjectPackage(descriptor, sourceRepositories))
{
yield return(ToOutput(m));
}
}
}
else if (System)
{
foreach (var m in PackageManager.AddSystemPackage(PackageRequest, sourceRepositories, HostEnvironment.SystemRepository, AddOptions))
{
yield return(ToOutput(m));
}
}
if (_packageNotFound)
{
var hit = false;
foreach (var m in PackageManager.ListPackages(sourceRepositories, Name))
{
if (!hit)
{
yield return(new Info("Did you mean one of the following packages?", Name));
hit = true;
}
yield return(ToOutput(m));
}
}
}
ICommandOutput VerifyDescriptor(FileBased<IPackageDescriptor> descriptor)
{
if (Project == false) return null;
if (NoDescriptorUpdate)
return new Info("Descriptor file will not be updated.");
return descriptor.File.Exists
? new Info(@"Using descriptor {0}.", descriptor.File.Name)
: new Info("Creating descriptor {0}.", descriptor.File.Name);
}
protected override IEnumerable<ICommandOutput> ExecuteCore()
{
_targetDescriptor = HostEnvironment.GetOrCreateScopedDescriptor(Scope ?? string.Empty);
yield return VerifyDescriptor(_targetDescriptor);
yield return VerifyProjectRepository();
yield return SetupEnvironmentForAdd();
var sourceRepositories = GetSourceRepositories().ToList();
var descriptor = new PackageDescriptor(_targetDescriptor.Value);
if (Project && System)
{
var sysToAdd = new List<PackageIdentifier>();
using (SaveDescriptorOnSuccess(_targetDescriptor))
{
foreach (var m in AddProjectPackage(descriptor, sourceRepositories))
{
yield return ToOutput(m);
ParseSuccess(m, sysToAdd.Add);
}
foreach (var identifier in sysToAdd)
foreach (var m in PackageManager.AddSystemPackage(PackageRequest.Exact(identifier.Name, identifier.Version), sourceRepositories, HostEnvironment.SystemRepository))
yield return ToOutput(m);
}
}
else if (Project)
{
using (SaveDescriptorOnSuccess(_targetDescriptor))
{
foreach (var m in AddProjectPackage(descriptor, sourceRepositories))
{
yield return ToOutput(m);
}
}
}
else if (System)
{
foreach (var m in PackageManager.AddSystemPackage(PackageRequest, sourceRepositories, HostEnvironment.SystemRepository, AddOptions))
{
yield return ToOutput(m);
}
}
if (_packageNotFound)
{
var hit = false;
foreach (var m in PackageManager.ListPackages(sourceRepositories, Name))
{
if (!hit)
{
yield return new Info("Did you mean one of the following packages?", Name);
hit = true;
}
yield return ToOutput(m);
}
}
}
public static void Save(this FileBased <IPackageDescriptor> descriptor)
{
using (var writeStream = descriptor.File.OpenWrite())
new PackageDescriptorReaderWriter().Write(descriptor.Value.GetPersistableEntries(), writeStream);
}
IEnumerable<ICommandOutput> UpdateProjectPackages()
{
yield return new Info("Updating project packages...");
var sourceRepos = _remoteRepositories;
var errors = new List<PackageOperationResult>();
bool updated = false;
_targetDescriptor = HostEnvironment.GetOrCreateScopedDescriptor(Scope ?? string.Empty);
var packageDescriptor = _targetDescriptor.Value.Lock(HostEnvironment.ProjectRepository);
foreach (var x in (string.IsNullOrEmpty(Name)
? PackageManager.UpdateProjectPackages(sourceRepos, HostEnvironment.ProjectRepository, packageDescriptor)
: PackageManager.UpdateProjectPackages(sourceRepos, HostEnvironment.ProjectRepository, packageDescriptor, Name)))
if (x is PackageMissingResult || x is PackageConflictResult)
{
errors.Add(x);
}
else
{
updated = true;
yield return x.ToOutput();
}
if (updated)
_targetDescriptor.File.Touch();
foreach (var failed in errors.GetFailures())
{
var errorMessage = "{0} could not be updated\r\n{1}";
var details = failed.SelectMany(_ => new[] { " - " + _.First() }.Concat(_.Skip(1).Select(x => " " + x)));
yield return new Error(errorMessage, failed.Key, details.JoinString(@"\r\n"));
}
}
IEnumerable<ICommandOutput> InProject()
{
if (!Project) yield break;
if (HostEnvironment.ProjectRepository != null)
_targetDescriptor = HostEnvironment.GetOrCreateScopedDescriptor(Scope);
else
yield return new Error("Not in a package directory.");
}
ICommandOutput VerifyDescriptor(FileBased<IPackageDescriptor> descriptor)
{
if (NoDescriptorUpdate)
return new GenericMessage("Descriptor file will not be updated.");
return descriptor.File.Exists
? new GenericMessage(@"Using descriptor {0}.", descriptor.File.Name)
: new GenericMessage("Creating descriptor {0}.", descriptor.File.Name);
}
protected override IEnumerable<ICommandOutput> ExecuteCore()
{
_targetDescriptor = HostEnvironment.GetOrCreateScopedDescriptor(Scope ?? string.Empty);
yield return VerifyDescriptor(_targetDescriptor);
yield return VerifyProjectRepository();
yield return SetupEnvironmentForAdd();
var sourceRepositories = GetSourceRepositories().ToList();
foreach(var repository in from r in sourceRepositories
let cache = r.Feature<ISupportCaching>()
where cache != null
select new { repository = r, cache })
{
var updateTime = new Stopwatch();
updateTime.Start();
yield return new Info("Updating repository {0}.", repository.repository.Name);
repository.cache.Update();
yield return new Info("Updated repository {0} in {1}.",
repository.repository.Name,
updateTime.Elapsed);
}
var descriptor = new PackageDescriptor(_targetDescriptor.Value);
if (Project && System)
{
var sysToAdd = new List<PackageIdentifier>();
using (SaveDescriptorOnSuccess(_targetDescriptor))
{
foreach (var m in AddProjectPackage(descriptor, sourceRepositories))
{
yield return ToOutput(m);
ParseSuccess(m, sysToAdd.Add);
}
foreach (var identifier in sysToAdd)
foreach (var m in PackageManager.AddSystemPackage(PackageRequest.Exact(identifier.Name, identifier.Version), sourceRepositories, HostEnvironment.SystemRepository))
yield return ToOutput(m);
}
}
else if (Project)
{
using (SaveDescriptorOnSuccess(_targetDescriptor))
{
foreach (var m in AddProjectPackage(descriptor, sourceRepositories))
{
yield return ToOutput(m);
}
}
}
else if (System)
{
foreach (var m in PackageManager.AddSystemPackage(PackageRequest, sourceRepositories, HostEnvironment.SystemRepository, AddOptions))
{
yield return ToOutput(m);
}
}
if (_packageNotFound)
{
var hit = false;
foreach (var m in PackageManager.ListPackages(sourceRepositories, Name))
{
if (!hit)
{
yield return new Info("Did you mean one of the following packages?", Name);
hit = true;
}
yield return ToOutput(m);
}
}
}
