internal MockServiceReferenceInfo( PluginInfo ownerPlugin, ServiceInfo referencedService, DependencyRequirement requirement ) { Debug.Assert( ownerPlugin != null ); Debug.Assert( referencedService != null ); _owner = ownerPlugin; _reference = referencedService; _requirement = requirement; }
internal LabServiceInfo( ServiceInfo serviceInfo) { Debug.Assert( serviceInfo != null ); _serviceInfo = serviceInfo; StartServiceCommand = new RelayCommand( ExecuteStartService, CanExecuteStartService ); StopServiceCommand = new RelayCommand( ExecuteStopService, CanExecuteStopService ); }
internal PluginInfo( string pluginFullName, IAssemblyInfo assemblyInfo, ServiceInfo service = null ) { Debug.Assert( assemblyInfo != null ); _pluginFullName = pluginFullName; _assemblyInfo = assemblyInfo; _service = service; _serviceReferences = new CKObservableSortedArrayList<MockServiceReferenceInfo>( ( x, y ) => String.CompareOrdinal( x.Reference.ServiceFullName, y.Reference.ServiceFullName ), false ); }
/// <summary> /// Attempts to rename a service. /// </summary> /// <param name="serviceInfo">Service to rename</param> /// <param name="newName">New service name</param> /// <returns>Operation result</returns> internal DetailedOperationResult RenameService( ServiceInfo serviceInfo, string newName ) { return _labStateManager.RenameService( serviceInfo, newName ); }
internal PendingGeneralization( ServiceInfo service, string pendingServiceFullName ) { Service = service; PendingServiceFullName = pendingServiceFullName; }
private static void SerializeServiceInfoToXmlWriter( ServiceInfo si, XmlWriter w ) { w.WriteStartAttribute( "FullName" ); w.WriteValue( si.ServiceFullName ); w.WriteEndAttribute(); w.WriteStartElement( "Generalization" ); if( si.Generalization != null ) w.WriteValue( si.Generalization.ServiceFullName ); w.WriteEndElement(); // That's pretty much all we need. Implementations will be guessed from the plugins themselves. // HasError, AssemblyInfo and others aren't supported at this time, but can be added here later on. w.WriteStartElement( "X" ); if( si.PositionInGraph.IsValid() ) w.WriteValue( si.PositionInGraph.X.ToString( CultureInfo.InvariantCulture ) ); w.WriteEndElement(); w.WriteStartElement( "Y" ); if( si.PositionInGraph.IsValid() ) w.WriteValue( si.PositionInGraph.Y.ToString( CultureInfo.InvariantCulture ) ); w.WriteEndElement(); }
private void ReadService( XmlReader r ) { r.Read(); string serviceFullName = r.GetAttribute( "FullName" ); Debug.Assert( serviceFullName != null, "FullName attribute was found in Service XML element." ); ServiceInfo s = new ServiceInfo( serviceFullName, AssemblyInfoHelper.ExecutingAssemblyInfo ); loadedServices.Add( s ); ServiceInfo generalization = null; Point pos = new Point(); pos.X = Double.NaN; pos.Y = Double.NaN; while( r.Read() ) { if( r.IsStartElement() && !r.IsEmptyElement ) { switch( r.Name ) { case "Generalization": if( r.Read() ) { string generalizationName = r.Value; if( !String.IsNullOrEmpty( generalizationName ) ) { if( loadedServices.Contains( generalizationName ) ) { generalization = loadedServices.GetByKey( generalizationName ); s.Generalization = generalization; } else { pendingGeneralizations.Add( new PendingGeneralization( s, generalizationName ) ); } } } break; case "X": if( r.Read() ) { double posX; if( Double.TryParse( r.Value, NumberStyles.Any, CultureInfo.InvariantCulture, out posX ) ) pos.X = posX; } break; case "Y": if( r.Read() ) { double posY; if( Double.TryParse( r.Value, NumberStyles.Any, CultureInfo.InvariantCulture, out posY ) ) pos.Y = posY; } break; } } } s.PositionInGraph = pos; // Fix pending references of this service foreach( var pg in pendingGeneralizations.Where( x => x.PendingServiceFullName == serviceFullName ).ToList() ) { pg.Service.Generalization = s; pendingGeneralizations.Remove( pg ); } foreach( var pps in pendingPluginServices.Where( x => x.PendingServiceFullName == serviceFullName ).ToList() ) { pps.Plugin.Service = s; s.InternalImplementations.Add( pps.Plugin ); pendingPluginServices.Remove( pps ); } foreach( var psr in pendingServiceReferences.Where( x => x.PendingServiceFullName == serviceFullName ).ToList() ) { var reference = new MockServiceReferenceInfo( psr.Plugin, s, psr.Requirement ); psr.Plugin.InternalServiceReferences.Add( reference ); pendingServiceReferences.Remove( psr ); } }
/// <summary> /// Creates a lab wrapper item around an existing mock service, and adds it to our collection. /// </summary> /// <param name="s">Existing mock service</param> private void CreateLabService( ServiceInfo s ) { LabServiceInfo newServiceInfo; if( s.Generalization != null ) { LabServiceInfo generalizationLiveInfo = _labServiceInfos.GetByKey( (ServiceInfo)s.Generalization ); newServiceInfo = new LabServiceInfo( s ); // TODO: Running requirement } else { newServiceInfo = new LabServiceInfo( s ); } _labServiceInfos.Add( newServiceInfo ); }
/// <summary> /// Set an existing plugin's dependency to an existing service. /// </summary> /// <param name="plugin">Plugin</param> /// <param name="service">Service the plugin depends on</param> /// <param name="runningRequirement">How the plugin depends on the service</param> internal void SetPluginDependency( PluginInfo plugin, ServiceInfo service, DependencyRequirement runningRequirement ) { Debug.Assert( plugin != null ); Debug.Assert( service != null ); Debug.Assert( ServiceInfos.Contains( service ) ); Debug.Assert( PluginInfos.Contains( plugin ) ); MockServiceReferenceInfo reference = new MockServiceReferenceInfo( plugin, service, runningRequirement ); plugin.InternalServiceReferences.Add( reference ); }
/// <summary> /// Attempts to change one of our services' ServiceFullName. /// </summary> /// <param name="serviceInfo">ServiceInfo to rename</param> /// <param name="newName">New name</param> /// <returns>DetailedOperationResult on renaming attempt.</returns> /// <remarks> /// Can fail: Two services cannot coexist with the same name. /// </remarks> internal Utils.DetailedOperationResult RenameService( ServiceInfo serviceInfo, string newName ) { if( _engine.IsRunning ) { throw new InvalidOperationException( "Cannot rename Service while Engine is running." ); } bool exists; ServiceInfo existingInfo = _serviceInfos.GetByKey( newName, out exists ); if( exists ) return new Utils.DetailedOperationResult( false, "A service with this name already exists." ); serviceInfo.ServiceFullName = newName; return new Utils.DetailedOperationResult( true ); }
/// <summary> /// Removes a mock service info from our collections. /// </summary> /// <param name="serviceInfo">Mock service info to remove</param> internal void RemoveService( ServiceInfo serviceInfo ) { // If we delete a service : Unbind linked plugins and services. // Unbind generalized services foreach( ServiceInfo s in ServiceInfos.Where( si => si.Generalization == serviceInfo ).ToList() ) { s.Generalization = null; } // Unbind implementations foreach( PluginInfo p in PluginInfos.Where( pi => pi.Service == serviceInfo ).ToList() ) { p.Service = null; } // Delete all existing service references foreach( PluginInfo p in PluginInfos ) { foreach( MockServiceReferenceInfo reference in p.InternalServiceReferences.Where( r => r.Reference == serviceInfo ).ToList() ) { p.InternalServiceReferences.Remove( reference ); } } _labServiceInfos.Remove( serviceInfo ); _serviceInfos.Remove( serviceInfo ); }
/// <summary> /// Removes an existing plugin dependency. /// </summary> /// <param name="plugin">Plugin owner.</param> /// <param name="service">Service reference</param> internal void RemovePluginDependency( PluginInfo plugin, ServiceInfo service ) { Debug.Assert( plugin != null ); Debug.Assert( service != null ); Debug.Assert( ServiceInfos.Contains( service ) ); Debug.Assert( PluginInfos.Contains( plugin ) ); MockServiceReferenceInfo reference = plugin.InternalServiceReferences.First( x => x.Reference == service ); if( reference != null ) plugin.InternalServiceReferences.Remove( reference ); }
/// <summary> /// Loads a foreign mock service info and all it depends on into our collections. /// </summary> /// <param name="serviceInfo">Foreign mock service info</param> internal void LoadServiceInfo( ServiceInfo serviceInfo ) { if( _serviceInfos.Contains( serviceInfo ) ) return; // Already loaded CreateLabService( serviceInfo ); _serviceInfos.Add( serviceInfo ); if( serviceInfo.Generalization != null ) { LoadServiceInfo( (ServiceInfo)serviceInfo.Generalization ); } }
/// <summary> /// Creates a new named service, which specializes another service. /// </summary> /// <param name="serviceName">Name of the new service</param> /// <param name="generalization">Specialized service</param> /// <returns>New service</returns> /// <remarks>Cannot be used when engine is running.</remarks> internal ServiceInfo CreateNewService( string serviceName, ServiceInfo generalization = null ) { Debug.Assert( serviceName != null ); Debug.Assert( _serviceInfos.Any( x => x.ServiceFullName == serviceName ) == false, "Service does not exist and can be added" ); if( generalization != null ) Debug.Assert( ServiceInfos.Contains( generalization ) ); ServiceInfo newService = new ServiceInfo( serviceName, AssemblyInfoHelper.ExecutingAssemblyInfo, generalization ); CreateLabService( newService ); _serviceInfos.Add( newService ); // Throws on duplicate return newService; }
/// <summary> /// Creates a new named plugin, which implements an existing service. /// </summary> /// <param name="pluginName">Name of the new plugin</param> /// <param name="service">Implemented service</param> /// <returns>New plugin</returns> internal PluginInfo CreateNewPlugin( string pluginName, ServiceInfo service = null ) { Debug.Assert( !String.IsNullOrWhiteSpace( pluginName ) ); if( service != null ) Debug.Assert( ServiceInfos.Contains( service ) ); PluginInfo plugin = new PluginInfo( pluginName, AssemblyInfoHelper.ExecutingAssemblyInfo, service ); CreateLabPlugin( plugin ); _pluginInfos.Add( plugin ); // Throws on duplicate return plugin; }