{"id":6082,"date":"2015-12-31T06:54:43","date_gmt":"2015-12-31T06:54:43","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/webdev\/2015\/12\/31\/new-year-updates-to-asp-net-webhooks-preview\/"},"modified":"2023-09-21T11:33:52","modified_gmt":"2023-09-21T18:33:52","slug":"new-year-updates-to-asp-net-webhooks-preview","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/dotnet\/new-year-updates-to-asp-net-webhooks-preview\/","title":{"rendered":"New Year Updates to ASP.NET WebHooks Preview"},"content":{"rendered":"

We just released a new update of ASP.NET WebHooks with a couple of interesting new features on the WebHooks sender<\/em> side \u2013 that is, when you want to send WebHooks to others when some event happens \u2013 including:<\/p>\n

    \n
  1. Sending events to all<\/em> users registered for a particular event. <\/li>\n
  2. Scaling out and load balancing events using persistent queues. <\/li>\n<\/ol>\n

    You can get the update from nuget.org<\/a> by looking for the packages under Microsoft.AspNet.WebHooks.*<\/a> with \u2018preview\u2019 filter enabled. If you haven\u2019t heard about ASP.NET WebHooks then you may want to look at Introducing Microsoft ASP.NET WebHooks Preview<\/a>. As this blog is about the sending side, the blog Sending WebHooks with ASP.NET WebHooks Preview<\/a> also provides good background.<\/p>\n

    Sending Events to All Users<\/h3>\n

    In addition to sending events in the form of WebHooks to individual users, it is now possible to send WebHooks to all users who have registered for a particular event. We now expose the method NotifyAllAsync<\/strong> in the same places where you could use NotifyAsync<\/strong> to send notifications to all active registered WebHooks. <\/p>\n

    Also, you can use a predicate as a filter if you want to control which users get the WebHook notification. For example, in the below illustration, Receiver 2 and 5 don\u2019t get this particular event due to the predicate.<\/p>\n

    \"NotifyAll\"<\/a><\/p>\n

    Using NotifyAllAsync<\/strong> is very similar to using NotifyAsync<\/strong> and it is available in the same places. Assuming you have a project already set up to support WebHooks as described in the blog entry Sending WebHooks with ASP.NET WebHooks Preview<\/a> or using this sample<\/a>, here\u2019s how you can use NotifyAllAsync<\/strong> in an MVC controller:<\/p>\n

    \n

    [Authorize]
    public<\/span> class<\/span> NotifyController : Controller
    {
        [HttpPost]
        public<\/span> async Task<ActionResult> Submit()
        {
            \/\/ Create an event with action 'event1' and additional data<\/span>
            await this<\/span>.NotifyAsync("event1"<\/span>, new<\/span> { P1 = "p1"<\/span> });
     
            \/\/ Send event1 to all users not called 'henrik'<\/span>
            await this<\/span>.NotifyAllAsync("event1"<\/span>, 
                new<\/span> { P1 = "p1"<\/span> }, (webHook, user) => { return<\/span> user != "henrik"<\/span> });
    <\/font> 
            return<\/span> new<\/span> EmptyResult();
        }
    }<\/pre>\n
    The model looks exactly the same in a Web API controller:<\/p>\n
    \n
    [Authorize]
    public<\/span> class<\/span> NotifyApiController : ApiController
    {
        public<\/span> async Task<IHttpActionResult> Post()
        {
            \/\/ Create an event with 'event2' and additional data<\/span>
            await this<\/span>.NotifyAsync("event2"<\/span>, new<\/span> { P1 = "p1"<\/span> });
     
            \/\/ Send event2 to all users not called 'henrik'<\/span>
            await this<\/span>.NotifyAllAsync("event2"<\/span>,
                new<\/span> { P1 = "p1"<\/span> }, (webHook, user) => { return<\/span> user != "henrik"<\/span> });
    <\/font> 
            return<\/span> Ok();
        }
    }<\/pre>\n
    <\/div>\n
    Sending WebHooks: Scaling Out and Load Balancing<\/h3>\n
    We have introduced a new IWebHookSender<\/a> abstraction which allows you to scale-out and load-balance the act of sending out WebHooks. That is, instead of having the Web server directly sending out WebHooks, it is now possible to have an architecture like this allowing you to both persist WebHooks on the sender side and to scale up and out as you want:<\/p>\n
    \"ScaleOut\"<\/a><\/p>\n
    To illustrate this, we provide out of the box support for sending WebHooks via an Azure Storage Queue<\/a> but you can hook  in any kind of queue. Once you have a project already set up to support WebHooks (like this sample<\/a>) as described in the blog entry Sending WebHooks with ASP.NET WebHooks Preview<\/a>, configuring it to support Azure Storage Queues is quite simple:<\/p>\n
      \n
    1. On the frontend side, you register a special IWebHookSender implementation<\/a> which simply submits all WebHooks to an Azure Storage Queue. <\/li>\n
    2. On the sender side, you use the AzureWebHookDequeueManager class<\/a> which dequeues messages from the Azure Storage Queue and then sends them out as WebHooks. <\/li>\n<\/ol>\n
      To register the queue IWebHookSender<\/strong> implementation (part of the Microsoft.AspNet.WebHooks.Custom.AzureStorage nuget package<\/a>) on the frontend<\/em>, simply add this line to the initialization:<\/p>\n
      \n
      public<\/span> static<\/span> class<\/span> WebApiConfig
      {
          public<\/span> static<\/span> void<\/span> Register(HttpConfiguration config)
          {
              \/\/ Web API routes<\/span>
              config.MapHttpAttributeRoutes();
       
              config.Routes.MapHttpRoute(
                  name: "DefaultApi"<\/span>,
                  routeTemplate: "api\/{controller}\/{id}"<\/span>,
                  defaults: new<\/span> { id = RouteParameter.Optional }
              );
       
              \/\/ Load basic support for sending WebHooks<\/span>
              config.InitializeCustomWebHooks();
       
              \/\/ Load Azure Storage (or SQL) for persisting subscriptions<\/span>
              config.InitializeCustomWebHooksAzureStorage();
       
              \/\/ Load Azure Queued Sender for enqueueing outgoing WebHooks to an Azure Storage Queue<\/span>
              config.InitializeCustomWebHooksAzureQueueSender();
      <\/font> 
              \/\/ Load Web API controllers for managing subscriptions<\/span>
              config.InitializeCustomWebHooksApis();
          }
      }<\/pre>\n
      <\/div>\n
      To configure the frontend, you need to set the Azure Storage connection string, that it should use, for example:<\/p>\n
      \n
      <<\/span>connectionStrings<\/span>><\/span>
        <<\/span>add<\/span> name<\/span>="MS_AzureStoreConnectionString"<\/span> connectionString<\/span>="UseDevelopmentStorage=true;"<\/span> \/><\/span>
      <\/<\/span>connectionStrings<\/span>><\/span><\/pre>\n
      <\/div>\n
      On the sender<\/em> side, you now need a process that can dequeue messages from the Azure Storage Queue and send them out to the targeted WebHook recipients. This can be a simple command line program (like this sample<\/a>):<\/p>\n
      \n
      internal<\/span> class<\/span> Program
      {
          private<\/span> const<\/span> string<\/span> QueueConnectionString = "MS_AzureStoreConnectionString"<\/span>;
       
          public<\/span> static<\/span> void<\/span> Main(string<\/span>[] args)
          {
              CancellationTokenSource cancellationTokenSource = new<\/span> CancellationTokenSource();
              Task.Run(() => DequeueAndSendWebHooks(cancellationTokenSource.Token));
       
              Console.WriteLine("Hit ENTER to exit!"<\/span>);
              Console.ReadLine();
       
              cancellationTokenSource.Cancel();
          }
       
          private<\/span> static<\/span> async Task DequeueAndSendWebHooks(CancellationToken cancellationToken)
          {
              \/\/ Create the dequeue manager<\/span>
              string<\/span> connectionString = 
                  ConfigurationManager.ConnectionStrings[QueueConnectionString].ConnectionString;
              ILogger logger = CommonServices.GetLogger();
              AzureWebHookDequeueManager manager = new<\/span> AzureWebHookDequeueManager(connectionString, logger);<\/font>
       
              \/\/ Start the dequeue manager<\/span>
              await manager.Start(cancellationToken);
      <\/font>    }
      }<\/pre>\n
      <\/div>\n
      The two highlighted lines are the key ones \u2013 the first creates the AzureWebHookDequeueManager<\/strong> using the given connection string pointing to the queue. The second line starts an event loop returning a Task<\/strong> that you can cancel when you are done. The AzureWebHookDequeueManager<\/strong> will periodically poll for new messages in the queue and send them out as WebHooks.<\/p>\n
      If the WebHook requests either succeed or return HTTP status code 410 Gone, then we consider the message delivered and delete it from the queue. Otherwise we leave it in the queue ensuring that it will get another chance of being sent out after a couple of minutes. After 3 attempts we give up and delete the message from the queue regardless. For more information about Azure Storage Queues, please see the blog How to use Queue storage from .NET<\/a>.<\/p>\n
      Like for the sender side, we can provide the Azure Storage connection string in the config file, for example:<\/p>\n
      \n
      <<\/span>connectionStrings<\/span>><\/span>
        <<\/span>add<\/span> name<\/span>="MS_AzureStoreConnectionString"<\/span> connectionString<\/span>="UseDevelopmentStorage=true;"<\/span> \/><\/span>
      <\/<\/span>connectionStrings<\/span>><\/span>
      <\/pre>\n<\/div>\n
       <\/div>\n
      That\u2019s it \u2013 I hope you enjoy these new features in ASP.NET WebHooks!<\/div>\n
      Happy New Year!<\/p>\n
      Henrik<\/p>\n","protected":false},"excerpt":{"rendered":"
      We just released a new update of ASP.NET WebHooks with a couple of interesting new features on the WebHooks sender side \u2013 that is, when you want to send WebHooks to others when some event happens \u2013 including: Sending events to all users registered for a particular event. Scaling out and load balancing events using […]<\/p>\n","protected":false},"author":403,"featured_media":58792,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[197],"tags":[34,7505,7506],"class_list":["post-6082","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-aspnet","tag-asp-net-web-api","tag-asp-net-webhooks","tag-webhooks"],"acf":[],"blog_post_summary":"
      We just released a new update of ASP.NET WebHooks with a couple of interesting new features on the WebHooks sender side \u2013 that is, when you want to send WebHooks to others when some event happens \u2013 including: Sending events to all users registered for a particular event. Scaling out and load balancing events using […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts\/6082","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/users\/403"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/comments?post=6082"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts\/6082\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/media\/58792"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/media?parent=6082"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/categories?post=6082"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/tags?post=6082"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}