示例#1
0
 /// <summary>
 /// Implements standard name checking for <see cref="ActionConfiguration.Name"/>. 
 /// The provided <paramref name="nameToCheck"/> must not be null or empty or contains only whitespaces nor '/' character.
 /// The '/' is reserved to structure the namespace.
 /// </summary>
 /// <param name="routeName">The name of the route that contains the action.</param>
 /// <param name="monitor">The monitor that will receive error descriptions.</param>
 /// <param name="nameToCheck">The name to check.</param>
 /// <returns>True if the name is valid. False otherwise.</returns>
 static public bool CheckActionNameValidity( string routeName, IActivityMonitor monitor, string nameToCheck )
 {
     if( String.IsNullOrWhiteSpace( nameToCheck ) ) monitor.SendLine( LogLevel.Error, string.Format( "Invalid name '{0}' in route '{1}'. Name must not be empty or contains only white space.", nameToCheck, routeName ), null );
     else if( nameToCheck.Contains( '/' ) ) monitor.SendLine( LogLevel.Error, string.Format( "Invalid name '{0}' in route '{1}'. Name must not contain '/'.", nameToCheck, routeName ), null );
     else return true;
     return false;
 }
 internal ActionCompositeConfigurationResolved( IActivityMonitor monitor, int index, IReadOnlyList<string> path, ActionCompositeConfiguration a, bool flattenUselessComposite )
     : base( index, path, a )
 {
     _isParallel = a.IsParallel;
     _children = new List<ActionConfigurationResolved>();
     AppendChildren( monitor, a, path.Append( a.Name ).ToArray(), flattenUselessComposite );
 }
示例#3
0
 static TestHelper()
 {
     _monitor = new ActivityMonitor();
     _monitor.Output.BridgeTarget.HonorMonitorFilter = false;
     _console = new ActivityMonitorConsoleClient();
     _monitor.Output.RegisterClients( _console );
 }
 /// <summary>
 /// Checks the validity: name and <see cref="DeclaredName"/> must be valid.
 /// </summary>
 /// <param name="routeName">Name of the route that contains this configuration.</param>
 /// <param name="monitor">Monitor to use to explain errors.</param>
 /// <returns>True if valid, false otherwise.</returns>
 protected internal override bool CheckValidity( string routeName, IActivityMonitor monitor )
 {
     // If we support insertion in a composite we will allow name with / inside/
     // If we allow / in DeclaredName, it means that an action inside a Composite can be inserted
     // somewhere else... This is possible technically, but does it make sense?
     return CheckActionNameValidity( routeName, monitor, _name ) && CheckActionNameValidity( routeName, monitor, _declaredName );
 }
示例#5
0
 /// <summary>
 /// Initialization of the handler: computes the path.
 /// </summary>
 /// <param name="m"></param>
 public override void Initialize( IActivityMonitor m )
 {
     using( m.OpenGroup( LogLevel.Trace, string.Format( "Initializing BinaryFile handler '{0}' (MaxCountPerFile = {1}).", Name, _file.MaxCountPerFile ), null ) )
     {
         _file.Initialize( m );
     }
 }
示例#6
0
 internal bool Override( IActivityMonitor monitor, IReadOnlyList<string> fullPath, ActionConfiguration a )
 {
     var e = fullPath.GetEnumerator();
     if( !e.MoveNext() ) throw new ArgumentException( "Must not be empty.", "fullPath" );
     if( e.Current != _action.Name ) throw new ArgumentException( "Must start with the action name.", "fullPath" );
     if( !e.MoveNext() )
     {
         _action = a;
         _isCloned = false;
         monitor.SendLine( LogLevel.Info, string.Format( "Action '{0}' has been overridden.", a.Name ), null );
         return true;
     }
     ActionCompositeConfiguration parent;
     int idx = FindInComposite( e, out parent );
     if( idx >= 0 )
     {
         Debug.Assert( _action is ActionCompositeConfiguration, "It is a composite." );
         Debug.Assert( _action.IsCloneable, "A composite is cloneable." );
         if( !_isCloned )
         {
             _action = ((ActionCompositeConfiguration)_action).CloneComposite( true );
             monitor.SendLine( LogLevel.Info, string.Format( "Action '{0}' has been cloned in order to override an inner action.", string.Join( "/", fullPath ) ), null );
             _isCloned = true;
             idx = FindInComposite( e, out parent );
         }
         Debug.Assert( parent.Children[idx].Name == fullPath.Last() );
         parent.Override( idx, a );
         monitor.SendLine( LogLevel.Info, string.Format( "Inner action '{0}' has been overridden.", string.Join( "/", fullPath ) ), null );
         return true;
     }
     monitor.SendLine( LogLevel.Error, string.Format( "Action '{0}' not found. Unable to override it.", string.Join( "/", fullPath ) ), null );
     return false;
 }
 void DemoOpenGroupBetter( IActivityMonitor m )
 {
     using( m.OpenInfo().Send( "Doing things..." ) )
     {
         // ...
     }
 }
示例#8
0
 static TestHelper()
 {
     _monitor = new ActivityMonitor();
     // Do not pollute the console by default...
     // ... but this may be useful sometimes: LogsToConsole does the job.
     _console = new ActivityMonitorConsoleClient();
 }
 /// <summary>
 /// Internal factory for ActionConfigurationResolved avoids externally visible virtual protected method on ActionConfiguration.
 /// This prevents any other composite implementations than our.
 /// </summary>
 internal static ActionConfigurationResolved Create( IActivityMonitor monitor, ActionConfiguration a, bool flattenUselessComposite, int index = 0, IReadOnlyList<string> path = null )
 {
     if( path == null ) path = Util.Array.Empty<string>();
     Impl.ActionCompositeConfiguration c = a as Impl.ActionCompositeConfiguration;
     if( c != null ) return new Impl.ActionCompositeConfigurationResolved( monitor, index, path, c, flattenUselessComposite );
     return new ActionConfigurationResolved( index, path, a );
 }
 /// <summary>
 /// Used only by filtering extension methods (level is filtered and not None) or by static FakeLineSender (level is None).
 /// </summary>
 internal ActivityMonitorLineSender( IActivityMonitor monitor, LogLevel level, string fileName, int lineNumber )
     : base( level, fileName, lineNumber )
 {
     Debug.Assert( FakeLineSender == null || ((level & LogLevel.IsFiltered) != 0 && MaskedLevel != LogLevel.None), 
         "The level is already filtered and not None or we are initializing the static FakeLineSender." );
     _monitor = monitor;
 }
 void DemoOpenGroupThisWorksFine( IActivityMonitor m )
 {
     using( m.OpenInfo().Send( "Doing things..." ) )
     {
         // ...
         m.CloseGroup( "Success." );
     }
 }
 void DemoLogs( IActivityMonitor m, FileInfo f, Exception ex )
 {
     m.Trace().Send( "Data from '{0}' processed.", f.Name );
     m.Info().Send( ex, "An error occurred while processing '{0}'. Process will be retried later.", f.Name );
     m.Warn().Send( "File '{0}' is too big ({1} Kb). It must be less than 50Kb.", f.Name, f.Length / 1024 );
     m.Error().Send( ex, "File '{0}' can not be processed.", f.Name );
     m.Fatal().Send( ex, "This will cancel the whole operation." );
 }
