async Task <Stream> DownloadCertificate() { HttpResponseMessage response = await HttpRequest.GetHttpResponse(EndPointHelper.GetCertificateURL()); Stream stream = await response.Content.ReadAsStreamAsync(); return(stream); }
public void Me_should_parse_document_correctly(string json, string expectedEndPoint) { var endPoint = expectedEndPoint == null ? (EndPoint)null : EndPointHelper.Parse(expectedEndPoint); var subject = new IsMasterResult(BsonDocument.Parse(json)); subject.Me.Should().Be(endPoint); }
private void VerifyEvent(BsonDocument content, ServerOpeningEvent @event) { @event.ClusterId.Should().Be(_cluster.ClusterId); var expectedEndPoint = EndPointHelper.Parse(content["address"].ToString()); EndPointHelper.EndPointEqualityComparer.Equals(@event.ServerId.EndPoint, expectedEndPoint) .Should().BeTrue(); }
// static methods private static string FormatMessage(ConnectionId connectionId, long cursorId) { return(string.Format( "Cursor {0} not found on server {1} using connection {2}.", cursorId, EndPointHelper.ToString(connectionId.ServerId.EndPoint), connectionId.ServerValue)); }
// static methods internal static MongoWaitQueueFullException ForConnectionPool(EndPoint endPoint) { var message = string.Format( "The wait queue for acquiring a connection to server {0} is full.", EndPointHelper.ToString(endPoint)); return(new MongoWaitQueueFullException(message)); }
protected override bool TryGetServer(EndPoint endPoint, out IClusterableServer server) { lock (_serversLock) { server = _servers.FirstOrDefault(s => EndPointHelper.Equals(s.EndPoint, endPoint)); return(server != null); } }
private void VerifyEvent(ServerClosedEvent actualEvent, BsonDocument expectedEvent) { JsonDrivenHelper.EnsureAllFieldsAreValid(expectedEvent, "address", "topologyId"); var expectedEndPoint = EndPointHelper.Parse(expectedEvent["address"].AsString); actualEvent.ClusterId.Should().Be(_cluster.ClusterId); actualEvent.ServerId.EndPoint.WithComparer(EndPointHelper.EndPointEqualityComparer).Should().Be(expectedEndPoint); }
// constructors /// <summary> /// Initializes a new instance of the <see cref="ServerDescription" /> class. /// </summary> /// <param name="serverId">The server identifier.</param> /// <param name="endPoint">The end point.</param> /// <param name="reasonChanged">The reason the server description was last changed.</param> /// <param name="averageRoundTripTime">The average round trip time.</param> /// <param name="canonicalEndPoint">The canonical end point.</param> /// <param name="electionId">The election identifier.</param> /// <param name="heartbeatException">The heartbeat exception.</param> /// <param name="heartbeatInterval">The heartbeat interval.</param> /// <param name="helloOk">Whether the server supports the hello command.</param> /// <param name="lastHeartbeatTimestamp">The last heartbeat timestamp.</param> /// <param name="lastUpdateTimestamp">The last update timestamp.</param> /// <param name="lastWriteTimestamp">The last write timestamp.</param> /// <param name="logicalSessionTimeout">The logical session timeout.</param> /// <param name="maxBatchCount">The maximum batch count.</param> /// <param name="maxDocumentSize">The maximum size of a document.</param> /// <param name="maxMessageSize">The maximum size of a message.</param> /// <param name="maxWireDocumentSize">The maximum size of a wire document.</param> /// <param name="replicaSetConfig">The replica set configuration.</param> /// <param name="state">The server state.</param> /// <param name="tags">The replica set tags.</param> /// <param name="topologyVersion">The topology version.</param> /// <param name="type">The server type.</param> /// <param name="version">The server version.</param> /// <param name="wireVersionRange">The wire version range.</param> /// <exception cref="ArgumentException">EndPoint and ServerId.EndPoint must match.</exception> public ServerDescription( ServerId serverId, EndPoint endPoint, Optional <string> reasonChanged = default(Optional <string>), Optional <TimeSpan> averageRoundTripTime = default(Optional <TimeSpan>), Optional <EndPoint> canonicalEndPoint = default(Optional <EndPoint>), Optional <ElectionId> electionId = default(Optional <ElectionId>), Optional <Exception> heartbeatException = default(Optional <Exception>), Optional <TimeSpan> heartbeatInterval = default(Optional <TimeSpan>), Optional <bool> helloOk = default(Optional <bool>), Optional <DateTime?> lastHeartbeatTimestamp = default(Optional <DateTime?>), Optional <DateTime> lastUpdateTimestamp = default(Optional <DateTime>), Optional <DateTime?> lastWriteTimestamp = default(Optional <DateTime?>), Optional <TimeSpan?> logicalSessionTimeout = default(Optional <TimeSpan?>), Optional <int> maxBatchCount = default(Optional <int>), Optional <int> maxDocumentSize = default(Optional <int>), Optional <int> maxMessageSize = default(Optional <int>), Optional <int> maxWireDocumentSize = default(Optional <int>), Optional <ReplicaSetConfig> replicaSetConfig = default(Optional <ReplicaSetConfig>), Optional <ServerState> state = default(Optional <ServerState>), Optional <TagSet> tags = default(Optional <TagSet>), Optional <TopologyVersion> topologyVersion = default(Optional <TopologyVersion>), Optional <ServerType> type = default(Optional <ServerType>), Optional <SemanticVersion> version = default(Optional <SemanticVersion>), Optional <Range <int> > wireVersionRange = default(Optional <Range <int> >)) { Ensure.IsNotNull(endPoint, nameof(endPoint)); Ensure.IsNotNull(serverId, nameof(serverId)); if (!EndPointHelper.Equals(endPoint, serverId.EndPoint)) { throw new ArgumentException("EndPoint and ServerId.EndPoint must match."); } _averageRoundTripTime = averageRoundTripTime.WithDefault(TimeSpan.Zero); _canonicalEndPoint = canonicalEndPoint.WithDefault(null); _electionId = electionId.WithDefault(null); _endPoint = endPoint; _heartbeatException = heartbeatException.WithDefault(null); _heartbeatInterval = heartbeatInterval.WithDefault(TimeSpan.Zero); _helloOk = helloOk.WithDefault(false); _lastHeartbeatTimestamp = lastHeartbeatTimestamp.WithDefault(null); _lastUpdateTimestamp = lastUpdateTimestamp.WithDefault(DateTime.UtcNow); _lastWriteTimestamp = lastWriteTimestamp.WithDefault(null); _logicalSessionTimeout = logicalSessionTimeout.WithDefault(null); _maxBatchCount = maxBatchCount.WithDefault(1000); _maxDocumentSize = maxDocumentSize.WithDefault(4 * 1024 * 1024); _maxMessageSize = maxMessageSize.WithDefault(Math.Max(_maxDocumentSize + 1024, 16000000)); _maxWireDocumentSize = maxWireDocumentSize.WithDefault(_maxDocumentSize + 16 * 1024); _reasonChanged = reasonChanged.WithDefault("NotSpecified"); _replicaSetConfig = replicaSetConfig.WithDefault(null); _serverId = serverId; _state = state.WithDefault(ServerState.Disconnected); _tags = tags.WithDefault(null); _topologyVersion = topologyVersion.WithDefault(null); _type = type.WithDefault(ServerType.Unknown); _version = version.WithDefault(null); _wireVersionRange = wireVersionRange.WithDefault(null); }
private async Task <List <Attachment> > GetAttachments(Document doc) { using (var progress = DialogHelper.ShowProgress(AppResources.LOADING_DOCUMENT_INFO)) { var autores = await HttpRequest.GetJson <List <Attachment> >(EndPointHelper.GetDocumentAttachments(doc.Id)); return(autores); } }
public void GetEndPointForService_ProgramNameContainsBundledAndCategoryIsSettlingIn_ShouldReturnDestinationChecklist() { _service.ServiceType.Category = ServiceCategory.SettlingIn; _service.Order.ProgramName = "Test Bundled Program"; var endpoint = EndPointHelper.GetEndPointForService(_service); endpoint.Should().Be(EndPointHelper.DestinationChecklistEndPoint); }
private ServerId(SerializationInfo info, StreamingContext context) { _clusterId = (ClusterId)info.GetValue("_clusterId", typeof(ClusterId)); _endPoint = EndPointHelper.FromObjectData((List <object>)info.GetValue("_endPoint", typeof(List <object>))); _hashCode = new Hasher() .Hash(_clusterId) .Hash(_endPoint) .GetHashCode(); }
public void IsValidHost_should_return_expected_result(string lookupDomainName, string host, bool expectedResult) { var subject = CreateSubject(lookupDomainName: lookupDomainName); var endPoint = (DnsEndPoint)EndPointHelper.Parse(host); var result = subject.IsValidHost(endPoint); result.Should().Be(expectedResult); }
private IEnumerable <EndPoint> GetMembers(string elementName) { if (!_wrapped.Contains(elementName)) { return(new EndPoint[0]); } return(((BsonArray)_wrapped[elementName]).Select(v => EndPointHelper.Parse((string)v))); }
/// <summary> /// returns a newly instantiated host with the given throttling. The host is in the Uninitialized state. /// </summary> /// <param name="wireBuilderId"></param> /// <param name="port"></param> /// <param name="logic"></param> /// <param name="maxConnections"></param> /// <returns></returns> public static IEndPointHost BuildThrottledHost(string wireBuilderId, int port, IEndPointLogic logic, int maxConnections) { var builder = EndPointHostBuilder.Instance.GetBuilder(wireBuilderId); var ep = EndPointHelper.GetLocalEndPoint(port); var throttleLogic = ThrottleLogic(logic, maxConnections); var host = builder.BuildEndPointHost(ep, throttleLogic); return(host); }
private async Task <List <AuthorViewModel> > GetAuthors(Document doc) { using (var progress = DialogHelper.ShowProgress(AppResources.LOADING_DOCUMENT_INFO)) { var autores = await HttpRequest.GetJson <List <Author> >(EndPointHelper.GetDocumentAuthors(doc.Id)); return(autores.Select(a => new AuthorViewModel(a)).ToList()); } }
public void ParseFail() { Assert.Throws <ArgumentNullException>(() => EndPointHelper.Parse(null)); Assert.Throws <ArgumentNullException>(() => EndPointHelper.Parse("")); Assert.Throws <ArgumentException>(() => EndPointHelper.Parse("host:")); Assert.Throws <ArgumentException>(() => EndPointHelper.Parse(":1234")); Assert.Throws <ArgumentOutOfRangeException>(() => EndPointHelper.Parse("abcd:-100")); Assert.Throws <ArgumentOutOfRangeException>(() => EndPointHelper.Parse("abcd:0")); }
private void VerifyOutcome(BsonDocument outcome) { VerifyFields(outcome, "compatible", "logicalSessionTimeoutMinutes", "servers", "setName", "topologyType"); var expectedTopologyType = (string)outcome["topologyType"]; VerifyTopology(_cluster, expectedTopologyType); var actualDescription = _cluster.Description; var actualServers = actualDescription.Servers.Select(x => x.EndPoint); var expectedServers = outcome["servers"].AsBsonDocument.Elements.Select(x => new { EndPoint = EndPointHelper.Parse(x.Name), Description = (BsonDocument)x.Value }); actualServers.WithComparer(EndPointHelper.EndPointEqualityComparer).Should().BeEquivalentTo(expectedServers.Select(x => x.EndPoint).WithComparer(EndPointHelper.EndPointEqualityComparer)); foreach (var actualServer in actualDescription.Servers) { var expectedServer = expectedServers.Single(x => EndPointHelper.EndPointEqualityComparer.Equals(x.EndPoint, actualServer.EndPoint)); VerifyServerDescription(actualServer, expectedServer.Description); } if (outcome.Contains("setName")) { // TODO: assert something against setName } if (outcome.Contains("logicalSessionTimeoutMinutes")) { TimeSpan?expectedLogicalSessionTimeout; switch (outcome["logicalSessionTimeoutMinutes"].BsonType) { case BsonType.Null: expectedLogicalSessionTimeout = null; break; case BsonType.Int32: case BsonType.Int64: expectedLogicalSessionTimeout = TimeSpan.FromMinutes(outcome["logicalSessionTimeoutMinutes"].ToDouble()); break; default: throw new FormatException($"Invalid logicalSessionTimeoutMinutes BSON type: {outcome["setName"].BsonType}."); } actualDescription.LogicalSessionTimeout.Should().Be(expectedLogicalSessionTimeout); } if (outcome.Contains("compatible")) { var expectedIsCompatibleWithDriver = outcome["compatible"].ToBoolean(); actualDescription.IsCompatibleWithDriver.Should().Be(expectedIsCompatibleWithDriver); } }
private void VerifyEvent(ServerDescriptionChangedEvent actualEvent, BsonDocument expectedEvent) { VerifyFields(expectedEvent, "address", "newDescription", "previousDescription", "topologyId"); var expectedEndPoint = EndPointHelper.Parse(expectedEvent["address"].AsString); actualEvent.ClusterId.Should().Be(_cluster.ClusterId); actualEvent.ServerId.EndPoint.WithComparer(EndPointHelper.EndPointEqualityComparer).Should().Be(expectedEndPoint); VerifyServerDescription(actualEvent.OldDescription, expectedEvent["previousDescription"].AsBsonDocument); VerifyServerDescription(actualEvent.NewDescription, expectedEvent["newDescription"].AsBsonDocument); }
// methods /// <inheritdoc/> public bool Equals(ServerId other) { if (other == null) { return(false); } return (_clusterId.Equals(other._clusterId) && EndPointHelper.Equals(_endPoint, other._endPoint)); }
private void ApplyResponse(BsonArray response) { if (response.Count != 2) { throw new FormatException($"Invalid response count: {response.Count}."); } var address = response[0].AsString; var helloDocument = response[1].AsBsonDocument; var expectedNames = new[] { "arbiterOnly", "arbiters", "electionId", "hidden", "hosts", "helloOk", "isWritablePrimary", OppressiveLanguageConstants.LegacyHelloResponseIsWritablePrimaryFieldName, "isreplicaset", "logicalSessionTimeoutMinutes", "maxWireVersion", "me", "minWireVersion", "msg", "ok", "passive", "passives", "primary", "secondary", "setName", "setVersion", "topologyVersion" }; JsonDrivenHelper.EnsureAllFieldsAreValid(helloDocument, expectedNames); var endPoint = EndPointHelper.Parse(address); var helloResult = new HelloResult(helloDocument); var currentServerDescription = _serverFactory.GetServerDescription(endPoint); var newServerDescription = currentServerDescription.With( canonicalEndPoint: helloResult.Me, electionId: helloResult.ElectionId, logicalSessionTimeout: helloResult.LogicalSessionTimeout, replicaSetConfig: helloResult.GetReplicaSetConfig(), state: helloResult.Wrapped.GetValue("ok", false).ToBoolean() ? ServerState.Connected : ServerState.Disconnected, topologyVersion: helloResult.TopologyVersion, type: helloResult.ServerType, wireVersionRange: new Range <int>(helloResult.MinWireVersion, helloResult.MaxWireVersion)); var currentClusterDescription = _cluster.Description; _serverFactory.PublishDescription(newServerDescription); SpinWait.SpinUntil(() => !object.ReferenceEquals(_cluster.Description, currentClusterDescription), 100); // sometimes returns false and that's OK }
private void ProcessServerDescriptionChanged(ServerDescriptionChangedEventArgs args) { var newServers = new List <IClusterableServer>(); lock (_updateClusterDescriptionLock) { var newServerDescription = args.NewServerDescription; var newClusterDescription = Description; if (!_servers.Any(x => EndPointHelper.Equals(x.EndPoint, newServerDescription.EndPoint))) { return; } if (newServerDescription.State == ServerState.Disconnected) { newClusterDescription = newClusterDescription.WithServerDescription(newServerDescription); } else { if (IsServerValidForCluster(newClusterDescription.Type, Settings.ConnectionMode, newServerDescription.Type)) { if (newClusterDescription.Type == ClusterType.Unknown) { newClusterDescription = newClusterDescription.WithType(newServerDescription.Type.ToClusterType()); } switch (newClusterDescription.Type) { case ClusterType.ReplicaSet: newClusterDescription = ProcessReplicaSetChange(newClusterDescription, args, newServers); break; case ClusterType.Sharded: newClusterDescription = ProcessShardedChange(newClusterDescription, args); break; default: throw new MongoInternalException("Unexpected cluster type."); } } else { newClusterDescription = newClusterDescription.WithoutServerDescription(newServerDescription.EndPoint); } } UpdateClusterDescription(newClusterDescription); } foreach (var server in newServers) { server.Initialize(); } }
private void AssertServers(List <ServerDescription> actual, List <ServerDescription> expected) { if (expected.Count == 0) { actual.Count.Should().Be(0); } else { actual.Should().OnlyContain(x => expected.Any(y => EndPointHelper.Equals(x.EndPoint, y.EndPoint))); } }
public void GetValidEndPoints_should_return_expected_results(string[] srvEndPoints, string[] validEndPoints) { var lookupDomainName = "a.b.com"; var subject = CreateSubject(lookupDomainName: lookupDomainName); var srvRecords = CreateSrvRecords(srvEndPoints); var result = subject.GetValidEndPoints(srvRecords); var expectedResult = validEndPoints.Select(x => (DnsEndPoint)EndPointHelper.Parse(x)).ToList(); result.Should().Equal(expectedResult); }
/// <summary> /// Gets the server description. /// </summary> /// <returns>The server description.</returns> public ServerDescription GetServerDescription() { var serverDescription = _cluster.Description.Servers.FirstOrDefault(s => EndPointHelper.Equals(s.EndPoint, _endPoint)); if (serverDescription == null) { throw new InvalidOperationException(string.Format( "Cluster does not contain a server with end point: '{0}'.", _endPoint)); } return(serverDescription); }
private ClusterSettings ConfigureCluster(ClusterSettings settings, ClusterKey clusterKey) { var endPoints = clusterKey.Servers.Select(s => EndPointHelper.Parse(s.ToString())); return(settings.With( connectionMode: clusterKey.ConnectionMode.ToCore(), endPoints: Optional.Enumerable(endPoints), replicaSetName: clusterKey.ReplicaSetName, maxServerSelectionWaitQueueSize: clusterKey.WaitQueueSize, serverSelectionTimeout: clusterKey.ServerSelectionTimeout, postServerSelector: new LatencyLimitingServerSelector(clusterKey.LocalThreshold))); }
private ClusterDescription ProcessReplicaSetChange(ClusterDescription clusterDescription, ServerDescriptionChangedEventArgs args) { if (!args.NewServerDescription.Type.IsReplicaSetMember()) { return(RemoveServer(clusterDescription, args.NewServerDescription.EndPoint, string.Format("Server is a {0}, not a replica set member.", args.NewServerDescription.Type))); } if (args.NewServerDescription.Type == ServerType.ReplicaSetGhost) { return(clusterDescription.WithServerDescription(args.NewServerDescription)); } if (_replicaSetName == null) { _replicaSetName = args.NewServerDescription.ReplicaSetConfig.Name; } if (_replicaSetName != args.NewServerDescription.ReplicaSetConfig.Name) { return(RemoveServer(clusterDescription, args.NewServerDescription.EndPoint, string.Format("Server was a member of the '{0}' replica set, but should be '{1}'.", args.NewServerDescription.ReplicaSetConfig.Name, _replicaSetName))); } clusterDescription = clusterDescription.WithServerDescription(args.NewServerDescription); clusterDescription = EnsureServers(clusterDescription, args.NewServerDescription); if (args.NewServerDescription.Type == ServerType.ReplicaSetPrimary && args.OldServerDescription.Type != ServerType.ReplicaSetPrimary) { var currentPrimaryEndPoints = clusterDescription.Servers .Where(x => x.Type == ServerType.ReplicaSetPrimary) .Where(x => !EndPointHelper.Equals(x.EndPoint, args.NewServerDescription.EndPoint)) .Select(x => x.EndPoint) .ToList(); if (currentPrimaryEndPoints.Count > 0) { lock (_serversLock) { var currentPrimaries = _servers.Where(x => EndPointHelper.Contains(currentPrimaryEndPoints, x.EndPoint)); foreach (var currentPrimary in currentPrimaries) { // kick off the server to invalidate itself currentPrimary.Invalidate(); // set it to disconnected in the cluster clusterDescription = clusterDescription.WithServerDescription( new ServerDescription(currentPrimary.ServerId, currentPrimary.EndPoint)); } } } } return(clusterDescription); }
private EndPoint GetPrimary() { BsonValue primary; if (_wrapped.TryGetValue("primary", out primary)) { // TODO: what does primary look like when there is no current primary (null, empty string)? return(EndPointHelper.Parse((string)primary)); } return(null); }
private ServerDescription BuildServerDescription(BsonDocument serverDescription, TimeSpan heartbeatInterval) { JsonDrivenHelper.EnsureAllFieldsAreValid(serverDescription, "address", "avg_rtt_ms", "tags", "type", "lastUpdateTime", "lastWrite", "maxWireVersion"); var endPoint = EndPointHelper.Parse(serverDescription["address"].ToString()); var averageRoundTripTime = TimeSpan.FromMilliseconds(serverDescription.GetValue("avg_rtt_ms", 0.0).ToDouble()); var type = GetServerType(serverDescription["type"].ToString()); TagSet tagSet = null; if (serverDescription.Contains("tags")) { tagSet = BuildTagSet((BsonDocument)serverDescription["tags"]); } DateTime lastWriteTimestamp; if (serverDescription.Contains("lastWrite")) { lastWriteTimestamp = BsonUtils.ToDateTimeFromMillisecondsSinceEpoch(serverDescription["lastWrite"]["lastWriteDate"].ToInt64()); } else { lastWriteTimestamp = _utcNow; } var maxWireVersion = serverDescription.GetValue("maxWireVersion", 5).ToInt32(); var wireVersionRange = new Range <int>(0, maxWireVersion); var serverVersion = maxWireVersion == 5 ? new SemanticVersion(3, 4, 0) : new SemanticVersion(3, 2, 0); DateTime lastUpdateTimestamp; if (serverDescription.Contains("lastUpdateTime")) { lastUpdateTimestamp = BsonUtils.ToDateTimeFromMillisecondsSinceEpoch(serverDescription.GetValue("lastUpdateTime", 0).ToInt64()); } else { lastUpdateTimestamp = _utcNow; } var serverId = new ServerId(_clusterId, endPoint); return(new ServerDescription( serverId, endPoint, averageRoundTripTime: averageRoundTripTime, type: type, lastUpdateTimestamp: lastUpdateTimestamp, lastWriteTimestamp: lastWriteTimestamp, heartbeatInterval: heartbeatInterval, wireVersionRange: wireVersionRange, version: serverVersion, tags: tagSet, state: ServerState.Connected)); }
protected override bool TryGetServer(EndPoint endPoint, out IClusterableServer server) { if (EndPointHelper.Equals(_server.EndPoint, endPoint)) { server = _server; return(true); } else { server = null; return(false); } }
private void ApplyResponse(BsonValue response) { var server = (string)response[0]; var endPoint = EndPointHelper.Parse(server); var isMasterResult = new IsMasterResult((BsonDocument)response[1]); var currentDescription = _serverFactory.GetServerDescription(endPoint); var description = currentDescription.With( state: isMasterResult.Wrapped.GetValue("ok", false).ToBoolean() ? ServerState.Connected : ServerState.Disconnected, type: isMasterResult.ServerType, replicaSetConfig: isMasterResult.GetReplicaSetConfig()); _serverFactory.PublishDescription(description); }