private async Task <PublisherClient> CreatePublisher(TopicName topicName)
{
// Publish a message to the topic using PublisherClient.
return(string.IsNullOrEmpty(_pubsubEmulatorHost)
? await PublisherClient.CreateAsync(topicName)
: await PublisherClient.CreateAsync(topicName, clientCreationSettings : new PublisherClient.ClientCreationSettings(credentials: ChannelCredentials.Insecure, serviceEndpoint: _pubsubEmulatorHost)));
}
public void PublishMessage([FromBody] Message message)
{
var topicName = TopicName.FromProjectTopic(ProjectId, message.TopicId);
var publisher = PublisherClient.CreateAsync(topicName).Result;
publisher.PublishAsync(message.Text);
}
public async Task PublishMessageWithRetrySettingsAsync(string projectId, string topicId, string messageText)
{
TopicName topicName = TopicName.FromProjectTopic(projectId, topicId);
// Retry settings control how the publisher handles retry-able failures
var maxAttempts = 3;
var initialBackoff = TimeSpan.FromMilliseconds(110); // default: 100 ms
var maxBackoff = TimeSpan.FromSeconds(70); // default : 60 seconds
var backoffMultiplier = 1.3; // default: 1.0
var totalTimeout = TimeSpan.FromSeconds(100); // default: 600 seconds
var publisher = await PublisherClient.CreateAsync(topicName,
clientCreationSettings : new PublisherClient.ClientCreationSettings(
publisherServiceApiSettings: new PublisherServiceApiSettings
{
PublishSettings = CallSettings.FromRetry(RetrySettings.FromExponentialBackoff(
maxAttempts: maxAttempts,
initialBackoff: initialBackoff,
maxBackoff: maxBackoff,
backoffMultiplier: backoffMultiplier,
retryFilter: RetrySettings.FilterForStatusCodes(StatusCode.Unavailable)))
.WithTimeout(totalTimeout)
}
)).ConfigureAwait(false);
string message = await publisher.PublishAsync(messageText);
Console.WriteLine($"Published message {message}");
}
public async Task <bool> PublishAsync(Event[] message, string topicName)
{
try{
TopicName topic = new TopicName(_busSettings.ProjectId, topicName);
PublisherClient publisher;
publisher = await PublisherClient.CreateAsync(topic);
var pubSubMessage = new PubsubMessage {
Data = ByteString.CopyFrom(JsonConvert.SerializeObject(message), Encoding.UTF8)
};
if (_busSettings.Token != null && _busSettings.Token != "")
{
pubSubMessage.Attributes["token"] = _busSettings.Token;
}
var result = await publisher.PublishAsync(pubSubMessage);
if (result == "")
{
return(false);
}
return(true);
} catch (Exception ex) {
return(false);
}
}
public async Task InitializeAsync(
CancellationToken ct)
{
var topicName = new TopicName(options.ProjectId, $"{options.Prefix}{topicId}");
publisherClient = await PublisherClient.CreateAsync(topicName);
}
public async Task <IActionResult> Index(UploadViewModel model)
{
if (!ModelState.IsValid)
{
model.Errors = "All fields are required!";
return(View(model));
}
var image = model.Image.OpenReadStream();
var fighterType = await _imageDescriptor.GetFighterTypeAsync(image);
if (!fighterType.HasValue)
{
model.Errors = "Please upload an image of either a dog or a cat";
return(View(model));
}
var fighterId = await _dataService.SaveFighterAsync(new Fighter { Name = model.Name },
image, model.Image.ContentType, fighterType.Value);
TopicName topicName = new TopicName(_config.ProjectId, _config.Topic);
PublisherClient publisher = await PublisherClient.CreateAsync(topicName);
string messageId = await publisher.PublishAsync(fighterId);
_logger.LogInformation($"Published message : {messageId}");
return(View(new UploadViewModel {
IsSuccess = true
}));
}
public async Task Initialize()
{
try
{
_publisher = await PublisherClient.CreateAsync(_customEndpoint);
}
catch (Exception e)
{
ReportErrorAndRethrow(e, "CreateAsync", GoogleErrorCode.Initializing);
}
bool didCreate = false;
try
{
_topic = await _publisher.CreateTopicAsync(TopicName);
didCreate = true;
}
catch (RpcException e)
{
if (e.Status.StatusCode != StatusCode.AlreadyExists)
{
ReportErrorAndRethrow(e, "CreateTopicAsync", GoogleErrorCode.Initializing);
}
_topic = await _publisher.GetTopicAsync(TopicName);
}
_logger.LogInformation((int)GoogleErrorCode.Initializing, "{Verb} Google PubSub Topic {TopicId}", (didCreate ? "Created" : "Attached to"), TopicName.TopicId);
didCreate = false;
try
{
_subscriber = await SubscriberClient.CreateAsync(_customEndpoint);
_subscription = await _subscriber.CreateSubscriptionAsync(SubscriptionName, TopicName, pushConfig : null,
ackDeadlineSeconds : _deadline.HasValue?(int)_deadline.Value.TotalSeconds : 60);
didCreate = true;
}
catch (RpcException e)
{
if (e.Status.StatusCode != StatusCode.AlreadyExists)
{
ReportErrorAndRethrow(e, "CreateSubscriptionAsync", GoogleErrorCode.Initializing);
}
_subscription = await _subscriber.GetSubscriptionAsync(SubscriptionName);
}
_logger.LogInformation(
(int)GoogleErrorCode.Initializing,
"{Verb} Google PubSub Subscription {SubscriptionId} to Topic {TopicId}",
(didCreate ? "Created" : "Attached to"),
SubscriptionName.SubscriptionId,
TopicName.TopicId);
}
public SpeedTestEvents(string projectId, string topicId)
{
var publisherClient = PublisherServiceApiClient.Create();
_publisher = PublisherClient.CreateAsync(
new TopicName(projectId, topicId))
.GetAwaiter().GetResult();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddSingleton <FirestoreDb>(
provider => FirestoreDb.Create(GetFirestoreProjectId()));
services.AddSingleton <PublisherClient>(
provider => PublisherClient.CreateAsync(new TopicName(
GetProjectId(), GetTopicName())).Result);
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
}
public async Task <int> PublishMessagesAsync(string projectId, string topicId, IEnumerable <string> messageTexts)
{
TopicName topicName = TopicName.FromProjectTopic(projectId, topicId);
PublisherClient publisher = await PublisherClient.CreateAsync(topicName,
new PublisherClient.ClientCreationSettings(credentials: this.channelCredentials));
int publishedMessageCount = 0;
var publishTasks = messageTexts.Select(async text =>
{
try
{
string message = await publisher.PublishAsync(text);
Console.WriteLine($"Published message {message}");
Interlocked.Increment(ref publishedMessageCount);
}
catch (Exception exception)
{
Console.WriteLine($"An error ocurred when publishing message {text}: {exception.Message}");
}
});
await Task.WhenAll(publishTasks);
return(publishedMessageCount);
//clientCreationSettings.Credentials
//PublisherServiceApiSettings publisherServiceApiSettings = new PublisherServiceApiSettings();
//clientCreationSettings.PublisherServiceApiSettings
//clientCreationSettings.Credentials
//Channel channel = new Channel(
// PublisherClient.DefaultEndpoint.Host,
// PublisherClient.DefaultEndpoint.Port,
// googleCredential.ToChannelCredentials());
//PublisherClient publisher2 = await PublisherClient.CreateAsync(topicName, clientCreationSettings, settings);
//PublisherServiceApiClientBuilder bld = new PublisherServiceApiClientBuilder();
//var credential = GoogleCredential.FromJson(@"{""your_credentials_json_itself"":""here""}");
//var channel = new Grpc.Core.Channel(PublisherServiceApiClient.DefaultEndpoint.ToString(), credential.ToChannelCredentials());
//PublisherServiceApiClient.DefaultScopes
//var publisher3 = bld.
//PublisherServiceApiClientBuilder x = new PublisherServiceApiClientBuilder
//{
// CredentialsPath = jsonPath
//};
//PublisherServiceApiClient client = x.Build();
}
public async Task SimpleOverview()
{
string projectId = _fixture.ProjectId;
string topicId = _fixture.CreateTopicId();
string subscriptionId = _fixture.CreateSubscriptionId();
// Sample: SimpleOverview
// First create a topic.
PublisherServiceApiClient publisherService = await PublisherServiceApiClient.CreateAsync();
TopicName topicName = new TopicName(projectId, topicId);
publisherService.CreateTopic(topicName);
// Subscribe to the topic.
SubscriberServiceApiClient subscriberService = await SubscriberServiceApiClient.CreateAsync();
SubscriptionName subscriptionName = new SubscriptionName(projectId, subscriptionId);
subscriberService.CreateSubscription(subscriptionName, topicName, pushConfig: null, ackDeadlineSeconds: 60);
// Publish a message to the topic using PublisherClient.
PublisherClient publisher = await PublisherClient.CreateAsync(topicName);
// PublishAsync() has various overloads. Here we're using the string overload.
string messageId = await publisher.PublishAsync("Hello, Pubsub");
// PublisherClient instance should be shutdown after use.
// The TimeSpan specifies for how long to attempt to publish locally queued messages.
await publisher.ShutdownAsync(TimeSpan.FromSeconds(15));
// Pull messages from the subscription using SimpleSubscriber.
SubscriberClient subscriber = await SubscriberClient.CreateAsync(subscriptionName);
List <PubsubMessage> receivedMessages = new List <PubsubMessage>();
// Start the subscriber listening for messages.
await subscriber.StartAsync((msg, cancellationToken) =>
{
receivedMessages.Add(msg);
Console.WriteLine($"Received message {msg.MessageId} published at {msg.PublishTime.ToDateTime()}");
Console.WriteLine($"Text: '{msg.Data.ToStringUtf8()}'");
// Stop this subscriber after one message is received.
// This is non-blocking, and the returned Task may be awaited.
subscriber.StopAsync(TimeSpan.FromSeconds(15));
// Return Reply.Ack to indicate this message has been handled.
return(Task.FromResult(SubscriberClient.Reply.Ack));
});
// Tidy up by deleting the subscription and the topic.
subscriberService.DeleteSubscription(subscriptionName);
publisherService.DeleteTopic(topicName);
// End sample
Assert.Equal(1, receivedMessages.Count);
Assert.Equal("Hello, Pubsub", receivedMessages[0].Data.ToStringUtf8());
}
static public async Task publishMessage(string company)
{
List <string> test = new List <string>();
test.Add(company);
Console.WriteLine("dit is in de payment service publishmessage:" + test[0]);
publisherclient = await PublisherClient.CreateAsync(new TopicName("pts6-bijbaan", "paypal-generic"));
await Domain.Publisher.PublishMessagesAsync(publisherclient, test);
}
public static async Task <PublisherClient> GetPublisherAsync(string projectId,
string topicId)
{
// [START pubsub_publish]
PublisherClient publisher = await PublisherClient.CreateAsync(
new TopicName(projectId, topicId));
// [END pubsub_publish]
return(publisher);
}
public async static Task Main(string[] args)
{
Console.WriteLine("Hello World!");
Environment.SetEnvironmentVariable(
"GOOGLE_APPLICATION_CREDENTIALS",
Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "My First Project-065d320bab2e.json"));
CompanyServiceClient companyServiceClient = CompanyServiceClient.Create();
// GoogleCredential credential = GoogleCredential.GetApplicationDefault();
Google.Cloud.Talent.V4Beta1.Company c = new Google.Cloud.Talent.V4Beta1.Company
{
Name = "ADI",
DisplayName = "ADI",
ExternalId = "123"
};
Google.Cloud.Talent.V4Beta1.CreateCompanyRequest request = new Google.Cloud.Talent.V4Beta1.CreateCompanyRequest
{
Company = c
};
Google.Cloud.Talent.V4Beta1.Company response = companyServiceClient.CreateCompany(request);
Console.WriteLine("Created Company");
Console.WriteLine($"Name: {response.Name}");
Console.WriteLine($"Display Name: {response.DisplayName}");
Console.WriteLine($"External ID: {response.ExternalId}");
//JobServiceClient jobServiceClient = JobServiceClient.Create();
// TenantName tenantName = TenantName.FromProjectTenant(projectId, tenantId);
PublisherClient publisher = await PublisherClient.CreateAsync(topicName, null, null);
var pubsubMessage = new PubsubMessage()
{
Data = ByteString.CopyFromUtf8("this is new sample message")
};
string messageId = await publisher.PublishAsync(pubsubMessage);
var subscriptionName = new SubscriptionName(ProjectId, SubscriptionId);
var subscription = await SubscriberClient.CreateAsync(subscriptionName);
try
{
// PullResponse response = subscription.(subscriptionName, true, 10);
await subscription.StartAsync((pubsubMessage, cancellationToken) =>
{
// Process the message here.
var all = Task.FromResult(SubscriberClient.Reply.Ack);
return(all);
});
}
catch (Exception e)
{
Console.WriteLine("Something went wrong: {0}", e.Message);
}
}
public async Task Write(string eventData, HttpContext context)
{
var topicName = new TopicName(_projectId, _topicId);
_logger.LogInformation($"Publishing to topic '{_topicId}' with data '{eventData}");
var publisher = await PublisherClient.CreateAsync(topicName);
await publisher.PublishAsync(eventData);
await publisher.ShutdownAsync(TimeSpan.FromSeconds(10));
}
private void InitializeQueue(string topicName)
{
if (_publisher == null)
{
var googleCredential = GoogleCredential.FromFile(_queueSetting.CredentialFile);
var createSettings = new PublisherClient.ClientCreationSettings(credentials: googleCredential.ToChannelCredentials());
var toppicName = new TopicName(_queueSetting.ProjectId, topicName);
var publisher = PublisherClient.CreateAsync(toppicName, createSettings);
_publisher = publisher.Result;
}
}
public async Task OnUserRegistered(UserDto user)
{
var tmp = new PublisherClient.ClientCreationSettings();
var publisher = await PublisherClient.CreateAsync(topicName);
var body = JsonSerializer.Serialize(user);
string messageId = await publisher.PublishAsync(body);
await publisher.ShutdownAsync(TimeSpan.FromSeconds(15));
}
private async Task <PublisherClient> TryGetPublisherClient(string topic)
{
var topicName = new TopicName(m_projectId, topic);
if (!m_publisherClients.TryGetValue(topicName, out PublisherClient client))
{
client = await PublisherClient.CreateAsync(topicName);
m_publisherClients.Add(topicName, client);
}
return(client);
}
public async Task GetIamPolicyAsync()
{
// Snippet: GetIamPolicyAsync(string,CallSettings)
// Additional: GetIamPolicyAsync(string,CancellationToken)
// Create client
PublisherClient publisherClient = await PublisherClient.CreateAsync();
// Initialize request argument(s)
string formattedResource = new TopicName("[PROJECT]", "[TOPIC]").ToString();
// Make the request
Policy response = await publisherClient.GetIamPolicyAsync(formattedResource);
// End snippet
}
private async Task <string> PublishAsync <T>(TopicName topicName, string emulatorHostAndPort, T message)
{
PublisherClient publisher = await PublisherClient.CreateAsync(topicName,
new PublisherClient.ClientCreationSettings(null, null, ChannelCredentials.Insecure, emulatorHostAndPort));
// PublishAsync() has various overloads. Here we're using the string overload.
string messageId = await publisher.PublishAsync(serializer(message), System.Text.Encoding.UTF8);
// PublisherClient instance should be shutdown after use.
// The TimeSpan specifies for how long to attempt to publish locally queued messages.
await publisher.ShutdownAsync(TimeSpan.FromSeconds(15)); //?
return(messageId);
}
public async Task DeleteTopicAsync()
{
// Snippet: DeleteTopicAsync(TopicName,CallSettings)
// Additional: DeleteTopicAsync(TopicName,CancellationToken)
// Create client
PublisherClient publisherClient = await PublisherClient.CreateAsync();
// Initialize request argument(s)
TopicName topic = new TopicName("[PROJECT]", "[TOPIC]");
// Make the request
await publisherClient.DeleteTopicAsync(topic);
// End snippet
}
public async Task CreateQueueIfNecessary(QueueBindings queueBindings, string identity)
{
var client = await PublisherClient.CreateAsync()
.ConfigureAwait(false);
var addresses = queueBindings.ReceivingAddresses.Concat(queueBindings.SendingAddresses).ToArray();
var tasks = new List <Task>(addresses.Length);
foreach (var address in addresses)
{
tasks.Add(CreateTopic(client, projectId, address));
}
await Task.WhenAll(tasks)
.ConfigureAwait(false);
}
public async Task TestIamPermissionsAsync()
{
// Snippet: TestIamPermissionsAsync(string,IEnumerable<string>,CallSettings)
// Additional: TestIamPermissionsAsync(string,IEnumerable<string>,CancellationToken)
// Create client
PublisherClient publisherClient = await PublisherClient.CreateAsync();
// Initialize request argument(s)
string formattedResource = new TopicName("[PROJECT]", "[TOPIC]").ToString();
IEnumerable <string> permissions = new List <string>();
// Make the request
TestIamPermissionsResponse response = await publisherClient.TestIamPermissionsAsync(formattedResource, permissions);
// End snippet
}
public void PublishMessage(string message)
{
try
{
var topicName = new TopicName(EnvResources.ProjectId, EnvResources.TopicId);
var publisher = PublisherClient.CreateAsync(topicName).Result;
var messageId = publisher.PublishAsync(message).Result;
publisher.ShutdownAsync(TimeSpan.FromSeconds(15));
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public async void PublishAuthor(Author author)
{
var topicName = new TopicName(_pubsubSettings.Value.ProjectId, _pubsubSettings.Value.PushTopicId);
PublisherClient publisher = await PublisherClient.CreateAsync(topicName);
var json = JsonConvert.SerializeObject(author);
var message = new PubsubMessage()
{
Data = ByteString.CopyFromUtf8(json)
};
// Publish it
var response = publisher.PublishAsync(message);
}
private async Task RunPublisherAsync()
{
// The GOOGLE_APPLICATION_CREDENTIALS environment variable contains the path to the
// key json file.
// string value = Environment.GetEnvironmentVariable("GOOGLE_APPLICATION_CREDENTIALS");
// var credential = await GoogleCredential.GetApplicationDefaultAsync();
// Make sure you topicId doesn't contain '/' symbols.
var projectId = "{YOUR-PROJECT-ID}";
var topicId = "{YOUR-TOPIC-ID}";
var topicName = new TopicName(projectId, topicId);
var topic = await PublisherClient.CreateAsync(topicName);
var pubSubMessage = CreatePubSubMessage("Hello Ilya! This is my first message.");
await topic.PublishAsync(pubSubMessage);
}
public async Task OversizedMessage()
{
var topicId = _fixture.CreateTopicId();
// Create topic
var topicName = new TopicName(_fixture.ProjectId, topicId);
var publisher = await PublisherClient.CreateAsync().ConfigureAwait(false);
await publisher.CreateTopicAsync(topicName).ConfigureAwait(false);
// Create SimplePublisher
var simplePublisher = await SimplePublisher.CreateAsync(topicName).ConfigureAwait(false);
// Create oversized message
Random rnd = new Random(1234);
byte[] msg = new byte[10_000_001];
public async Task GetIamPolicyAsync_RequestObject()
{
// Snippet: GetIamPolicyAsync(GetIamPolicyRequest,CallSettings)
// Create client
PublisherClient publisherClient = await PublisherClient.CreateAsync();
// Initialize request argument(s)
GetIamPolicyRequest request = new GetIamPolicyRequest
{
Resource = new TopicName("[PROJECT]", "[TOPIC]").ToString(),
};
// Make the request
Policy response = await publisherClient.GetIamPolicyAsync(request);
// End snippet
}
public async Task DeleteTopicAsync_RequestObject()
{
// Snippet: DeleteTopicAsync(DeleteTopicRequest,CallSettings)
// Create client
PublisherClient publisherClient = await PublisherClient.CreateAsync();
// Initialize request argument(s)
DeleteTopicRequest request = new DeleteTopicRequest
{
TopicAsTopicName = new TopicName("[PROJECT]", "[TOPIC]"),
};
// Make the request
await publisherClient.DeleteTopicAsync(request);
// End snippet
}
public async Task CreateTopicAsync_RequestObject()
{
// Snippet: CreateTopicAsync(Topic,CallSettings)
// Create client
PublisherClient publisherClient = await PublisherClient.CreateAsync();
// Initialize request argument(s)
Topic request = new Topic
{
TopicName = new TopicName("[PROJECT]", "[TOPIC]"),
};
// Make the request
Topic response = await publisherClient.CreateTopicAsync(request);
// End snippet
}