示例#13
0
 internal PreRoute( IActivityMonitor monitor, IProtoRoute protoRoute )
 {
     _monitor = monitor;
     _protoRoute = protoRoute;
     _actionsByName = new Dictionary<string,ActionConfigurationResolved>();
     _actions = new List<ActionConfigurationResolved>();
     foreach( var meta in _protoRoute.MetaConfigurations ) meta.Apply( this );
 }
 /// <summary>
 /// Private method used by OpenXXX (Trace, Info,..., Fatal) extension methods.
 /// </summary>
 static IActivityMonitorGroupSender FilteredGroup( IActivityMonitor @this, LogLevel level, string fileName, int lineNumber )
 {
     Debug.Assert( (level & LogLevel.IsFiltered) == 0 );
     if( @this.ShouldLogGroup( level, fileName, lineNumber ) )
     {
         return new ActivityMonitorGroupSender( @this, level | LogLevel.IsFiltered, fileName, lineNumber );
     }
     return new ActivityMonitorGroupSender( @this );
 }
        public override void Initialize(IActivityMonitor monitor)
        {
            base.Initialize(monitor);

            if (monitor == null)
            {
                return;
            }

            this.bridgeEventWriter = new BridgeEventTraceWriter();
            this.messageBusEventWriter = new MessageBusEventTraceWriter();
            this.publisherEventWriter = new PublisherEventTraceWriter();
            this.subscriberEventWriter = new SubscriberEventTraceWriter();
            this.workerEventWriter = new WorkerEventTraceWriter();

            monitor.BridgeClosed += this.OnBridgeClosed;
            monitor.BridgeClosing += this.OnBridgeClosing;
            monitor.BridgeInitialized += this.OnBridgeInitialized;
            monitor.BridgeInitializing += this.OnBridgeInitializing;
            monitor.BridgeTransferred += this.OnBridgeTransferred;
            monitor.BridgeTransferring += this.OnBridgeTransferring;
            monitor.BridgeException += this.OnBridgeException;
            monitor.BridgeWarning += this.OnBridgeWarning;
            monitor.MessageBusWarning += this.OnMessageBusWarning;
            monitor.MessageBusException += this.OnMessageBusException;
            monitor.MessageBusClosed += this.OnMessageBusClosed;
            monitor.MessageBusClosing += this.OnMessageBusClosing;
            monitor.MessageBusRegisteredHandler += this.OnMessageBusHandlerRegistered;
            monitor.MessageBusRegisteringHandler += this.OnMessageBusHandlerRegistering;
            monitor.MessageBusSending += this.OnMessageBusMessageSending;
            monitor.MessageBusSent += this.OnMessageBusMessageSent;
            monitor.PublisherWarning += this.OnPublisherWarning;
            monitor.PublisherException += this.OnPublisherException;
            monitor.PublisherClosed += this.OnPublisherClosed;
            monitor.PublisherClosing += this.OnPublisherClosing;
            monitor.PublisherInitializing += this.OnPublisherInitializing;
            monitor.PublisherInitialized += this.OnPublisherInitialized;
            monitor.PublisherSending += this.OnPublisherSending;
            monitor.PublisherSent += this.OnPublisherSent;
            monitor.SubscriberWarning += this.OnSubscriberWarning;
            monitor.SubscriberException += this.OnSubscriberException;
            monitor.SubscriberClosed += this.OnSubscriberClosed;
            monitor.SubscriberClosing += this.OnSubscriberClosing;
            monitor.SubscriberInitialized += this.OnSubscriberInitialized;
            monitor.SubscriberInitializing += this.OnSubscriberInitializing;
            monitor.SubscriberReceived += this.OnSubscriberReceived;
            monitor.SubscriberReceiving += this.OnSubscriberReceiving;
            monitor.WorkerRunning += this.OnWorkerRunning;
            monitor.WorkerStarted += this.OnWorkerStarted;
            monitor.WorkerStarting += this.OnWorkerStarting;
            monitor.WorkerStopped += this.OnWorkerStopped;
            monitor.WorkerStopping += this.OnWorkerStopping;
            monitor.WorkerCompleted += this.OnWorkerCompleted;
            monitor.WorkerException += this.OnWorkerException;
            monitor.WorkerWarning += this.OnWorkerWarning;
        }
示例#16
0
 /// <summary>
 /// Initialize a new <see cref="ActivityMonitorBridge"/> bound to an existing <see cref="ActivityMonitorBridgeTarget"/>
 /// This Client should be registered in the <see cref="IActivityMonitor.Output"/> of a local monitor.
 /// </summary>
 /// <param name="bridge">The target bridge.</param>
 /// <param name="pullTargetTopicAndAutoTagsFromTarget">
 /// When true, the <see cref="IActivityMonitor.Topic"/> and <see cref="IActivityMonitor.AutoTags"/> are automaticaly updated whenever they change on the target monitor.
 /// </param>
 /// <param name="pushTopicAndAutoTagsToTarget">
 /// When true, any change to <see cref="IActivityMonitor.Topic"/> or <see cref="IActivityMonitor.AutoTags"/> are applied to the target monitor.
 /// </param>
 /// <param name="applyTargetFilterToUnfilteredLogs">
 /// True to avoid sending logs with level below the target <see cref="IActivityMonitor.MinimalFilter"/> (when <see cref="ActivityMonitorBridgeTarget.HonorMonitorFilter"/> is true
 /// and it is an unfiltered line or group log).
 /// This is an optimization that can be used to send less data to the target monitor but breaks the UnfilteredLog/UnfilteredOpenGroup contract.
 /// </param>
 public ActivityMonitorBridge( ActivityMonitorBridgeTarget bridge, bool pullTargetTopicAndAutoTagsFromTarget, bool pushTopicAndAutoTagsToTarget, bool applyTargetFilterToUnfilteredLogs = false )
 {
     if( bridge == null ) throw new ArgumentNullException( "bridge" );
     _bridgeTarget = bridge;
     _pullTargetTopicAndAutoTagsFromTarget = pullTargetTopicAndAutoTagsFromTarget;
     _pushTopicAndAutoTagsToTarget = pushTopicAndAutoTagsToTarget;
     _applyTargetFilterToUnfilteredLogs = applyTargetFilterToUnfilteredLogs;
     _targetMonitor = _bridgeTarget.TargetMonitor;
     _openedGroups = new List<bool>();
 }
        private static void PrintAll(IActivityMonitor monitor, string key, DateTime time)
        {
            Console.WriteLine("Users for {0}", key);

            foreach (var user in monitor.GetAll(key, time))
            {
                Console.WriteLine("* {0}-{1}", user.Id, user.Name);
            }

            Console.WriteLine();
        }
示例#18
0
        public ActivityInfoProcessor()
        {
            this.monitor = new WindowsActivityMonitor();
            this.watcher = new WindowsProcessWatcher(monitor, queue);

            myTimer = new Timer {Interval = 1000};
            myTimer.Tick += watcher.Handle;

            consumeTimer = new Timer {Interval = 100};
            consumeTimer.Tick += consume;
        }
 void DemoOpenGroupWithDynamicConclusion( IActivityMonitor m )
 {
     int nbProcessed = 0;
     using( m.OpenInfo().Send( "Doing things..." )
                         .ConcludeWith( () => String.Format( "{0} files.", nbProcessed ) ) )
     {
         // ...
         nbProcessed += 21;
         m.CloseGroup( "Success." );
         // The user Group conclusion is: "Success. - 21 files." (the two conclusions are concatenated).
     }
 }
 void AppendChildren( IActivityMonitor monitor, ActionCompositeConfiguration a, IReadOnlyList<string> childPath, bool flattenUselessComposite )
 {
     foreach( var child in a.Children )
     {
         ActionCompositeConfiguration composite = child as ActionCompositeConfiguration;
         if( flattenUselessComposite && composite != null && composite.IsParallel == a.IsParallel )
         {
             AppendChildren( monitor, composite, childPath = childPath.Append( composite.Name ).ToArray(), true );
         }
         else _children.Add( ActionConfigurationResolved.Create( monitor, child, flattenUselessComposite, _children.Count, childPath ) );
     }
 }
 /// <summary>
 /// Loads this configuration from a <see cref="XElement"/>.
 /// </summary>
 /// <param name="path">Path to the configuration xml file.</param>
 /// <param name="monitor">Monitor that will be used.</param>
 /// <returns>True on success, false if the configuration can not be read.</returns>
 public bool LoadFromFile( string path, IActivityMonitor monitor )
 {
     if( path == null ) throw new ArgumentNullException( "path" );
     if( monitor == null ) throw new ArgumentNullException( "monitor" );
     try
     {
         var doc = XDocument.Load( path, LoadOptions.SetBaseUri|LoadOptions.SetLineInfo );
         return Load( doc.Root, monitor );
     }
     catch( Exception ex )
     {
         monitor.SendLine( LogLevel.Error, null, ex );
         return false;
     }
 }
