static async Task AsyncMain()
{
var configuration = new BusConfiguration();
configuration.EndpointName("Gru");
configuration.UseSerialization<JsonSerializer>();
configuration.UsePersistence<InMemoryPersistence>();
configuration.EnableInstallers();
configuration.SendFailedMessagesTo("error");
var minionEndpoint = new EndpointName("Minion");
configuration.Routing().UnicastRoutingTable.AddStatic(typeof(DoSomethingNaughty), minionEndpoint);
configuration.Routing().UseFileBasedEndpointInstanceLists().LookForFilesIn(@".\");
var endpoint = await Endpoint.Start(configuration);
var busContext = endpoint.CreateBusContext();
Console.WriteLine("Press enter to send a message");
Console.WriteLine("Press any key to exit");
while (true)
{
ConsoleKeyInfo key = Console.ReadKey();
Console.WriteLine();
if (key.Key != ConsoleKey.Enter)
{
await endpoint.Stop();
return;
}
Console.WriteLine("Commanding to do something naughty.");
await busContext.Send<DoSomethingNaughty>(m => m.Data = "Go minion, go!");
}
}
private static async Task MainAsync()
{
var factory = LogManager.Use<DefaultFactory>();
factory.Level(LogLevel.Debug);
var configuration = new EndpointConfiguration();
configuration.EndpointName("Sender");
configuration.EnableInstallers();
configuration.UseSerialization<JsonSerializer>();
configuration.UsePersistence<InMemoryPersistence>();
configuration.SendFailedMessagesTo("error");
var transportConfiguration = configuration.UseTransport<AzureServiceBusTransport>();
transportConfiguration.ConnectionString(Environment.GetEnvironmentVariable("AzureServiceBus.ConnectionString"));
// define routing (what used to be message endpoint mapping)
var endpointName = new EndpointName("Receiver");
// configuration.Routing().SetMessageDistributionStrategy(new SingleInstanceRoundRobinDistributionStrategy(), t => true);
configuration.Routing().UnicastRoutingTable.RouteToEndpoint(typeof(TestCommand), endpointName);
configuration.Routing().EndpointInstances.AddStatic(endpointName, new EndpointInstance(endpointName, null, null));
var endpoint = await Endpoint.Start(configuration);
Console.WriteLine("Press ESC to exit, any other key to send a message");
Console.WriteLine("Press any other key to send a message");
while (Console.ReadKey().Key != ConsoleKey.Escape)
{
await endpoint.Send<TestCommand>(m => m.Data = "Testing ASB send");
Console.WriteLine("message sent");
}
}
/// <summary>
/// Adds a named endpoint to the collection
/// </summary>
/// <param name="endpointName">The name of the endpoint</param>
/// <param name="endpoint">The endpoint</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="endpointName"/>
/// or <paramref name="endpoint"/> are <c>null</c></exception>
/// <exception cref="EndpointAlreadyExistsException">Thrown if there is already an
/// endpoint with the specified <paramref name="endpointName"/></exception>
public void Add(EndpointName endpointName, IEndpoint endpoint)
{
if (endpointName == null) throw new ArgumentNullException("endpointName");
if (endpoint == null) throw new ArgumentNullException("endpoint");
if (_endpoints.ContainsKey(endpointName)) throw new EndpointAlreadyExistsException(endpointName);
_endpoints[endpointName] = endpoint;
}
/// <summary>
/// Initializes a serialized <see cref="EndpointNotFoundException"/> from
/// a streaming context
/// </summary>
/// <param name="info">The serialization info</param>
/// <param name="context">The streaming context</param>
public EndpointNotFoundException(SerializationInfo info, StreamingContext context)
: base(info, context)
{
_endpoint = info.GetString("Endpoint");
var addressStr = info.GetString("Address");
_address = string.IsNullOrWhiteSpace(addressStr) ? null : new Uri(addressStr);
}
public void StaticEndpointMappingWithDiscriminators()
{
var busConfig = new BusConfiguration();
#region Routing-StaticEndpointMappingWithDiscriminators
EndpointName sales = new EndpointName("Sales");
busConfig.Routing().EndpointInstances.AddStaticUsingTransportDiscriminators(sales, "MachineA", "MachineB");
#endregion
}
public void StaticEndpointMapping()
{
var busConfig = new BusConfiguration();
#region Routing-StaticEndpointMapping
EndpointName sales = new EndpointName("Sales");
busConfig.Routing().EndpointInstances.AddStatic(sales, new EndpointInstanceName(sales, "1", null), new EndpointInstanceName(sales, "2", null));
#endregion
}
public void StaticEndpointMapping()
{
BusConfiguration busConfiguration = new BusConfiguration();
#region Routing-StaticEndpointMapping
EndpointName sales = new EndpointName("Sales");
busConfiguration.Routing().EndpointInstances
.AddStatic(sales, new EndpointInstance(sales, "1", null), new EndpointInstance(sales, "2", null));
#endregion
}
public override int GetHashCode()
{
unchecked
{
var hashCode = (EndpointName != null ? EndpointName.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (InstanceId != null ? InstanceId.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (InstanceName != null ? InstanceName.GetHashCode() : 0);
return(hashCode);
}
}
/// <summary>
/// Updates entities in TSheets via an HTTP PUT call to the API endpoint, with retries.
/// </summary>
/// <param name="endpointName">The name of the endpoint, <see cref="EndpointName"/></param>
/// <param name="jsonData">The content to be sent in the body of the request.</param>
/// <param name="logContext">Call-specific contextual information for logging purposes.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>The serialized response of the API method call.</returns>
public async Task <string> UpdateAsync(
EndpointName endpointName,
string jsonData,
LogContext logContext,
CancellationToken cancellationToken)
{
return(await ExecutePolicyAsync(
logContext,
() => this.restClient.UpdateAsync(endpointName, jsonData, logContext, cancellationToken))
.ConfigureAwait(false));
}
/// <summary>Snippet for GetEndpoint</summary>
public void GetEndpointResourceNames()
{
// Snippet: GetEndpoint(EndpointName, CallSettings)
// Create client
IDSClient iDSClient = IDSClient.Create();
// Initialize request argument(s)
EndpointName name = EndpointName.FromProjectLocationEndpoint("[PROJECT]", "[LOCATION]", "[ENDPOINT]");
// Make the request
Endpoint response = iDSClient.GetEndpoint(name);
// End snippet
}
/// <summary>
/// Removes entities in TSheets via an HTTP DELETE call to the API endpoint, with retries.
/// </summary>
/// <param name="endpointName">The name of the endpoint, <see cref="EndpointName"/></param>
/// <param name="ids">The ids of the entities to be deleted.</param>
/// <param name="logContext">Call-specific contextual information for logging purposes.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>The serialized response of the API method call.</returns>
public async Task <string> DeleteAsync(
EndpointName endpointName,
IEnumerable <long> ids,
LogContext logContext,
CancellationToken cancellationToken)
{
return(await ExecutePolicyAsync(
logContext,
() => this.restClient.DeleteAsync(endpointName, ids, logContext, cancellationToken))
.ConfigureAwait(false));
}
/// <summary>
/// Downloads binary data from TSheets via an HTTP POST call to the API endpoint, with retries.
/// </summary>
/// <param name="endpointName">The name of the endpoint, <see cref="EndpointName"/></param>
/// <param name="filters">The key-value pairs to be sent as URL request parameters.</param>
/// <param name="logContext">Call-specific contextual information for logging purposes.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>The serialized response of the API method call.</returns>
public async Task <byte[]> DownloadAsync(
EndpointName endpointName,
Dictionary <string, string> filters,
LogContext logContext,
CancellationToken cancellationToken)
{
return(await ExecutePolicyAsync(
logContext,
() => this.restClient.DownloadAsync(endpointName, filters, logContext, cancellationToken))
.ConfigureAwait(false));
}
/// <summary>Snippet for RawPredict</summary>
public void RawPredictResourceNames()
{
// Snippet: RawPredict(EndpointName, HttpBody, CallSettings)
// Create client
PredictionServiceClient predictionServiceClient = PredictionServiceClient.Create();
// Initialize request argument(s)
EndpointName endpoint = EndpointName.FromProjectLocationEndpoint("[PROJECT]", "[LOCATION]", "[ENDPOINT]");
HttpBody httpBody = new HttpBody();
// Make the request
HttpBody response = predictionServiceClient.RawPredict(endpoint, httpBody);
// End snippet
}
/// <summary>
/// Initializes a new <see cref="DiagnosticEvent"/>
/// </summary>
/// <param name="source">The object that emitted the event</param>
/// <param name="type">The type of event</param>
/// <param name="detail">Specific details regarding this instance of the event</param>
/// <param name="exception">The exception related to the event, if applicable</param>
/// <param name="message">The message to which the event pertains, if applicable</param>
/// <param name="endpoint">The name of the endpoint, if applicable</param>
/// <param name="queue">The queue to which the event pertains, if applicable</param>
/// <param name="topic">The topic to which the message pertains, if applicable</param>
public DiagnosticEvent(object source, DiagnosticEventType type, string detail = null, Exception exception = null, Message message = null, EndpointName endpoint = null, QueueName queue = null, TopicName topic = null)
{
Timestamp = DateTime.UtcNow;
Source = source;
Type = type ?? throw new ArgumentNullException(nameof(type));
Detail = detail;
Exception = exception;
Message = message;
Endpoint = endpoint;
Queue = queue;
Topic = topic;
}
private Uri CreateRequestUri(EndpointName endpointName, Dictionary <string, string> filters = null)
{
string endpointSegment = EndpointMapper.GetEndpoint(endpointName);
Uri fullUri = new Uri($"{this.context.ConnectionInfo.BaseUri}/{endpointSegment}");
return(filters?.Count > 0
? new UriBuilder(fullUri)
{
Query = filters.ToUrlQueryString()
}.Uri
: fullUri);
}
private void SetupAsyncMocks <TEntity, TContext>(EndpointName endpoint, Params expect)
where TEntity : new()
where TContext : PipelineContext <TEntity>
{
this.mockPipeline
.Setup(f => f.ProcessAsync(It.IsAny <TContext>(), It.IsAny <ILogger>(), It.IsAny <CancellationToken>()))
.Callback((PipelineContext <TEntity> context, ILogger log, CancellationToken cancellationToken) =>
Process(context, endpoint, expect))
.Returns(Task.CompletedTask);
SetupPipelineFactoryMock <TEntity>();
}
void StaticEndpointMapping(EndpointConfiguration endpointConfiguration)
{
#region Routing-StaticEndpointMapping
EndpointName sales = new EndpointName("Sales");
endpointConfiguration.UnicastRouting().Mapping.Physical
.Add(sales,
new EndpointInstance(sales, "1", null),
new EndpointInstance(sales, "2", null));
#endregion
}
/// <summary>
/// Initializes a new instance of the <see cref="DeleteContext{T}"/> class.
/// </summary>
/// <param name="endpoint">The endpoint with which to interact.</param>
/// <param name="ids">The set of ids corresponding to the data entities to be deleted.</param>
internal DeleteContext(EndpointName endpoint, IEnumerable <int> ids)
: base(MethodType.Delete, endpoint)
{
List <int> listIds = ids?.ToList();
if (listIds == null || !listIds.Any())
{
throw new BadRequestException("Request cannot contain a null or empty set of ids.");
}
Ids = listIds;
}
/// <summary>
/// Returns the endpoint with the specified name
/// </summary>
/// <param name="endpointName">The name of the endpoint</param>
/// <returns>Returns the endpoint</returns>
/// <exception cref="EndpointNotFoundException">Thrown if there
/// is no endpoint with the specified name</exception>
public IEndpoint this[EndpointName endpointName]
{
get
{
IEndpoint endpoint;
if (!_endpoints.TryGetValue(endpointName, out endpoint))
{
throw new EndpointNotFoundException(endpointName);
}
return endpoint;
}
}
void StaticEndpointMapping(EndpointConfiguration endpointConfiguration)
{
#region Routing-StaticEndpointMapping
EndpointName sales = new EndpointName("Sales");
endpointConfiguration.Routing().EndpointInstances
.AddStatic(sales,
new EndpointInstance(sales, "1", null),
new EndpointInstance(sales, "2", null));
#endregion
}
void StaticEndpointMapping(EndpointConfiguration endpointConfiguration)
{
#region Routing-StaticEndpointMapping
EndpointName sales = new EndpointName("Sales");
endpointConfiguration.UnicastRouting().Mapping.Physical
.Add(sales,
new EndpointInstance(sales, "1", null),
new EndpointInstance(sales, "2", null));
#endregion
}
/// <summary>
/// Adds a named endpoint to the configuration
/// </summary>
/// <param name="name">The name of the endpoint</param>
/// <param name="endpoint">The endpoint</param>
/// <remarks>
/// Named endpoints must be added before messages can be sent or
/// subscriptions can be created
/// </remarks>
/// <exception cref="ArgumentNullException">Thrown if either argument
/// is <c>null</c></exception>
public virtual void AddEndpoint(EndpointName name, IEndpoint endpoint)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (endpoint == null)
{
throw new ArgumentNullException(nameof(endpoint));
}
_endpoints.Add(name, endpoint);
}
public static EndpointMetaAttribute GetAttribute(EndpointName enumValue)
{
#if NETSTANDARD1_3
Type type = enumValue.GetType();
string name = Enum.GetName(type, enumValue);
return(type.GetRuntimeField(name).GetCustomAttribute <EndpointMetaAttribute>());
#else
Type type = enumValue.GetType();
string name = Enum.GetName(type, enumValue);
return(type.GetField(name).GetCustomAttribute <EndpointMetaAttribute>());
#endif
}
public async stt::Task UpdateEndpointAsync()
{
moq::Mock <EndpointService.EndpointServiceClient> mockGrpcClient = new moq::Mock <EndpointService.EndpointServiceClient>(moq::MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
UpdateEndpointRequest request = new UpdateEndpointRequest
{
Endpoint = new Endpoint(),
UpdateMask = new wkt::FieldMask(),
};
Endpoint expectedResponse = new Endpoint
{
EndpointName = EndpointName.FromProjectLocationEndpoint("[PROJECT]", "[LOCATION]", "[ENDPOINT]"),
DisplayName = "display_name137f65c2",
Description = "description2cf9da67",
DeployedModels =
{
new DeployedModel(),
},
TrafficSplit =
{
{
"key8a0b6e3c",
1623286560
},
},
Etag = "etage8ad7218",
Labels =
{
{
"key8a0b6e3c",
"value60c16320"
},
},
CreateTime = new wkt::Timestamp(),
UpdateTime = new wkt::Timestamp(),
EncryptionSpec = new EncryptionSpec(),
NetworkAsNetworkName = NetworkName.FromProjectNetwork("[PROJECT]", "[NETWORK]"),
ModelDeploymentMonitoringJobAsModelDeploymentMonitoringJobName = ModelDeploymentMonitoringJobName.FromProjectLocationModelDeploymentMonitoringJob("[PROJECT]", "[LOCATION]", "[MODEL_DEPLOYMENT_MONITORING_JOB]"),
EnablePrivateServiceConnect = false,
};
mockGrpcClient.Setup(x => x.UpdateEndpointAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <Endpoint>(stt::Task.FromResult(expectedResponse), null, null, null, null));
EndpointServiceClient client = new EndpointServiceClientImpl(mockGrpcClient.Object, null);
Endpoint responseCallSettings = await client.UpdateEndpointAsync(request.Endpoint, request.UpdateMask, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
xunit::Assert.Same(expectedResponse, responseCallSettings);
Endpoint responseCancellationToken = await client.UpdateEndpointAsync(request.Endpoint, request.UpdateMask, st::CancellationToken.None);
xunit::Assert.Same(expectedResponse, responseCancellationToken);
mockGrpcClient.VerifyAll();
}
/// <summary>Snippet for Predict</summary>
public void PredictResourceNames()
{
// Snippet: Predict(EndpointName, IEnumerable<Value>, Value, CallSettings)
// Create client
PredictionServiceClient predictionServiceClient = PredictionServiceClient.Create();
// Initialize request argument(s)
EndpointName endpoint = EndpointName.FromProjectLocationEndpoint("[PROJECT]", "[LOCATION]", "[ENDPOINT]");
IEnumerable <Value> instances = new Value[] { new Value(), };
Value parameters = new Value();
// Make the request
PredictResponse response = predictionServiceClient.Predict(endpoint, instances, parameters);
// End snippet
}
public void JsonPaths_ReturnsExpectedResults()
{
foreach (KeyValuePair <EndpointName, string> mapping in ExpectedJsonPaths)
{
EndpointName endpointName = mapping.Key;
string expectedJsonPath = mapping.Value;
var pipelineContext = new GetContext <TestEntity>(mapping.Key, null);
string actualJsonPath = pipelineContext.JsonPath();
Assert.AreEqual(expectedJsonPath, actualJsonPath);
}
}
/// <summary>Snippet for GetEndpointAsync</summary>
public async Task GetEndpointResourceNamesAsync()
{
// Snippet: GetEndpointAsync(EndpointName, CallSettings)
// Additional: GetEndpointAsync(EndpointName, CancellationToken)
// Create client
IDSClient iDSClient = await IDSClient.CreateAsync();
// Initialize request argument(s)
EndpointName name = EndpointName.FromProjectLocationEndpoint("[PROJECT]", "[LOCATION]", "[ENDPOINT]");
// Make the request
Endpoint response = await iDSClient.GetEndpointAsync(name);
// End snippet
}
public void DeleteEndpoint(
string projectId = "my-project",
string locationId = "us-east1",
string namespaceId = "test-namespace",
string serviceId = "test-service",
string endpointId = "test-endpoint")
{
// Create client
RegistrationServiceClient registrationServiceClient = RegistrationServiceClient.Create();
// Initialize request argument(s)
var endpointName = EndpointName.FromProjectLocationNamespaceServiceEndpoint(projectId, locationId, namespaceId, serviceId, endpointId);
registrationServiceClient.DeleteEndpoint(endpointName);
}
/// <summary>Snippet for GetEndpoint</summary>
public void GetEndpointRequestObject()
{
// Snippet: GetEndpoint(GetEndpointRequest, CallSettings)
// Create client
IDSClient iDSClient = IDSClient.Create();
// Initialize request argument(s)
GetEndpointRequest request = new GetEndpointRequest
{
EndpointName = EndpointName.FromProjectLocationEndpoint("[PROJECT]", "[LOCATION]", "[ENDPOINT]"),
};
// Make the request
Endpoint response = iDSClient.GetEndpoint(request);
// End snippet
}
/// <summary>
/// Retrieves entities from TSheets via an HTTP GET call to the API endpoint.
/// </summary>
/// <param name="endpointName">The name of the endpoint, <see cref="EndpointName"/></param>
/// <param name="filters">The key-value pairs to be sent as URL request parameters.</param>
/// <param name="logContext">Call-specific contextual information for logging purposes.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>The serialized response of the API method call.</returns>
public async Task <string> GetAsync(
EndpointName endpointName,
Dictionary <string, string> filters,
LogContext logContext,
CancellationToken cancellationToken)
{
Uri requestUri = CreateRequestUri(endpointName, filters);
LogMethodCall(MethodType.Get, requestUri, logContext);
HttpResponseMessage response = await this.httpClient.GetAsync(requestUri, cancellationToken).ConfigureAwait(false);
return(ProcessResponse(response, logContext, MethodType.Get));
}
/// <summary>Snippet for RawPredict</summary>
public void RawPredictRequestObject()
{
// Snippet: RawPredict(RawPredictRequest, CallSettings)
// Create client
PredictionServiceClient predictionServiceClient = PredictionServiceClient.Create();
// Initialize request argument(s)
RawPredictRequest request = new RawPredictRequest
{
EndpointAsEndpointName = EndpointName.FromProjectLocationEndpoint("[PROJECT]", "[LOCATION]", "[ENDPOINT]"),
HttpBody = new HttpBody(),
};
// Make the request
HttpBody response = predictionServiceClient.RawPredict(request);
// End snippet
}
/// <summary>Snippet for RawPredictAsync</summary>
public async Task RawPredictResourceNamesAsync()
{
// Snippet: RawPredictAsync(EndpointName, HttpBody, CallSettings)
// Additional: RawPredictAsync(EndpointName, HttpBody, CancellationToken)
// Create client
PredictionServiceClient predictionServiceClient = await PredictionServiceClient.CreateAsync();
// Initialize request argument(s)
EndpointName endpoint = EndpointName.FromProjectLocationEndpoint("[PROJECT]", "[LOCATION]", "[ENDPOINT]");
HttpBody httpBody = new HttpBody();
// Make the request
HttpBody response = await predictionServiceClient.RawPredictAsync(endpoint, httpBody);
// End snippet
}
/// <summary>
/// Updates entities in TSheets via an HTTP PUT call to the API endpoint.
/// </summary>
/// <param name="endpointName">The name of the endpoint, <see cref="EndpointName"/></param>
/// <param name="requestData">The content to be sent in the body of the request.</param>
/// <param name="logContext">Call-specific contextual information for logging purposes.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>The serialized response of the API method call.</returns>
public async Task <string> UpdateAsync(
EndpointName endpointName,
string requestData,
LogContext logContext,
CancellationToken cancellationToken)
{
Uri requestUri = CreateRequestUri(endpointName);
LogMethodCall(MethodType.Put, requestUri, logContext, requestData);
HttpContent content = new StringContent(requestData, Encoding.UTF8, "application/json");
HttpResponseMessage response = await this.httpClient.PutAsync(requestUri, content, cancellationToken).ConfigureAwait(false);
return(ProcessResponse(response, logContext, MethodType.Put));
}
public override void Initialize()
{
base.Initialize();
this.endpointName = EndpointName.Tests;
this.inputData = "{ \"input\": \"data\" }";
this.inputFilter = new Dictionary <string, string> {
{ "ids", "1,2,3" }
};
this.deleteIds = new List <int> {
1, 2, 3
};
this.logContext = new LogContext();
this.mockRestClient = new Mock <IRestClient>();
}
public void GetEndpointResourceNames()
{
moq::Mock <EndpointService.EndpointServiceClient> mockGrpcClient = new moq::Mock <EndpointService.EndpointServiceClient>(moq::MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
GetEndpointRequest request = new GetEndpointRequest
{
EndpointName = EndpointName.FromProjectLocationEndpoint("[PROJECT]", "[LOCATION]", "[ENDPOINT]"),
};
Endpoint expectedResponse = new Endpoint
{
EndpointName = EndpointName.FromProjectLocationEndpoint("[PROJECT]", "[LOCATION]", "[ENDPOINT]"),
DisplayName = "display_name137f65c2",
Description = "description2cf9da67",
DeployedModels =
{
new DeployedModel(),
},
TrafficSplit =
{
{
"key8a0b6e3c",
1623286560
},
},
Etag = "etage8ad7218",
Labels =
{
{
"key8a0b6e3c",
"value60c16320"
},
},
CreateTime = new wkt::Timestamp(),
UpdateTime = new wkt::Timestamp(),
EncryptionSpec = new EncryptionSpec(),
NetworkAsNetworkName = NetworkName.FromProjectNetwork("[PROJECT]", "[NETWORK]"),
ModelDeploymentMonitoringJobAsModelDeploymentMonitoringJobName = ModelDeploymentMonitoringJobName.FromProjectLocationModelDeploymentMonitoringJob("[PROJECT]", "[LOCATION]", "[MODEL_DEPLOYMENT_MONITORING_JOB]"),
EnablePrivateServiceConnect = false,
};
mockGrpcClient.Setup(x => x.GetEndpoint(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
EndpointServiceClient client = new EndpointServiceClientImpl(mockGrpcClient.Object, null);
Endpoint response = client.GetEndpoint(request.EndpointName);
xunit::Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public async stt::Task GetEndpointRequestObjectAsync()
{
moq::Mock <EndpointService.EndpointServiceClient> mockGrpcClient = new moq::Mock <EndpointService.EndpointServiceClient>(moq::MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
GetEndpointRequest request = new GetEndpointRequest
{
EndpointName = EndpointName.FromProjectLocationEndpoint("[PROJECT]", "[LOCATION]", "[ENDPOINT]"),
};
Endpoint expectedResponse = new Endpoint
{
EndpointName = EndpointName.FromProjectLocationEndpoint("[PROJECT]", "[LOCATION]", "[ENDPOINT]"),
DisplayName = "display_name137f65c2",
Description = "description2cf9da67",
DeployedModels =
{
new DeployedModel(),
},
TrafficSplit =
{
{
"key8a0b6e3c",
1623286560
},
},
Etag = "etage8ad7218",
Labels =
{
{
"key8a0b6e3c",
"value60c16320"
},
},
CreateTime = new wkt::Timestamp(),
UpdateTime = new wkt::Timestamp(),
EncryptionSpec = new EncryptionSpec(),
};
mockGrpcClient.Setup(x => x.GetEndpointAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <Endpoint>(stt::Task.FromResult(expectedResponse), null, null, null, null));
EndpointServiceClient client = new EndpointServiceClientImpl(mockGrpcClient.Object, null);
Endpoint responseCallSettings = await client.GetEndpointAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
xunit::Assert.Same(expectedResponse, responseCallSettings);
Endpoint responseCancellationToken = await client.GetEndpointAsync(request, st::CancellationToken.None);
xunit::Assert.Same(expectedResponse, responseCancellationToken);
mockGrpcClient.VerifyAll();
}
/// <summary>Snippet for ListConnectionsAsync</summary>
public async Task ListConnectionsRequestObjectAsync()
{
// Snippet: ListConnectionsAsync(ListConnectionsRequest, CallSettings)
// Create client
ConnectionServiceClient connectionServiceClient = await ConnectionServiceClient.CreateAsync();
// Initialize request argument(s)
ListConnectionsRequest request = new ListConnectionsRequest
{
ParentAsEndpointName = EndpointName.FromProjectEndpoint("[PROJECT]", "[ENDPOINT]"),
};
// Make the request
PagedAsyncEnumerable <ListConnectionsResponse, Connection> response = connectionServiceClient.ListConnectionsAsync(request);
// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Connection item) =>
{
// Do something with each item
Console.WriteLine(item);
});
// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListConnectionsResponse page) =>
{
// Do something with each page of items
Console.WriteLine("A page of results:");
foreach (Connection item in page)
{
// Do something with each item
Console.WriteLine(item);
}
});
// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page <Connection> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Connection item in singlePage)
{
// Do something with each item
Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;
// End snippet
}
/// <summary>Snippet for Predict</summary>
public void PredictRequestObject()
{
// Snippet: Predict(PredictRequest, CallSettings)
// Create client
PredictionServiceClient predictionServiceClient = PredictionServiceClient.Create();
// Initialize request argument(s)
PredictRequest request = new PredictRequest
{
EndpointAsEndpointName = EndpointName.FromProjectLocationEndpoint("[PROJECT]", "[LOCATION]", "[ENDPOINT]"),
Instances = { new Value(), },
Parameters = new Value(),
};
// Make the request
PredictResponse response = predictionServiceClient.Predict(request);
// End snippet
}
public void DynamicEndpointMapping()
{
var busConfig = new BusConfiguration();
#region Routing-DynamicEndpointMapping
EndpointName sales = new EndpointName("Sales");
busConfig.Routing().EndpointInstances.AddDynamic(e =>
{
if (e.ToString().StartsWith("Sales"))
{
return new[]
{
new EndpointInstanceName(e, "1", "MachineA"),
new EndpointInstanceName(e, "2", "MachineB")
};
}
return null;
});
#endregion
}
private IEndpoint GetEndpoint(EndpointName endpointName, HttpContext context)
{
if (_options.Endpoints.IsEndpointEnabled(endpointName))
{
var mapping = _mappings.Where(x => x.Endpoint == endpointName).LastOrDefault();
if (mapping != null)
{
_logger.LogDebug("Mapping found for endpoint: {0}, creating handler: {1}", endpointName, mapping.Handler.FullName);
return context.RequestServices.GetService(mapping.Handler) as IEndpoint;
}
else
{
_logger.LogError("No mapping found for endpoint: {0}", endpointName);
}
}
else
{
_logger.LogWarning("{0} endpoint requested, but is diabled in endpoint options.", endpointName);
}
return null;
}
public static bool IsEndpointEnabled(this EndpointsOptions options, EndpointName endpointName)
{
switch (endpointName)
{
case EndpointName.Authorize:
return options.EnableAuthorizeEndpoint;
case EndpointName.CheckSession:
return options.EnableCheckSessionEndpoint;
case EndpointName.Discovery:
return options.EnableDiscoveryEndpoint;
case EndpointName.EndSession:
return options.EnableEndSessionEndpoint;
case EndpointName.Introspection:
return options.EnableIntrospectionEndpoint;
case EndpointName.Revocation:
return options.EnableTokenRevocationEndpoint;
case EndpointName.Token:
return options.EnableTokenEndpoint;
case EndpointName.UserInfo:
return options.EnableUserInfoEndpoint;
default:
return false;
}
}
/// <summary>
/// Initializes a serialized <see cref="EndpointAlreadyExistsException"/>
/// from a streaming context.
/// </summary>
/// <param name="info">The serialization info</param>
/// <param name="context">The streaming context</param>
public EndpointAlreadyExistsException(SerializationInfo info, StreamingContext context)
: base(info, context)
{
_endpoint = info.GetString("Endpoint");
}
/// <summary>
/// Adds a named endpoint to the configuration
/// </summary>
/// <param name="name">The name of the endpoint</param>
/// <param name="endpoint">The endpoint</param>
/// <remarks>
/// Named endpoints must be added before messages can be sent or
/// subscriptions can be created
/// </remarks>
/// <exception cref="ArgumentNullException">Thrown if either argument
/// is <c>null</c></exception>
public void AddEndpoint(EndpointName name, IEndpoint endpoint)
{
if (name == null) throw new ArgumentNullException("name");
if (endpoint == null) throw new ArgumentNullException("endpoint");
_endpoints.Add(name, endpoint);
}
/// <summary>
/// Sends <paramref name="content" /> to a single caller-specified
/// <paramref name="endpointName" />.
/// </summary>
/// <param name="content">The message to send.</param>
/// <param name="endpointName">The name of the endpoint to which the message should be sent.</param>
/// <param name="options">Optional settings that influence how the message is sent.</param>
/// <param name="cancellationToken">An optional cancellation token</param>
public async Task<ISentMessage> Send(object content, EndpointName endpointName,
SendOptions options = default(SendOptions), CancellationToken cancellationToken = default(CancellationToken))
{
CheckDisposed();
if (content == null) throw new ArgumentNullException("content");
if (endpointName == null) throw new ArgumentNullException("endpointName");
var endpoint = _endpoints[endpointName];
var credentials = endpoint.Credentials;
var headers = new MessageHeaders
{
Destination = endpoint.Address
};
var message = BuildMessage(content, headers, options);
Log.DebugFormat("Sending message ID {0} to endpoint \"{1}\" ({2})...",
message.Headers.MessageId, endpointName, endpoint.Address);
// Create the sent message before transporting it in order to ensure that the
// reply stream is cached before any replies arrive.
var sentMessage = _replyHub.CreateSentMessage(message);
await _transportService.SendMessage(message, credentials, cancellationToken);
return sentMessage;
}
private Dictionary<EndpointName, HashSet<EndpointInstanceName>> BuildNewInstanceMap(EndpointName endpointName, EndpointInstanceName instanceName)
{
var newInstanceMap = new Dictionary<EndpointName, HashSet<EndpointInstanceName>>();
foreach (var pair in instanceMap)
{
var otherInstances = pair.Value.Where(x => x != instanceName);
newInstanceMap[pair.Key] = new HashSet<EndpointInstanceName>(otherInstances);
}
HashSet<EndpointInstanceName> endpointEntry;
if (!newInstanceMap.TryGetValue(endpointName, out endpointEntry))
{
endpointEntry = new HashSet<EndpointInstanceName>();
newInstanceMap[endpointName] = endpointEntry;
}
endpointEntry.Add(instanceName);
return newInstanceMap;
}
private Task UpdateCaches(EndpointName endpointName, EndpointInstanceName instanceName, Type[] types)
{
instanceMap = BuildNewInstanceMap(endpointName, instanceName);
endpointMap = BuildNewEndpointMap(endpointName, types);
return Task.FromResult(0);
}
private Dictionary<Type, HashSet<EndpointName>> BuildNewEndpointMap(EndpointName endpointName, Type[] types)
{
var newEndpointMap = new Dictionary<Type, HashSet<EndpointName>>();
foreach (var pair in endpointMap)
{
var otherEndpoints = pair.Value.Where(x => x != endpointName);
newEndpointMap[pair.Key] = new HashSet<EndpointName>(otherEndpoints);
}
foreach (var type in types)
{
HashSet<EndpointName> typeEntry;
if (!newEndpointMap.TryGetValue(type, out typeEntry))
{
typeEntry = new HashSet<EndpointName>();
newEndpointMap[type] = typeEntry;
}
typeEntry.Add(endpointName);
}
return newEndpointMap;
}
/// <summary>
/// Initializes a new <see cref="EndpointNotFoundException"/> for the
/// specified <paramref name="endpoint"/> name
/// </summary>
/// <param name="endpoint">The name of the endpoint that could not be
/// found</param>
public EndpointNotFoundException(EndpointName endpoint) : base(endpoint)
{
_endpoint = endpoint;
}
private IEnumerable<EndpointInstanceName> FindInstances(EndpointName endpointName)
{
HashSet<EndpointInstanceName> instances;
if (instanceMap.TryGetValue(endpointName, out instances))
{
var activeInstances =
instances.Where(i => instanceInformation[i].State == InstanceState.Active).ToArray();
if (activeInstances.Any())
{
return activeInstances;
}
Logger.InfoFormat("No active instances of endpoint {0} detected. Trying to route to the inactive ones.", endpointName);
return instances;
}
return Enumerable.Empty<EndpointInstanceName>();
}
/// <summary>
/// Initializes a new <see cref="EndpointAlreadyExistsException"/> with
/// the specified <paramref name="endpoint"/>
/// </summary>
/// <param name="endpoint">The endpoint name that already exists</param>
public EndpointAlreadyExistsException(EndpointName endpoint)
{
_endpoint = endpoint;
}
// ReSharper disable once ConvertClosureToMethodGroup
public void TransportAddressRules()
{
var busConfig = new BusConfiguration();
#region Routing-TransportAddressRule
EndpointName sales = new EndpointName("Sales");
busConfig.Routing().TransportAddresses.AddRule(i => CustomTranslationRule(i));
#endregion
}
public void SpecialCaseTransportAddress()
{
var busConfig = new BusConfiguration();
#region Routing-SpecialCaseTransportAddress
EndpointName sales = new EndpointName("Sales");
busConfig.Routing().TransportAddresses.AddException(new EndpointInstanceName(sales, "1", null), "Sales-One@MachineA");
#endregion
}
protected override async Task OnStart(IBusContext context)
{
var routingTable = settings.Get<UnicastRoutingTable>();
var endpointInstances = settings.Get<EndpointInstances>();
routingTable.AddDynamic((list, bag) => FindDestination(list));
endpointInstances.AddDynamic(FindInstances);
subscription = await dataBackplane.GetAllAndSubscribeToChanges("NServiceBus.HandledMessages",
async e =>
{
var deserializedData = JsonConvert.DeserializeObject<HandledMessageDeclaration>(e.Data);
var endpointName = new EndpointName(deserializedData.EndpointName);
var instanceName = new EndpointInstanceName(endpointName, deserializedData.UserDiscriminator, deserializedData.TransportDiscriminator);
var types =
deserializedData.HandledMessageTypes.Select(x => Type.GetType(x, false))
.Where(x => x != null)
.ToArray();
EndpointInstanceInfo instanceInfo;
if (!instanceInformation.TryGetValue(instanceName, out instanceInfo))
{
var newInstanceInformation = new Dictionary<EndpointInstanceName, EndpointInstanceInfo>(instanceInformation);
instanceInfo = new EndpointInstanceInfo();
newInstanceInformation[instanceName] = instanceInfo;
instanceInformation = newInstanceInformation;
}
if (deserializedData.Active)
{
instanceInfo.Activate(deserializedData.Timestamp);
Logger.InfoFormat("Instance {0} active (heartbeat).", instanceName);
}
else
{
instanceInfo.Deactivate();
Logger.InfoFormat("Instance {0} deactivated.", instanceName);
}
await UpdateCaches(endpointName, instanceName, types);
},
async e =>
{
var deserializedData = JsonConvert.DeserializeObject<HandledMessageDeclaration>(e.Data);
var endpointName = new EndpointName(deserializedData.EndpointName);
var instanceName = new EndpointInstanceName(endpointName, deserializedData.UserDiscriminator,
deserializedData.TransportDiscriminator);
Logger.InfoFormat("Instance {0} removed from routing tables.", instanceName);
await UpdateCaches(endpointName, instanceName, new Type[0]);
instanceInformation.Remove(instanceName);
});
sweepTimer = new Timer(state =>
{
foreach (var info in instanceInformation)
{
if (!info.Value.Sweep(DateTime.UtcNow, heartbeatTimeout))
{
Logger.InfoFormat("Instance {0} deactivated (heartbeat timeout).", info.Key);
}
}
}, null, sweepPeriod, sweepPeriod);
}