message_bus 3.3.7 → 3.3.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 16601ac02268a477a94bf0347922162f66ce17dfdba1c4c655d576b46e78a79c
-  data.tar.gz: 746e2295f873d9cfe75c28b079b406bb42329a992146d414c63292c2148a8f48
+  metadata.gz: b45c0d65f5a82c9465f620059d2125ebca09ee5619a9094fcbc309a0e179a983
+  data.tar.gz: b691c40ae2360ae661aa83f83e9647cb0223a70a6ca536f285db21ce791a3ae3
 SHA512:
-  metadata.gz: 3d048dde14c63d5abdda283571cb9c2be1b7fc809a94c7f0b4ec2eaa4785da03bc47535264741f65cfa1d66c75e1b0169ea0de39449456b9c791ba91518d62e9
-  data.tar.gz: 0cfbed1cab954e33805c94c7662c9094276615d5f338168da48d26f033da0f42685024b87aaee64d221e192d0592cd655fba7473da8d973616b218ce2858b045
+  metadata.gz: 2bb5db140d0fc8bbee5df6e00f57560b1e399c7cac86d825f9841c4c9d8bc805ec8f9ab2ea8ba0ad066c53039a44b5044ecef7299a74f942b3a52cd426ecbef6
+  data.tar.gz: 66fdc2a3c483d1b775b3963b71bdc422edcdf16233cb47aa2ec99d3a6946e6e0f6f6ca917db12e5d528de6dfb39cc494923e2abe380ca0c75d64d92f6f167d7e

data/.github/workflows/ci.yml

@@ -1,16 +1,10 @@
-name: Message Bus Tests
+name: CI
 
 on:
-  pull_request:
   push:
     branches:
       - main
-
-env:
-  PGHOST: localhost
-  PGPORT: 5432
-  PGPASSWORD: postgres
-  PGUSER: postgres
+  pull_request:
 
 jobs:
   build:
@@ -18,10 +12,22 @@ jobs:
     name: Ruby ${{ matrix.ruby }} (redis ${{ matrix.redis }})
     timeout-minutes: 10
 
+    env:
+      PGHOST: localhost
+      PGPASSWORD: postgres
+      PGUSER: postgres
+
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: [2.6, 2.7, 3.0]
+        redis: [5, 6]
+
     services:
       postgres:
-        image: postgres:14.0
+        image: postgres:14
         env:
+          POSTGRES_DB: message_bus_test
           POSTGRES_PASSWORD: postgres
         ports:
           - 5432:5432
@@ -36,19 +42,13 @@ jobs:
           --health-timeout 5s
           --health-retries 5
 
-    strategy:
-      fail-fast: false
-      matrix:
-        ruby: ["3.0", "2.7", "2.6"]
-        redis: ["5", "6"]
-
     steps:
       - uses: actions/checkout@v2
 
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.ruby }}
-          bundler-cache: true # 'bundle install' and cache
+          bundler-cache: true
 
       - name: Set up Node.js
         uses: actions/setup-node@v2
@@ -59,13 +59,41 @@ jobs:
       - name: Setup npm
         run: npm install
 
-      - name: Create Database
-        run: |
-          createdb message_bus_test
-
       - name: Tests
         run: bundle exec rake
         timeout-minutes: 3
 
       - name: Linting
         run: npx eslint .
+
+  publish:
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    needs: build
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Release gem
+        uses: discourse/publish-rubygems-action@v2
+        id: publish-gem
+        env:
+          RUBYGEMS_API_KEY: ${{ secrets.RUBYGEMS_API_KEY }}
+          GIT_EMAIL: team@discourse.org
+          GIT_NAME: discoursebot
+
+      - name: Update package version
+        if: steps.publish-gem.outputs.new_version == 'true'
+        run: |
+          VERSION=$(ruby -r './lib/message_bus/version' -e 'puts MessageBus::VERSION')
+          sed -i "s/0.0.0-version-placeholder/$VERSION/" package.json
+          git config --global user.email "ci@ci.invalid"
+          git config --global user.name "Discourse CI"
+          git add package.json
+          git commit -m 'bump'
+
+      - name: Publish package
+        uses: JS-DevTools/npm-publish@v1
+        if: steps.publish-gem.outputs.new_version == 'true'
+        with:
+          token: ${{ secrets.NPM_TOKEN }}