示例#22
0
        static void CleanupTimedFolders(IActivityMonitor m, IBasicTestHelper basic, string basePath, int maxCurrentLogFolderCount, int maxArchivedLogFolderCount)
        {
            Debug.Assert(basePath.EndsWith(FileUtil.DirectorySeparatorString));
            // Note: The comparer is a reverse comparer. The most RECENT timed folder is the FIRST.
            GetTimedFolders(basePath, out SortedDictionary <DateTime, string> timedFolders, out string archivePath, false);
            if (timedFolders.Count > maxCurrentLogFolderCount)
            {
                int retryCount = 5;
retry:
                try
                {
                    if (archivePath == null)
                    {
                        m.Trace("Creating Archive folder.");
                        Directory.CreateDirectory(archivePath = basePath + "Archive");
                    }
                    foreach (var old in timedFolders.Values.Skip(maxCurrentLogFolderCount))
                    {
                        var fName = Path.GetFileName(old);
                        m.Trace($"Moving '{fName}' folder into Archive folder.");
                        var target = Path.Combine(archivePath, fName);
                        if (Directory.Exists(target))
                        {
                            target += '-' + Guid.NewGuid().ToString();
                        }
                        Directory.Move(old, target);
                    }
                    GetTimedFolders(archivePath, out timedFolders, out _, true);
                    foreach (var tooOld in timedFolders.Values.Skip(maxArchivedLogFolderCount))
                    {
                        basic.CleanupFolder(tooOld, false);
                    }
                }
                catch (Exception ex)
                {
                    if (--retryCount < 0)
                    {
                        m.Error($"Aborting Log's cleanup of timed folders in '{basePath}' after 5 retries.", ex);
                        return;
                    }
                    m.Warn($"Log's cleanup of timed folders in '{basePath}' failed. Retrying.", ex);
                    Thread.Sleep(retryCount * 100);
                    goto retry;
                }
            }
        }
        /// <summary>
        /// Overridden to ensure that the target folder exists and, if the target folder is "$StObjGen" that
        /// a .gitignore file exists in it.
        /// </summary>
        /// <param name="monitor">The monitor to use.</param>
        /// <returns>Always true.</returns>
        protected override bool PrepareWrite(IActivityMonitor monitor)
        {
            var folder = Path.RemoveLastPart();

            Directory.CreateDirectory(Path.RemoveLastPart());
            // For '$StObjGen' folders, ensures that a .gitignore file exists.
            if (Path.LastPart == "$StObjGen")
            {
                var gitIgnore = folder.AppendPart(".gitignore");
                if (!File.Exists(gitIgnore))
                {
                    // Ignores error.
                    SafeWrite(monitor, gitIgnore, "*");
                }
            }
            return(true);
        }
示例#24
0
        TypeAttributesCache(IActivityMonitor monitor,
                            Type type,
                            IAttributeContextBound[] typeAttributes,
                            IServiceProvider services,
                            bool includeBaseClasses)
        {
            if (type == null)
            {
                throw new ArgumentNullException(nameof(type));
            }

            // This is ready to be injected in the delegated attribute constructor: no other attributes are visible.
            // If other attributes must be accessed, then the IAttributeContextBoundInitializer interface must be used.
            Type = type;
            _all = Array.Empty <Entry>();

            var          all = new List <Entry>();
            int          initializerCount = Register(monitor, services, all, type, includeBaseClasses, typeAttributes);
            BindingFlags flags            = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly;

            if (includeBaseClasses)
            {
                flags &= ~BindingFlags.DeclaredOnly;
            }
            _typeMembers = type.GetMembers(flags);
            foreach (var m in _typeMembers)
            {
                initializerCount += Register(monitor, services, all, m, false);
            }
            _all = all.ToArray();
            _includeBaseClasses = includeBaseClasses;
            if (initializerCount > 0)
            {
                foreach (Entry e in _all)
                {
                    if (e.Attr is IAttributeContextBoundInitializer aM)
                    {
                        aM.Initialize(monitor, this, e.M);
                        if (--initializerCount == 0)
                        {
                            break;
                        }
                    }
                }
            }
        }
        /// <summary>
        /// Tries to set the <see cref="CKTypeKind.IsPocoClass"/> flag for a type (that must be a class).
        /// This fails if the type is already registered as another kind of type.
        /// </summary>
        /// <param name="m">The monitor to use.</param>
        /// <param name="t">The type to configure.</param>
        /// <returns>True on success, false on error.</returns>
        internal bool SetPocoClass(IActivityMonitor m, Type t)
        {
            Debug.Assert(t.IsClass);
            var exist = RawGet(m, t);

            if (exist == CKTypeKind.None)
            {
                m.Trace($"Type '{t}' is now defined as a PocoClass.");
                _cache[t] = CKTypeKind.IsPocoClass;
            }
            else if (exist != CKTypeKind.IsPocoClass)
            {
                m.Error($"Type '{t}' is already registered as a '{ToStringFull( exist )}'. It can not be defined as a PocoClass.");
                return(false);
            }
            return(true);
        }
示例#26
0
            public bool PushLocalArtifacts(IActivityMonitor m, IArtifactRepository target, IEnumerable <ArtifactInstance> artifacts, bool arePublicArtifacts)
            {
                bool success = true;

                foreach (var h in _provider._handlers)
                {
                    using (m.OpenTrace($"Pushing for type handler '{h}'."))
                    {
                        if (!h.PushLocalArtifacts(this, m, target, artifacts, arePublicArtifacts))
                        {
                            m.CloseGroup("Failed.");
                            success = false;
                        }
                    }
                }
                return(success);
            }
 // This is NOT how it works in CK.SqlServer.Setup.Engine: StObjConstruct is used.
 static void ConfigureByDirectSetProperties(IActivityMonitor monitor, IStObjMutableItem o, SqlDatabase db)
 {
     if (db.IsDefaultDatabase)
     {
         o.SetDirectPropertyValue(monitor, nameof(SqlDatabase.ConnectionString), "The default connection string.", sourceDescription: "By configurator.");
     }
     else if (db.Name == "histo")
     {
         o.SetDirectPropertyValue(monitor, nameof(SqlDatabase.ConnectionString), "The histo connection string.", sourceDescription: "By configurator.");
         o.SetDirectPropertyValue(monitor, nameof(SqlDatabase.HasCKCore), true, sourceDescription: "By configurator.");
         o.SetDirectPropertyValue(monitor, nameof(SqlDatabase.UseSnapshotIsolation), true, sourceDescription: "By configurator.");
     }
     else
     {
         monitor.Warn($"Unable to find configuration for Database named '{db.Name}' of type {db.GetType()}. Its ConnectionString will be null.");
     }
 }
 public IStObjServiceFinalManualMapping?GetFinalMapping(
     IActivityMonitor m,
     StObjObjectEngineMap engineMap,
     IAutoServiceKindComputeFacade kindComputeFacade,
     ref bool success)
 {
     if (!_finalMappingDone)
     {
         _finalMappingDone = true;
         Class.ComputeFinalTypeKind(m, kindComputeFacade, new Stack <AutoServiceClassInfo>(), ref success);
         if (Assignments.Any())
         {
             _finalMapping = engineMap.CreateServiceFinalManualMapping(this);
         }
     }
     return(_finalMapping);
 }
        TSTypeFile DoGetTSTypeFile(IActivityMonitor monitor, Type t, ref HashSet <Type>?cycleDetector)
        {
            TSTypeFile?f = _typeMappings.GetValueOrDefault(t);

            if (f == null)
            {
                Debug.Assert(!_attributeCache.ContainsKey(t));
                f = new TSTypeFile(this, t, Array.Empty <ITSCodeGeneratorType>(), null);
                _typeMappings.Add(t, f);
                _typeFiles.Add(f);
            }
            if (!f.IsInitialized)
            {
                EnsureInitialized(monitor, f, ref cycleDetector);
            }
            return(f);
        }
