public static WcfTimeout Parse(string wcfTimeoutStr, WcfTimeout defaultTimeout = null)
{
WcfTimeout wcfTimeout = (defaultTimeout != null) ? defaultTimeout.Clone() : new WcfTimeout();
string[] array = wcfTimeoutStr.Split(new char[]
{
';'
});
foreach (string text in array)
{
string[] array3 = (from s in text.Split(new char[]
{
'='
})
select s.Trim()).ToArray <string>();
if (array3.Length > 1)
{
string text2 = array3[0];
string tsStr = array3[1];
string a;
if ((a = text2) != null)
{
if (!(a == "open"))
{
if (!(a == "close"))
{
if (!(a == "send"))
{
if (!(a == "receive"))
{
if (a == "operation")
{
wcfTimeout.Receive = WcfTimeout.StringToTimeSpan(tsStr, wcfTimeout.Receive);
}
}
else
{
wcfTimeout.Receive = WcfTimeout.StringToTimeSpan(tsStr, wcfTimeout.Receive);
}
}
else
{
wcfTimeout.Send = WcfTimeout.StringToTimeSpan(tsStr, wcfTimeout.Send);
}
}
else
{
wcfTimeout.Close = WcfTimeout.StringToTimeSpan(tsStr, wcfTimeout.Close);
}
}
else
{
wcfTimeout.Open = WcfTimeout.StringToTimeSpan(tsStr, wcfTimeout.Open);
}
}
}
}
return(wcfTimeout);
}
public AccessClientFactory(InstanceGroupConfig groupCfg, WcfTimeout timeout = null)
{
this.FactoryByTarget = new ConcurrentDictionary <string, Tuple <CachedChannelFactory <IDxStoreAccess>, IDxStoreAccessClient> >();
this.groupCfg = groupCfg;
this.DefaultTimeout = timeout;
if (groupCfg.Settings.IsUseHttpTransportForClientCommunication)
{
HttpConfiguration.Configure(this.groupCfg);
}
}
public static void SetTimeout(Binding binding, WcfTimeout timeout)
{
EndpointBuilder.IfHasValue <TimeSpan>(timeout.Open, delegate(TimeSpan t)
{
binding.OpenTimeout = t;
});
EndpointBuilder.IfHasValue <TimeSpan>(timeout.Close, delegate(TimeSpan t)
{
binding.CloseTimeout = t;
});
EndpointBuilder.IfHasValue <TimeSpan>(timeout.Send, delegate(TimeSpan t)
{
binding.SendTimeout = t;
});
EndpointBuilder.IfHasValue <TimeSpan>(timeout.Receive, delegate(TimeSpan t)
{
binding.ReceiveTimeout = t;
});
}
public ManagerClientFactory(InstanceManagerConfig managerConfig, WcfTimeout timeout = null)
{
this.FactoryByTarget = new ConcurrentDictionary <string, Tuple <CachedChannelFactory <IDxStoreManager>, DxStoreManagerClient> >();
this.managerConfig = managerConfig;
this.DefaultTimeout = timeout;
}
public static BasicHttpBinding CreateHttpBindingAndInitialize(string bindingName, WcfTimeout timeout, bool isServerBinding)
{
BasicHttpBinding basicHttpBinding = new BasicHttpBinding();
basicHttpBinding.Name = bindingName;
basicHttpBinding.MaxBufferPoolSize = (long)EndpointBuilder.MebiBytes(64);
basicHttpBinding.MaxBufferSize = EndpointBuilder.MebiBytes(64);
basicHttpBinding.MaxReceivedMessageSize = (long)EndpointBuilder.MebiBytes(64);
if (isServerBinding)
{
EndpointBuilder.SetReaderQuotas(basicHttpBinding.ReaderQuotas);
}
else
{
EndpointBuilder.SetTimeout(basicHttpBinding, timeout);
}
return(basicHttpBinding);
}
public static Binding CreateBindingAndInitialize(string address, string bindingName, WcfTimeout timeout, bool isServerBinding)
{
string a = address.Substring(0, address.IndexOf(':'));
Binding result;
if (Utils.IsEqual(a, "http", StringComparison.OrdinalIgnoreCase))
{
result = EndpointBuilder.CreateHttpBindingAndInitialize(bindingName, timeout, isServerBinding);
}
else if (Utils.IsEqual(a, "net.tcp", StringComparison.OrdinalIgnoreCase))
{
result = EndpointBuilder.CreateNettcpBindingAndInitialize(bindingName, timeout, isServerBinding);
}
else
{
if (!Utils.IsEqual(a, "net.pipe", StringComparison.OrdinalIgnoreCase))
{
throw new DxStoreBindingNotSupportedException(address);
}
result = EndpointBuilder.CreateNamedPipeBindingAndInitialize(bindingName, timeout, isServerBinding);
}
return(result);
}
public static ServiceEndpoint GetStoreInstanceEndpoint(InstanceGroupConfig cfg, string target, bool isUseDefaultGroup, bool isServerBinding, WcfTimeout timeout = null)
{
string storeInstanceEndPointAddress = cfg.GetStoreInstanceEndPointAddress(target, isUseDefaultGroup);
string bindingName = cfg.ConstructUniqueInstanceBindingName(target, isUseDefaultGroup);
timeout = (timeout ?? cfg.Settings.StoreInstanceWcfTimeout);
return(EndpointBuilder.ConstructAndInitializeEndpoint(typeof(IDxStoreInstance), storeInstanceEndPointAddress, bindingName, timeout, isServerBinding));
}
public static ServiceEndpoint GetStoreManagerEndpoint(InstanceManagerConfig cfg, string target, bool isServerBinding, WcfTimeout timeout = null)
{
string endPointAddress = cfg.GetEndPointAddress(target);
string bindingName = cfg.ConstructUniqueBindingName(target);
timeout = (timeout ?? cfg.DefaultTimeout);
return(EndpointBuilder.ConstructAndInitializeEndpoint(typeof(IDxStoreManager), endPointAddress, bindingName, timeout, isServerBinding));
}
public static ServiceEndpoint ConstructAndInitializeEndpoint(Type interfaceType, string address, string bindingName, WcfTimeout timeout, bool isServerBinding)
{
Binding binding = EndpointBuilder.CreateBindingAndInitialize(address, bindingName, timeout, isServerBinding);
return(new ServiceEndpoint(ContractDescription.GetContract(interfaceType), binding, new EndpointAddress(address)));
}
public static NetTcpBinding CreateNettcpBindingAndInitialize(string bindingName, WcfTimeout timeout, bool isServerBinding)
{
NetTcpBinding netTcpBinding = new NetTcpBinding();
netTcpBinding.Name = bindingName;
netTcpBinding.MaxBufferPoolSize = (long)EndpointBuilder.MebiBytes(64);
netTcpBinding.MaxBufferSize = EndpointBuilder.MebiBytes(64);
netTcpBinding.MaxReceivedMessageSize = (long)EndpointBuilder.MebiBytes(64);
netTcpBinding.MaxConnections = 200;
if (isServerBinding)
{
netTcpBinding.PortSharingEnabled = true;
EndpointBuilder.SetReaderQuotas(netTcpBinding.ReaderQuotas);
}
else
{
EndpointBuilder.SetTimeout(netTcpBinding, timeout);
EndpointBuilder.SetBindingSecurity(netTcpBinding.Security);
}
return(netTcpBinding);
}
public static Dictionary <string, ServiceEndpoint> GetAllMemberAccessClientEndPoints(this InstanceGroupConfig cfg, bool isUseDefaultGroup = false, WcfTimeout timeout = null)
{
Dictionary <string, ServiceEndpoint> dictionary = new Dictionary <string, ServiceEndpoint>();
foreach (InstanceGroupMemberConfig instanceGroupMemberConfig in cfg.Members)
{
ServiceEndpoint storeAccessEndpoint = cfg.GetStoreAccessEndpoint(instanceGroupMemberConfig.Name, false, false, timeout ?? cfg.Settings.StoreAccessWcfTimeout);
dictionary[instanceGroupMemberConfig.Name] = storeAccessEndpoint;
}
return(dictionary);
}
internal static WcfTimeout GetWcfTimeoutProperty(RegistryKey key, string propertyName, WcfTimeout defaultTimeout)
{
string property = RegUtils.GetProperty <string>(key, propertyName, string.Empty);
return(WcfTimeout.Parse(property, defaultTimeout));
}
public virtual ServiceEndpoint GetStoreInstanceEndpoint(string target, bool isUseDefaultGroup, bool isServerBinding, WcfTimeout timeout = null)
{
return(EndpointBuilder.GetStoreInstanceEndpoint(this, target, isUseDefaultGroup, isServerBinding, timeout));
}
public InstanceClientFactory(InstanceGroupConfig groupCfg, WcfTimeout timeout = null)
{
this.FactoryByTarget = new ConcurrentDictionary <string, Tuple <CachedChannelFactory <IDxStoreInstance>, DxStoreInstanceClient> >();
this.groupCfg = groupCfg;
this.DefaultTimeout = timeout;
}
public CommonSettings CreateDefaultCommonSettings(int defaultEndPointPortNumber, string defaultProtocolName, WcfTimeout defaultTimeout)
{
CommonSettings input = new CommonSettings
{
InstanceProcessName = this.DefaultInstanceProcessFullPath,
AccessEndpointPortNumber = defaultEndPointPortNumber,
AccessEndpointProtocolName = defaultProtocolName,
StoreAccessWcfTimeout = defaultTimeout,
StoreAccessHttpTimeoutInMSec = 60000,
InstanceEndpointPortNumber = defaultEndPointPortNumber,
InstanceEndpointProtocolName = defaultProtocolName,
StoreInstanceWcfTimeout = defaultTimeout,
DurationToWaitBeforeRestart = TimeSpan.FromMinutes(2.0),
InstanceHealthCheckPeriodicInterval = TimeSpan.FromSeconds(30.0),
TruncationPeriodicCheckInterval = TimeSpan.FromSeconds(15.0),
TruncationLimit = 1000,
TruncationPaddingLength = 500,
StateMachineStopTimeout = TimeSpan.FromSeconds(30.0),
LeaderPromotionTimeout = TimeSpan.FromSeconds(30.0),
PaxosCommandExecutionTimeout = TimeSpan.FromSeconds(30.0),
GroupHealthCheckDuration = TimeSpan.FromSeconds(15.0),
GroupHealthCheckAggressiveDuration = TimeSpan.FromSeconds(10.0),
GroupStatusWaitTimeout = TimeSpan.FromSeconds(15.0),
MaxEntriesToKeep = 10,
MaximumAllowedInstanceNumberLag = 5,
DefaultHealthCheckRequiredNodePercent = 51,
MemberReconfigureTimeout = TimeSpan.FromSeconds(30.0),
PaxosUpdateTimeout = TimeSpan.FromSeconds(30.0),
SnapshotUpdateInterval = TimeSpan.FromSeconds(30.0),
PeriodicExceptionLoggingDuration = TimeSpan.FromMinutes(5.0),
PeriodicTimeoutLoggingDuration = TimeSpan.FromMinutes(5.0),
ServiceHostCloseTimeout = TimeSpan.FromSeconds(60.0),
MaxAllowedLagToCatchup = 200,
DefaultSnapshotFileName = "DxStoreSnapshot.xml",
IsAllowDynamicReconfig = false,
IsAppendOnlyMembership = true,
IsKillInstanceProcessWhenParentDies = true,
AdditionalLogOptions = LogOptions.None,
InstanceStartHoldUpDuration = TimeSpan.FromHours(1.0),
InstanceStartHoldupDurationMaxAllowedStarts = 10,
InstanceStartSilenceDuration = TimeSpan.FromMinutes(5.0),
InstanceMemoryCommitSizeLimitInMb = 500,
IsUseHttpTransportForInstanceCommunication = true,
IsUseHttpTransportForClientCommunication = true,
IsUseBinarySerializerForClientCommunication = false,
IsUseEncryption = true,
StartupDelay = TimeSpan.Zero
};
return(this.UpdateDefaultCommonSettings(input));
}
public virtual ServiceEndpoint GetEndpoint(string target, bool isServerBinding, WcfTimeout timeout = null)
{
return(EndpointBuilder.GetStoreManagerEndpoint(this, target, isServerBinding, timeout));
}
