Esempio n. 1
0
                                      private void validateRouting(ValidationContext ctx)
                                      {
                                          var routing = this.LevelConfig[CONFIG_NETWORK_ROUTING_SECTION];

                                          if (!routing.Exists)
                                          {
                                              return;
                                          }
                                          var routeNodes = routing.Children.Where(n => n.IsSameName(CONFIG_NETWORK_ROUTING_ROUTE_SECTION));

                                          foreach (var rnode in routeNodes)
                                          {
                                              foreach (var anode in rnode.Attributes)
                                              {
                                                  if (!anode.IsSameName(CONFIG_NETWORK_ROUTING_NETWORK_ATTR) &&
                                                      !anode.IsSameName(CONFIG_NETWORK_ROUTING_SERVICE_ATTR) &&
                                                      !anode.IsSameName(CONFIG_NETWORK_ROUTING_BINDING_ATTR) &&
                                                      !anode.IsSameName(CONFIG_NETWORK_ROUTING_FROM_ATTR) &&
                                                      !anode.IsSameName(CONFIG_NETWORK_ROUTING_TO_ADDRESS_ATTR) &&
                                                      !anode.IsSameName(CONFIG_NETWORK_ROUTING_TO_PORT_ATTR) &&
                                                      !anode.IsSameName(CONFIG_NETWORK_ROUTING_TO_GROUP_ATTR)
                                                      )
                                                  {
                                                      ctx.Output.Add(new MetabaseValidationMsg(MetabaseValidationMessageType.Warning, Catalog, this,
                                                                                               StringConsts.METABASE_NETWORK_REGION_ROUTING_ATTR_UNRECOGNIZED_WARNING.Args(RegionPath, anode.Name)));
                                                  }
                                              }



                                              var net     = rnode.AttrByName(CONFIG_NETWORK_ROUTING_NETWORK_ATTR).Value;
                                              var svc     = rnode.AttrByName(CONFIG_NETWORK_ROUTING_SERVICE_ATTR).Value;
                                              var binding = rnode.AttrByName(CONFIG_NETWORK_ROUTING_BINDING_ATTR).Value;
                                              var from    = rnode.AttrByName(CONFIG_NETWORK_ROUTING_FROM_ATTR).Value;

                                              var toaddr  = rnode.AttrByName(CONFIG_NETWORK_ROUTING_TO_ADDRESS_ATTR).Value;
                                              var toport  = rnode.AttrByName(CONFIG_NETWORK_ROUTING_TO_PORT_ATTR).Value;
                                              var togroup = rnode.AttrByName(CONFIG_NETWORK_ROUTING_TO_GROUP_ATTR).Value;

                                              if (toaddr.IsNullOrWhiteSpace() &&
                                                  toport.IsNullOrWhiteSpace() &&
                                                  togroup.IsNullOrWhiteSpace())
                                              {
                                                  ctx.Output.Add(new MetabaseValidationMsg(MetabaseValidationMessageType.Error, Catalog, this, StringConsts.METABASE_NETWORK_REGION_ROUTING_EMPTY_ROUTE_ASSIGNMENT_ERROR.Args(RegionPath)));
                                              }

                                              if (net.IsNotNullOrEmpty())
                                              {
                                                  try
                                                  {
                                                      var netNode = Metabank.GetNetworkConfNode(net);
                                                  }
                                                  catch (Exception error)
                                                  {
                                                      ctx.Output.Add(new MetabaseValidationMsg(MetabaseValidationMessageType.Error, Catalog, this, error.ToMessageWithType()));
                                                  }

                                                  if (svc.IsNotNullOrWhiteSpace())
                                                  {
                                                      try
                                                      {
                                                          var svcNode = Metabank.GetNetworkSvcConfNode(net, svc);
                                                      }
                                                      catch (Exception error)
                                                      {
                                                          ctx.Output.Add(new MetabaseValidationMsg(MetabaseValidationMessageType.Error, Catalog, this, error.ToMessageWithType()));
                                                      }

                                                      if (binding.IsNotNullOrWhiteSpace())
                                                      {
                                                          try
                                                          {
                                                              var svcNode = Metabank.GetNetworkSvcBindingConfNode(net, svc, binding);
                                                          }
                                                          catch (Exception error)
                                                          {
                                                              ctx.Output.Add(new MetabaseValidationMsg(MetabaseValidationMessageType.Error, Catalog, this, error.ToMessageWithType()));
                                                          }
                                                      }
                                                  }
                                              }

                                              if (from.IsNotNullOrWhiteSpace())
                                              {
                                                  var reg = Metabank.CatalogReg[from];
                                                  if (reg == null)
                                                  {
                                                      ctx.Output.Add(new MetabaseValidationMsg(MetabaseValidationMessageType.Error, Catalog, this, StringConsts.METABASE_NETWORK_REGION_ROUTING_FROM_PATH_ERROR.Args(RegionPath, from)));
                                                  }
                                              }
                                          }
                                      }