示例#30
0
        private bool HandleStObjPropertySource(IActivityMonitor monitor, StObjProperty p, MutableItem source, string sourceName, bool doSetOrMerge)
        {
            StObjProperty?c = source.GetStObjProperty(p.Name);

            // Source property is defined somewhere in the source.
            if (c != null)
            {
                // If the property is explicitly defined (Info != null) and its type is not
                // compatible with our, there is a problem.
                if (c.InfoOnType != null && !p.Type.IsAssignableFrom(c.Type))
                {
                    // It is a warning because if actual values work, everything is okay... but one day, it should fail.
                    var msg = String.Format("StObjProperty '{0}.{1}' of type '{2}' is not compatible with the one of its {6} ('{3}.{4}' of type '{5}'). Type should be compatible since {6}'s property value will be propagated if no explicit value is set for '{7}.{1}' or if '{3}.{4}' is set with an incompatible value.",
                                            ToString(), p.Name, p.Type.Name,
                                            source.RealObjectType.Type.Name, c.Name, c.Type.Name,
                                            sourceName,
                                            RealObjectType.Type.Name);
                    monitor.Warn(msg);
                }
                if (doSetOrMerge)
                {
                    // The source value must have been set and not explicitly "removed" with a System.Type.Missing value.
                    if (c.Value != System.Type.Missing)
                    {
                        // We "Set" the value from this source.
                        if (!p.ValueHasBeenSet)
                        {
                            p.Value = c.Value;
                        }
                        else if (p.Value is IMergeable)
                        {
                            using (var services = new SimpleServiceContainer())
                            {
                                services.Add(monitor);
                                if (!((IMergeable)p.Value).Merge(c.Value, services))
                                {
                                    monitor.Error($"Unable to merge StObjProperty '{ToString()}.{p.Value}' with value from {sourceName}.");
                                }
                            }
                        }
                        return(true);
                    }
                }
            }
            return(false);
        }
示例#31
0
        internal T FindProjectByGuid <T>(IActivityMonitor m, string guid, int lineNumber = 0) where T : ProjectBase
        {
            var project = FindProjectByGuid(m, guid);

            if (project == null)
            {
                return(null);
            }
            if (project is T typed)
            {
                return(typed);
            }
            m.Error(lineNumber == 0
                        ? $"Project '{guid}' must be a {typeof( T ).GetType().Name}."
                        : $"Guid '{guid}' defined on line #{lineNumber} references must be a {typeof( T ).GetType().Name}.");
            return(null);
        }
示例#32
0
 /// <summary>
 /// Opens the key vault.
 /// </summary>
 /// <param name="m">The monitor to use.</param>
 /// <param name="passPhrase">The key vault pass phrase.</param>
 /// <returns>True on success.</returns>
 public bool OpenKeyVault(IActivityMonitor m, string passPhrase)
 {
     if (!CheckPassPhraseConstraints(m, passPhrase))
     {
         return(false);
     }
     if (_passPhrase != null)
     {
         m.Info($"Key Vault is already opened.");
         return(true);
     }
     if (KeyVaultFileExists)
     {
         try
         {
             var keys = KeyVault.DecryptValues(File.ReadAllText(KeyVaultPath), passPhrase);
             m.OpenInfo($"Opening existing Key Vault with keys: {keys.Keys.Concatenate()}.");
             _store.ImportSecretKeys(m, keys);
             _passPhrase = passPhrase;
             _vaultContent.Clear();
             _vaultContent.AddRange(keys);
         }
         catch (Exception ex)
         {
             m.Error("Unable to open the key vault.", ex);
             return(false);
         }
     }
     else
     {
         _passPhrase = passPhrase;
         m.OpenInfo($"New Key Vault opened.");
     }
     if (_store.Infos.Any(s => !s.IsSecretAvailable))
     {
         using (m.OpenWarn($"Missing secrets:"))
         {
             foreach (var s in _store.Infos.Where(s => !s.IsSecretAvailable))
             {
                 m.Warn(s.ToString());
             }
         }
     }
     m.CloseGroup();
     return(true);
 }
示例#33
0
        /// <summary>
        /// Initialization of this handler always returns true.
        /// </summary>
        /// <param name="m">The monitor to use.</param>
        /// <returns>Always true.</returns>
        public ValueTask <bool> ActivateAsync(IActivityMonitor m)
        {
            // Ensure the System.Console colors are actually valid when starting.
            // Linux consoles may start with an invalid and undocumented value (-1).
            // In System.Console's source code, -1 is internally referenced as "UnknownColor".
            if (!Enum.IsDefined(typeof(ConsoleColor), System.Console.BackgroundColor))
            {
                System.Console.BackgroundColor = ConsoleColor.Black;
            }

            if (!Enum.IsDefined(typeof(ConsoleColor), System.Console.ForegroundColor))
            {
                System.Console.ForegroundColor = ConsoleColor.White;
            }

            return(ValueTask.FromResult(true));
        }
            public CSCodeGenerationResult Implement(IActivityMonitor monitor, MethodInfo m, ICSCodeGenerationContext c, ITypeScope b)
            {
                IFunctionScope mB = b.CreateOverride(m);

                mB.Parent.Should().BeSameAs(b, "The function is ready to be implemented.");

                if (IsLambda)
                {
                    mB.Append("=> ").Append(ActualCode).Append(';').NewLine();
                }
                else
                {
                    mB.Append(ActualCode);
                }

                return(CSCodeGenerationResult.Success);
            }
示例#35
0
        /// <summary>
        /// Gets the simple git version <see cref="RepositoryInfo"/> from a branch.
        /// Returns null if an error occurred or if RepositoryInfo.xml has not been successfully read.
        /// </summary>
        /// <param name="m">The monitor to use.</param>
        /// <param name="branchName">Defaults to <see cref="CurrentBranchName"/>.</param>
        /// <returns>The RepositoryInfo or null if it it cannot be obtained.</returns>
        public RepositoryInfo ReadRepositoryVersionInfo(IActivityMonitor m, string branchName = null)
        {
            if (branchName == null)
            {
                branchName = CurrentBranchName;
            }
            try
            {
                Branch b = Git.Branches[branchName];
                if (b == null)
                {
                    m.Error($"Unknown branch {branchName}.");
                    return(null);
                }
                var pathOpt = b.IsRemote
                                ? SubPath.AppendPart("remotes").Combine(b.FriendlyName)
                                : SubPath.AppendPart("branches").AppendPart(branchName);

                pathOpt = pathOpt.AppendPart("RepositoryInfo.xml");
                var fOpt = FileSystem.GetFileInfo(pathOpt);
                if (!fOpt.Exists)
                {
                    m.Error($"Missing required {pathOpt} file.");
                    return(null);
                }
                var opt = RepositoryInfoOptions.Read(fOpt.ReadAsXDocument().Root);
                opt.StartingBranchName = branchName;
                var result = new RepositoryInfo(Git, opt);
                if (result.RepositoryError != null)
                {
                    m.Error($"Unable to read RepositoryInfo. RepositoryError: {result.RepositoryError}.");
                    return(null);
                }
                if (result.Error != null)
                {
                    m.Error(result.ReleaseTagError);
                    return(null);
                }
                return(result);
            }
            catch (Exception ex)
            {
                m.Fatal($"While reading version info for branch '{branchName}'.", ex);
                return(null);
            }
        }
