public void LogEtlSessionStart(EtlSession session)
 {
     foreach (var logger in _loggers)
     {
         logger.LogEtlSessionStart(session);
     }
 }
Example #2
0
 public void LogEtlSessionEnd(EtlSession session)
 {
     foreach (var logger in _loggers)
     {
         logger.LogEtlSessionEnd(session);
     }
 }
Example #3
0
        public void LogEtlSessionStart(EtlSession session)
        {
            if (session == null)
            {
                throw new ArgumentNullException("session");
            }

            _sessions.Add(session);
        }
        public void LogEtlSessionStart(EtlSession session)
        {
            if (session == null)
            {
                throw new ArgumentNullException("session");
            }

            _currentProgress = 0;
            //_worker.ReportProgress(_currentProgress, null);
        }
 public static EtlPackageMonitorItemStatus GetMonitorItemStatus(EtlSession session, int runInvervalSeconds)
 {
     return session.Status ==
         EtlStatus.Failed ? EtlPackageMonitorItemStatus.Failed :
         // пакет выполнялся слишком давно
         session.EndDateTime.HasValue ?
             runInvervalSeconds > 0 && DateTime.Now.Subtract(session.EndDateTime.Value).TotalSeconds >= runInvervalSeconds ?
                 EtlPackageMonitorItemStatus.TooFar :
                         session.Status == EtlStatus.Succeeded ?
                             EtlPackageMonitorItemStatus.Succeeded :
                             EtlPackageMonitorItemStatus.Failed :
             EtlPackageMonitorItemStatus.Running;
 }
        public EtlContext(
            EtlSession session
            )
        {
            if (session == null)
            {
                throw new ArgumentNullException("session");
            }

            _parentSessionId = session.ParentEtlSessionId;
            _packageId = session.EtlPackageId;
            _sessionId = session.EtlSessionId;
            _userName = session.UserName;
            _startDateTime = session.StartDateTime;
            _startUtcDateTime = session.StartUtcDateTime;
        }
Example #7
0
        public void LogEtlSessionEnd(EtlSession session)
        {
            if (session == null)
            {
                throw new ArgumentNullException("session");
            }

            foreach (var exSession in _sessions)
            {
                if (exSession.EtlPackageId == session.EtlPackageId && exSession.EtlSessionId == session.EtlSessionId)
                {
                    exSession.EndDateTime    = session.EndDateTime;
                    exSession.EndUtcDateTime = session.EndUtcDateTime;
                    exSession.Status         = session.Status;

                    break;
                }
            }
        }
 public void LogEtlSessionStart(EtlSession session)
 {
 }
 public void LogEtlSessionEnd(EtlSession session)
 {
 }
Example #10
0
 public void LogEtlSessionEnd(EtlSession session)
 {
 }
