Esempio n. 1
0
        private async Task LogAllReliableCollections()
        {
            while (!ReliableDictionariesInitialized)
            {
                await Task.Delay(1000);
            }

            StringBuilder sb = new StringBuilder();

            sb.AppendLine("Reliable Collections");

            sb.AppendLine("CurrentGidToPointItemMap =>");
            var currentGidToPointItemMap = await CurrentGidToPointItemMap.GetEnumerableDictionaryAsync();

            foreach (var element in currentGidToPointItemMap)
            {
                sb.AppendLine($"Key => {element.Key}, Value => Gid: 0x{element.Value.Gid:X16}, Address: {element.Value.Address}, Name: {element.Value.Name}, RegisterType: {element.Value.RegisterType}, Alarm: {element.Value.Alarm}, Initialized: {element.Value.Initialized}");
            }
            sb.AppendLine();

            sb.AppendLine("IncomingGidToPointItemMap =>");
            var incomingGidToPointItemMap = await IncomingGidToPointItemMap.GetEnumerableDictionaryAsync();

            foreach (var element in incomingGidToPointItemMap)
            {
                sb.AppendLine($"Key => {element.Key}, Value => Gid: 0x{element.Value.Gid:X16}, Address: {element.Value.Address}, Name: {element.Value.Name}, RegisterType: {element.Value.RegisterType}, Alarm: {element.Value.Alarm}, Initialized: {element.Value.Initialized}");
            }
            sb.AppendLine();

            sb.AppendLine("CurrentAddressToGidMap =>");
            var currentAddressToGidMap = await CurrentAddressToGidMap.GetEnumerableDictionaryAsync();

            foreach (var element in currentAddressToGidMap)
            {
                sb.AppendLine($"Key => {element.Key}, Value => Dictionary Count: {element.Value.Count}");
            }
            sb.AppendLine();

            sb.AppendLine("IncomingAddressToGidMap =>");
            var incomingAddressToGidMap = await IncomingAddressToGidMap.GetEnumerableDictionaryAsync();

            foreach (var element in incomingAddressToGidMap)
            {
                sb.AppendLine($"Key => {element.Key}, Value => Dictionary Count: {element.Value.Count}");
            }
            sb.AppendLine();

            sb.AppendLine("InfoCache =>");
            var infoCache = await InfoCache.GetEnumerableDictionaryAsync();

            foreach (var element in infoCache)
            {
                sb.AppendLine($"Key => {element.Key}, Value => {element.Value}");
            }
            sb.AppendLine();

            sb.AppendLine("ModelChanges =>");
            var modelChanges = await ModelChanges.GetEnumerableDictionaryAsync();

            foreach (var element in modelChanges)
            {
                sb.AppendLine($"Key => {element.Key}, Value => List Count: {element.Value.Count}");
            }
            sb.AppendLine();

            sb.AppendLine("MeasurementsCache =>");
            var measurementsCache = await MeasurementsCache.GetEnumerableDictionaryAsync();

            foreach (var element in measurementsCache)
            {
                sb.AppendLine($"Key => {element.Key}, Value => MeasurementGid: {element.Value.MeasurementGid:X16}, Alarm: {element.Value.Alarm}, CommandOrigin: {element.Value.CommandOrigin}");
            }
            sb.AppendLine();

            sb.AppendLine("CommandDescriptionCache =>");
            var commandDescriptionCache = await CommandDescriptionCache.GetEnumerableDictionaryAsync();

            foreach (var element in commandDescriptionCache)
            {
                sb.AppendLine($"Key => {element.Key}, Value => Gid: {element.Value.Gid:X16}, Address: {element.Value.Address}, Value: {element.Value.Value}, CommandOrigin: {element.Value.CommandOrigin}");
            }
            sb.AppendLine();

            Logger.LogDebug($"{baseLogString} LogAllReliableCollections => {sb}");
        }
Esempio n. 2
0
        public async Task <bool> Prepare()
        {
            bool success;

            while (!ReliableDictionariesInitialized)
            {
                await Task.Delay(1000);
            }

            try
            {
                //INIT INCOMING SCADA MODEL with current model values
                await InitializeIncomingScadaModel();

                //IMPORT ALL measurements from NMS and create PointItems for them
                var enumerableModelChanges = await ModelChanges.GetEnumerableDictionaryAsync();

                Dictionary <long, IScadaModelPointItem> incomingPointItems = await CreatePointItemsFromNetworkModelMeasurements(enumerableModelChanges);

                //ORDER IS IMPORTANT due to IncomingAddressToGidMap validity: DELETE => UPDATE => INSERT
                var orderOfOperations = new List <DeltaOpType>()
                {
                    DeltaOpType.Delete, DeltaOpType.Update, DeltaOpType.Insert
                };

                foreach (var operation in orderOfOperations)
                {
                    foreach (long gid in enumerableModelChanges[(byte)operation])
                    {
                        ModelCode type = modelResourceDesc.GetModelCodeFromId(gid);
                        if (type != ModelCode.ANALOG && type != ModelCode.DISCRETE)
                        {
                            continue;
                        }

                        if (operation == DeltaOpType.Delete)
                        {
                            await HandleDeleteOperation(gid);
                        }
                        else if (operation == DeltaOpType.Update)
                        {
                            IScadaModelPointItem incomingPointItem = incomingPointItems[gid];
                            await HandleUpdateOperation(incomingPointItem, gid);
                        }
                        else if (operation == DeltaOpType.Insert)
                        {
                            IScadaModelPointItem incomingPointItem = incomingPointItems[gid];
                            await HandleInsertOperation(incomingPointItem, gid);
                        }
                    }
                }

                success = await CheckSuccessiveAddressCondition();

                ;
            }
            catch (Exception e)
            {
                string errorMessage = $"{baseLogString} Prepare => Exception: {e.Message}";
                Logger.LogError(errorMessage, e);
                success = false;
            }

            return(success);
        }