示例#36
0
        void OnWorkingFolderChanged(IActivityMonitor m, LocalWorldName local)
        {
            var repo = _repos.FirstOrDefault(r => local.XmlDescriptionFilePath.StartsWith(r.Root));

            if (repo == null)
            {
                m.Warn($"Unable to find the local repository for {local.FullName}.");
            }
            else if (!repo.IsOpen)
            {
                m.Warn($"Local repository {local.FullName} ({repo.Root}) is not opened.");
            }
            else
            {
                repo.PushChanges(m);
            }
        }
示例#37
0
 protected override BuildResult CreateBuildResult(IActivityMonitor m)
 {
     foreach (var(s, driver) in DependentSolutionContext.Solutions)
     {
         var buildProjectUpgrades = GetBuildProjectUpgrades(s);
         if (!driver.UpdatePackageDependencies(m, buildProjectUpgrades))
         {
             return(null);
         }
         if (!driver.GitRepository.Commit(m, "Updated Build project dependencies.", CommitBehavior.AmendIfPossibleAndOverwritePreviousMessage))
         {
             return(null);
         }
         _commits[s.Index] = driver.GitRepository.Head.CommitSha;
     }
     return(base.CreateBuildResult(m));
 }
示例#38
0
 /// <summary>
 /// Reads this cache from a serialized data.
 /// </summary>
 /// <param name="monitor">The monitor to use.</param>
 /// <param name="reader">The deserializer to use.</param>
 /// <returns>True on success, false on error.</returns>
 public bool Read(IActivityMonitor monitor, ICKBinaryReader reader)
 {
     if (reader == null)
     {
         throw new ArgumentNullException(nameof(reader));
     }
     try
     {
         _db = new PackageDB(reader);
         return(true);
     }
     catch (Exception ex)
     {
         monitor.Error("Unable to read package database.", ex);
         return(false);
     }
 }
示例#39
0
        protected override void DoApplySettings(IActivityMonitor m)
        {
            var solution = _driver.GetSolution(m, allowInvalidSolution: true);

            if (solution == null)
            {
                return;
            }

            var projects = _npmDriver.GetNPMProjects(m);

            if (projects == null)
            {
                return;
            }
            bool useNpm = projects.Any();

            if (useNpm)
            {
                //CakeExtensions
                SetTextResource(m, "CakeExtensions/NpmDistTagRunner.cs");
                SetTextResource(m, "CakeExtensions/NpmView.cs");
                SetTextResource(m, "CakeExtensions/NpmGetNpmVersion.cs");
                //npm itself
                SetTextResource(m, "npm/Build.NPMArtifactType.cs", text => AdaptBuildNPMArtifactForPushFeeds(text, solution));
                SetTextResource(m, "npm/Build.NPMFeed.cs");
                SetTextResource(m, "npm/NPMProject.cs");
                SetTextResource(m, "npm/NPMPublishedProject.cs");
                SetTextResource(m, "npm/NPMSolution.cs");
                SetTextResource(m, "npm/NPMProjectContainer.cs");
                SetTextResource(m, "npm/TempFileTextModification.cs");
                SetTextResource(m, "npm/SimplePackageJsonFile.cs");
                SetTextResource(m, "npm/AngularWorkspace.cs");
            }
            else
            {
                DeleteFile(m, "CakeExtensions/NpmDistTagRunner.cs");
                DeleteFile(m, "CakeExtensions/NpmView.cs");
                DeleteFile(m, "CakeExtensions/NpmGetNpmVersion.cs");
                DeleteFile(m, "npm/Build.NPMArtifactType.cs");
                DeleteFile(m, "npm/Build.NPMFeed.cs");
                DeleteFile(m, "npm/NPMProject.cs");
                DeleteFile(m, "npm/NPMPublishedProject.cs");
                DeleteFile(m, "npm/NPMSolution.cs");
            }
        }
示例#40
0
 /// <summary>
 /// Computes the root path.
 /// </summary>
 /// <param name="m">A monitor (must not be null).</param>
 /// <returns>The final path to use (ends with '\'). Null if unable to compute the path.</returns>
 string ComputeBasePath( IActivityMonitor m )
 {
     string rootPath = null;
     if( String.IsNullOrWhiteSpace( _configPath ) ) m.SendLine( LogLevel.Error, "The configured path is empty.", null );
     else if( FileUtil.IndexOfInvalidPathChars( _configPath ) >= 0 ) m.SendLine( LogLevel.Error, string.Format( "The configured path '{0}' is invalid.", _configPath ), null );
     else
     {
         rootPath = _configPath;
         if( !Path.IsPathRooted( rootPath ) )
         {
             string rootLogPath = SystemActivityMonitor.RootLogPath;
             if( String.IsNullOrWhiteSpace( rootLogPath ) ) m.SendLine( LogLevel.Error, string.Format( "The relative path '{0}' requires that {1} be specified (typically in the AppSettings).", _configPath, SystemActivityMonitor.AppSettingsKey ), null );
             else rootPath = Path.Combine( rootLogPath, _configPath );
         }
     }
     return rootPath != null ? FileUtil.NormalizePathSeparator( rootPath, true ) : null;
 }
 public void ApplySettings(IActivityMonitor m)
 {
     if (!this.CheckCurrentBranch(m))
     {
         return;
     }
     if (PluginBranch == StandardGitStatus.Local &&
         _solutionSpec.UseCKSetup &&
         !_solutionSpec.NoDotNetUnitTests)
     {
         EnsureStorePath(m, _localFeedProvider.Local.GetCKSetupStorePath());
     }
     else
     {
         Delete(m);
     }
 }
示例#42
0
        public void ApplySettings(IActivityMonitor monitor)
        {
            using (monitor.OpenInfo($"Executing {_scripts.Count} script(s) on this Workstation."))
                using (var tempPS1 = new TemporaryFile("ps1"))
                {
                    bool             hasError         = false;
                    HashSet <EnvVar> currentVariables = null;
                    foreach (var o in _scripts)
                    {
                        if (hasError)
                        {
                            break;
                        }
                        switch (o)
                        {
                        case HashSet <EnvVar> v: currentVariables = v; break;

                        case ScriptLine script:
                        {
                            using (monitor.OpenTrace($"Executing script Type='{script.Type}', WorkingDir='{script.WorkingDir}', Arguments='{script.Arguments}', ContinueOnNonZeroExitCode='{script.ContinueOnNonZeroExitCode}'."))
                            {
                                monitor.Debug($"With EnvironmentVariables: {currentVariables?.Select( v => v.ToString() ).Concatenate()}.");
                                monitor.Debug(script.Script);
                                System.IO.File.WriteAllText(tempPS1.Path, script.Script);
                                if (!ProcessRunner.RunPowerShell(
                                        monitor,
                                        script.WorkingDir,
                                        tempPS1.Path,
                                        new[] { script.Arguments },
                                        stdErrorLevel: LogLevel.Warn,
                                        currentVariables?.Select(v => (v.Name, Environment.ExpandEnvironmentVariables(v.Value)))))
                                {
                                    hasError |= !script.ContinueOnNonZeroExitCode;
                                    if (!hasError)
                                    {
                                        monitor.Warn("ContinueOnNonZeroExitCode is true: error is ignored.");
                                    }
                                }
                            }
                            break;
                        }
                        }
                    }
                }
        }
