/// <summary> /// Asynchronously adds a metadata payload to Google PubSub /// </summary> /// <param name="metadata">metadata to add to queue</param> /// <returns>success of operation</returns> public async Task <bool> Enqueue(QueueMetadata metadata) { try { PublisherServiceApiClient publisher = PublisherServiceApiClient.Create(); TopicName topicName = new TopicName(this.cloud.GoogleProjectID, this.cloud.QueueName); await this.CreateTopicIfNotExistsAsync(publisher, topicName); var message = new PubsubMessage() { Data = ByteString.CopyFromUtf8(JsonConvert.SerializeObject(metadata)), }; var messageList = new List <PubsubMessage>() { message }; await publisher.PublishAsync(topicName, messageList); } catch { return(false); } return(true); }
/// <inherithdoc/> public IBatchContainer FromPullResponseMessage(PubsubMessage msg, long sequenceId) { var batchContainer = _serializationManager.DeserializeFromByteArray <PubSubBatchContainer>(msg.Data.ToByteArray()); batchContainer.RealSequenceToken = new EventSequenceTokenV2(sequenceId); return(batchContainer); }
public async Task PublishAsync() { string projectId = _fixture.ProjectId; string topicId = _fixture.CreateTopicId(); // Snippet: PublishAsync(*,*,CallSettings) // Additional: PublishAsync(*,*,CancellationToken) PublisherClient client = PublisherClient.Create(); // Make sure we have a topic to publish to string topicName = PublisherClient.FormatTopicName(projectId, topicId); await client.CreateTopicAsync(topicName); PubsubMessage message = new PubsubMessage { // The data is any arbitrary ByteString. Here, we're using text. Data = ByteString.CopyFromUtf8("Hello, Pubsub"), // The attributes provide metadata in a string-to-string dictionary. Attributes = { { "description", "Simple text message" } } }; await client.PublishAsync(topicName, new[] { message }); // End snippet }
public void StartPeriodicallyPublish(int timeIntervalInSeconds) { PublisherServiceApiClient publisher = PublisherServiceApiClient.Create(); TopicName topicName = new TopicName("k8s-brewery", "sdk-example-test-topic"); try { publisher.CreateTopic(topicName); } catch (Exception) { Console.WriteLine("Failed to create topic"); } int j = 0; Task.Run(() => { while (!token.IsCancellationRequested) { // Publish a message to the topic. PubsubMessage message = new PubsubMessage { Data = ByteString.CopyFromUtf8("Test message number " + j), Attributes = { { "description", "Simple text message number " + j } } }; publisher.Publish(topicName, new[] { message }); j++; Thread.Sleep(timeIntervalInSeconds * 1000); } }); }
public void Publish() { string projectId = _fixture.ProjectId; string topicId = _fixture.CreateTopicId(); // Snippet: Publish(*,*,*) PublisherClient client = PublisherClient.Create(); // Make sure we have a topic to publish to TopicName topicName = new TopicName(projectId, topicId); client.CreateTopic(topicName); PubsubMessage message = new PubsubMessage { // The data is any arbitrary ByteString. Here, we're using text. Data = ByteString.CopyFromUtf8("Hello, Pubsub"), // The attributes provide metadata in a string-to-string dictionary. Attributes = { { "description", "Simple text message" } } }; client.Publish(topicName, new[] { message }); // End snippet }
public Topic CreateTopic(string projectId, string topicId) { PublisherServiceApiClient publisher = PublisherServiceApiClient.Create(); var topicName = TopicName.FromProjectTopic(projectId, topicId); Topic topic = null; try { topic = publisher.CreateTopic(topicName); Console.WriteLine($"Topic {topic.Name} created."); } catch (RpcException e) when(e.Status.StatusCode == StatusCode.AlreadyExists) { Console.WriteLine($"Topic {topicName} already exists."); } PubsubMessage message = new PubsubMessage { // The data is any arbitrary ByteString. Here, we're using text. Data = ByteString.CopyFromUtf8("Hello, Pubsub"), // The attributes provide metadata in a string-to-string dictionary. Attributes = { { "description", "Simple text message" } } }; publisher.Publish(topicName, new[] { message }); return(topic); }
private static void RePublishMessages() { var json = File.ReadAllText(jsonFile); List <PubsubMessage> unPublishedMessages = new List <PubsubMessage>(); try { var jsonObj = JObject.Parse(json); var messageArray = jsonObj.GetValue("messages") as JArray; if (messageArray != null) { foreach (var newMessage in messageArray) { PubsubMessage pubsubMessage = new PubsubMessage { Data = ByteString.CopyFromUtf8(newMessage["Data"].ToString()), Attributes = { { "description", newMessage["Attributes"]["description"].ToString() } } }; //Now we can call Google Publish Method Again } } } catch (Exception ex) { Console.WriteLine("Add Error : " + ex.Message.ToString()); } }
private void HandlePubSubEvent(object sender, PubSubEventArgs pubSubEventArgs) { // The PubSubMessage header should only contain the message type. // The message data should contain all information to process the message. PubsubMessage pubsubMessage = pubSubEventArgs.PubsubMessage; string pubSubMessageType = GetPubSubMessageAttribute(pubsubMessage, "type"); // the gameId should not be stored in the message Attributes but rather in the data string gameIdString = GetPubSubMessageAttribute(pubsubMessage, "comp_id"); Guid gameId = Guid.Parse(gameIdString); string pubsubData = pubsubMessage.Data.ToStringUtf8(); switch (pubSubMessageType) { case "marketOdds": HandleMarketOddsUpdate(pubsubData, gameId); break; case "liveOdds": HandleLiveMarketOddsUpdate(pubsubData, gameId); break; case "odds": HandleOddsUpdate(pubsubData, gameId); break; case "test": HandleTest(pubsubData); break; default: Logger.Error($"Could not handle PubSub message type = '{pubSubMessageType}'"); return; } }
static async Task <SubscriberClient.Reply> HandleMessage(PubsubMessage message, CancellationToken token) { var messageBody = Encoding.UTF8.GetString(message.Data.ToByteArray()); if (messageBody != "RUN_SPEEDTEST") { return(SubscriberClient.Reply.Nack); } Console.WriteLine("Running speedtest!"); var runner = new SpeedTestRunner(_loggerConfig.LoggerLocation); var testData = runner.RunSpeedTest(); var results = new TestResult { User = _loggerConfig.UserId, Device = _loggerConfig.LoggerId, Timestamp = DateTimeOffset.Now.ToUnixTimeMilliseconds(), Data = testData }; var success = false; using (var client = new SpeedTestApiClient(_loggerConfig.ApiUrl)) { success = await client.PublishTestResult(results); } Console.WriteLine($"SpeedTest {(success == true ? "complete" : "failed")}!"); return(success == true ? SubscriberClient.Reply.Ack : SubscriberClient.Reply.Nack); }
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); } }
/// <summary> /// Extracts and deserializes a given message /// </summary> /// <param name="message">The message that needs deserialized</param> /// <returns>T.</returns> /// <exception cref="InvalidOperationException">Cannot access the message content for message {message.MessageId}</exception> private T GetTypedMessageContent <T>(PubsubMessage message) where T : class { string content = message.Data.ToStringUtf8(); // Check for no content (we cannot process this). if (content.IsNullOrEmpty()) { throw new InvalidOperationException($"Cannot access the message content for message {message.MessageId}"); } try { // Deserialize to a specific type. return(JsonConvert.DeserializeObject <T>(content)); } catch (Exception ex) when(ex is JsonReaderException || ex is JsonSerializationException) { // If we are actually expecting T to be a system type, just return without serialization. if (typeof(T).IsSystemType()) { return(content as T); } _logger?.LogWarning($"Could not map message to {typeof(T)}, sending message to error flow"); // NOTE: Maybe should automatically dead-letter the message if conversion fails? return(null); } }
private static void PublishToTopic() { var topicName = new TopicName(ProjectId, TopicId); var publisher = PublisherServiceApiClient.Create(); // Create a message var message = new PubsubMessage() { Data = ByteString.CopyFromUtf8("hello world") }; message.Attributes.Add("myattrib", "its value"); // Add it to the list of messages to publish var messageList = new List <PubsubMessage>() { message }; // Publish it Console.WriteLine("Publishing..."); var response = publisher.Publish(topicName, messageList); // Get the message ids GCloud gave us Console.WriteLine(" Message ids published:"); foreach (string messageId in response.MessageIds) { Console.WriteLine($" {messageId}"); } }
protected override async Task ExecuteAsync(CancellationToken stoppingToken) { while (!stoppingToken.IsCancellationRequested) { try { _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now); if (CanConnectToPubSub()) { // Subscribe to the topic. SubscriberServiceApiClient subscriber = CreateSubscriber(); var subscriptionName = new SubscriptionName(GCP_PROJECT, GCP_SUBSCRIBER); PullResponse response = subscriber.Pull(subscriptionName, returnImmediately: true, maxMessages: 100); foreach (ReceivedMessage received in response.ReceivedMessages) { PubsubMessage msg = received.Message; _logger.LogInformation($"Received message {msg.MessageId} published at {msg.PublishTime.ToDateTime()}"); _logger.LogInformation($"Text: '{msg.Data.ToStringUtf8()}'"); } if (response.ReceivedMessages.Any()) { subscriber.Acknowledge(subscriptionName, response.ReceivedMessages.Select(m => m.AckId)); } } } catch (Exception e) { _logger.LogError($"{e.Message} - {e.StackTrace}"); } await Task.Delay(5000, stoppingToken); } }
public async Task <string> EnviarMensagem(string mensagem) { var topicName = new TopicName("estudo-ci-cd", "tp-poc-ex"); string retornoIdMensagem = ""; PublisherServiceApiClient publisher = PublisherServiceApiClient.Create(); // Create a message var message = new PubsubMessage() { Data = ByteString.CopyFromUtf8(mensagem) }; //message.Attributes.Add("myattrib", "its value"); var messageList = new List <PubsubMessage>() { message }; var response = await publisher.PublishAsync(topicName, messageList); foreach (var item in response.MessageIds) { retornoIdMensagem = item; } return(retornoIdMensagem); }
async Task <SimpleSubscriber.Reply> Consume(PubsubMessage message, CancellationToken token) { using (var tokenSource = new CancellationTokenSource()) { var processed = false; var errorHandled = false; var numberOfDeliveryAttempts = 0; var headers = message.Attributes.ToDictionary(k => k.Key, v => v.Value); var body = message.Data.ToByteArray(); var messageId = message.MessageId; while (!processed && !errorHandled) { try { var messageContext = new MessageContext(messageId, headers, body ?? emptyBody, transportTransaction, tokenSource, contextBag); await onMessage(messageContext).ConfigureAwait(false); processed = true; } catch (Exception ex) { ++numberOfDeliveryAttempts; var errorContext = new ErrorContext(ex, headers, messageId, body ?? emptyBody, transportTransaction, numberOfDeliveryAttempts); errorHandled = await onError(errorContext).ConfigureAwait(false) == ErrorHandleResult.Handled; } } if (processed && tokenSource.IsCancellationRequested) { return(SimpleSubscriber.Reply.Nack); } return(SimpleSubscriber.Reply.Ack); } }
public async Task CreateConsumer(TopicName topic) { SubscriberServiceApiClient subscriber = SubscriberServiceApiClient.Create(); SubscriptionName subscriptionName = new SubscriptionName(_projectId, "SubscriptionN"); PubsubMessage messageSubscription = new PubsubMessage(); var subscriptionCreated = subscriber.CreateSubscription(subscriptionName, topic, pushConfig: null, ackDeadlineSeconds: 60); SubscriberClient subscriberClient = await SubscriberClient.CreateAsync( subscriptionName); var result = subscriberClient.StartAsync( async(PubsubMessage message, CancellationToken cancel) => { string text = Encoding.UTF8.GetString(message.Data.ToArray()); messageSubscription = message; await Console.Out.WriteLineAsync($"Message {message.MessageId} : {text}"); Console.WriteLine(message); return(await Task.FromResult(SubscriberClient.Reply.Ack)); }); await Task.Delay(3000); await subscriberClient.StopAsync(CancellationToken.None); Console.WriteLine($"Subscriber message {messageSubscription} "); }
public IActionResult Index(MessageForm messageForm) { var model = new MessageList(); if (!_options.HasGoodProjectId()) { model.MissingProjectId = true; return View(model); } if (!string.IsNullOrEmpty(messageForm.Message)) { // Publish the message. var topicName = new TopicName(_options.ProjectId, _options.TopicId); lock(s_lock) CreateTopicAndSubscriptionOnce(_publisher, topicName); var pubsubMessage = new PubsubMessage() { Data = ByteString.CopyFromUtf8(messageForm.Message) }; pubsubMessage.Attributes["token"] = _options.VerificationToken; _publisher.Publish(topicName, new[] { pubsubMessage }); model.PublishedMessage = messageForm.Message; } // Render the current list of messages. lock (s_lock) model.Messages = s_receivedMessages.ToArray(); return View(model); }
//public Task<SubscriberClient.Reply> OnReceivePubsubMessage(PubsubMessage pubSubMessage, CancellationToken ct, Action doWork) //{ // bool acknowledge = true; // doWork(pubSubMessage, ct); // return Task.FromResult(acknowledge ? SubscriberClient.Reply.Ack : SubscriberClient.Reply.Nack); //} public Task <SubscriberClient.Reply> OnReceivePubsubMessage(PubsubMessage pubSubMessage, CancellationToken ct, Action <object, CancellationToken> doWork) { bool acknowledge = true; doWork(pubSubMessage, ct); return(Task.FromResult(acknowledge ? SubscriberClient.Reply.Ack : SubscriberClient.Reply.Nack)); }
private Task <SubscriberClient.Reply> HandleMessage(PubsubMessage message, CancellationToken token) { var receivedMessage = message.Data.ToStringUtf8(); Console.WriteLine($"New message has been received!\nMessage: {receivedMessage}"); return(Task.Run(() => SubscriberClient.Reply.Ack)); }
public Task <SubscriberClient.Reply> ProcMessage3(PubsubMessage pubSubMessage, CancellationToken ct, Action a) { bool acknowledge = true; a(); return(Task.FromResult(acknowledge ? SubscriberClient.Reply.Ack : SubscriberClient.Reply.Nack)); }
public void Overview() { string projectId = _fixture.ProjectId; string topicId = _fixture.CreateTopicId(); string subscriptionId = _fixture.CreateSubscriptionId(); // Sample: Overview // First create a topic. PublisherClient publisher = PublisherClient.Create(); TopicName topicName = new TopicName(projectId, topicId); publisher.CreateTopic(topicName); // Subscribe to the topic. SubscriberClient subscriber = SubscriberClient.Create(); SubscriptionName subscriptionName = new SubscriptionName(projectId, subscriptionId); subscriber.CreateSubscription(subscriptionName, topicName, pushConfig: null, ackDeadlineSeconds: 60); // Publish a message to the topic. PubsubMessage message = new PubsubMessage { // The data is any arbitrary ByteString. Here, we're using text. Data = ByteString.CopyFromUtf8("Hello, Pubsub"), // The attributes provide metadata in a string-to-string dictionary. Attributes = { { "description", "Simple text message" } } }; publisher.Publish(topicName, new[] { message }); // Pull messages from the subscription. We're returning immediately, whether or not there // are messages; in other cases you'll want to allow the call to wait until a message arrives. PullResponse response = subscriber.Pull(subscriptionName, returnImmediately: true, maxMessages: 10); foreach (ReceivedMessage received in response.ReceivedMessages) { PubsubMessage msg = received.Message; Console.WriteLine($"Received message {msg.MessageId} published at {msg.PublishTime.ToDateTime()}"); Console.WriteLine($"Text: '{msg.Data.ToStringUtf8()}'"); } // Acknowledge that we've received the messages. If we don't do this within 60 seconds (as specified // when we created the subscription) we'll receive the messages again when we next pull. subscriber.Acknowledge(subscriptionName, response.ReceivedMessages.Select(m => m.AckId)); // Tidy up by deleting the subscription and the topic. subscriber.DeleteSubscription(subscriptionName); publisher.DeleteTopic(topicName); // End sample Assert.Equal(1, response.ReceivedMessages.Count); Assert.Equal("Hello, Pubsub", response.ReceivedMessages[0].Message.Data.ToStringUtf8()); Assert.Equal("Simple text message", response.ReceivedMessages[0].Message.Attributes["description"]); }
private static string GetPubSubMessageAttribute(PubsubMessage pubsubMessage, string key) { if (pubsubMessage.Attributes.ContainsKey(key)) { return(pubsubMessage.Attributes[key]); } return(""); }
public Task <SubscriberClient.Reply> ProcMessage(PubsubMessage pubSubMessage, CancellationToken ct) { int messageCount = 0; bool acknowledge = true; string text = System.Text.Encoding.UTF8.GetString(pubSubMessage.Data.ToArray()); Console.WriteLine($"Message {pubSubMessage.MessageId}: {text}"); Interlocked.Increment(ref messageCount); return(Task.FromResult(acknowledge ? SubscriberClient.Reply.Ack : SubscriberClient.Reply.Nack)); }
private PubsubMessage CreateMessage(Item item) { var message = new PubsubMessage() { Data = ByteString.CopyFromUtf8(JsonSerializer.Serialize(item)) }; message.Attributes.Add("itemId", item.Id.ToString()); return(message); }
public async Task Create(Entityframework.IEvent Profile) { var message = JsonConvert.SerializeObject(Profile); var pubsubMessage = new PubsubMessage() { Data = ByteString.CopyFromUtf8(message) }; // pubsubMessage.Attributes["token"] = _options.VerificationToken; await publisher.PublishAsync(pubsubMessage); }
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 SendMessage(VehiclePositionEvent message) { var messageJson = JsonConvert.SerializeObject(message); var pubsubMessage = new PubsubMessage() { Data = ByteString.CopyFromUtf8(messageJson) }; await _client.PublishAsync(pubsubMessage); }
public async Task ProduceAsync(string key, T message) { var serialized = serializer.SerializeToBytes(message); var pubSubMessage = new PubsubMessage { Data = ByteString.CopyFrom(serialized) }; await publisherClient.PublishAsync(pubSubMessage); }
public async Task NoRetry(PubsubMessage message) { await ExecuteCloudEventRequestAsync( MessagePublishedData.MessagePublishedCloudEventType, new MessagePublishedData { Message = message }); var logEntry = Assert.Single(GetFunctionLogEntries()); Assert.Equal(LogLevel.Information, logEntry.Level); Assert.Equal("Not retrying...", logEntry.Message); }
public async Task <string> SendAsync <T>(T message) where T : class { var publisher = await this.publisherLazy.Value; var psMessage = new PubsubMessage(); psMessage.Attributes.Add(nameof(Type), typeof(T).FullName); var text = JsonConvert.SerializeObject(message); psMessage.Data = ByteString.CopyFromUtf8(text); return(await publisher.PublishAsync(psMessage)); }
//--------- public PubsubMessage ConvertToPubsubMessage(IEnumerable<string> dataList) { StringBuilder sb = new StringBuilder(); string attrMinValue = null; if (dataList != null) { foreach (string data in dataList) { sb.AppendLine(data); //--- if (this._attrMinCreate) { attrMinValue = this._CalculateMinValue(attrMinValue, data); } } } //--- PubsubMessage message = new PubsubMessage(); //--- if (this._options.MessageDataToBase64) { message.Data = ByteString.FromBase64(Convert.ToBase64String(Encoding.UTF8.GetBytes(sb.ToString()))); } else { message.Data = ByteString.CopyFromUtf8(sb.ToString()); } if (this._attrMinCreate) { message.Attributes.Add(this._attrMinName, (attrMinValue ?? string.Empty)); } if (this._options.MessageAttrFixed != null) { foreach (KeyValuePair<string,string> kv in this._options.MessageAttrFixed) { message.Attributes.Add(kv.Key, (kv.Value ?? string.Empty)); } } //--- return message; }
public void CreateTopicMessage(string topicId, PublisherClient publisher) { // [START publish_message] string topicName = PublisherClient.FormatTopicName(_projectId, topicId); PubsubMessage message = new PubsubMessage { // The data is any arbitrary ByteString. Here, we're using text. Data = ByteString.CopyFromUtf8("Hello Cloud Pub/Sub!"), // The attributes provide metadata in a string-to-string // dictionary. Attributes = { { "description", "Simple text message" } } }; publisher.Publish(topicName, new[] { message }); // [END publish_message] }