Question

Problem Description

You have been asked to develop basic Event Broker functionality for a piece of home automation software.

Your system needs to:

• Subscribe event handlers to handle different types of events when they occur
• Unsubscribe event handlers that no-longer need to handle specific events
• Receive emitted events
• Handle events by calling subscribed event handlers

Events & Handlers:

• Each event has a type
• Event handlers may subscribe to be handle events of a given type
• An event handler can handle multiple types of event
• An event can have multiple handlers
• Handlers should be called in the order they were subscribed (FIFO)

Your Task

Your task is to plan and implement a JavaScript module for the system described above.

Your code will be run in a NodeJS environment as a module similar to this:

const bkr = require('./broker');

let handler1 = function() {    /* do stuff... */    }
let handler2 = function() {    /* do stuff... */    }

bkr.subscribe('event1',handler1);
bkr.subscribe('event1',handler2);
bkr.subscribe('event2',handler2);

bkr.emit('event1');
bkr.emit('event2');

bkr.unsubscribe('event1',handler1);

Your module needs to support 3 functions:

• emit(type)
  • Takes a parameter event type, which is a string name of an event.
  • Runs all registered handlers of that event type in the order that those handlers were subscribed.
• subscribe(type,handler)
  • Takes a parameter event type, which is a string name of an event.
  • Takes a parameter event handler, which is a function.
  • Whenever an event of this type is emitted, this handler function should run.
  • Multiple handlers may be added to an event
  • A handler may be added to multiple different events
  • A handler may only be added once to the same event
• unsubscribe(type,handler)
  • Takes a parameter event type, which is a string name of an event.
  • Takes a parameter event handler, which is a function.
  • This event handler function should no longer be triggered when events of this type are emitted.

First, plan your system

• Make sure you understand the problem.
• Determine any data structures and algorithms that you might need.
• Refer to the Notes/Readings listed in the section below for information on event brokers and JavaScript modules.

Finally, implement your code.

• Create a file named broker.js and implement the emit(type), subscribe(type,handler), and unsubscribe(handler) functions and other code.
• Be sure to thoroughly test your code.

Key Requirements

Be sure to adhere to the following requirements.
Not doing so may result in a reduction or complete loss of marks.

• You must use JavaScript
• You must not use any existing event handling/brokering functions/libraries

Answer 1

The custom library is created with which you can subscribe to events and emit the events. The library also supports unsubscribing from the event. The whole program is done in pure java script. No external libraries are used.

Broker.js

function Broker() {
        this.event = {};
}
// This method will register a handler for an event.
Broker.prototype.subscribe = function (eventName, handler) {
    // We will check if the event already exist in the event object, if so add to the array of handlers
        if(this.event[eventName])
        {
                const handlerArray=this.event[eventName];
                handlerArray.push(handler);
                this.event[eventName]=handlerArray;
        }
        else
        {
        // Create a new handler array and push the new handler to register it
                const handlerArray = [];
                handlerArray.push(handler);
                this.event[eventName]=handlerArray;
        }
        
}
// This method will deregister a handler for an event.
Broker.prototype.unsubscribe = function (eventName, handler) {
        if(this.event[eventName])
        {
        // We remove the handler from the event handler array
                const handlerArray=this.event[eventName];
                let handlerIndex = handlerArray.indexOf(handler);
                if(handlerIndex > -1)
                        handlerArray.splice(handlerIndex, 1);
                this.event[eventName]=handlerArray;
        }       
}
// This method will emit the event
Broker.prototype.emit = function (eventName) {
        handlerArray=this.event[eventName];
    // We iterate through each handlers in the array and invoke each of them
        for (let i = 0 ; i < handlerArray.length; i++)
        {
                handlerArray[i]();      
        }

}


module.exports = new Broker();

BrokerDriver.js

var bkr = require('./broker');

var handler1 =   function() { 
   console.log("handler1");  
}
var handler2 =  function() { 
   console.log("handler2");   
        }
console.log("Suscribing event1 with handler 1");
bkr.subscribe('event1',handler1);
console.log("Suscribing event1 with handler 2");
bkr.subscribe('event1',handler2);
console.log("Suscribing event2 with handler 2");
bkr.subscribe('event2',handler2);

console.log("Emitting event 1");
bkr.emit('event1');
console.log("Emitting event 2");
bkr.emit('event2');

console.log("Unsuscribing event1 with handler 1");
bkr.unsubscribe('event1',handler1);
console.log("Emitting event 1");
bkr.emit('event1');

Output