示例#43
0
        public void ApplySettings(IActivityMonitor m)
        {
            if (!this.CheckCurrentBranch(m))
            {
                return;
            }
            YamlMapping firstMapping = GetFirstMapping(m, true);

            if (firstMapping == null)
            {
                m.Error("First mapping should not return null !");
                return;
            }
            // We don't use GitLab for public repositories
            if (GitFolder.IsPublic || GitFolder.KnownGitProvider != KnownGitProvider.GitLab)
            {
                if (TextContent != null)
                {
                    m.Log(LogLevel.Info, "The project is public or the repository is not on GitLab, so we don't use GitLab and the .gitlab-ci.yml is not needed.");
                    Delete(m);
                }
                return;
            }
            // We use GitLab when the repository is private.
            YamlMapping codeCakeJob = FindOrCreateYamlElement(m, firstMapping, "codecakebuilder");

            SetSequence(codeCakeJob, "tags", new YamlValue("windows"));
            SetSequence(codeCakeJob, "script",
                        new YamlValue("dotnet run --project CodeCakeBuilder -nointeraction")
                        );
            codeCakeJob["artifacts"] =
                new YamlMapping()
            {
                ["paths"] = new YamlSequence()
                {
                    new YamlValue(@"'**\*.log'"),
                    new YamlValue(@"'**\*.trx'"),
                    new YamlValue(@"'**\Tests\**\TestResult*.xml'"),
                    new YamlValue(@"'**Tests\**\Logs\**\*'"),
                },
                ["when"]      = new YamlValue("always"),
                ["expire_in"] = new YamlValue("6 month")
            };
            CreateOrUpdate(m, YamlMappingToString(m));
        }
示例#44
0
        public void ApplySettings(IActivityMonitor m)
        {
            if (_solutionSpec.NoSharedPropsFile)
            {
                Delete(m);
                return;
            }
            if (!_commonFolder.EnsureDirectory(m))
            {
                return;
            }
            var s = _driver.GetSolution(m, false);

            if (s == null)
            {
                return;
            }
            bool useCentralPackage = s.Projects.Select(p => p.Tag <MSBuildSln.MSProject>())
                                     .Where(p => p != null)
                                     .Any(p => p.UseMicrosoftBuildCentralPackageVersions);

            // If Shared.props exists, we make sure there is no xml namespace defined.
            if (Document == null)
            {
                Document = new XDocument(new XElement("Project"));
            }
            else
            {
                Document.Root.RemoveAllNamespaces();
            }

            HandleBasicDefinitions(m, useCentralPackage);
            HandleStandardProperties(m);
            XCommentSection.FindOrCreate(Document.Root, "ReproducibleBuilds", false)?.Remove();
            HandleZeroVersion(m);
            HandleGenerateDocumentation(m);
            HandleSourceLink(m, useCentralPackage);

            Document.Root.Elements("PropertyGroup")
            .Where(e => !e.HasElements)
            .Select(e => e.ClearCommentsBeforeAndNewLineAfter())
            .Remove();

            Save(m);
        }
示例#45
0
 bool IStObjTypeFilter.TypeFilter(IActivityMonitor monitor, Type t)
 {
     // Type.FullName is null if the current instance represents a generic type parameter, an array
     // type, pointer type, or byref type based on a type parameter, or a generic type
     // that is not a generic type definition but contains unresolved type parameters.
     // This FullName is also null for (at least) classes nested into nested generic classes.
     // In all cases, we emit a warn and filters this beast out.
     if (t.FullName == null)
     {
         monitor.Warn($"Type has no FullName: '{t.Name}'. It is excluded.");
         return(false);
     }
     Debug.Assert(t.AssemblyQualifiedName != null, "Since FullName is defined.");
     if (_excludedTypes.Contains(t.Name))
     {
         monitor.Info($"Type {t.AssemblyQualifiedName} is filtered out by its Type Name.");
         return(false);
     }
     if (_excludedTypes.Contains(t.FullName))
     {
         monitor.Info($"Type {t.AssemblyQualifiedName} is filtered out by its Type FullName.");
         return(false);
     }
     if (_excludedTypes.Contains(t.AssemblyQualifiedName))
     {
         monitor.Info($"Type {t.AssemblyQualifiedName} is filtered out by its Type AssemblyQualifiedName.");
         return(false);
     }
     if (SimpleTypeFinder.WeakenAssemblyQualifiedName(t.AssemblyQualifiedName, out var weaken) &&
         _excludedTypes.Contains(weaken))
     {
         monitor.Info($"Type {t.AssemblyQualifiedName} is filtered out by its weak type name ({weaken}).");
         return(false);
     }
     // We only care about IPoco and IRealObject. Nothing more.
     if (_isUnifiedPure)
     {
         if (!typeof(IPoco).IsAssignableFrom(t) &&
             !typeof(IRealObject).IsAssignableFrom(t))
         {
             return(false);
         }
     }
     return(_firstLayer?.TypeFilter(monitor, t) ?? true);
 }
示例#46
0
        StackRepo FindRepo(IActivityMonitor m, string stackName)
        {
            int idx = _stacks.IndexOf(d => d.StackName == stackName);

            if (idx < 0)
            {
                m.Error($"Stack named '{stackName}' not found.");
                return(null);
            }
            var home = _repos.FirstOrDefault(r => r.OriginUrl == _stacks[idx].OriginUrl);

            if (home == null)
            {
                m.Error($"Repository initialization error for stack '{_stacks[idx]}'.");
                return(null);
            }
            return(home);
        }
示例#47
0
        public async ValueTask <ISender> CreateSenderAsync(IActivityMonitor monitor,
                                                           TrustedParty audience,
                                                           ISignAlgorithm algorithm,
                                                           TimeSpan validity,
                                                           bool encrypt     = false,
                                                           uint maxUseCount = 0)
        {
            Throw.CheckNotNullArgument(monitor);
            Throw.CheckNotNullArgument(audience);
            Throw.CheckNotNullArgument(algorithm);
            Throw.CheckArgument(validity >= Configuration.MinSignatureLifetime && validity <= Configuration.MaxSignatureLifetime);
            var bestBefore = _appClock.Clock.UtcNow + validity;
            var key        = algorithm.KeyRequirement != null
                        ? await ResolveOutgoingKeyAsync(monitor, audience, algorithm.KeyRequirement, bestBefore, maxUseCount)
                        : null;

            return(new Sender(this, audience, algorithm, key, bestBefore));
        }
        public CSCodeGenerationResult Implement(IActivityMonitor monitor,
                                                MethodInfo m,
                                                ICSCodeGenerationContext codeGenContext,
                                                ITypeScope typeBuilder)
        {
            IFunctionScope mB = typeBuilder.CreateOverride(m);

            Debug.Assert(mB.Parent == typeBuilder, "The function is ready to be implemented.");
            if (_attr.IsLambda)
            {
                mB.Append("=> ").Append(_attr.ActualCode).Append(';').NewLine();
            }
            else
            {
                mB.Append(_attr.ActualCode).NewLine();
            }
            return(CSCodeGenerationResult.Success);
        }
示例#49
0
 /// <summary>
 /// Computes the road map for all the solutions.
 /// </summary>
 /// <param name="m">The monitor to use.</param>
 /// <param name="versionSelector">The version selector to use.</param>
 /// <param name="forgetAllExistingRoadmapVersions">
 /// True to automatically skip any previously reolved versions.
 /// <paramref name="versionSelector"/> will not see them.
 /// </param>
 /// <returns>True on success, false on error or cancellation..</returns>
 public bool UpdateRoadmap(IActivityMonitor m, IReleaseVersionSelector versionSelector, bool forgetAllExistingRoadmapVersions)
 {
     if (!forgetAllExistingRoadmapVersions)
     {
         foreach (var info in _infos)
         {
             info.ClearReleaseInfo();
         }
     }
     foreach (var info in _infos)
     {
         if (!info.EnsureReleaseInfo(m, versionSelector).IsValid)
         {
             return(false);
         }
     }
     return(true);
 }
 /// <summary>
 /// Common validator function for names.
 /// </summary>
 /// <param name="monitor">The monitor.</param>
 /// <param name="propertyName">The property name.</param>
 /// <param name="value">The value.</param>
 /// <param name="isRequired">Whether it is required or can be let to null.</param>
 /// <returns>True on success, false otherwise.</returns>
 public static bool ValidateName(IActivityMonitor monitor, string propertyName, string?value, bool isRequired)
 {
     if (string.IsNullOrWhiteSpace(value))
     {
         if (isRequired)
         {
             monitor.Error($"{propertyName} is required and {_nameSuffix}");
             return(false);
         }
         return(true);
     }
     if (value.Any(c => !IsValidNameChar(c)) || Char.IsDigit(value[0]) || value[0] == '_')
     {
         monitor.Error($"{propertyName} {_nameSuffix} {propertyName} = '{value}'.");
         return(false);
     }
     return(true);
 }
