/// <summary>
/// The <see cref="Configure"/> implementation method.
/// </summary>
/// <remarks>
/// This method must only be called by a thread that has synchronized
/// on this RemoteService.
/// </remarks>
/// <param name="xml">
/// The <see cref="IXmlElement"/> containing the new configuration
/// for this RemoteService.
/// </param>
protected virtual void DoConfigure(IXmlElement xml)
{
if (xml == null)
{
throw new ArgumentNullException("xml", "xml configuration must not be null");
}
Xml = xml;
// find the configuration for the Initiator
IXmlElement xmlInitiator = Tangosol.Util.Daemon.QueueProcessor.
Service.Peer.Initiator.Initiator.FindInitiatorConfig(xml);
// inject service configuration
IXmlElement xmlHandler = XmlHelper.EnsureElement(xmlInitiator, "incoming-message-handler");
IXmlElement xmlSub = XmlHelper.EnsureElement(xmlHandler, "request-timeout");
if (xmlSub.Value == null)
{
xmlSub.SetString(xml.GetSafeElement("request-timeout").GetString());
}
// create the Initiator
IConnectionInitiator initiator = Tangosol.Util.Daemon.QueueProcessor.
Service.Peer.Initiator.Initiator.CreateInitiator(xmlInitiator, OperationalContext);
if (initiator is Initiator)
{
var initiatorImpl = (Initiator)initiator;
initiatorImpl.ServiceName = ServiceName + ':' + initiatorImpl.ServiceName;
initiatorImpl.ParentService = this;
}
Initiator = initiator;
RemoteClusterName = xml.GetSafeElement("cluster-name").GetString();
RemoteServiceName = xml.GetSafeElement("proxy-service-name").GetString();
ScopeName = xml.GetSafeElement("scope-name").GetString();
if (initiator is TcpInitiator)
{
IsNameServiceAddressProvider = ((TcpInitiator)initiator).IsNameService;
}
}
/// <summary>
/// The <see cref="RemoteService.Configure"/> implementation method.
/// </summary>
/// <remarks>
/// This method must only be called by a thread that has synchronized
/// on this RemoteService.
/// </remarks>
/// <param name="xml">
/// The <see cref="IXmlElement"/> containing the new configuration
/// for this RemoteService.
/// </param>
protected override void DoConfigure(IXmlElement xml)
{
base.DoConfigure(xml);
DeferKeyAssociationCheck =
xml.GetSafeElement("defer-key-association-check")
.GetBoolean(DeferKeyAssociationCheck);
// register all Protocols
IConnectionInitiator initiator = Initiator;
initiator.RegisterProtocol(CacheServiceProtocol.Instance);
initiator.RegisterProtocol(NamedCacheProtocol.Instance);
}
/// <summary>
/// Return a child <b>IXmlElement</b> of the given <b>IXmlElement</b>
/// that can be used to create and configure a new
/// <b>IConnectionInitiator</b>.
/// </summary>
/// <remarks>
/// The given <b>IXmlElement</b> must have a child element with one
/// of the following names:
/// <list type="number">
/// <item>
/// tcp-initiator: used to create and configure a new TcpInitiator
/// </item>
/// </list>
/// </remarks>
/// <param name="xml">
/// The parent <b>IXmlElement</b> of the <b>IXmlElement</b> used to
/// create and configure a new <b>IConnectionInitiator</b>.
/// </param>
/// <returns>
/// A child <b>IXmlElement</b> that can be used to create and
/// configure a new <b>IConnectionInitiator</b> or <c>null</c> if no
/// such <b>IXmlElement</b> exists.
/// </returns>
/// <exception cref="ArgumentException">
/// If the given <b>IXmlElement</b> does not have a valid
/// <b>IConnectionInitiator</b> configuration child element.
/// </exception>
public static IXmlElement FindInitiatorConfig(IXmlElement xml)
{
IXmlElement xmlConfig = xml.Name.Equals("initiator-config")
? xml : xml.GetSafeElement("initiator-config");
if (xmlConfig.GetElement("tcp-initiator") != null)
{
return((IXmlElement)xmlConfig.Clone());
}
throw new ArgumentException("the \"initiator-config\" element is either"
+ " missing, empty, or does not contain a valid transport-specific"
+ " child element:\n" + xml);
}
/// <summary>
/// Parse the given <b>IXmlElement</b> as a local <b>IPEndPoint</b>.
/// </summary>
/// <remarks>
/// If the specified <b>IXmlElement</b> contains an empty address,
/// <c>null</c> is returned.
/// </remarks>
/// <param name="xml">
/// The <b>IXmlElement</b> to parse.
/// </param>
/// <returns>
/// A new <b>IPEndPoint</b> representing the contents of the given
/// <b>XmlNode</b>.
/// </returns>
protected static IPEndPoint ParseLocalSocketAddress(IXmlElement xml)
{
IXmlElement xmlAddr = xml.GetElement("address");
IXmlElement xmlPort = xml.GetElement("port");
String sAddressFamiliy =
xml.GetSafeElement("address-family").GetString(
"InterNetwork");
if (xmlAddr == null && xmlPort == null)
{
return(null);
}
string addr = xmlAddr == null ? "localhost" : xmlAddr.GetString();
int port = xmlPort == null ? 0 : xmlPort.GetInt();
NetworkUtils.PreferredAddressFamily =
(AddressFamily)
Enum.Parse(typeof(AddressFamily), sAddressFamiliy);
IPAddress ipAddress;
try
{
ipAddress = addr.Equals("localhost")
? NetworkUtils.GetLocalHostAddress()
: NetworkUtils.GetHostAddress(addr);
}
catch (Exception e)
{
throw new Exception("The \"" + xml.Name + "\" configuration "
+
"element contains an invalid \"address\" element",
e);
}
try
{
return(new IPEndPoint(ipAddress, port));
}
catch (Exception e)
{
throw new Exception("The \"" + xml.Name + "\" configuration "
+
"element contains an invalid \"port\" element",
e);
}
}
public static IDictionary CreateFilterConfigMap(IXmlElement filterConfig)
{
IDictionary mapConfigByName = new Hashtable();
IXmlElement config = filterConfig;
if (config != null)
{
for (IEnumerator enumerator = config.GetElements("filter"); enumerator.MoveNext();)
{
IXmlElement xmlFilter = (IXmlElement)enumerator.Current;
string name = xmlFilter.GetSafeElement("filter-name").GetString();
mapConfigByName.Add(name, xmlFilter);
}
}
return(mapConfigByName);
}
/// <summary>
/// Construct a new DefaultOperationalContext.
/// </summary>
/// <param name="config">
/// An XML element corresponding to coherence.xsd.
/// </param>
public DefaultOperationalContext(IXmlElement config)
{
if (config == null)
{
config = LoadDefaultOperationalConfig();
}
m_config = config;
ParseEditionConfig();
ParseLoggingConfig();
ParseLocalMemberConfig();
ParseFilterConfig();
ParseSerializerConfig();
ParseAddressProviderConfig();
ParseSecurityConfig();
DiscoveryTimeToLive = config.GetSafeElement("multicast-listener/time-to-live").GetInt(4);
}
/// <summary>
/// Parse and configure local <see cref="IMember"/> information.
/// </summary>
private void ParseLocalMemberConfig()
{
LocalMember member = new LocalMember();
IXmlElement xmlConfig = Config.FindElement("cluster-config/member-identity");
if (xmlConfig != null)
{
member.ClusterName = xmlConfig.GetSafeElement("cluster-name").GetString();
member.SiteName = xmlConfig.GetSafeElement("site-name").GetString();
member.RackName = xmlConfig.GetSafeElement("rack-name").GetString();
member.MachineName = xmlConfig.GetSafeElement("machine-name").GetString();
member.ProcessName = xmlConfig.GetSafeElement("process-name").GetString();
member.MemberName = xmlConfig.GetSafeElement("member-name").GetString();
member.RoleName = xmlConfig.GetSafeElement("role-name").GetString();
}
if (StringUtils.IsNullOrEmpty(member.ClusterName))
{
// set default cluster name to the user name
string name = Environment.UserName;
if (StringUtils.IsNullOrEmpty(name))
{
// we can't obtain the user name, this could be a transient error for instance in the case of NIS.
// while we could generate some random or fixed default that wouldn't defend well against transient errors
// and we could end up with multiple clusters. Given that any production system should actually set the
// cluster name rather then using a default we will treat this as a hard error. Note don't try to obtain
// the name by other means such as reading env variables because they may produce a different string then
// reading "user.name" and again if the error is transient multiple clusters could be unintentionally produced.
throw new NotSupportedException(
"unable to generate a default cluster name, user name is not available, explicit cluster name configuration is required");
}
// this suffix in addition to be cute and suggesting this is not a production cluster also helps
// minimize the possibility of a collision with a manually named cluster which would be very unlikely
// to use such a cute name.
member.ClusterName = name = name + "'s cluster";
CacheFactory.Log("The cluster name has not been configured, a value of \"" + name + "\" has been automatically generated", CacheFactory.LogLevel.Info);
}
if (StringUtils.IsNullOrEmpty(member.MachineName))
{
var host = System.Net.Dns.GetHostName();
var delim = host.IndexOf('.');
if (delim == -1 || !Char.IsLetter(host[0]))
{
member.MachineName = host;
}
else
{
member.MachineName = host.Substring(0, delim);
member.SiteName = host.Substring(delim + 1);
}
}
if (StringUtils.IsNullOrEmpty(member.RoleName))
{
member.RoleName = ".NET " + EditionName + " client";
}
if (StringUtils.IsNullOrEmpty(member.ProcessName))
{
member.ProcessName = Process.GetCurrentProcess().ProcessName;
}
LocalMember = member;
}
/// <summary>
/// Configure the controllable service.
/// </summary>
/// <remarks>
/// <p/>
/// This method can only be called before the controllable service
/// is started.
/// </remarks>
/// <param name="xml">
/// An <see cref="IXmlElement"/> carrying configuration information
/// specific to the IControllable object.
/// </param>
/// <exception cref="InvalidOperationException">
/// Thrown if the service is already running.
/// </exception>
/// <exception cref="ArgumentException">
/// Thrown if the configuration information is invalid.
/// </exception>
public override void Configure(IXmlElement xml)
{
lock (this)
{
base.Configure(xml);
if (xml == null)
{
return;
}
// <tcp-initiator>
IXmlElement xmlCat = xml.GetSafeElement("tcp-initiator");
// <stream-provider/>
IXmlElement xmlSub = xmlCat.GetSafeElement("stream-provider");
StreamProvider = StreamProviderFactory.CreateProvider(xmlSub);
// <local-address>
xmlSub = xmlCat.GetSafeElement("local-address");
// <address>
// <port>
LocalAddress = ParseLocalSocketAddress(xmlSub);
// <reusable>
IsLocalAddressReusable = xmlSub.GetSafeElement("reusable").
GetBoolean(IsLocalAddressReusable);
// <remote-addresses>
bool isNameService = false;
xmlSub = xmlCat.GetElement("name-service-addresses");
if (xmlSub == null)
{
xmlSub = xmlCat.GetSafeElement("remote-addresses");
}
else
{
isNameService = true;
}
IAddressProviderFactory factory;
IXmlElement xmlProvider = xmlSub.GetElement("address-provider");
bool missing = xmlProvider == null;
bool empty = !missing && xmlProvider.IsEmpty;
if (empty || missing)
{
ConfigurableAddressProviderFactory factoryImpl =
new ConfigurableAddressProviderFactory();
factoryImpl.Config = missing ? xmlSub : xmlProvider;
factory = factoryImpl;
}
else
{
String name = xmlProvider.GetString();
factory = (IAddressProviderFactory)
OperationalContext.AddressProviderMap[name];
if (factory == null)
{
throw new ArgumentException("Address provider "
+ name + " not found.");
}
}
RemoteAddressProvider = factory.CreateAddressProvider();
if (RemoteAddressProvider is ConfigurableAddressProvider && ConnectTimeout > 0)
{
((ConfigurableAddressProvider)RemoteAddressProvider).RequestTimeout = ConnectTimeout;
}
IsNameService = isNameService;
if (isNameService)
{
Subport = (int)WellKnownSubPorts.NameService;
}
else
{
Subport = -1;
}
// <reuse-address>
IsLocalAddressReusable = xmlCat.GetSafeElement("reuse-address").
GetBoolean(IsLocalAddressReusable);
// <keep-alive-enabled/>
IsKeepAliveEnabled = xmlCat.GetSafeElement("keep-alive-enabled")
.
GetBoolean(IsKeepAliveEnabled);
// <tcp-delay-enabled>
IsTcpDelayEnabled = xmlCat.GetSafeElement("tcp-delay-enabled").
GetBoolean(IsTcpDelayEnabled);
// <receive-buffer-size>
ReceiveBufferSize = ParseMemorySize(
xmlCat, "receive-buffer-size", ReceiveBufferSize);
// <send-buffer-size>
SendBufferSize = ParseMemorySize(
xmlCat, "send-buffer-size", SendBufferSize);
// <linger-timeout>
LingerTimeout = ParseTime(
xmlCat, "linger-timeout", LingerTimeout);
}
}