data/.prettierrc

@@ -0,0 +1 @@
+{}

data/lib/message_bus/backends/base.rb

@@ -84,6 +84,11 @@ module MessageBus
         raise ConcreteClassMustImplementError
       end
 
+      # Closes all open connections to the storage.
+      def destroy
+        raise ConcreteClassMustImplementError
+      end
+
       # Deletes all backlogs and their data. Does not delete non-backlog data that message_bus may persist, depending on the concrete backend implementation. Use with extreme caution.
       # @abstract
       def expire_all_backlogs!

data/lib/message_bus/backends/memory.rb

@@ -212,6 +212,12 @@ module MessageBus
         client.reset!
       end
 
+      # No-op; this backend doesn't maintain any storage connections.
+      # (see Base#destroy)
+      def destroy
+        nil
+      end
+
       # (see Base#expire_all_backlogs!)
       def expire_all_backlogs!
         client.expire_all_backlogs!

data/lib/message_bus/backends/postgres.rb

@@ -86,10 +86,12 @@ module MessageBus
           hold { |conn| exec_prepared(conn, 'get_message', [channel, id]) { |r| r.getvalue(0, 0) } }
         end
 
-        def reconnect
+        def after_fork
           sync do
-            @listening_on.clear
+            @pid = Process.pid
+            INHERITED_CONNECTIONS.concat(@available)
             @available.clear
+            @listening_on.clear
           end
         end
 
@@ -101,6 +103,13 @@ module MessageBus
           end
         end
 
+        def destroy
+          sync do
+            @available.each(&:close)
+            @available.clear
+          end
+        end
+
         # use with extreme care, will nuke all of the data
         def expire_all_backlogs!
           reset!
@@ -174,11 +183,7 @@ module MessageBus
         def hold
           current_pid = Process.pid
           if current_pid != @pid
-            @pid = current_pid
-            sync do
-              INHERITED_CONNECTIONS.concat(@available)
-              @available.clear
-            end
+            after_fork
           end
 
           if conn = sync { @allocated[Thread.current] }
@@ -253,12 +258,13 @@ module MessageBus
         # after 7 days inactive backlogs will be removed
         @max_backlog_age = 604800
         @clear_every = config[:clear_every] || 1
+        @mutex = Mutex.new
       end
 
       # Reconnects to Postgres; used after a process fork, typically triggered by a forking webserver
       # @see Base#after_fork
       def after_fork
-        client.reconnect
+        client.after_fork
       end
 
       # (see Base#reset!)
@@ -266,6 +272,11 @@ module MessageBus
         client.reset!
       end
 
+      # (see Base#destroy)
+      def destroy
+        client.destroy
+      end
+
       # (see Base#expire_all_backlogs!)
       def expire_all_backlogs!
         client.expire_all_backlogs!
@@ -401,11 +412,7 @@ module MessageBus
       private
 
       def client
-        @client ||= new_connection
-      end
-
-      def new_connection
-        Client.new(@config)
+        @client || @mutex.synchronize { @client ||= Client.new(@config) }
       end
 
       def postgresql_channel_name

data/lib/message_bus/backends/redis.rb

@@ -65,7 +65,7 @@ module MessageBus
       # Reconnects to Redis; used after a process fork, typically triggered by a forking webserver
       # @see Base#after_fork
       def after_fork
-        pub_redis.disconnect!
+        @pub_redis&.disconnect!
       end
 
       # (see Base#reset!)
@@ -75,6 +75,11 @@ module MessageBus
         end
       end
 
+      # (see Base#destroy)
+      def destroy
+        @pub_redis&.disconnect!
+      end
+
       # Deletes all backlogs and their data. Does not delete ID pointers, so new publications will get IDs that continue from the last publication before the expiry. Use with extreme caution.
       # @see Base#expire_all_backlogs!
       def expire_all_backlogs!

data/lib/message_bus/client.rb

@@ -46,6 +46,9 @@ class MessageBus::Client
     @bus = opts[:message_bus] || MessageBus
     @subscriptions = {}
     @chunks_sent = 0