示例#51
0
        public void ShowLogsBetweenDates(
            IActivityMonitor m,
            DateTimeOffset beginning,
            DateTimeOffset ending,
            IEnumerable <DiffRoot> diffRoot)
        {
            List <Commit> commits = GetCommitsBetweenDates(beginning, ending).ToList();

            if (commits.Count == 0)
            {
                m.Info("No commits between the given dates.");
            }
            else
            {
                IDiffResult diffResult = GetReleaseDiff(m, diffRoot, commits);
                Console.WriteLine(diffResult.ToString());
            }
        }
示例#52
0
        /// <summary>
        /// Reads the solution level dependencies.
        /// </summary>
        /// <param name="m">The monitor to use.</param>
        /// <param name="dep">The action per dependent project.</param>
        /// <returns>True on success, false on error.</returns>
        protected bool EnumerateSolutionLevelProjectDependencies(IActivityMonitor m, Action <Project> dep)
        {
            var deps = FindSection("ProjectDependencies");

            if (deps != null)
            {
                foreach (var line in deps.PropertyLines)
                {
                    var p = Solution.FindProjectByGuid <Project>(m, line.Name, line.LineNumber);
                    if (p == null)
                    {
                        return(false);
                    }
                    dep(p);
                }
            }
            return(true);
        }
 /// <summary>
 /// The initialize.
 /// </summary>
 /// <param name="monitor">
 /// The monitor.
 /// </param>
 public override void Initialize(IActivityMonitor monitor)
 {
     monitor.BridgeClosed += this.OnBridgeClosed;
     monitor.BridgeClosing += this.OnBridgeClosing;
     monitor.BridgeInitialized += this.OnBridgeInitialized;
     monitor.BridgeInitializing += this.OnBridgeInitializing;
     monitor.BridgeTransferred += this.OnBridgeTransferred;
     monitor.BridgeTransferring += this.OnBridgeTransferring;
     monitor.BridgeException += this.OnBridgeException;
     monitor.BridgeWarning += this.OnBridgeWarning;
     monitor.MessageBusWarning += this.OnMessageBusWarning;
     monitor.MessageBusException += this.OnMessageBusException;
     monitor.MessageBusClosed += this.OnMessageBusClosed;
     monitor.MessageBusClosing += this.OnMessageBusClosing;
     monitor.MessageBusRegisteredHandler += this.OnMessageBusHandlerRegistered;
     monitor.MessageBusRegisteringHandler += this.OnMessageBusHandlerRegistering;
     monitor.MessageBusSending += this.OnMessageBusMessageSending;
     monitor.MessageBusSent += this.OnMessageBusMessageSent;
     monitor.PublisherWarning += this.OnPublisherWarning;
     monitor.PublisherException += this.OnPublisherException;
     monitor.PublisherClosed += this.OnPublisherClosed;
     monitor.PublisherClosing += this.OnPublisherClosing;
     monitor.PublisherInitializing += this.OnPublisherInitializing;
     monitor.PublisherInitialized += this.OnPublisherInitialized;
     monitor.PublisherSending += this.OnPublisherSending;
     monitor.PublisherSent += this.OnPublisherSent;
     monitor.SubscriberWarning += this.OnSubscriberWarning;
     monitor.SubscriberException += this.OnSubscriberException;
     monitor.SubscriberClosed += this.OnSubscriberClosed;
     monitor.SubscriberClosing += this.OnSubscriberClosing;
     monitor.SubscriberInitialized += this.OnSubscriberInitialized;
     monitor.SubscriberInitializing += this.OnSubscriberInitializing;
     monitor.SubscriberReceived += this.OnSubscriberReceived;
     monitor.SubscriberReceiving += this.OnSubscriberReceiving;
     monitor.WorkerRunning += this.OnWorkerRunning;
     monitor.WorkerStarted += this.OnWorkerStarted;
     monitor.WorkerStarting += this.OnWorkerStarting;
     monitor.WorkerStopped += this.OnWorkerStopped;
     monitor.WorkerStopping += this.OnWorkerStopping;
     monitor.WorkerCompleted += this.OnWorkerCompleted;
     monitor.WorkerException += this.OnWorkerException;
     monitor.WorkerWarning += this.OnWorkerWarning;
     base.Initialize(monitor);
 }
        /// <summary>
        /// The initialize method.
        /// </summary>
        /// <param name="monitor">
        /// The monitor.
        /// </param>
        public virtual void Initialize(IActivityMonitor monitor)
        {
            this.MachineName = Environment.MachineName;
            this.DeploymentId = string.Empty;
            this.RoleInstanceName = string.Empty;
            this.RoleInstanceId = string.Empty;

            if (RoleEnvironment.CurrentRoleInstance == null)
            {
                return;
            }

            this.DeploymentId = RoleEnvironment.DeploymentId;
            this.RoleInstanceId = RoleEnvironment.CurrentRoleInstance.Id;

            if (RoleEnvironment.CurrentRoleInstance.Role != null)
            {
                this.RoleInstanceName = RoleEnvironment.CurrentRoleInstance.Role.Name;
            }
        }
 /// <summary>
 /// Ensures that the <see cref="Default"/> GrandOutput is created (see <see cref="EnsureActiveDefault"/>) and configured with default settings:
 /// only one one channel with its minimal filter sets to Debug with one text file handler that writes .txt files in "<see cref="SystemActivityMonitor.RootLogPath"/>\GrandOutputDefault" directory.
 /// The <see cref="SystemActivityMonitor.RootLogPath"/> must be valid and if a GrandOutput.config file exists inside, it is loaded as the configuration.
 /// If it exists, it must be valid (otherwise an exception is thrown).
 /// Once loaded, the file is monitored and any change that occurs to it dynamically triggers a <see cref="SetConfiguration"/> with the new file.
 /// </summary>
 /// <param name="monitor">An optional monitor.</param>
 static public GrandOutput EnsureActiveDefaultWithDefaultSettings( IActivityMonitor monitor = null )
 {
     lock( _defaultLock )
     {
         if( _default == null )
         {
             if( monitor == null ) monitor = new SystemActivityMonitor( true, "GrandOutput" ) { MinimalFilter = GrandOutputMinimalFilter };
             using( monitor.OpenGroup( LogLevel.Info, "Attempting Default GrandOutput configuration.", null ) )
             {
                 try
                 {
                     SystemActivityMonitor.AssertRootLogPathIsSet();
                     _configPath = SystemActivityMonitor.RootLogPath + "GrandOutput.config";
                     GrandOutputConfiguration def = CreateDefaultConfig();
                     if( !File.Exists( _configPath ) )
                     {
                         File.WriteAllText( _configPath, _defaultConfig );
                     }
                     if( !def.LoadFromFile( _configPath, monitor ) )
                     {
                         throw new CKException( "Unable to load Configuration file: '{0}'.", _configPath );
                     }
                     GrandOutput output = new GrandOutput();
                     if( !output.SetConfiguration( def, monitor ) )
                     {
                         throw new CKException( "Failed to set Configuration." );
                     }
                     StartMonitoring( monitor );
                     _default = output;
                     ActivityMonitor.AutoConfiguration += m => _default.Register( m );
                 }
                 catch( Exception ex )
                 {
                     monitor.SendLine( LogLevel.Fatal, null, ex );
                     throw;
                 }
             }
         }
     }
     return _default;
 }
        /// <summary>
        /// Loads this configuration from a <see cref="XElement"/>.
        /// </summary>
        /// <param name="e">The xml element: its name must be GrandOutputConfiguration.</param>
        /// <param name="monitor">Monitor that will be used.</param>
        /// <returns>True on success, false if the configuration can not be read.</returns>
        public bool Load( XElement e, IActivityMonitor monitor )
        {
            if( e == null ) throw new ArgumentNullException( "e" );
            if( monitor == null ) throw new ArgumentNullException( "monitor" );
            try
            {
                if( e.Name != "GrandOutputConfiguration" ) throw new XmlException( "Element name must be <GrandOutputConfiguration>." + e.GetLineColumnString() );
                // AppDomainDefaultFilter was the name before.
                LogFilter? globalDefaultFilter = e.GetAttributeLogFilter( "GlobalDefaultFilter", false ) 
                                                    ?? e.GetAttributeLogFilter( "AppDomainDefaultFilter", false );

                SourceFilterApplyMode applyMode;
                Dictionary<string, LogFilter> sourceFilter = ReadSourceOverrideFilter( e, out applyMode, monitor );
                if( sourceFilter == null ) return false;

                RouteConfiguration routeConfig;
                using( monitor.OpenGroup( LogLevel.Trace, "Reading root Channel.", null ) )
                {
                    XElement channelElement = e.Element( "Channel" );
                    if( channelElement == null )
                    {
                        monitor.SendLine( LogLevel.Error, "Missing <Channel /> element." + e.GetLineColumnString(), null );
                        return false;
                    }
                    routeConfig = FillRoute( monitor, channelElement, new RouteConfiguration() );
                }
                // No error: set the new values.
                _routeConfig = routeConfig;
                _sourceFilter = sourceFilter;
                _sourceFilterApplyMode = applyMode;
                _globalDefaultFilter = globalDefaultFilter;
                return true;
            }
            catch( Exception ex )
            {
                monitor.SendLine( LogLevel.Error, null, ex );
            }
            return false;
        }
