public IPEndPoint GetMemcachedEndPoint()
{
var hostName = Hostname.Replace(HostToken, LocalHost);
hostName = hostName.Replace(ViewPort, Ports.Direct.ToString(CultureInfo.InvariantCulture));
return(IPEndPointExtensions.GetEndPoint(hostName));
}
private unsafe IPEndPoint Start(QuicListenerOptions options)
{
List <SslApplicationProtocol> applicationProtocols = options.ServerAuthenticationOptions !.ApplicationProtocols !;
IPEndPoint listenEndPoint = options.ListenEndPoint !;
Internals.SocketAddress address = IPEndPointExtensions.Serialize(listenEndPoint);
Debug.Assert(_stateHandle.IsAllocated);
try
{
Debug.Assert(!Monitor.IsEntered(_state), "!Monitor.IsEntered(_state)");
using var msquicBuffers = new MsQuicBuffers();
msquicBuffers.Initialize(applicationProtocols, applicationProtocol => applicationProtocol.Protocol);
// TODO: is the layout same for SocketAddress.Buffer and QuicAddr?
// TODO: maybe add simple extensions/helpers:
// - QuicAddr ToQuicAddr(this IPEndPoint ipEndPoint)
// - IPEndPoint ToIPEndPoint(this ref QuicAddr quicAddress)
fixed(byte *paddress = address.Buffer)
{
ThrowIfFailure(MsQuicApi.Api.ApiTable->ListenerStart(
_state.Handle.QuicHandle,
msquicBuffers.Buffers,
(uint)applicationProtocols.Count,
(QuicAddr *)paddress), "ListenerStart failed");
}
}
catch
{
_stateHandle.Free();
throw;
}
Debug.Assert(!Monitor.IsEntered(_state), "!Monitor.IsEntered(_state)");
return(MsQuicParameterHelpers.GetIPEndPointParam(MsQuicApi.Api, _state.Handle, QUIC_PARAM_LISTENER_LOCAL_ADDRESS));
}
public void When_Replica_Index_Postive_LocatePrimary_Returns_It()
{
var server = new Server(
new FakeIOService(IPEndPointExtensions.GetEndPoint("127.0.0.1:8091"),
new FakeConnectionPool(), false),
new NodeAdapter(new Node {
Hostname = "127.0.0.1"
},
new NodeExt()),
new ClientConfiguration(),
new BucketConfig {
Name = "default"
},
new FakeTranscoder());
var vbucket =
new VBucket(new Dictionary <IPAddress, IServer>
{
{ IPEndPointExtensions.GetEndPoint("127.0.0.1:10210").Address, server },
{ IPEndPointExtensions.GetEndPoint("127.0.0.2:10210").Address, server }
},
100, -1, new[] { 0 }, 0, new VBucketServerMap {
ServerList = new[] { "127.0.0.1:10210", "127.0.0.2:10210" }
});
var found = vbucket.LocatePrimary();
Assert.IsNotNull(found);
}
public override void LoadConfig()
{
var servers = new List <IServer>();
var clientBucketConfig = ClientConfig.BucketConfigs[BucketConfig.Name];
var nodes = BucketConfig.GetNodes();
foreach (var adapter in nodes)
{
var endpoint = IPEndPointExtensions.GetEndPoint(adapter, clientBucketConfig, BucketConfig);
try
{
var connectionPool = ConnectionPoolFactory(clientBucketConfig.PoolConfiguration, endpoint);
var ioStrategy = IOStrategyFactory(connectionPool);
var server = new Core.Server(ioStrategy, adapter, ClientConfig, BucketConfig);
var saslMechanism = SaslFactory(BucketConfig.Name, BucketConfig.Password, ioStrategy, Transcoder);
ioStrategy.SaslMechanism = saslMechanism;
servers.Add(server);
}
catch (Exception e)
{
Log.ErrorFormat("Could not add server {0}. Exception: {1}", endpoint, e);
}
}
var old = Interlocked.Exchange(ref Servers, servers);
if (old != null)
{
old.ForEach(x => x.Dispose());
old.Clear();
}
Interlocked.Exchange(ref KeyMapper, new KetamaKeyMapper(Servers));
}
public void When_Replica_Index_Postive_LocatePrimary_Returns_It()
{
var mockBucketConfig = new Mock <IBucketConfig>();
var server = new Server(
new FakeIOService(IPEndPointExtensions.GetEndPoint("127.0.0.1:8091"),
new FakeConnectionPool(), false),
new NodeAdapter(new Node {
Hostname = "127.0.0.1"
}, new NodeExt(), mockBucketConfig.Object),
new FakeTranscoder(),
ContextFactory.GetCouchbaseContext());
var vbucket =
new VBucket(new Dictionary <IPEndPoint, IServer>
{
{ IPEndPointExtensions.GetEndPoint("127.0.0.1:10210"), server },
{ IPEndPointExtensions.GetEndPoint("127.0.0.2:10210"), server }
},
100, -1, new[] { 0 }, 0, new VBucketServerMap {
ServerList = new[] { "127.0.0.1:10210", "127.0.0.2:10210" }
}, "default");
var found = vbucket.LocatePrimary();
Assert.IsNotNull(found);
}
public void Test_Authenticate(bool isAuthenticated, bool isEncrypted, bool isSigned)
{
var endpoint = IPEndPointExtensions.GetEndPoint(TestConfiguration.Settings.Hostname, 11207);
var bootstrapUri = new Uri($@"https://{endpoint.Address}:8091/pools");
var socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
socket.Connect(endpoint);
var poolConfig = new PoolConfiguration {
UseSsl = true, Uri = bootstrapUri, ClientConfiguration = new ClientConfiguration()
};
var sslStream = new Mock <SslStream>(new MemoryStream(), true, new RemoteCertificateValidationCallback(ServerCertificateValidationCallback));
sslStream.Setup(x => x.IsAuthenticated).Returns(isAuthenticated);
sslStream.Setup(x => x.IsEncrypted).Returns(isEncrypted);
sslStream.Setup(x => x.IsSigned).Returns(isSigned);
var connPool = new Mock <IConnectionPool <IConnection> >();
connPool.Setup(x => x.Configuration).Returns(poolConfig);
var conn = new SslConnection(connPool.Object, socket, sslStream.Object, new DefaultConverter(),
new BufferAllocator(1024, 1024));
if (isAuthenticated && isEncrypted && isSigned)
{
Assert.DoesNotThrow(conn.Authenticate);
}
else
{
Assert.Throws <AuthenticationException>(conn.Authenticate);
}
}
public void When_Hostname_Is_Provided_IPAdress_Is_Returned()
{
var hostname = "127.0.0.1:8091";
var expected = "127.0.0.1";
var actual = IPEndPointExtensions.GetEndPoint(hostname);
Assert.AreEqual(expected, actual.Address.ToString());
}
/// <summary>
/// Loads the most updated configuration creating any resources as needed.
/// </summary>
/// <param name="bucketConfig">The latest <see cref="IBucketConfig"/>
/// that will drive the recreation if the configuration context.</param>
public override void LoadConfig(IBucketConfig bucketConfig, bool force = false)
{
try
{
Lock.EnterWriteLock();
if (bucketConfig == null)
{
throw new ArgumentNullException("bucketConfig");
}
if (BucketConfig == null || !BucketConfig.Nodes.AreEqual <Node>(bucketConfig.Nodes) || !Servers.Any() ||
force)
{
Log.Info(m => m("o1-Creating the Servers {0} list using rev#{1}", Servers.Count(), bucketConfig.Rev));
var clientBucketConfig = ClientConfig.BucketConfigs[bucketConfig.Name];
var servers = new List <IServer>();
var nodes = bucketConfig.GetNodes();
foreach (var adapter in nodes)
{
var endpoint = IPEndPointExtensions.GetEndPoint(adapter, clientBucketConfig, BucketConfig);
try
{
var poolConfiguration = ClientConfig.BucketConfigs[bucketConfig.Name].PoolConfiguration;
var connectionPool = ConnectionPoolFactory(poolConfiguration, endpoint);
var ioStrategy = IOStrategyFactory(connectionPool);
var saslMechanism = SaslFactory(bucketConfig.Name, bucketConfig.Password, ioStrategy, Converter);
ioStrategy.SaslMechanism = saslMechanism;
var server = new Core.Server(ioStrategy, adapter, ClientConfig, bucketConfig);
servers.Add(server);
}
catch (Exception e)
{
Log.ErrorFormat("Could not add server {0}. Exception: {1}", endpoint, e);
}
}
var old = Interlocked.Exchange(ref Servers, servers);
if (old != null)
{
old.ForEach(x => x.Dispose());
old.Clear();
}
}
Log.Info(m => m("Creating the KeyMapper list using rev#{0}", bucketConfig.Rev));
Interlocked.Exchange(ref _bucketConfig, bucketConfig);
Interlocked.Exchange(ref KeyMapper, new VBucketKeyMapper(Servers, _bucketConfig.VBucketServerMap)
{
Rev = _bucketConfig.Rev
});
}
catch (Exception e)
{
Log.Error(e);
}
finally
{
Lock.ExitWriteLock();
}
}
public static string Connect(IPEndPoint EndPoint, out DateTime LastSeen)
{
LastSeen = DateTime.MinValue;
if (EndPoint == null || EndPoint.Address == null)
{
return("");
}
MySqlConnection ConX = null;
bool openConX = ConX == null;
if (openConX)
{
ConX = new MySqlConnection(DBOps.ConnectionString);
ConX.Open();
}
uint ip = IPEndPointExtensions.ToUint32(EndPoint);
string hash = IPEndPointExtensions.CalculateHash(EndPoint);
string sql = @"INSERT IGNORE INTO geo (ClientHash,IPAddress) VALUES (@ClientHash,@IPAddress);";
using (var cmd = new MySqlCommand(sql, ConX))
{
cmd.Parameters.AddWithValue("ClientHash", hash);
cmd.Parameters.AddWithValue("IPAddress", ip);
cmd.ExecuteNonQuery();
cmd.CommandText = @"UPDATE geo gg
JOIN geo g ON gg.ClientHash=g.ClientHash
SET gg.IPAddress=@IPAddress
WHERE g.IPAddress IS NULL
AND g.Geo IS NULL
AND g.ClientHash=@ClientHash;";
cmd.ExecuteNonQuery();
}
sql = @"SELECT MAX(`Timestamp`) AS ts
FROM stats
WHERE ClientHash=@ClientHash;";
using (var cmd = new MySqlCommand(sql, ConX))
{
cmd.Parameters.AddWithValue("ClientHash", hash);
using (var rdr = cmd.ExecuteReader())
{
while (rdr.Read())
{
LastSeen = rdr.GetDateTimeSafe("ts");
break;
}
}
}
if (openConX)
{
ConX.Close();
}
return(hash);
}
public void LoadConfig(IOStrategy ioStrategy)
{
try
{
Lock.EnterWriteLock();
Log.Info(m => m("o2-Creating the Servers list using rev#{0}", BucketConfig.Rev));
var clientBucketConfig = ClientConfig.BucketConfigs[BucketConfig.Name];
var servers = new List <IServer>();
var nodes = BucketConfig.GetNodes();
foreach (var adapter in nodes)
{
var endpoint = IPEndPointExtensions.GetEndPoint(adapter, clientBucketConfig, BucketConfig);
try
{
IServer server = null;
if (Equals(ioStrategy.EndPoint, endpoint) || nodes.Count() == 1)
{
server = new Core.Server(ioStrategy, adapter, ClientConfig, BucketConfig);
}
else
{
var poolConfig = ClientConfig.BucketConfigs[BucketConfig.Name].PoolConfiguration;
var connectionPool = ConnectionPoolFactory(poolConfig, endpoint);
var newIoStrategy = IOStrategyFactory(connectionPool);
var saslMechanism = SaslFactory(BucketConfig.Name, BucketConfig.Password, newIoStrategy, Converter);
newIoStrategy.SaslMechanism = saslMechanism;
server = new Core.Server(newIoStrategy, adapter, ClientConfig, BucketConfig);
}
servers.Add(server);
}
catch (Exception e)
{
Log.ErrorFormat("Could not add server {0}. Exception: {1}", endpoint, e);
}
}
Log.Info(m => m("Creating the KeyMapper list using rev#{0}", BucketConfig.Rev));
var old = Interlocked.Exchange(ref Servers, servers);
if (old != null)
{
old.ForEach(x => x.Dispose());
old.Clear();
}
Interlocked.Exchange(ref KeyMapper, new VBucketKeyMapper(Servers, BucketConfig.VBucketServerMap)
{
Rev = BucketConfig.Rev
});
}
finally
{
Lock.ExitWriteLock();
}
}
internal static unsafe QuicAddr ToQuicAddr(this IPEndPoint iPEndPoint)
{
// TODO: is the layout same for SocketAddress.Buffer and QuicAddr on all platforms?
QuicAddr result = default;
Span <byte> rawAddress = MemoryMarshal.AsBytes(MemoryMarshal.CreateSpan(ref result, 1));
Internals.SocketAddress address = IPEndPointExtensions.Serialize(iPEndPoint);
Debug.Assert(address.Size <= rawAddress.Length);
address.Buffer.AsSpan(0, address.Size).CopyTo(rawAddress);
return(result);
}
/// <summary>
/// Gets the <see cref="T:System.Net.IPEndPoint" /> for the KV port for this node.
/// </summary>
/// <param name="port">The port for the <see cref="T:System.Net.IPEndPoint" /></param>
/// <returns>
/// An <see cref="T:System.Net.IPEndPoint" /> with the port passed in.
/// </returns>
public IPEndPoint GetIPEndPoint(int port)
{
var key = Hostname + ":" + port;
if (!_cachedEndPoints.TryGetValue(key, out var endPoint))
{
endPoint = IPEndPointExtensions.GetEndPoint(Hostname, port);
IsIPv6 = endPoint.AddressFamily == AddressFamily.InterNetworkV6;
_cachedEndPoints.TryAdd(key, endPoint);
}
return(endPoint);
}
/// <summary>
/// Gets the <see cref="IPEndPoint" /> for the KV port for this node.
/// </summary>
/// <param name="port">The port for the <see cref="IPEndPoint" /></param>
/// <returns>
/// An <see cref="IPEndPoint" /> with the port passed in.
/// </returns>
public IPEndPoint GetIPEndPoint(int port)
{
var key = Hostname + ":" + port;
IPEndPoint endPoint;
if (!_cachedEndPoints.TryGetValue(key, out endPoint))
{
endPoint = IPEndPointExtensions.GetEndPoint(Hostname + ":" + port);
_cachedEndPoints.TryAdd(key, endPoint);
}
return(endPoint);
}
public void When_NodeExt_And_UseSsl_Is_True_And_IPv6_IPEndpoint_Uses_Port_11207()
{
var serverConfigJson = ResourceHelper.ReadResource("Data\\Configuration\\config-with-nodes-ext.json");
var serverConfig = JsonConvert.DeserializeObject <BucketConfig>(serverConfigJson);
var clientConfig = new BucketConfiguration {
UseSsl = true
};
const string expected = "192.168.56.101:11207";
var actual = IPEndPointExtensions.GetEndPoint(serverConfig.NodesExt[0].Hostname);
Assert.AreEqual(expected, actual.ToString());
}
public void When_NodeAdapter_And_UseSsl_Is_True_IPEndPoint_Uses_Port_11210()
{
var serverConfigJson = ResourceHelper.ReadResource("Data\\Configuration\\config-with-nodes-ext.json");
var serverConfig = JsonConvert.DeserializeObject <BucketConfig>(serverConfigJson);
var clientConfig = new BucketConfiguration {
UseSsl = false
};
const string expected = "192.168.56.102:11210";
var actual = IPEndPointExtensions.GetEndPoint(serverConfig.GetNodes()[0], clientConfig, serverConfig);
Assert.AreEqual(expected, actual.ToString());
}
public void When_Node_And_UseSsl_Is_True_IPEndPoint_Uses_Port_11207()
{
var serverConfigJson = File.ReadAllText("Data\\Configuration\\config-with-nodes-ext.json");
var serverConfig = JsonConvert.DeserializeObject <BucketConfig>(serverConfigJson);
var clientConfig = new BucketConfiguration {
UseSsl = true
};
const string expected = "192.168.56.101:11207";
var actual = IPEndPointExtensions.GetEndPoint(serverConfig.Nodes[0], clientConfig, serverConfig);
Assert.AreEqual(expected, actual.ToString());
}
// ReSharper disable once InconsistentNaming
private void EnsureIPEndPointsAreLoaded()
{
lock (_syncObj)
{
if (_ipEndPoints == null || !_ipEndPoints.Any())
{
_ipEndPoints = new List <IPEndPoint>();
foreach (var server in ServerList)
{
_ipEndPoints.Add(IPEndPointExtensions.GetEndPoint(server));
}
}
}
}
public void When_LocalHost_And_CB251_Verify_Ports()
{
var bucketConfig =
JsonConvert.DeserializeObject <BucketConfig>(
File.ReadAllText("Data\\Configuration\\carrier-publication-config.json"));
var nodes = bucketConfig.GetNodes();
Assert.AreEqual(8091, nodes[0].MgmtApi);
Assert.AreEqual(8092, nodes[0].Views);
Assert.AreEqual(18091, nodes[0].MgmtApiSsl);
Assert.AreEqual(18092, nodes[0].ViewsSsl);
Assert.AreEqual(11210, nodes[0].KeyValue);
Assert.AreEqual(11207, nodes[0].KeyValueSsl);
Assert.AreEqual(IPEndPointExtensions.GetEndPoint(@"127.0.0.1:8092"), nodes[0].GetIPEndPoint(8092));
}
public void Test_Authenticate_With_Ssl()
{
var endpoint = IPEndPointExtensions.GetEndPoint(TestConfiguration.Settings.Hostname, 11207);
var bootstrapUri = new Uri($@"https://{endpoint.Address}:8091/pools");
var connFactory = DefaultConnectionFactory.GetGeneric <SslConnection>();
var poolFactory = ConnectionPoolFactory.GetFactory();
ClientConfiguration.IgnoreRemoteCertificateNameMismatch = true;
var poolConfig = new PoolConfiguration {
UseSsl = true, Uri = bootstrapUri, ClientConfiguration = new ClientConfiguration()
};
var pool = poolFactory(poolConfig, endpoint);
var conn = connFactory((IConnectionPool <SslConnection>)pool, new DefaultConverter(), new BufferAllocator(1024 * 16, 1024 * 16));
Assert.IsTrue(conn.IsConnected);
}
internal static unsafe void SetIPEndPointParam(MsQuicApi api, SafeHandle nativeObject, uint param, IPEndPoint value)
{
Internals.SocketAddress socketAddress = IPEndPointExtensions.Serialize(value);
// MsQuic always reads same amount of memory as if IPv6 was used, so we can't pass pointer to socketAddress.Buffer directly
Span <byte> address = stackalloc byte[Internals.SocketAddress.IPv6AddressSize];
socketAddress.Buffer.AsSpan(0, socketAddress.Size).CopyTo(address);
address.Slice(socketAddress.Size).Clear();
fixed(byte *paddress = &MemoryMarshal.GetReference(address))
{
QuicExceptionHelpers.ThrowIfFailed(
api.SetParamDelegate(nativeObject, param, (uint)address.Length, paddress),
"Could not set IPEndPoint");
}
}
public Stats(DateTime timestamp, string ipAddress, string Page, string Frame)
{
Timestamp = timestamp;
int pageNo;
int.TryParse(Page, out pageNo);
if (pageNo < 0)
{
throw new InvalidDataException("Invalid page number");
}
PageNo = pageNo;
int frameNo = ((Frame ?? "").Trim() + " ")[0] - 'a';
if (frameNo < 0 || frameNo > 25)
{
throw new InvalidDataException("Invalid frame number");
}
FrameNo = frameNo;
IPAddress = IPAddress.Parse(ipAddress);
ClientHash = IPEndPointExtensions.CalculateHash(ipAddress);
}
protected override void OnStart(string[] args)
{
Log.DebugFormat("Starting...");
try
{
var configuration = ServerConfiguration.ReadOrCreate(Constants.ApplicationConfigurationFile);
_repository = PluginRepository.Create();
var repositoryProxy = new PluginRepositoryProxy(_repository, configuration);
var ep = IPEndPointExtensions.Parse(configuration.Address);
_server = new Server(ep, repositoryProxy);
Log.InfoFormat("Started");
}
catch (Exception e)
{
Log.ErrorFormat("Caught unexpected exception while trying to start: {0}", e);
throw;
}
}
internal IVBucket GetVBucket()
{
var bucketConfig = ConfigUtil.ServerConfig.Buckets.First(x => x.Name == "default");
var vBucketServerMap = bucketConfig.VBucketServerMap;
var servers = new Dictionary <IPAddress, IServer>();
foreach (var node in bucketConfig.GetNodes())
{
servers.Add(IPEndPointExtensions.GetEndPoint(node.Hostname + ":" + node.KeyValue).Address,
new Server(_ioService,
node,
new ClientConfiguration(), bucketConfig,
new FakeTranscoder()));
}
var vBucketMap = vBucketServerMap.VBucketMap.First();
var primary = vBucketMap[0];
var replicas = new int[] { vBucketMap[1] };
return(new VBucket(servers, 0, primary, replicas, bucketConfig.Rev, vBucketServerMap));
}
public static bool Update(DateTime Timestamp, string IPAddress, int Page, int Frame)
{
if (Timestamp == DateTime.MinValue || string.IsNullOrWhiteSpace(IPAddress) || (Page < 0 && Frame < 0))
{
return(false);
}
uint ip = IPEndPointExtensions.ToUint32(IPAddress);
if (ip == 0)
{
return(false);
}
MySqlConnection ConX = null;
bool openConX = ConX == null;
if (openConX)
{
ConX = new MySqlConnection(DBOps.ConnectionString);
ConX.Open();
}
string hash = IPEndPointExtensions.CalculateHash(IPAddress);
string sql = @"INSERT INTO stats (ClientHash,Timestamp,PageNo,FrameNo)
VALUES (@ClientHash,@Timestamp,@PageNo,@FrameNo);";
var cmd = new MySqlCommand(sql, ConX);
cmd.Parameters.AddWithValue("ClientHash", hash);
cmd.Parameters.AddWithValue("Timestamp", Timestamp);
cmd.Parameters.AddWithValue("PageNo", Page);
cmd.Parameters.AddWithValue("FrameNo", Frame);
cmd.ExecuteNonQuery();
if (openConX)
{
ConX.Close();
}
return(true);
}
internal IVBucket GetVBucket()
{
var bucketConfig = ConfigUtil.ServerConfig.Buckets.First(x => x.Name == "default");
var vBucketServerMap = bucketConfig.VBucketServerMap;
var servers = new Dictionary <IPEndPoint, IServer>();
foreach (var node in bucketConfig.GetNodes())
{
servers.Add(IPEndPointExtensions.GetEndPoint(node.Hostname + ":" + node.KeyValue),
new Server(IOService,
node,
new FakeTranscoder(),
ContextFactory.GetCouchbaseContext(bucketConfig)));
}
var vBucketMap = vBucketServerMap.VBucketMap.First();
var primary = vBucketMap[0];
var replicas = new [] { vBucketMap[1] };
return(new VBucket(servers, 0, primary, replicas, bucketConfig.Rev, vBucketServerMap, "default"));
}
private int SendEcho(IPAddress address, byte[] buffer, int timeout, PingOptions options, bool isAsync)
{
Interop.IpHlpApi.IPOptions ipOptions = new Interop.IpHlpApi.IPOptions(options);
if (!_ipv6)
{
return((int)Interop.IpHlpApi.IcmpSendEcho2(
_handlePingV4,
GetWaitHandle(isAsync),
IntPtr.Zero,
IntPtr.Zero,
#pragma warning disable CS0618 // Address is marked obsolete
(uint)address.Address,
#pragma warning restore CS0618
_requestBuffer,
(ushort)buffer.Length,
ref ipOptions,
_replyBuffer,
MaxUdpPacket,
(uint)timeout));
}
IPEndPoint ep = new IPEndPoint(address, 0);
Internals.SocketAddress remoteAddr = IPEndPointExtensions.Serialize(ep);
byte[] sourceAddr = new byte[28];
return((int)Interop.IpHlpApi.Icmp6SendEcho2(
_handlePingV6,
GetWaitHandle(isAsync),
IntPtr.Zero,
IntPtr.Zero,
sourceAddr,
remoteAddr.Buffer,
_requestBuffer,
(ushort)buffer.Length,
ref ipOptions,
_replyBuffer,
MaxUdpPacket,
(uint)timeout));
}
private unsafe IPEndPoint Start(QuicListenerOptions options)
{
List <SslApplicationProtocol> applicationProtocols = options.ServerAuthenticationOptions !.ApplicationProtocols !;
IPEndPoint listenEndPoint = options.ListenEndPoint !;
Internals.SocketAddress address = IPEndPointExtensions.Serialize(listenEndPoint);
uint status;
Debug.Assert(_stateHandle.IsAllocated);
MemoryHandle[]? handles = null;
QuicBuffer[]? buffers = null;
try
{
Debug.Assert(!Monitor.IsEntered(_state), "!Monitor.IsEntered(_state)");
MsQuicAlpnHelper.Prepare(applicationProtocols, out handles, out buffers);
fixed(byte *paddress = address.Buffer)
{
status = MsQuicApi.Api.ListenerStartDelegate(_state.Handle, (QuicBuffer *)Marshal.UnsafeAddrOfPinnedArrayElement(buffers, 0), (uint)applicationProtocols.Count, paddress);
}
}
catch
{
_stateHandle.Free();
throw;
}
finally
{
MsQuicAlpnHelper.Return(ref handles, ref buffers);
}
QuicExceptionHelpers.ThrowIfFailed(status, "ListenerStart failed.");
Debug.Assert(!Monitor.IsEntered(_state), "!Monitor.IsEntered(_state)");
return(MsQuicParameterHelpers.GetIPEndPointParam(MsQuicApi.Api, _state.Handle, (uint)QUIC_PARAM_LISTENER.LOCAL_ADDRESS));
}
public void LoadConfig_When_Reused_Server_Use_Latest_NodeAdapter_Settings()
{
var initialConfig = JsonConvert.DeserializeObject <BucketConfig>(
ResourceHelper.ReadResource(@"Data\config-rev-46.json"));
var mockConnectionPool = new Mock <IConnectionPool>();
var mockIoService = new Mock <IIOService>();
mockIoService.Setup(x => x.ConnectionPool).Returns(mockConnectionPool.Object);
mockIoService.Setup(x => x.SupportsEnhancedDurability).Returns(true);
var mockSasl = new Mock <ISaslMechanism>();
var clientConfig = new ClientConfiguration();
var context = new CouchbaseConfigContext(
initialConfig,
clientConfig,
p => mockIoService.Object,
(a, b) => mockConnectionPool.Object,
(a, b, c, d) => mockSasl.Object,
new DefaultTranscoder(),
null, null);
context.LoadConfig();
var server = context.GetServers().First(x => Equals(x.EndPoint, IPEndPointExtensions.GetEndPoint("172.23.120.212", 0)));
Assert.IsFalse(server.IsQueryNode);
var newConfig = JsonConvert.DeserializeObject <BucketConfig>(
ResourceHelper.ReadResource(@"Data\config-rev-60.json"));
// load first config with single node
context.LoadConfig(newConfig);
server = context.GetServers().First(x => Equals(x.EndPoint, IPEndPointExtensions.GetEndPoint("172.23.120.212", 0)));
Assert.IsTrue(server.IsQueryNode);
}
public CachedSerializedEndPoint(IPAddress address)
{
IPEndPoint = new IPEndPoint(address, 0);
SocketAddress = IPEndPointExtensions.Serialize(IPEndPoint);
}
// Any exceptions that escape synchronously will be caught by the caller and wrapped in a PingException.
// We do not need to or want to capture such exceptions into the returned task.
private Task <PingReply> SendPingAsyncCore(IPAddress address, byte[] buffer, int timeout, PingOptions options)
{
var tcs = new TaskCompletionSource <PingReply>();
_taskCompletionSource = tcs;
_ipv6 = (address.AddressFamily == AddressFamily.InterNetworkV6);
_sendSize = buffer.Length;
// Get and cache correct handle.
if (!_ipv6 && _handlePingV4 == null)
{
_handlePingV4 = Interop.IpHlpApi.IcmpCreateFile();
if (_handlePingV4.IsInvalid)
{
_handlePingV4 = null;
throw new Win32Exception(); // Gets last error.
}
}
else if (_ipv6 && _handlePingV6 == null)
{
_handlePingV6 = Interop.IpHlpApi.Icmp6CreateFile();
if (_handlePingV6.IsInvalid)
{
_handlePingV6 = null;
throw new Win32Exception(); // Gets last error.
}
}
var ipOptions = new Interop.IpHlpApi.IPOptions(options);
if (_replyBuffer == null)
{
_replyBuffer = SafeLocalAllocHandle.LocalAlloc(MaxUdpPacket);
}
// Queue the event.
int error;
try
{
if (_pingEvent == null)
{
_pingEvent = new ManualResetEvent(false);
}
else
{
_pingEvent.Reset();
}
_registeredWait = ThreadPool.RegisterWaitForSingleObject(_pingEvent, (state, _) => ((Ping)state).PingCallback(), this, -1, true);
SetUnmanagedStructures(buffer);
if (!_ipv6)
{
SafeWaitHandle pingEventSafeWaitHandle = _pingEvent.GetSafeWaitHandle();
error = (int)Interop.IpHlpApi.IcmpSendEcho2(
_handlePingV4,
pingEventSafeWaitHandle,
IntPtr.Zero,
IntPtr.Zero,
(uint)address.GetAddress(),
_requestBuffer,
(ushort)buffer.Length,
ref ipOptions,
_replyBuffer,
MaxUdpPacket,
(uint)timeout);
}
else
{
IPEndPoint ep = new IPEndPoint(address, 0);
SystemNet.Internals.SocketAddress remoteAddr = IPEndPointExtensions.Serialize(ep);
byte[] sourceAddr = new byte[28];
SafeWaitHandle pingEventSafeWaitHandle = _pingEvent.GetSafeWaitHandle();
error = (int)Interop.IpHlpApi.Icmp6SendEcho2(
_handlePingV6,
pingEventSafeWaitHandle,
IntPtr.Zero,
IntPtr.Zero,
sourceAddr,
remoteAddr.Buffer,
_requestBuffer,
(ushort)buffer.Length,
ref ipOptions,
_replyBuffer,
MaxUdpPacket,
(uint)timeout);
}
}
catch
{
UnregisterWaitHandle();
throw;
}
if (error == 0)
{
error = Marshal.GetLastWin32Error();
// Only skip Async IO Pending error value.
if (error != Interop.IpHlpApi.ERROR_IO_PENDING)
{
// Cleanup.
FreeUnmanagedStructures();
UnregisterWaitHandle();
throw new Win32Exception(error);
}
}
return(tcs.Task);
}
