Example #1
0
        private void TxChanged(RsChangeInfo change)
        {
            RdSrvTxRs txRs = Deserialize <RdSrvTxRs>(change.Content);

            if (txRs != null)
            {
                Top.WorkingThread.Enqueue("NewConfig", delegate()
                {
                    //General.SafeLaunchEvent(TxStateChanged, this, txRs);
                });
            }
        }
Example #2
0
        private void RsChanged <T>(RsChangeInfo change) where T : class
        {
            T      rs = Deserialize <T>(change.Content);
            string id = change.Id;

            string type  = Identifiers.TypeId(typeof(T));
            string rsUid = id + "_" + type;

            _Logger.Trace($"RsChanged <{type} {rsUid}>");

            if (rs is GwTlfRs)
            {
                object rsTlf = rs;
                // No trato los eventos de proxies externos
                if (((GwTlfRs)rsTlf).Type > (uint)RsChangeInfo.RsTypeInfo.InternalAltProxy)
                {
                    return;
                }

                if (((GwTlfRs)rsTlf).Type >= (uint)RsChangeInfo.RsTypeInfo.ExternalSub)
                {
                    //TODO Le quito la informacion de puerto que no me sirve, de momento, hay que cambiar CORESIP y mas
                    String[] userData = ((GwTlfRs)rsTlf).GwIp.ToString().Split(':');
                    ((GwTlfRs)rsTlf).GwIp = userData[0];
                    if (((GwTlfRs)rsTlf).St == GwTlfRs.State.NotAvailable)
                    {
                        rs = null;
                    }
                }
            }

            Top.WorkingThread.Enqueue("RsChanged", delegate()
            {
                Resource resource;
                //if (!_Resources.TryGetValue(rsUid, out resource))
                if (!GetResource(rsUid, out resource))
                {
                    resource          = new Rs <T>(change.Id);
                    _Resources[rsUid] = resource;

                    _Logger.Trace($"RsChanged. Resource Added <{type} {rsUid}>");
                }

                resource.Reset(change.ContainerId, rs);
                _Logger.Trace($"RsChanged. Resource Reset <{type} {rsUid}>");
            });
        }
Example #3
0
 private void OnRsChanged(object sender, RsChangeInfo change)
 {
     try
     {
         if (change.Type == Identifiers.TypeId(typeof(Cd40Cfg)))
         {
             CfgChanged(change);
         }
         else if (change.Type == Identifiers.TypeId(typeof(TopRs)))
         {
             RsChanged <TopRs>(change);
         }
         else if (change.Type == Identifiers.TypeId(typeof(GwTlfRs)))
         {
             RsChanged <GwTlfRs>(change);
         }
         else if (change.Type == Identifiers.TypeId(typeof(GwLcRs)))
         {
             RsChanged <GwLcRs>(change);
         }
         else if (change.Type == Identifiers.TypeId(typeof(RdSrvRxRs)))
         {
             RsChanged <RdSrvRxRs>(change);
         }
         else if (change.Type == Identifiers.TypeId(typeof(RdSrvFrRs)))
         {
             RsChanged <RdSrvFrRs>(change);
         }
         else if (change.Type == Identifiers.TypeId(typeof(RdSrvTxRs)))
         {
             TxChanged(change);
         }
         else
         {
             _Logger.Error($"OnRsChanged Error, Unkown Type <{change.Type}>");
         }
     }
     catch (Exception ex)
     {
         _Logger.Error("ERROR deserializando recurso de tipo " + change.Type, ex);
     }
 }
Example #4
0
        private void CfgChanged(RsChangeInfo change)
        {
            Cd40Cfg cfg = Deserialize <Cd40Cfg>(Tools.Decompress(change.Content));

            if (cfg != null)
            {
                _Logger.Trace($"CfgChanged <{cfg.Version}>");

                Top.WorkingThread.Enqueue("NewConfig", delegate()
                {
                    foreach (Resource rs in _Resources.Values)
                    {
                        rs.ResetSubscribers();
                        _Logger.Trace($"CfgChanged. Resource {rs.Id} => ResetSubscribers");
                    }

                    General.SafeLaunchEvent(NewConfig, this, cfg);

                    Dictionary <string, Resource> resources = new Dictionary <string, Resource>(_Resources);
                    _Resources.Clear();

                    foreach (KeyValuePair <string, Resource> p in resources)
                    {
                        if (!p.Value.IsUnreferenced)
                        {
                            _Resources.Add(p.Key, p.Value);
                            _Logger.Trace($"CfgChanged. Resource {p.Key} => Added..");
                        }
                        else
                        {
                            _Logger.Error($"CfgChanged. Adding Resource Error. {p.Value.Id} is Unreferenced");
                        }
                    }
                    LogResourcesConfig();
                });
            }
        }