+    @async_response = nil
+    @io = nil
+    @wrote_headers = false
   end
 
   # @yield executed with a lock on the Client instance

data/lib/message_bus/distributed_cache.rb

@@ -22,6 +22,7 @@ module MessageBus
         @lock = Mutex.new
         @message_bus = message_bus || MessageBus
         @publish_queue_in_memory = publish_queue_in_memory
+        @app_version = nil
       end
 
       def subscribers

data/lib/message_bus/rack/thin_ext.rb

@@ -9,6 +9,7 @@ module Thin
 
       def initialize
         @queue = []
+        @body_callback = nil
       end
 
       def call(body)

data/lib/message_bus/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MessageBus
-  VERSION = "3.3.7"
+  VERSION = "3.3.8"
 end

data/lib/message_bus.rb

@@ -41,6 +41,10 @@ module MessageBus::Implementation
   def initialize
     @config = {}
     @mutex = Synchronizer.new
+    @off = false
+    @destroyed = false
+    @timer_thread = nil
+    @subscriber_thread = nil
   end
 
   # @param [Boolean] val whether or not to cache static assets for the diagnostics pages
@@ -533,6 +537,7 @@ module MessageBus::Implementation
     return if @destroyed
 
     reliable_pub_sub.global_unsubscribe
+    reliable_pub_sub.destroy
 
     @mutex.synchronize do
       return if @destroyed

data/message_bus.gemspec

@@ -9,7 +9,8 @@ Gem::Specification.new do |gem|
   gem.summary       = %q{}
   gem.homepage      = "https://github.com/discourse/message_bus"
   gem.license       = "MIT"
-  gem.files         = `git ls-files`.split($\)
+  gem.files         = `git ls-files`.split($\) +
+                      ["vendor/assets/javascripts/message-bus.js", "vendor/assets/javascripts/message-bus-ajax.js"]
   gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.name          = "message_bus"
@@ -19,9 +20,11 @@ Gem::Specification.new do |gem|
 
   gem.add_runtime_dependency 'rack', '>= 1.1.3'
 
+  # Optional runtime dependencies
   gem.add_development_dependency 'redis'
   gem.add_development_dependency 'pg'
   gem.add_development_dependency 'concurrent-ruby' # for distributed-cache
+
   gem.add_development_dependency 'minitest'
   gem.add_development_dependency 'minitest-hooks'
   gem.add_development_dependency 'minitest-global_expectations'

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "message-bus-client",
-  "version": "3.3.5",
+  "version": "0.0.0-version-placeholder",
   "description": "A message bus client in Javascript",
   "main": "assets/message-bus.js",
   "keywords": [
@@ -12,10 +12,7 @@
   ],
   "jsnext:main": "assets/message-bus.js",
   "module": "assets/message-bus.js",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/discourse/message_bus.git"
