public string Serialize(EtlPackage package)
            {
                if (package == null)
                {
                    return(null);
                }

                using (var writer = new StringWriter())
                {
                    var ser = new XmlSerializer(typeof(EtlPackage), _overridesProvider.GetXmlOverrides());
                    ser.Serialize(writer, package);

                    return(writer.ToString());
                }
            }
            public EtlSession InvokePackage(EtlPackage package, EtlVariableAssignment[] assignments, string parentSessionId)
            {
                if (package == null)
                {
                    throw new ArgumentNullException("package");
                }

                if (assignments == null)
                {
                    assignments = new EtlVariableAssignment[0];
                }

                var session = InvokePackageCore(package, assignments, parentSessionId);
                return session;
            }
Esempio n. 3
0
            public EtlSession InvokePackage(EtlPackage package, EtlVariableAssignment[] assignments, string parentSessionId)
            {
                if (package == null)
                {
                    throw new ArgumentNullException("package");
                }

                if (assignments == null)
                {
                    assignments = new EtlVariableAssignment[0];
                }

                var session = InvokePackageCore(package, assignments, parentSessionId);

                return(session);
            }
Esempio n. 4
0
        public EtlPackage PreprocessPackage(EtlPackage package, EtlVariable[] variables)
        {
            if (package == null)
            {
                throw new ArgumentNullException("package");
            }

            var ser = new EtlPackageXmlSerializer();
            var xml = ser.Serialize(package);

            xml = PreprocessPackageXml(xml, variables);

            var result = ser.Deserialize(xml);

            return(result);
        }
        public void Show(ILocalEtlAgent agent, EtlAgentInfo agentInfo, string packageId)
        {
            if (agent == null)
            {
                throw new ArgumentNullException("agent");
            }

            if (agentInfo == null)
            {
                throw new ArgumentNullException("agentInfo");
            }

            if (packageId == null)
            {
                throw new ArgumentNullException("packageId");
            }

            _agent = agent;
            _agentInfo = agentInfo;
            _packageId = packageId;

            EtlPackage package;
            var exc = TryGetPackage(_packageId, out package);
            if (exc != null)
            {
                MessageForm.ShowMessage(MessageFormType.Error, exc.Message, "Cannot open package", new ExceptionInfo(exc), MessageBoxButtons.OK);
            }
            else
            {
                _currentPackage = package;
                UpdateButtons();
                ResetLogView();
                ShowCurrentPackage();

                this.Show();
            }
        }
            private void InvokePackageSteps(EtlPackage package, _Context context)
            {
                var stepIndex = 0;

                while (stepIndex < package.Steps.Count)
                {
                    var step = package.Steps[stepIndex];

                    var stepResult = InvokePackageStep(step, context);
                    if (EtlStatuses.GetPriorityStatus(stepResult.Status, context.CurrentStatus) == stepResult.Status)
                    {
                        context.CurrentStatus = stepResult.Status;
                    }

                    if (stepResult.Status == EtlStatus.Failed)
                    {
                        break;
                    }

                    if (HasVariableAssignments(stepResult))
                    {
                        var rebuildStartDateTime = DateTime.Now;
                        _logger.LogEtlMessage
                        (
                            new EtlMessage
                            {
                                EtlPackageId = context.EtlPackageId,
                                EtlSessionId = context.EtlSessionId,
                                LogDateTime = rebuildStartDateTime,
                                LogUtcDateTime = rebuildStartDateTime.ToUniversalTime(),
                                MessageType = EtlMessageType.Debug,
                                Text = string.Format(Properties.Resources.VariablesUpdateStarted),
                            }
                        );

                        foreach (var assignment in stepResult.VariableAssignments)
                        {
                            var assignedVariable = context.AssignVariable(assignment);
                            var escapedVariable = EscapeVariable(assignedVariable);

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

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

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

                    stepIndex++;
                }
            }
            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 void DeployEtlPackage(EtlPackage package, EtlPackageDeploymentOptions options)
 {
     throw new NotImplementedException();
 }
 public string Serialize(EtlPackage package)
 {
     return _serializer.Serialize(package);
 }
        private Exception TryCreatePackage(string packageId, string packageName)
        {
            try
            {
                var package = new EtlPackage
                {
                    Id = packageId,
                    Name = packageName,
                    Enabled = true,
                };

                _agent.DeployEtlPackage(package, null);
                return null;
            }
            catch (Exception exc)
            {
                return exc;
            }
        }
            public string Serialize(EtlPackage package)
            {
                if (package == null)
                {
                    return null;
                }

                using (var writer = new StringWriter())
                {
                    var ser = new XmlSerializer(typeof(EtlPackage), _overridesProvider.GetXmlOverrides());
                    ser.Serialize(writer, package);

                    return writer.ToString();
                }
            }
Esempio n. 13
0
 public _Context(EtlPackage originalPackage, EtlSession session)
     : base(session)
 {
     _currentStatus   = session.Status;
     _originalPackage = originalPackage;
 }
Esempio n. 14
0
 public EtlSession InvokePackage(EtlPackage package, EtlVariableAssignment[] assignments)
 {
     return(InvokePackage(package, assignments, GetCurrentUserName()));
 }
Esempio n. 15
0
 public EtlSession InvokePackage(EtlPackage package)
 {
     return(InvokePackage(package, null, null));
 }
Esempio n. 16
0
            private void InvokePackageSteps(EtlPackage package, _Context context)
            {
                var stepIndex = 0;

                while (stepIndex < package.Steps.Count)
                {
                    var step = package.Steps[stepIndex];


                    var stepResult = InvokePackageStep(step, context);
                    if (EtlStatuses.GetPriorityStatus(stepResult.Status, context.CurrentStatus) == stepResult.Status)
                    {
                        context.CurrentStatus = stepResult.Status;
                    }

                    if (stepResult.Status == EtlStatus.Failed)
                    {
                        break;
                    }

                    if (HasVariableAssignments(stepResult))
                    {
                        var rebuildStartDateTime = DateTime.Now;
                        _logger.LogEtlMessage
                        (
                            new EtlMessage
                        {
                            EtlPackageId   = context.EtlPackageId,
                            EtlSessionId   = context.EtlSessionId,
                            LogDateTime    = rebuildStartDateTime,
                            LogUtcDateTime = rebuildStartDateTime.ToUniversalTime(),
                            MessageType    = EtlMessageType.Debug,
                            Text           = string.Format(Properties.Resources.VariablesUpdateStarted),
                        }
                        );

                        foreach (var assignment in stepResult.VariableAssignments)
                        {
                            var assignedVariable = context.AssignVariable(assignment);
                            var escapedVariable  = EscapeVariable(assignedVariable);

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

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

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

                    stepIndex++;
                }
            }
Esempio n. 17
0
            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;
            }
 private Exception TryGetPackages(out EtlPackage[] packages)
 {
     try
     {
         packages = _agent.GetEtlPackages();
         return null;
     }
     catch (Exception exc)
     {
         packages = null;
         return exc;
     }
 }
 public EtlSession InvokePackage(EtlPackage package)
 {
     return InvokePackage(package, null, null);
 }
 public EtlSession InvokePackage(EtlPackage package, EtlVariableAssignment[] assignments)
 {
     return InvokePackage(package, assignments, GetCurrentUserName());
 }
 private Exception TryGetPackage(string packageId, out EtlPackage package)
 {
     try
     {
         package = _agent.GetEtlPackage(packageId);
         return null;
     }
     catch (Exception exc)
     {
         package = null;
         return exc;
     }
 }
 public string Serialize(EtlPackage package)
 {
     return(_serializer.Serialize(package));
 }
 public _Context(EtlPackage originalPackage, EtlSession session)
     : base(session)
 {
     _currentStatus = session.Status;
     _originalPackage = originalPackage;
 }
        private EtlPackageMonitorModel RefreshModel(EtlPackageMonitorModel model)
        {
            // обновляем модель или создаем заново
            var refresh = true;

            if (model == null)
            {
                model = new EtlPackageMonitorModel();

                model.ItemsByColumns = new List<EtlPackageMonitorItem>[SiteConfiguration.MaxCoulmnsToShow];
                for (var columnIndex = 0; columnIndex < SiteConfiguration.MaxCoulmnsToShow; columnIndex++)
                {
                    model.ItemsByColumns[columnIndex] = new List<EtlPackageMonitorItem>();
                }

                refresh = false;
            }

            model.ColumnCount = SiteConfiguration.MaxCoulmnsToShow;

            IEnumerable<EtlPackage> packages = new EtlPackage[0];
            if (model.Items.Count() > 0)
            {
                // идентификаторы пакетов из модели которые необходимо обновить
                var packageIds = model.Items.Where(i => i.ForceRefresh || i.EtlPackageStatus != EtlPackageMonitorItemStatus.Succeeded).Select(i => i.EtlPackageId);
                // сами пакеты
                packages = GetEtlPackages().Where(p => packageIds.Contains(p.Id, StringComparer.OrdinalIgnoreCase));
            }
            else
            {
                packages = GetEtlPackages();
            }

            var agent = SiteConfiguration.GetEtlAgent();
            var logParser = agent.GetEtlLogParser();
            var sessions = logParser.GetLatestEtlSessions(packages.Select(p => p.Id).ToArray());

            model.HasErrors = false;

            var packageIndex = 0;
            foreach (var package in packages)
            {
                var item = new EtlPackageMonitorItem();
                item.EtlPackageId = package.Id;
                item.RunIntervalSeconds = package.RunIntervalSeconds;
                item.EtlPackageName = package.Name;
                item.CanInvoke = true;

                var session = sessions.Where(s => s.EtlPackageId == package.Id).FirstOrDefault();

                if (session != null)
                {
                    item.EtlSessionId = session.EtlSessionId;
                    item.EtlSessionDateTime = session.EndDateTime;
                    item.EtlPackageStatus = EtlPackageMonitorItemStatuses.GetMonitorItemStatus(session, package.RunIntervalSeconds);

                    item.Counters = logParser.GetEtlCounters(package.Id, session.EtlSessionId);

                    var messages = logParser.GetEtlMessages(package.Id, session.EtlSessionId);
                    if (item.EtlPackageStatus == EtlPackageMonitorItemStatus.Failed)
                    {
                        var errorMessage = messages.OrderByDescending(m => m.SequentialId).FirstOrDefault(m => m.MessageType == EtlMessageType.Error);
                        item.StatusMessage = errorMessage == null ? DEFAULT_ERROR_MSG : errorMessage.Text;
                    }

                    if (item.EtlPackageStatus == EtlPackageMonitorItemStatus.TooFar && session.Status == EtlStatus.Started)
                    {
                        item.StatusMessage = PACKAGE_CURRENTLY_RUNNING;
                    }
                }
                else
                {
                    item.EtlPackageStatus = EtlPackageMonitorItemStatus.Never;
                }

                if (item.EtlPackageStatus != EtlPackageMonitorItemStatus.Succeeded)
                {
                    model.HasErrors = true;
                }

                if (refresh)
                {
                    var pack = model.Items.FirstOrDefault(i => String.Equals(i.EtlPackageId, package.Id, StringComparison.OrdinalIgnoreCase));
                    if (pack != null)
                    {
                        pack.UpdateFromItem(item);
                    }
                }
                else
                {
                    var columnIndex = packageIndex % SiteConfiguration.MaxCoulmnsToShow;
                    model.ItemsByColumns[columnIndex].Add(item);
                }

                packageIndex++;
            }

            for (var columnIndex = 0; columnIndex < model.ItemsByColumns.Length; columnIndex++)
            {
                if (model.MaxItemCountInColumn < model.ItemsByColumns[columnIndex].Count)
                {
                    model.MaxItemCountInColumn = model.ItemsByColumns[columnIndex].Count;
                }
            }

            model.LastUpdated = DateTime.Now;

            return model;
        }
Esempio n. 25
0
            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);
            }