示例#57
0
 /// <summary>
 /// Tries to parse a recent file name entry.
 /// </summary>
 /// <param name="monitor">Monitor that may receive errors.</param>
 /// <param name="s">String to parse.</param>
 /// <returns>A recent file or null if parsing failed.</returns>
 public static RecentFile TryParse( IActivityMonitor monitor, string s )
 {
     if( monitor == null ) throw new ArgumentNullException( "monitor" );
     if( s == null ) throw new ArgumentNullException( "s" );
     int pipeIdx = s.IndexOf( '|' );
     if( pipeIdx > 0 )
     {
         string fName = s.Substring( 0, pipeIdx );
         if( System.IO.File.Exists( fName ) )
         {
             DateTime accessTime;
             if( !FileUtil.TryParseFileNameUniqueTimeUtcFormat( s.Substring( pipeIdx + 1 ), out accessTime ) )
             {
                 monitor.Warn().Send( "Invalid recent file access time for '{0}'. It is set to now.", fName );
                 accessTime = DateTime.UtcNow;
             }
             return new RecentFile( new FileInfo( fName ), accessTime );
         }
         else monitor.Warn().Send( "Recent file '{0}' does not exist. It is ignored.", fName );
     }
     else monitor.Warn().Send( "Invalid recent file entry '{0}'. It is ignored.", s );
     return null;
 }
 /// <summary>
 /// Checks that children are valid (action's name must be unique).
 /// </summary>
 /// <param name="routeName">Name of the route that references this action.</param>
 /// <param name="monitor">Monitor to report errors.</param>
 /// <returns>True if valid, false otherwise.</returns>
 public override bool CheckValidity( string routeName, IActivityMonitor monitor )
 {
     if( monitor == null ) throw new ArgumentNullException( "monitor" );
     bool result = true;
     for( int i = 0; i < _children.Count; ++i )
     {
         var child = _children[i];
         bool validChild = true;
         for( int j = ++i; j < _children.Count; ++j )
         {
             if( _children[j].Name == child.Name )
             {
                 monitor.SendLine( LogLevel.Error, string.Format( "Duplicate action name '{0}' in {1} '{2}', route '{3}'.", child.Name, TypeDisplayName, Name, routeName ), null );
                 validChild = false;
             }
         }
         validChild &= child.CheckValidity( routeName, monitor );
         // Remove child to continue the process but avoid cascading errors.
         if( !validChild ) _children.RemoveAt( i-- );
         result &= validChild;
     }
     return result;
 }
 void DoSequenceOrParallelOrAdd( IActivityMonitor monitor, Action<ActionConfiguration> collector, XElement xml )
 {
     if( xml.Name == "Parallel" || xml.Name == "Sequence" )
     {
         Action<ActionConfiguration> elementCollector;
         if( xml.Name == "Parallel" )
         {
             var p = new ActionParallelConfiguration( xml.AttributeRequired( "Name" ).Value );
             elementCollector = a => p.AddAction( a );
             collector( p );
         }
         else
         {
             var s = new ActionSequenceConfiguration( xml.AttributeRequired( "Name" ).Value );
             elementCollector = a => s.AddAction( a );
             collector( s );
         }
         foreach( var action in xml.Elements() ) DoSequenceOrParallelOrAdd( monitor, collector, action );
     }
     else
     {
         if( xml.Name != "Add" ) throw new XmlException( String.Format( "Unknown element '{0}': only <Add>, <Parallel> or <Sequence>.", xml.Name ) );
         string type = xml.AttributeRequired( "Type" ).Value;
         Type t = FindConfigurationType( type );
         HandlerConfiguration hC = (HandlerConfiguration)Activator.CreateInstance( t, xml.AttributeRequired( "Name" ).Value );
         hC.DoInitialize( monitor, xml );
         collector( hC );
     }
 }
        SubRouteConfiguration FillSubRoute( IActivityMonitor monitor, XElement xml, SubRouteConfiguration sub )
        {
            using( monitor.OpenGroup( LogLevel.Trace, string.Format( "Reading subordinated channel '{0}'.", sub.Name ), null ) )
            {
                var matchOptions = (string)xml.Attribute( "MatchOptions" );
                var filter = (string)xml.Attribute( "TopicFilter" );
                var regex = (string)xml.Attribute( "TopicRegex" );
                if( (filter == null) == (regex == null) )
                {
                    throw new XmlException( "Subordinated Channel must define one TopicFilter or TopicRegex attribute (and not both)." + xml.GetLineColumnString() );
                }
                RegexOptions opt = RegexOptions.IgnoreCase | RegexOptions.CultureInvariant | RegexOptions.Multiline | RegexOptions.ExplicitCapture;
                if( !String.IsNullOrWhiteSpace( matchOptions ) )
                {
                    if( !Enum.TryParse( matchOptions, true, out opt ) )
                    {
                        var expected = String.Join( ", ", Enum.GetNames( typeof( RegexOptions ) ).Where( n => n != "None" ) );
                        throw new XmlException( "MatchOptions value must be a subset of: " + expected + xml.GetLineColumnString() );
                    }
                    monitor.SendLine( LogLevel.Trace, string.Format( "MatchOptions for Channel '{0}' is: {1}.", sub.Name, opt ), null );
                }
                else monitor.SendLine( LogLevel.Trace, string.Format( "MatchOptions for Channel '{0}' defaults to: IgnoreCase, CultureInvariant, Multiline, ExplicitCapture.", sub.Name ), null );

                sub.RoutePredicate = filter != null ? CreatePredicateFromWildcards( filter, opt ) : CreatePredicateRegex( regex, opt );

                FillRoute( monitor, xml, sub );
                return sub;
            }
        }