Example #11
0
 public void LogEtlSessionStart(EtlSession session)
 {
 }
            private EtlSession InvokePackageCore(EtlPackage package, EtlVariableAssignment[] assignments, string parentSessionId)
            {
                var session = new EtlSession
                {
                    EtlSessionId = Guid.NewGuid().ToString(),
                    EtlPackageId = package.Id,
                    EtlPackageName = package.Name,
                    ParentEtlSessionId = parentSessionId,
                    Status = EtlStatus.Started,
                    UserName = GetCurrentUserName(),
                };

                session.StartDateTime = DateTime.Now;
                session.StartUtcDateTime = session.StartDateTime.ToUniversalTime();

                _logger.LogEtlSessionStart(session);
                _logger.LogEtlMessage
                (
                    new EtlMessage
                    {
                        EtlPackageId = session.EtlPackageId,
                        EtlSessionId = session.EtlSessionId,
                        LogDateTime = session.StartDateTime,
                        LogUtcDateTime = session.StartUtcDateTime,
                        MessageType = EtlMessageType.SessionStart,
                        Text = string.Format(Properties.Resources.SessionStarted, session.EtlSessionId, session.EtlPackageId, session.EtlPackageName)
                    }
                );

                try
                {
                    InvokePackageCatched(package, session, assignments);
                }
                catch (Exception exc)
                {
                    if (IsCriticalException(exc))
                    {
                        throw;
                    }

                    session.Status = EtlStatus.Failed;

                    var errorDateTime = DateTime.Now;
                    _logger.LogEtlMessage
                    (
                        new EtlMessage
                        {
                            EtlPackageId = session.EtlPackageId,
                            EtlSessionId = session.EtlSessionId,
                            LogDateTime = errorDateTime,
                            LogUtcDateTime = errorDateTime.ToUniversalTime(),
                            MessageType = EtlMessageType.Error,
                            Text = exc.Message,
                            StackTrace = exc.StackTrace,
                        }
                    );
                }
                finally
                {
                    session.EndDateTime = DateTime.Now;
                    session.EndUtcDateTime = session.EndDateTime.Value.ToUniversalTime();

                    _logger.LogEtlMessage
                    (
                        new EtlMessage
                        {
                            EtlPackageId = session.EtlPackageId,
                            EtlSessionId = session.EtlSessionId,
                            LogDateTime = session.EndDateTime.Value,
                            LogUtcDateTime = session.EndUtcDateTime.Value,
                            MessageType = EtlMessageType.SessionEnd,
                            Text = string.Format(Properties.Resources.SessionFinished, session.EtlSessionId, session.EtlPackageId, session.EtlPackageName, session.Status)
                        }
                    );

                    _logger.LogEtlSessionEnd(session);
                }

                return session;
            }
            private void InvokePackageCatched(EtlPackage package, EtlSession session, EtlVariableAssignment[] assignments)
            {
                var buildStartDateTime = DateTime.Now;
                _logger.LogEtlMessage
                (
                    new EtlMessage
                    {
                        EtlPackageId = session.EtlPackageId,
                        EtlSessionId = session.EtlSessionId,
                        LogDateTime = buildStartDateTime,
                        LogUtcDateTime = buildStartDateTime.ToUniversalTime(),
                        MessageType = EtlMessageType.Debug,
                        Text = string.Format(Properties.Resources.VariablesInitStarted),
                    }
                );

                var context = new _Context(package, session);
                context.InitVariables(package.Variables, assignments);

                foreach (var variable in context.GetVariables())
                {
                    var escapedVariable = EscapeVariable(variable);

                    _logger.LogEtlMessage
                    (
                        new EtlMessage
                        {
                            EtlPackageId = context.EtlPackageId,
                            EtlSessionId = context.EtlSessionId,
                            LogDateTime = buildStartDateTime,
                            LogUtcDateTime = buildStartDateTime.ToUniversalTime(),
                            MessageType = EtlMessageType.Debug,
                            Text = string.Format(Properties.Resources.VariableInit, escapedVariable.Name, escapedVariable.Value),
                        }
                    );

                    if (variable.Modifier == EtlVariableModifier.Input || variable.Modifier == EtlVariableModifier.Bound)
                    {
                        _logger.LogEtlVariable(escapedVariable);
                    }
                }

                var preprocessor = new EtlPackagePreprocessor();
                package = preprocessor.PreprocessPackage(package, context.GetVariables());

                var buildEndDateTime = DateTime.Now;
                _logger.LogEtlMessage
                (
                    new EtlMessage
                    {
                        EtlPackageId = session.EtlPackageId,
                        EtlSessionId = session.EtlSessionId,
                        LogDateTime = buildEndDateTime,
                        LogUtcDateTime = buildEndDateTime.ToUniversalTime(),
                        MessageType = EtlMessageType.Debug,
                        Text = string.Format(Properties.Resources.VariablesInitFinished),
                    }
                );

                InvokePackageSteps(package, context);

                foreach (var variable in context.GetVariables())
                {
                    if (variable.Modifier == EtlVariableModifier.Output)
                    {
                        _logger.LogEtlVariable(EscapeVariable(variable));

                    }
                }

                session.Status = context.CurrentStatus;
            }
 public _Context(EtlPackage originalPackage, EtlSession session)
     : base(session)
 {
     _currentStatus = session.Status;
     _originalPackage = originalPackage;
 }
        public void LogEtlSessionEnd(EtlSession session)
        {
            if (session == null)
            {
                throw new ArgumentNullException("session");
            }

            foreach (var exSession in _sessions)
            {
                if (exSession.EtlPackageId == session.EtlPackageId && exSession.EtlSessionId == session.EtlSessionId)
                {
                    exSession.EndDateTime = session.EndDateTime;
                    exSession.EndUtcDateTime = session.EndUtcDateTime;
                    exSession.Status = session.Status;

                    break;
                }
            }
        }
        public void LogEtlSessionStart(EtlSession session)
        {
            if (session == null)
            {
                throw new ArgumentNullException("session");
            }

            _sessions.Add(session);
        }