protected object TraverseChild <T>(T child, string name, object parent)
{
var t = this as ITraverser <T>;
if (t != null)
{
var node = new TraverseNode <T>(child, name, parent);
t.Traverse(node);
return(node.Result);
}
var unknown = this as ITraverser;
if (unknown != null)
{
var node = new TraverseNode <object>(child, name, parent);
unknown.Traverse(node);
return(node.Result);
}
throw new TraverserNotImplementedException(string.Format("Cannot traverse an instance of “{0}” type. Please implement a proper ITraverser interface.", child.GetType().Name));
}
/// <summary>
/// This is a very key service operation that really makes eveything work fast, across 3 dimensions:
/// x-horizontal connected services, y-layers deep, virtualized across z-virtual clustered hosts within a given service domain. It
/// will be the preceeding call to almost all other Config Service calls, to get the fastest path to a target
/// connected Config Service host on the network.
/// </summary>
/// <param name="queriedNodeList">This list is used to prevent circular references in a connected tree of nodes from being queried, and creating a race condition.</param>
/// <param name="targetHostNameIdentifier">The name of the target host we are seeking, as specified in the target's HOST_NAME_IDENTIFIER settings key.</param>
/// <param name="targetConfigServiceNameIdentifier">The fully qualified name of the Configuration Service implementation class for the host we are seeking, used in
/// conjunction with targetHostNameIdentifier to uniquely identify a target host.</param>
/// <param name="csUser">The user requesting the path.</param>
/// <returns>A network traverse path consisting of a List of TraverseNode types.</returns>
public override List<TraverseNode> getTraversePath(List<TraverseNode> queriedNodeList, string targetHostNameIdentifier, string targetConfigServiceNameIdentifier, ServiceUsers csUser)
{
switch (Trade.BusinessServiceConfigurationSettings.Settings.ORDER_PROCESSING_MODE)
{
case StockTraderUtility.OPS_INPROCESS:
{
if (targetHostNameIdentifier.Equals(StockTraderUtility.ORDER_PROCESSOR_SERVICE_SELFHOST))
{
ServiceConfigHelper configHelper = new ServiceConfigHelper(settingsInstance);
TraverseNode myNode = null;
List<TraverseNode> thisPath = new List<TraverseNode>();
try
{
if (!(configHelper.setServiceRights(ref csUser, ConfigUtility.CONFIG_CONNECTED_SERVICE_RIGHTS)>=ConfigUtility.CONFIG_CONNECTED_SERVICE_RIGHTS))
return null;
ConfigUtility.writeConfigConsoleMessage("\nRequest for traverse path received. Target Service Host: " + targetHostNameIdentifier + " hosting target ConfigService: " + targetConfigServiceNameIdentifier + ".\n", EventLogEntryType.Information, true, settingsInstance);
string HOST_NAME_IDENTIFIER = (string)ConfigUtility.reflectGetField(settingsInstance, "HOST_NAME_IDENTIFIER");
string CONFIG_SERVICENAME_IDENTIFIER = (string)ConfigUtility.reflectGetField(settingsInstance, "CONFIG_SERVICENAME_IDENTIFIER");
int NODE_ACTIVE_ID = (int)ConfigUtility.reflectGetField(settingsInstance, "NODE_ACTIVE_ID");
//This logic is used to ensure we construct a valid endpoint based on whether our config service
//is using an external load balancer such as Windows Network Load Balancing or hardware load-balancer. This
//would typically be the case for any service exposed to the Internet cloud where clients could be coming from
//anywhere and we thus need to virtualize our Internet DNS name--or even intranet DNS name.
List<HostedServices> hostedServices = (List<HostedServices>)ConfigUtility.reflectGetField(settingsInstance, "hostedServices");
//We may have this service listening on lots of different endpoints.
//We need to map the correct Service Endpoint (which implies a binding) to the incoming client request using this WCF property
//on the operation context. However note this is contained in the traversepath (TraverseNode) data structure,
//but given new design not currently used within Config Service/ConfigWeb as we dynamically figure out a new valid path on subsequent requests
//(given valid paths might change within seconds from original request).
//However, returning the correct information here may be important for those extending Config Service, as the
//addresses will be valid addresses given incoming request all the way up the stack from the original request. Those that want could
//override this method any choose not to return *any* actual endpoint information for services this service connects to.
//Just a choice; independent of security which should always be set on the WCF binding itself (wsHttp or netTcp for ConfigService)
//, which, if set with digital certs, InfoCard, Windows Auth (Kerberos) would be really locked down to identity of caller at the
//transport and/or message level to begin with (meaning we would never be at this point in code if the client was not valid!).
string currentRequestEndpoint = OperationContext.Current.EndpointDispatcher.EndpointAddress.ToString();
List<HostListenEndPointInstance> myConfigEndpoints = (List<HostListenEndPointInstance>)ConfigUtility.reflectGetField(settingsInstance, "hostConfigListenEndpoints");
if (ConfigUtility.onAzure)
{
Uri myUri = new Uri(currentRequestEndpoint);
string myHostMachine = myUri.Host;
string path = myUri.AbsolutePath.ToLower();
ConfigUtility.writeConfigConsoleMessage("\n*** currentRequestPath: " + path, EventLogEntryType.Information, true, settingsInstance);
HostListenEndPointInstance theConfigEndpoint = myConfigEndpoints.Find(delegate(HostListenEndPointInstance hExist)
{
Uri uri = new Uri(hExist.RemoteAddress);
return uri.AbsolutePath.ToLower().Equals(path) && uri.Scheme.Equals(myUri.Scheme);
}
);
if (theConfigEndpoint != null)
{
HostedServices thisService = hostedServices.Find(delegate(HostedServices hsExist)
{
return hsExist.HostedServiceID == theConfigEndpoint.HostedServiceID;
}
);
string myName = ServiceConfigHelper.getHostNameForServiceHosting(thisService, settingsInstance);
currentRequestEndpoint = currentRequestEndpoint.Replace(myHostMachine, myName);
}
}
HostListenEndPointInstance myEp = ServiceConfigHelper.currentRequestFindMatchingListenEndpoint(currentRequestEndpoint, myConfigEndpoints);
if (myConfigEndpoints!=null && myConfigEndpoints.Count>0)
ConfigUtility.writeConfigConsoleMessage("\n*** currentRequestEndpoint: " + currentRequestEndpoint + " myConfigEndpoints[0].RemoteAddress: " + myConfigEndpoints[0].RemoteAddress, EventLogEntryType.Information, true, settingsInstance);
if (myEp == null)
{
ConfigUtility.writeConfigConsoleMessage("myEp is null, returning null path", EventLogEntryType.Information, true, settingsInstance);
return null;
}
//If we are already in the path, then return null now. This prevents circular service references within the tree from causing a race
//condition. TODO is to add information about the reference so it shows up in physical maps within ConfigWeb, for now
//we will just return null and prevent a race condition.
if (queriedNodeList == null)
queriedNodeList = new List<TraverseNode>();
TraverseNode me = queriedNodeList.Find(delegate(TraverseNode tn) { return (tn.MyNode.HostNameIdentifier.Equals(HOST_NAME_IDENTIFIER) && tn.MyNode.ConfigServiceImplementationClassName.Equals(CONFIG_SERVICENAME_IDENTIFIER)); });
if (me != null)
return null;
//Note this does not populate peer nodes such that if using external load balancer, actual physical nodes remain
//hidden behind the virtualized endpoint and are not returned.
myNode = new TraverseNode(new ServiceNode(NODE_ACTIVE_ID, myEp.RemoteAddress, ConfigSettings.MESSAGE_ONLINE, myEp.ActiveSince, HOST_NAME_IDENTIFIER, null, CONFIG_SERVICENAME_IDENTIFIER), null);
myNode.MyInProcNode = myNode.MyNode;
myNode.OSName = OSInfo.Name;
queriedNodeList.Add(myNode);
thisPath.Add(myNode);
}
catch (Exception e)
{
ServiceConfigHelper.logServiceOperationException(csUser, e.ToString(), settingsInstance);
throw;
}
return thisPath;
}
else
return base.getTraversePath(queriedNodeList, targetHostNameIdentifier, targetConfigServiceNameIdentifier, csUser);
}
default:
{
List<TraverseNode> returnList = base.getTraversePath(queriedNodeList, targetHostNameIdentifier, targetConfigServiceNameIdentifier, csUser);
return returnList;
}
}
}