-  },
+  "repository": "https://github.com/discourse/message_bus",
   "author": "Sam Saffron, Robin Ward",
   "license": "MIT",
   "bugs": {

data/spec/helpers.rb

@@ -25,7 +25,12 @@ def test_config_for_backend(backend)
   when :redis
     config[:url] = ENV['REDISURL']
   when :postgres
-    config[:backend_options] = { host: ENV['PGHOST'], user: ENV['PGUSER'] || ENV['USER'], password: ENV['PGPASSWORD'], dbname: ENV['PGDATABASE'] || 'message_bus_test' }
+    config[:backend_options] = {
+      host: ENV['PGHOST'],
+      user: ENV['PGUSER'] || ENV['USER'],
+      password: ENV['PGPASSWORD'],
+      dbname: ENV['PGDATABASE'] || 'message_bus_test'
+    }
   end
   config
 end

data/spec/lib/fake_async_middleware.rb

@@ -7,6 +7,7 @@ class FakeAsyncMiddleware
     @simulate_thin_async = false
     @simulate_hijack = false
     @in_async = false
+    @allow_chunked = false
   end
 
   def app

data/spec/lib/message_bus/backend_spec.rb

@@ -10,6 +10,7 @@ describe PUB_SUB_CLASS do
 
   after do
     @bus.reset!
+    @bus.destroy
   end
 
   describe "API parity" do

data/spec/lib/message_bus/client_spec.rb

@@ -16,6 +16,7 @@ describe MessageBus::Client do
     end
 
     after do
+      @client.close
       @bus.reset!
       @bus.destroy
     end

data/spec/lib/message_bus/connection_manager_spec.rb

@@ -6,6 +6,10 @@ require 'message_bus'
 class FakeAsync
   attr_accessor :cleanup_timer
 
+  def initialize
+    @sent = nil
+  end
+
   def <<(val)
     sleep 0.01 # simulate IO
     @sent ||= +""

data/spec/lib/message_bus/multi_process_spec.rb

@@ -18,13 +18,15 @@ describe PUB_SUB_CLASS do
 
   def work_it
     bus = new_bus
-    $stdout.reopen("/dev/null", "w")
-    $stderr.reopen("/dev/null", "w")
-    # subscribe blocks, so we need a new bus to transmit
-    new_bus.subscribe("/echo", 0) do |msg|
-      bus.publish("/response", "#{msg.data}-#{Process.pid.to_s}")
+    bus.subscribe("/echo", 0) do |msg|
+      if msg.data == "done"
+        bus.global_unsubscribe
+      else
+        bus.publish("/response", "#{msg.data}-#{Process.pid.to_s}")
+      end
     end
   ensure
+    bus.destroy
     exit!(0)
   end
 
@@ -44,12 +46,14 @@ describe PUB_SUB_CLASS do
       test_never :memory
       skip("previous error") if self.class.error?
       GC.start
-      new_bus.reset!
+      bus = new_bus
+      bus.reset!
+
       begin
         pids = (1..10).map { spawn_child }
         expected_responses = pids.map { |x| (0...10).map { |i| "0#{i}-#{x}" } }.flatten
         unexpected_responses = []
-        bus = new_bus
+
         t = Thread.new do
           bus.subscribe("/response", 0) do |msg|
             if expected_responses.include?(msg.data)
@@ -59,10 +63,14 @@ describe PUB_SUB_CLASS do
             end
           end
         end
+
         10.times { |i| bus.publish("/echo", "0#{i}") }
-        wait_for 4000 do
+
+        wait_for(2000) do
           expected_responses.empty?
         end
+
+        bus.publish("/echo", "done")
         bus.global_unsubscribe
         t.join
 
@@ -81,7 +89,9 @@ describe PUB_SUB_CLASS do
             Process.wait(pid)
           end
         end
+
         bus.global_unsubscribe
+        bus.destroy
       end
     end
   end

data/spec/lib/message_bus/rack/middleware_spec.rb

@@ -83,7 +83,7 @@ describe MessageBus::Rack::Middleware do
         { "FOO" => "BAR" }
       end
 
-      Thread.new do
+      t = Thread.new do
         wait_for(2000) { middleware.in_async? }
         bus.publish "/foo", "םוֹלשָׁ"
       end
@@ -96,6 +96,7 @@ describe MessageBus::Rack::Middleware do
       parsed[0]["data"].must_equal "םוֹלשָׁ"
 
       last_response.headers["FOO"].must_equal "BAR"
+      t.join
     end
 
     it "should timeout within its alloted slot" do

data/spec/lib/message_bus_spec.rb

@@ -23,7 +23,8 @@ describe MessageBus do
     @bus.off?.must_equal true
   end
 
-  it "can call destroy twice" do
+  it "can call destroy multiple times" do
+    @bus.destroy
     @bus.destroy
     @bus.destroy
   end

data/vendor/assets/javascripts/message-bus-ajax.js

@@ -0,0 +1,38 @@
+// A bare-bones implementation of $.ajax that MessageBus will use
+// as a fallback if jQuery is not present
+//
+// Only implements methods & options used by MessageBus
+(function(global) {
+  'use strict';
+  if (!global.MessageBus){
+      throw new Error("MessageBus must be loaded before the ajax adapter");
+  }
+
+  global.MessageBus.ajax = function(options){
+    var XHRImpl = (global.MessageBus && global.MessageBus.xhrImplementation) || global.XMLHttpRequest;
+    var xhr = new XHRImpl();
+    xhr.dataType = options.dataType;
+    xhr.open('POST', options.url);
+    for (var name in options.headers){
+      xhr.setRequestHeader(name, options.headers[name]);
+    }
+    xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
+    if (options.messageBus.chunked){
+      options.messageBus.onProgressListener(xhr);
+    }
+    xhr.onreadystatechange = function(){
+      if (xhr.readyState === 4){
+        var status = xhr.status;
+        if (status >= 200 && status < 300 || status === 304){
+          options.success(xhr.responseText);
+        } else {
+          options.error(xhr, xhr.statusText);
+        }
+        options.complete();
+      }
+    }
+    xhr.send(new URLSearchParams(options.data).toString());
+    return xhr;
+  };
+
+})(window);

data/vendor/assets/javascripts/message-bus.js

@@ -0,0 +1,549 @@
+/*global define, jQuery*/
+
+(function (root, factory) {
+  if (typeof define === "function" && define.amd) {
+    // AMD. Register as an anonymous module.
+    define([], function () {
+      // Also create a global in case some scripts
+      // that are loaded still are looking for
+      // a global even when an AMD loader is in use.
+      return (root.MessageBus = factory());
+    });
+  } else {
+    // Browser globals
+    root.MessageBus = factory();
+  }
+})(typeof self !== "undefined" ? self : this, function () {
+  "use strict";
+
+  // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript
+  var uniqueId = function () {
+    return "xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx".replace(/[xy]/g, function (c) {
+      var r = (Math.random() * 16) | 0;
+      var v = c === "x" ? r : (r & 0x3) | 0x8;
+      return v.toString(16);
+    });
+  };
+
+  var me;
+  var delayPollTimeout;
+  var ajaxInProgress = false;
+  var started = false;
+  var clientId = uniqueId();
+  var callbacks = [];
+  var failCount = 0;
+  var baseUrl = "/";
+  var paused = false;
+  var later = [];
+  var chunkedBackoff = 0;
+  var stopped;
+  var pollTimeout = null;
+  var totalAjaxFailures = 0;
+  var totalAjaxCalls = 0;
+  var lastAjax;
+
+  var isHidden = (function () {
+    var prefixes = ["", "webkit", "ms", "moz"];
+    var hiddenProperty;
+    for (var i = 0; i < prefixes.length; i++) {
+      var prefix = prefixes[i];
+      var check = prefix + (prefix === "" ? "hidden" : "Hidden");
+      if (document[check] !== undefined) {
+        hiddenProperty = check;
+      }
+    }
+
+    return function () {
+      if (hiddenProperty !== undefined) {
+        return document[hiddenProperty];
+      } else {
+        return !document.hasFocus;
+      }
+    };
+  })();
+
+  var hasLocalStorage = (function () {
+    try {
+      localStorage.setItem("mbTestLocalStorage", Date.now());
+      localStorage.removeItem("mbTestLocalStorage");
+      return true;
+    } catch (e) {
+      return false;
+    }
+  })();
+
+  var updateLastAjax = function () {
+    if (hasLocalStorage) {
+      localStorage.setItem("__mbLastAjax", Date.now());
+    }
+  };
+
+  var hiddenTabShouldWait = function () {
+    if (hasLocalStorage && isHidden()) {
+      var lastAjaxCall = parseInt(localStorage.getItem("__mbLastAjax"), 10);
+      var deltaAjax = Date.now() - lastAjaxCall;
+
+      return deltaAjax >= 0 && deltaAjax < me.minHiddenPollInterval;
+    }
+    return false;
+  };
+
+  var hasonprogress = new XMLHttpRequest().onprogress === null;
+  var allowChunked = function () {
+    return me.enableChunkedEncoding && hasonprogress;
+  };
+
+  var shouldLongPoll = function () {
+    return (
+      me.alwaysLongPoll ||
+      (me.shouldLongPollCallback ? me.shouldLongPollCallback() : !isHidden())
+    );
+  };
+
+  var processMessages = function (messages) {
+    if (!messages || messages.length === 0) {
+      return false;
+    }
+
+    for (var i = 0; i < messages.length; i++) {
+      var message = messages[i];
+      for (var j = 0; j < callbacks.length; j++) {
+        var callback = callbacks[j];
+        if (callback.channel === message.channel) {
+          callback.last_id = message.message_id;
+          try {
+            callback.func(message.data, message.global_id, message.message_id);
+          } catch (e) {
+            if (console.log) {
+              console.log(
+                "MESSAGE BUS FAIL: callback " +
+                  callback.channel +
+                  " caused exception " +
+                  e.stack
+              );
+            }
+          }
+        }
+        if (message.channel === "/__status") {
+          if (message.data[callback.channel] !== undefined) {
+            callback.last_id = message.data[callback.channel];
+          }
+        }
+      }
+    }
+
+    return true;
+  };
+
+  var reqSuccess = function (messages) {
+    failCount = 0;
+    if (paused) {
+      if (messages) {
+        for (var i = 0; i < messages.length; i++) {
+          later.push(messages[i]);
+        }
+      }
+    } else {
+      return processMessages(messages);
+    }
+    return false;
+  };
+
+  var longPoller = function (poll, data) {
+    if (ajaxInProgress) {
+      // never allow concurrent ajax reqs
+      return;
+    }
+
+    var gotData = false;
+    var aborted = false;
+    var rateLimited = false;
+    var rateLimitedSeconds;
+
+    lastAjax = new Date();
+    totalAjaxCalls += 1;
+    data.__seq = totalAjaxCalls;
+
+    var longPoll = shouldLongPoll() && me.enableLongPolling;
+    var chunked = longPoll && allowChunked();
+    if (chunkedBackoff > 0) {
+      chunkedBackoff--;
+      chunked = false;
+    }
+
+    var headers = { "X-SILENCE-LOGGER": "true" };
+    for (var name in me.headers) {
+      headers[name] = me.headers[name];
+    }
+
+    if (!chunked) {
+      headers["Dont-Chunk"] = "true";
+    }
+
+    var dataType = chunked ? "text" : "json";
+
+    var handle_progress = function (payload, position) {
+      var separator = "\r\n|\r\n";
+      var endChunk = payload.indexOf(separator, position);
+
+      if (endChunk === -1) {
+        return position;
+      }
+
+      var chunk = payload.substring(position, endChunk);
+      chunk = chunk.replace(/\r\n\|\|\r\n/g, separator);
+
+      try {
+        reqSuccess(JSON.parse(chunk));
+      } catch (e) {
+        if (console.log) {
+          console.log("FAILED TO PARSE CHUNKED REPLY");
+          console.log(data);
+        }
+      }
+
+      return handle_progress(payload, endChunk + separator.length);
+    };
+
+    var disableChunked = function () {
+      if (me.longPoll) {
+        me.longPoll.abort();
+        chunkedBackoff = 30;
+      }
+    };
+
+    if (!me.ajax) {
+      throw new Error("Either jQuery or the ajax adapter must be loaded");
+    }
+
+    updateLastAjax();
+
+    ajaxInProgress = true;
+    var req = me.ajax({
+      url:
+        me.baseUrl +
+        "message-bus/" +
+        me.clientId +
+        "/poll" +
+        (!longPoll ? "?dlp=t" : ""),
+      data: data,
+      async: true,
+      dataType: dataType,
+      type: "POST",
+      headers: headers,
+      messageBus: {
+        chunked: chunked,
+        onProgressListener: function (xhr) {
+          var position = 0;
+          // if it takes longer than 3000 ms to get first chunk, we have some proxy
+          // this is messing with us, so just backoff from using chunked for now
+          var chunkedTimeout = setTimeout(disableChunked, 3000);
+          return (xhr.onprogress = function () {
+            clearTimeout(chunkedTimeout);
+            if (
+              xhr.getResponseHeader("Content-Type") ===
+              "application/json; charset=utf-8"
+            ) {
+              chunked = false; // not chunked, we are sending json back
+            } else {
+              position = handle_progress(xhr.responseText, position);
+            }
+          });
+        },
+      },
+      xhr: function () {
+        var xhr = jQuery.ajaxSettings.xhr();
+        if (!chunked) {
+          return xhr;
+        }
+        this.messageBus.onProgressListener(xhr);
+        return xhr;
+      },
+      success: function (messages) {
+        if (!chunked) {
+          // we may have requested text so jQuery will not parse
+          if (typeof messages === "string") {
+            messages = JSON.parse(messages);
+          }
+          gotData = reqSuccess(messages);
+        }
+      },
+      error: function (xhr, textStatus) {
+        if (xhr.status === 429) {
+          var tryAfter =
+            parseInt(
+              xhr.getResponseHeader && xhr.getResponseHeader("Retry-After")
+            ) || 0;
+          tryAfter = tryAfter || 0;
+          if (tryAfter < 15) {
+            tryAfter = 15;
+          }
+          rateLimitedSeconds = tryAfter;
+          rateLimited = true;
+        } else if (textStatus === "abort") {
+          aborted = true;
+        } else {
+          failCount += 1;
+          totalAjaxFailures += 1;
+        }
+      },
+      complete: function () {
+        ajaxInProgress = false;
+
+        var interval;
+        try {
+          if (rateLimited) {
+            interval = Math.max(me.minPollInterval, rateLimitedSeconds * 1000);
+          } else if (gotData || aborted) {
+            interval = me.minPollInterval;
+          } else {
+            interval = me.callbackInterval;
+            if (failCount > 2) {
+              interval = interval * failCount;
+            } else if (!shouldLongPoll()) {
+              interval = me.backgroundCallbackInterval;
+            }
+            if (interval > me.maxPollInterval) {
+              interval = me.maxPollInterval;
+            }
+
+            interval -= new Date() - lastAjax;
+
+            if (interval < 100) {
+              interval = 100;
+            }
+          }
+        } catch (e) {
+          if (console.log && e.message) {
+            console.log("MESSAGE BUS FAIL: " + e.message);
+          }
+        }
+
+        if (pollTimeout) {
+          clearTimeout(pollTimeout);
+          pollTimeout = null;
+        }
+
+        if (started) {
+          pollTimeout = setTimeout(function () {
+            pollTimeout = null;
+            poll();
+          }, interval);
+        }
+
+        me.longPoll = null;
+      },
+    });
+
+    return req;
+  };
+
+  me = {
+    /* shared between all tabs */
+    minHiddenPollInterval: 1500,
+    enableChunkedEncoding: true,
+    enableLongPolling: true,
+    callbackInterval: 15000,
+    backgroundCallbackInterval: 60000,
+    minPollInterval: 100,
+    maxPollInterval: 3 * 60 * 1000,
+    callbacks: callbacks,
+    clientId: clientId,
+    alwaysLongPoll: false,
+    shouldLongPollCallback: undefined,
+    baseUrl: baseUrl,
+    headers: {},
+    ajax: typeof jQuery !== "undefined" && jQuery.ajax,
+    diagnostics: function () {
+      console.log("Stopped: " + stopped + " Started: " + started);
+      console.log("Current callbacks");
+      console.log(callbacks);
+      console.log(
+        "Total ajax calls: " +
+          totalAjaxCalls +
+          " Recent failure count: " +
+          failCount +
+          " Total failures: " +
+          totalAjaxFailures
+      );
+      console.log(
+        "Last ajax call: " + (new Date() - lastAjax) / 1000 + " seconds ago"
+      );
+    },
+
+    pause: function () {
+      paused = true;
+    },
+
+    resume: function () {
+      paused = false;
+      processMessages(later);
+      later = [];
+    },
+
+    stop: function () {
+      stopped = true;
+      started = false;
+      if (delayPollTimeout) {
+        clearTimeout(delayPollTimeout);
+        delayPollTimeout = null;
+      }
+      if (pollTimeout) {
+        clearTimeout(pollTimeout);
+        pollTimeout = null;
+      }
+      if (me.longPoll) {
+        me.longPoll.abort();
+      }
+      if (me.onVisibilityChange) {
+        document.removeEventListener("visibilitychange", me.onVisibilityChange);
+        me.onVisibilityChange = null;
+      }
+    },
+
+    // Start polling
+    start: function () {
+      if (started) return;
+      started = true;
+      stopped = false;
+
+      var poll = function () {
+        if (stopped) {
+          return;
+        }
+
+        if (callbacks.length === 0 || hiddenTabShouldWait()) {
+          if (!delayPollTimeout) {
+            delayPollTimeout = setTimeout(function () {
+              delayPollTimeout = null;
+              poll();
+            }, parseInt(500 + Math.random() * 500));
+          }
+          return;
+        }
+
+        var data = {};
+        for (var i = 0; i < callbacks.length; i++) {
+          data[callbacks[i].channel] = callbacks[i].last_id;
+        }
+
+        // could possibly already be started
+        // notice the delay timeout above
+        if (!me.longPoll) {
+          me.longPoll = longPoller(poll, data);
+        }
+      };
+
+      // monitor visibility, issue a new long poll when the page shows
+      if (document.addEventListener && "hidden" in document) {
+        me.onVisibilityChange = function () {
+          if (
+            !document.hidden &&
+            !me.longPoll &&
+            (pollTimeout || delayPollTimeout)
+          ) {
+            clearTimeout(pollTimeout);
+            clearTimeout(delayPollTimeout);
+
+            delayPollTimeout = null;
+            pollTimeout = null;
+            poll();
+          }
+        };
+
+        document.addEventListener("visibilitychange", me.onVisibilityChange);
+      }
+
+      poll();
+    },
+
+    status: function () {
+      if (paused) {
+        return "paused";
+      } else if (started) {
+        return "started";
+      } else if (stopped) {
+        return "stopped";
+      } else {
+        throw "Cannot determine current status";
+      }
+    },
+
+    // Subscribe to a channel
+    // if lastId is 0 or larger, it will recieve messages AFTER that id
+    // if lastId is negative it will perform lookbehind
+    // -1 will subscribe to all new messages
+    // -2 will recieve last message + all new messages
+    // -3 will recieve last 2 messages + all new messages
+    // if undefined will default to -1
+    subscribe: function (channel, func, lastId) {
+      if (!started && !stopped) {
+        me.start();
+      }
+
+      if (lastId === null || typeof lastId === "undefined") {
+        lastId = -1;
+      } else if (typeof lastId !== "number") {
+        throw (
+          "lastId has type " + typeof lastId + " but a number was expected."
+        );
+      }
+
+      if (typeof channel !== "string") {
+        throw "Channel name must be a string!";
+      }
+
+      callbacks.push({
+        channel: channel,
+        func: func,
+        last_id: lastId,
+      });
+      if (me.longPoll) {
+        me.longPoll.abort();
+      }
+
+      return func;
+    },
+
+    // Unsubscribe from a channel
+    unsubscribe: function (channel, func) {
+      // TODO allow for globbing in the middle of a channel name
+      // like /something/*/something
+      // at the moment we only support globbing /something/*
+      var glob = false;
+      if (channel.indexOf("*", channel.length - 1) !== -1) {
+        channel = channel.substr(0, channel.length - 1);
+        glob = true;
+      }
+
+      var removed = false;
+
+      for (var i = callbacks.length - 1; i >= 0; i--) {
+        var callback = callbacks[i];
+        var keep;
+
+        if (glob) {
+          keep = callback.channel.substr(0, channel.length) !== channel;
+        } else {
+          keep = callback.channel !== channel;
+        }
+
+        if (!keep && func && callback.func !== func) {
+          keep = true;
+        }
+
+        if (!keep) {
+          callbacks.splice(i, 1);
+          removed = true;
+        }
+      }
+
+      if (removed && me.longPoll) {
+        me.longPoll.abort();
+      }
+
+      return removed;
+    },
+  };
+  return me;
+});

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: message_bus
 version: !ruby/object:Gem::Version
-  version: 3.3.7
+  version: 3.3.8
 platform: ruby
 authors:
 - Sam Saffron
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-12-17 00:00:00.000000000 Z
+date: 2021-12-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -272,6 +272,7 @@ files:
 - ".eslintrc.js"
 - ".github/workflows/ci.yml"
 - ".gitignore"
+- ".prettierrc"
 - ".rubocop.yml"
 - CHANGELOG
 - DEV.md
@@ -355,6 +356,8 @@ files:
 - spec/spec_helper.rb
 - spec/support/jasmine-browser.json
 - vendor/assets/javascripts/.gitignore
+- vendor/assets/javascripts/message-bus-ajax.js
+- vendor/assets/javascripts/message-bus.js
 homepage: https://github.com/discourse/message_bus
 licenses:
 - MIT
@@ -374,7 +377,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.33
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: ''