public IYodiiEngineResult Remove(IConfigurationLayer layer)
{
if (layer == null)
{
throw new ArgumentNullException("layer");
}
if (layer.ConfigurationManager != _parent)
{
return(_parent.Engine.SuccessResult);
}
// When called by a hacker.
ConfigurationLayer l = layer as ConfigurationLayer;
if (l == null)
{
throw new ArgumentException("Invalid layer.", "layer");
}
Debug.Assert(_layers.Contains(layer), "Since layer.ConfigurationManager == _parent, then it necessarily belongs to us.");
IYodiiEngineResult result = _parent.OnConfigurationLayerRemoving(l);
if (result.Success)
{
_layers.Remove(l);
l.SetConfigurationManager(null);
_parent.OnConfigurationChanged();
}
return(result);
}
public void ManagerCreationTests()
{
YodiiEngine engine = new YodiiEngine(new YodiiEngineHostMock());
int managerChangingCount = 0;
int managerChangedCount = 0;
engine.Configuration.ConfigurationChanging += delegate(object sender, ConfigurationChangingEventArgs e)
{
Assert.That(e.IsCanceled == false, "Configuration manager does not cancel by default.");
Assert.That(e.FinalConfiguration != null, "Proposed FinalConfiguration exists.");
managerChangingCount++;
};
engine.Configuration.ConfigurationChanged += delegate(object sender, ConfigurationChangedEventArgs e)
{
Assert.That(e.FinalConfiguration != null, "FinalConfiguration exists.");
managerChangedCount++;
};
IYodiiEngineResult result;
IConfigurationLayer layer = engine.Configuration.Layers.Create("BaseConfig");
result = layer.Items.Add("Yodii.ManagerService", ConfigurationStatus.Runnable);
Assert.That(result.Success, Is.True);
result = layer.Items.Add(Guid.NewGuid().ToString(), ConfigurationStatus.Disabled);
Assert.That(result.Success, Is.True);
Assert.That(managerChangingCount == 2);
Assert.That(managerChangedCount == 2);
Assert.That(engine.Configuration.FinalConfiguration != null, "Non-cancelled FinalConfiguration exists.");
}
private void ExecuteRemoveLayer(object param)
{
Debug.Assert(param is IConfigurationLayer);
IConfigurationLayer layer = (IConfigurationLayer)param;
bool cancelled = false;
if (layer.Items.Count != 0)
{
var messageBoxResult = MessageBox.Show("Really delete this layer ?\n\nIts configuration will be lost.", "Confirm layer deletion", MessageBoxButton.YesNo, MessageBoxImage.Warning, MessageBoxResult.No, MessageBoxOptions.None);
if (messageBoxResult != MessageBoxResult.Yes)
{
cancelled = true;
}
}
if (!cancelled)
{
var layerRemoveResult = layer.ConfigurationManager.Layers.Remove(layer);
if (!layerRemoveResult.Success)
{
RaiseUserError("Couldn't remove layer", String.Format("Failed to remove layer.\n\n{1}", String.Join("; ", layerRemoveResult.ConfigurationFailureResult.FailureReasons)));
}
}
}
private void ExecuteAddLayer(object param)
{
CreateConfigurationLayerWindow w = new CreateConfigurationLayerWindow();
w.Owner = _window;
bool?result = w.ShowDialog();
if (result == true)
{
string layerName = w.NewLayerName.Text;
IConfigurationLayer newLayer = _configurationManager.Layers.Create(layerName);
}
}
private void ApplyPersistedStateToLab()
{
// Stop running engine
if (state.Engine.IsRunning)
{
state.Engine.Stop();
}
// Clear configuration manager
foreach (var l in state.Engine.Configuration.Layers.ToList())
{
var result = state.Engine.Configuration.Layers.Remove(l);
Debug.Assert(result.Success);
}
// Clear services and plugins
state.ClearState();
// Add services and plugins
foreach (ServiceInfo s in deserializedState.Services)
{
state.LoadServiceInfo(s);
}
foreach (PluginInfo p in deserializedState.Plugins)
{
state.LoadPluginInfo(p);
}
// Load configuration manager data
foreach (PersistedConfigurationLayer l in deserializedState.ConfigurationLayers)
{
IConfigurationLayer newLayer = state.Engine.Configuration.Layers.Create(l.LayerName);
foreach (PersistedConfigurationItem item in l.Items)
{
var result = newLayer.Items.Add(item.ServiceOrPluginId, item.Status, item.StatusReason);
Debug.Assert(result.Success);
}
}
}
private void ExecuteAddConfigItem(object param)
{
if (_isChangingConfig)
{
return;
}
if (_disposed)
{
return;
}
_isChangingConfig = true;
Debug.Assert(param != null && param is IConfigurationLayer);
IConfigurationLayer layer = param as IConfigurationLayer;
CreateConfigurationItemWindow w = new CreateConfigurationItemWindow(_serviceInfoManager);
w.Owner = _window;
var windowResult = w.ShowDialog();
if (windowResult == true)
{
string serviceOrPluginId = w.ViewModel.SelectedServiceOrPluginId;
if (serviceOrPluginId != null)
{
var itemAddResult = layer.Items.Add(serviceOrPluginId, w.ViewModel.SelectedStatus);
if (!itemAddResult.Success)
{
string message = itemAddResult.Describe();
RaiseUserError("Couldn't add item", String.Format("Configuration of {0} could not be added, as it would cause the following error:\n\n{1}",
_serviceInfoManager.GetDescriptionOfServiceOrPluginFullName(serviceOrPluginId),
message)
);
}
}
}
_isChangingConfig = false;
}
public void LayerCreationTest()
{
YodiiEngine e = new YodiiEngine(new YodiiEngineHostMock());
IConfigurationLayer layer = e.Configuration.Layers.Create("TestConfig");
Assert.That(layer.Items.Count == 0);
Assert.That(layer.LayerName == "TestConfig");
string pluginIdentifier;
IYodiiEngineResult result;
// Add a random plugin GUID
pluginIdentifier = Guid.NewGuid().ToString();
result = layer.Items.Add(pluginIdentifier, ConfigurationStatus.Disabled);
Assert.That(result.Success, Is.True);
Assert.That(layer.Items.Count == 1);
Assert.That(layer.Items[pluginIdentifier], Is.InstanceOf <ConfigurationItem>());
// Add another random plugin GUID
pluginIdentifier = Guid.NewGuid().ToString();
result = layer.Items.Add(pluginIdentifier, ConfigurationStatus.Runnable);
Assert.That(result.Success, Is.True);
Assert.That(layer.Items.Count == 2);
Assert.That(layer.Items[pluginIdentifier], Is.InstanceOf <ConfigurationItem>());
// Remove last plugin GUID
result = layer.Items.Remove(pluginIdentifier);
Assert.That(result.Success, Is.True);
Assert.That(layer.Items.Count == 1);
// Add some service
pluginIdentifier = "Yodii.ManagerService";
result = layer.Items.Add(pluginIdentifier, ConfigurationStatus.Runnable);
Assert.That(result.Success, Is.True);
Assert.That(layer.Items.Count == 2);
Assert.That(layer.Items[pluginIdentifier], Is.InstanceOf <ConfigurationItem>());
}
public void ConfigChanged()
{
/**
* +--------+
* |ServiceA+ ------+
* | | |
* +---+----+ |
* | |
* | |
* | |
* | +---+---*-+
* +---+-----+ |PluginA-2|
* |PluginA-1| | |
* | | +---------+
* +---------+
*/
DiscoveredInfo info = MockInfoFactory.CreateGraph003();
YodiiEngine engine = new YodiiEngine(new YodiiEngineHostMock());
engine.SetDiscoveredInfo(info);
engine.Start();
ILiveServiceInfo sA = engine.LiveInfo.FindService("ServiceA");
ILivePluginInfo p1 = engine.LiveInfo.FindPlugin("PluginA-1");
ILivePluginInfo p2 = engine.LiveInfo.FindPlugin("PluginA-2");
Assert.That(sA != null && p1 != null && p2 != null);
Assert.That(p1.Capability.CanStart && p2.Capability.CanStart && sA.Capability.CanStart, Is.True);
Assert.That(p1.Capability.CanStartWithFullStart && p2.Capability.CanStartWithFullStart && sA.Capability.CanStartWithFullStart, Is.True);
Assert.That(p1.Capability.CanStartWithStartRecommended && p2.Capability.CanStartWithStartRecommended && sA.Capability.CanStartWithStartRecommended, Is.True);
Assert.That(p1.Capability.CanStartWithStopOptionalAndRunnable && p2.Capability.CanStartWithStopOptionalAndRunnable && sA.Capability.CanStartWithStopOptionalAndRunnable, Is.True);
Assert.That(p1.Capability.CanStartWithFullStop && p2.Capability.CanStartWithFullStop && sA.Capability.CanStartWithFullStop, Is.True);
HashSet <string> propertyChanged = new HashSet <string>();
p1.PropertyChanged += (s, e) =>
{
Assert.That(s, Is.SameAs(p1));
Assert.That(propertyChanged.Add("p1." + e.PropertyName));
};
p1.Capability.PropertyChanged += (s, e) =>
{
Assert.That(s, Is.SameAs(p1.Capability));
Assert.That(propertyChanged.Add("p1.Capablity." + e.PropertyName));
};
p2.PropertyChanged += (s, e) =>
{
Assert.That(s, Is.SameAs(p2));
Assert.That(propertyChanged.Add("p2." + e.PropertyName));
};
p2.Capability.PropertyChanged += (s, e) =>
{
Assert.That(s, Is.SameAs(p2.Capability));
Assert.That(propertyChanged.Add("p2.Capablity." + e.PropertyName));
};
sA.PropertyChanged += (s, e) =>
{
Assert.That(s, Is.SameAs(sA));
Assert.That(propertyChanged.Add("sA." + e.PropertyName));
};
sA.Capability.PropertyChanged += (s, e) =>
{
Assert.That(s, Is.SameAs(sA.Capability));
Assert.That(propertyChanged.Add("sA.Capablity." + e.PropertyName));
};
IConfigurationLayer config = engine.Configuration.Layers.Create("Default");
config.Items.Add(p1.FullName, ConfigurationStatus.Disabled);
Assert.That(p1.Capability.CanStart && p1.Capability.CanStartWithFullStart &&
p1.Capability.CanStartWithStartRecommended && p1.Capability.CanStartWithStopOptionalAndRunnable &&
p1.Capability.CanStartWithFullStop, Is.False);
Assert.That(p2.Capability.CanStart && sA.Capability.CanStart, Is.True);
Assert.That(p2.Capability.CanStartWithFullStart && sA.Capability.CanStartWithFullStart, Is.True);
Assert.That(p2.Capability.CanStartWithStartRecommended && sA.Capability.CanStartWithStartRecommended, Is.True);
Assert.That(p2.Capability.CanStartWithStopOptionalAndRunnable && sA.Capability.CanStartWithStopOptionalAndRunnable, Is.True);
Assert.That(p2.Capability.CanStartWithFullStop && sA.Capability.CanStartWithFullStop, Is.True);
CollectionAssert.AreEquivalent(new string[] {
"p1.Capablity.CanStart",
"p1.Capablity.CanStartWithFullStart",
"p1.Capablity.CanStartWithStartRecommended",
"p1.Capablity.CanStartWithStopOptionalAndRunnable",
"p1.Capablity.CanStartWithFullStop",
"p1.DisabledReason",
"p1.RunningStatus",
"p1.ConfigOriginalStatus",
"p1.WantedConfigSolvedStatus",
"p1.FinalConfigSolvedStatus"
}, propertyChanged);
propertyChanged.Clear();
config.Items.Add(p1.FullName, ConfigurationStatus.Optional);
CollectionAssert.AreEquivalent(new string[] {
"p1.Capablity.CanStart",
"p1.Capablity.CanStartWithFullStart",
"p1.Capablity.CanStartWithStartRecommended",
"p1.Capablity.CanStartWithStopOptionalAndRunnable",
"p1.Capablity.CanStartWithFullStop",
"p1.DisabledReason",
"p1.RunningStatus",
"p1.ConfigOriginalStatus",
"p1.WantedConfigSolvedStatus",
"p1.FinalConfigSolvedStatus"
}, propertyChanged);
}
internal void CheckPosition( IConfigurationLayer layer )
{
_layers.CheckPosition( _layers.IndexOf( layer ) );
}
public IYodiiEngineResult Remove( IConfigurationLayer layer )
{
if( layer == null ) throw new ArgumentNullException( "layer" );
if( layer.ConfigurationManager != _parent ) return _parent.Engine.SuccessResult;
// When called by a hacker.
ConfigurationLayer l = layer as ConfigurationLayer;
if ( l == null ) throw new ArgumentException( "Invalid layer.", "layer" );
Debug.Assert( _layers.Contains( layer ), "Since layer.ConfigurationManager == _parent, then it necessarily belongs to us." );
IYodiiEngineResult result = _parent.OnConfigurationLayerRemoving( l );
if( result.Success )
{
_layers.Remove( l );
l.SetConfigurationManager( null );
_parent.OnConfigurationChanged();
}
return result;
}
internal void OnLayerNameChanged( IConfigurationLayer layer )
{
_configurationLayerCollection.CheckPosition( layer );
}
/// <summary>
/// Creates a new instance of ConfigurationChangingEventArgs when change is triggered by a ConfigurationLayer.
/// </summary>
/// <param name="finalConfiguration">New FinalConfiguration</param>
/// <param name="finalConfigurationChanged">Details of changes in the new FinalConfiguration</param>
/// <param name="configurationLayer">Layer that provoked this change</param>
public ConfigurationChangingEventArgs(FinalConfiguration finalConfiguration, FinalConfigurationChange finalConfigurationChanged, IConfigurationLayer configurationLayer)
{
_finalConfiguration = finalConfiguration;
_finalConfigurationChange = finalConfigurationChanged;
_configurationLayerChanged = configurationLayer;
}
public void LayerAddPrecedenceTest()
{
var engine = new YodiiEngine(new YodiiEngineHostMock());
IConfigurationLayer layer = engine.Configuration.Layers.Create("TestConfig");
IYodiiEngineResult result;
// Precedence test for Disabled
string pluginId = Guid.NewGuid().ToString();
result = layer.Items.Add(pluginId, ConfigurationStatus.Disabled);
Assert.That(result.Success, Is.True);
Assert.That(layer.Items[pluginId].Status == ConfigurationStatus.Disabled);
result = layer.Items.Add(pluginId, ConfigurationStatus.Disabled);
Assert.That(result.Success, Is.True, "Adding the same plugin twice, in the same state, is a valid operation.");
Assert.That(layer.Items.Count == 1, "Adding the same plugin twice, in the same state, does not actually add it and increment the count.");
result = layer.Items.Add(pluginId, ConfigurationStatus.Optional);
Assert.That(result.Success, Is.True);
result = layer.Items.Add(pluginId, ConfigurationStatus.Runnable);
Assert.That(result.Success, Is.True);
result = layer.Items.Add(pluginId, ConfigurationStatus.Running);
Assert.That(result.Success, Is.True);
result = layer.Items.Add(pluginId, ConfigurationStatus.Disabled);
Assert.That(result.Success, Is.True);
result = layer.Items.Remove(pluginId);
Assert.That(result.Success, Is.True, "Plugin can always be removed if it exists and layer isn't bound to a parent.");
// Precedence test for Running
pluginId = Guid.NewGuid().ToString();
result = layer.Items.Add(pluginId, ConfigurationStatus.Running);
Assert.That(result.Success, Is.True);
Assert.That(layer.Items[pluginId].Status == ConfigurationStatus.Running);
result = layer.Items.Add(pluginId, ConfigurationStatus.Running);
Assert.That(result.Success, Is.True, "Adding the same plugin twice, in the same state, is a valid operation.");
Assert.That(layer.Items.Count == 1, "Adding the same plugin twice, in the same state, does not actually add it and increment the count.");
result = layer.Items.Add(pluginId, ConfigurationStatus.Optional);
Assert.That(result.Success, Is.True);
result = layer.Items.Add(pluginId, ConfigurationStatus.Runnable);
Assert.That(result.Success, Is.True);
result = layer.Items.Add(pluginId, ConfigurationStatus.Disabled);
Assert.That(result.Success, Is.True);
result = layer.Items.Remove(pluginId);
Assert.That(result.Success, Is.True, "Plugin can always be removed if it exists and layer isn't bound to a parent.");
// Precedence test for Optional -> Runnable -> Running
pluginId = Guid.NewGuid().ToString();
result = layer.Items.Add(pluginId, ConfigurationStatus.Optional);
Assert.That(result.Success, Is.True);
Assert.That(layer.Items[pluginId].Status == ConfigurationStatus.Optional);
result = layer.Items.Add(pluginId, ConfigurationStatus.Optional);
Assert.That(result.Success, Is.True, "Adding the same plugin twice, in the same state, is a valid operation.");
Assert.That(layer.Items.Count == 1, "Adding the same plugin twice, in the same state, does not actually add it and increment the count.");
result = layer.Items.Add(pluginId, ConfigurationStatus.Runnable);
Assert.That(result.Success, Is.True, "Layer override precedence: Optional -> Runnable is a valid operation.");
Assert.That(layer.Items[pluginId].Status == ConfigurationStatus.Runnable);
result = layer.Items.Add(pluginId, ConfigurationStatus.Running);
Assert.That(result.Success, Is.True, "Layer override precedence: Runnable -> Running is a valid operation.");
Assert.That(layer.Items[pluginId].Status == ConfigurationStatus.Running);
Assert.That(layer.Items.Count == 1, "Adding the same plugin over and over does not actually increment the count.");
result = layer.Items.Remove(pluginId);
Assert.That(result.Success, Is.True, "Plugin can always be removed if it exists and layer isn't bound to a parent.");
}
internal void OnLayerNameChanged(IConfigurationLayer layer)
{
_configurationLayerCollection.CheckPosition(layer);
}
internal void CheckPosition(IConfigurationLayer layer)
{
_layers.CheckPosition(_layers.IndexOf(layer));
}
/// <summary>
/// Creates a new instance of ConfigurationChangingEventArgs when change is triggered by a ConfigurationLayer.
/// </summary>
/// <param name="finalConfiguration">New FinalConfiguration</param>
/// <param name="finalConfigurationChanged">Details of changes in the new FinalConfiguration</param>
/// <param name="configurationLayer">Layer that provoked this change</param>
public ConfigurationChangingEventArgs( FinalConfiguration finalConfiguration, FinalConfigurationChange finalConfigurationChanged, IConfigurationLayer configurationLayer )
{
_finalConfiguration = finalConfiguration;
_finalConfigurationChange = finalConfigurationChanged;
_configurationLayerChanged = configurationLayer;
}
