private void RespondToRequiredByProject(PluginContainer pluginContainer, bool requiredByProject)
{
var name = pluginContainer.Name;
var requiredPlugins = GlueState.Self.CurrentGlueProject.PluginData.RequiredPlugins;
bool shouldSave = false;
if (requiredByProject && requiredPlugins.Any(item => item.Name == name) == false)
{
var pluginToAdd = new PluginRequirement
{
Name = name,
Version = pluginContainer.Plugin.Version.ToString()
};
requiredPlugins.Add(pluginToAdd);
shouldSave = true;
}
else if (requiredByProject == false && requiredPlugins.Any(item => item.Name == name))
{
var toRemove = requiredPlugins.First(item => item.Name == name);
requiredPlugins.Remove(toRemove);
shouldSave = true;
}
if (shouldSave)
{
TaskManager.Self.AddAsyncTask(
() => GlueCommands.Self.GluxCommands.SaveGlux(),
"Saving project after changing plugin requirements");
}
}
public bool SetPluginRequirement(Interfaces.IPlugin plugin, bool requiredByProject)
{
var name = plugin.FriendlyName;
var requiredPlugins = GlueState.Self.CurrentGlueProject.PluginData.RequiredPlugins;
bool didChange = false;
if (requiredByProject && requiredPlugins.Any(item => item.Name == name) == false)
{
var pluginToAdd = new PluginRequirement
{
Name = name,
Version = plugin.Version.ToString()
};
requiredPlugins.Add(pluginToAdd);
didChange = true;
}
else if (requiredByProject == false && requiredPlugins.Any(item => item.Name == name))
{
var toRemove = requiredPlugins.First(item => item.Name == name);
requiredPlugins.Remove(toRemove);
didChange = true;
}
return(didChange);
}
public bool UpdatePlugin(Guid pluginId, bool runnerDisabled, ISolvedPluginConfiguration config, IEnumerable <RequirementLayer> layers, IPluginDiscoverer d)
{
SolvedConfigStatus s;
Info = d.FindPlugin(pluginId);
bool isAvailable = !(Info == null || Info.HasError || RunningError != null);
if (isAvailable)
{
if (runnerDisabled)
{
s = SolvedConfigStatus.Disabled;
}
else
{
s = config.GetStatus(pluginId);
foreach (RequirementLayer l in layers)
{
PluginRequirement r = l.PluginRequirements.Find(pluginId);
if (r != null && (int)r.Requirement > (int)s)
{
s = (SolvedConfigStatus)r.Requirement;
}
}
}
}
else
{
s = SolvedConfigStatus.Disabled;
}
return(DoUpdateStatus(isAvailable, s));
}
public void TestPluginRequirementCollectionEnumerable()
{
Guid guid0 = Guid.NewGuid();
Guid guid1 = Guid.NewGuid();
Guid guid2 = Guid.NewGuid();
IPluginRequirementCollection reqs = new PluginRequirementCollection( );
PluginRequirement req0 = reqs.AddOrSet(guid0, RunningRequirement.MustExistAndRun);
Assert.That(reqs.Count == 1);
PluginRequirement req1 = reqs.AddOrSet(guid1, RunningRequirement.Optional);
Assert.That(reqs.Count == 2);
PluginRequirement req2 = reqs.AddOrSet(guid2, RunningRequirement.OptionalTryStart);
Assert.That(reqs.Count == 3);
Assert.That(reqs.Contains(req2) && reqs.Contains(req1) && reqs.Contains(req0));
reqs.Remove(guid2);
Assert.That(reqs.Count == 2);
Assert.That(!reqs.Contains(req2));
int passed = 0;
foreach (PluginRequirement o in reqs)
{
if (o.PluginId == guid0)
{
Assert.That(o.Requirement == RunningRequirement.MustExistAndRun);
passed++;
}
if (o.PluginId == guid1)
{
Assert.That(o.Requirement == RunningRequirement.Optional);
passed++;
}
}
Assert.That(passed, Is.EqualTo(2));
reqs.Clear();
Assert.That(reqs.Count == 0);
Assert.That(((PluginRequirement)req0).Holder == null);
Assert.That(((PluginRequirement)req1).Holder == null);
Assert.That(((PluginRequirement)req2).Holder == null);
passed = 0;
foreach (PluginRequirement o in reqs)
{
passed++;
}
Assert.That(passed == 0);
}
void PluginRequirementCollectionEvents(PluginRequirementCollection collection)
{
Guid id = Guid.NewGuid();
PluginRequirementCollectionChangingEventArgs lastChanging = null;
PluginRequirementCollectionChangedEventArgs lastChanged = null;
int changingCount = 0;
int changedCount = 0;
collection.Changing += (o, e) => { lastChanging = e; changingCount++; };
collection.Changed += (o, e) => { lastChanged = e; changedCount++; };
// Check add
PluginRequirement req = collection.AddOrSet(id, RunningRequirement.MustExistAndRun);
Assert.That(changedCount == 1 && changingCount == 1);
Assert.That(lastChanging.Action == CK.Core.ChangeStatus.Add);
Assert.That(lastChanged.Action == CK.Core.ChangeStatus.Add);
Assert.That(lastChanging.Collection == collection);
Assert.That(lastChanged.Collection == collection);
Assert.That(lastChanging.PluginId == id);
Assert.That(lastChanged.PluginId == id);
Assert.That(lastChanging.Requirement == RunningRequirement.MustExistAndRun);
Assert.That(lastChanged.Requirement == RunningRequirement.MustExistAndRun);
changedCount = 0; changingCount = 0;
// Check delete : from the collection
collection.Remove(id);
Assert.That(changedCount == 1 && changingCount == 1);
Assert.That(lastChanging.Action == CK.Core.ChangeStatus.Delete);
Assert.That(lastChanged.Action == CK.Core.ChangeStatus.Delete);
Assert.That(lastChanging.Collection == collection);
Assert.That(lastChanged.Collection == collection);
Assert.That(lastChanging.PluginId == id);
Assert.That(lastChanged.PluginId == id);
Assert.That(lastChanging.Requirement == RunningRequirement.MustExistAndRun);
Assert.That(lastChanged.Requirement == RunningRequirement.MustExistAndRun);
changedCount = 0; changingCount = 0;
// Check clear
collection.Clear();
Assert.That(changedCount == 1 && changingCount == 1);
Assert.That(lastChanging.Action == CK.Core.ChangeStatus.ContainerClear);
Assert.That(lastChanged.Action == CK.Core.ChangeStatus.ContainerClear);
Assert.That(lastChanging.Collection == collection);
Assert.That(lastChanged.Collection == collection);
Assert.That(lastChanging.PluginId == Guid.Empty);
Assert.That(lastChanged.PluginId == Guid.Empty);
Assert.That(lastChanging.Requirement == 0);
Assert.That(lastChanged.Requirement == 0);
}
public void TestPluginRequirementCollectionUpdate()
{
bool updated = false;
Guid guid1 = Guid.NewGuid();
Guid guid2 = Guid.NewGuid();
Guid guid3 = Guid.NewGuid();
IPluginRequirementCollection reqs = new PluginRequirementCollection( );
reqs.Changed += (o, e) => { if (e.Action == CK.Core.ChangeStatus.Update)
{
updated = true;
}
};
PluginRequirement req = reqs.AddOrSet(guid1, RunningRequirement.MustExistAndRun);
Assert.That(reqs.Count == 1);
//Assert.That( (req.Source == reqs.Source) && (reqs.Source == ctx) );
PluginRequirement req1 = reqs.AddOrSet(guid2, RunningRequirement.MustExistAndRun);
Assert.That(reqs.Count == 2);
PluginRequirement req2 = reqs.AddOrSet(guid3, RunningRequirement.MustExistAndRun);
Assert.That(reqs.Count == 3);
Assert.That(reqs.Contains(req2) && reqs.Contains(req1) && reqs.Contains(req));
PluginRequirement req3 = reqs.AddOrSet(guid3, RunningRequirement.Optional);
Assert.That(updated);
Assert.That(req2 == req3);
Assert.That(reqs.Count == 3);
}
public void TestPluginRequirementCollectionEvents()
{
int createdEventFired = 0;
int removedEventFired = 0;
int updatedEventFired = 0;
int clearedEventFired = 0;
int creatingEventFired = 0;
int removingEventFired = 0;
int updatingEventFired = 0;
int clearingEventFired = 0;
bool cancel = false;
Guid changingPluginId = Guid.Empty;
RunningRequirement previousRequirement = RunningRequirement.OptionalTryStart;
RunningRequirement newRequirement = RunningRequirement.OptionalTryStart;
PluginRequirement lastRequirementCreated = null;
PluginRequirement lastRequirementRemoved = null;
IPluginRequirementCollection reqs = new PluginRequirementCollection();
reqs.Changing += (sender, args) =>
{
switch (args.Action)
{
case CK.Core.ChangeStatus.Update:
updatingEventFired++;
if (!cancel)
{
previousRequirement = args.Collection.Find(args.PluginId).Requirement;
}
break;
case CK.Core.ChangeStatus.Add:
creatingEventFired++;
break;
case CK.Core.ChangeStatus.Delete:
removingEventFired++;
break;
case CK.Core.ChangeStatus.ContainerClear:
clearingEventFired++;
break;
}
if (cancel)
{
args.Cancel = true;
}
};
reqs.Changed += (sender, args) =>
{
switch (args.Action)
{
case CK.Core.ChangeStatus.Update:
updatedEventFired++;
newRequirement = args.Requirement;
break;
case CK.Core.ChangeStatus.Add:
lastRequirementCreated = args.Collection.Find(args.PluginId);
createdEventFired++;
break;
case CK.Core.ChangeStatus.Delete:
lastRequirementRemoved = args.Collection.Find(args.PluginId);
removedEventFired++;
break;
case CK.Core.ChangeStatus.ContainerClear:
clearedEventFired++;
break;
}
};
PluginRequirement req = reqs.AddOrSet(Guid.NewGuid(), RunningRequirement.MustExistAndRun);
Assert.That(lastRequirementCreated == req);
Assert.That(createdEventFired == 1);
Assert.That(creatingEventFired == 1);
PluginRequirement req1 = reqs.AddOrSet(Guid.NewGuid(), RunningRequirement.MustExistAndRun);
Assert.That(lastRequirementCreated == req1);
Assert.That(createdEventFired == 2);
Assert.That(creatingEventFired == 2);
PluginRequirement req2 = reqs.AddOrSet(Guid.NewGuid(), RunningRequirement.MustExistAndRun);
Assert.That(lastRequirementCreated == req2);
Assert.That(createdEventFired == 3);
Assert.That(creatingEventFired == 3);
reqs.AddOrSet(req2.PluginId, RunningRequirement.MustExist);
Assert.That(previousRequirement == RunningRequirement.MustExistAndRun);
Assert.That(newRequirement == RunningRequirement.MustExist);
Assert.That(updatingEventFired == 1);
Assert.That(updatedEventFired == 1);
// Now, cancel is true, nothing should be done
cancel = true;
reqs.AddOrSet(req2.PluginId, RunningRequirement.Optional);
Assert.That(previousRequirement == RunningRequirement.MustExistAndRun);
Assert.That(newRequirement == RunningRequirement.MustExist);
Assert.That(updatingEventFired == 2);
Assert.That(updatedEventFired == 1);
cancel = false;
reqs.Clear();
Assert.That(clearedEventFired, Is.EqualTo(1));
}
