CareerCup

I believe this question tests knowledge on the Observer Design pattern. Implementations across languages vary but I present a solution in Swift (iOS) below using Property Observers.

import Foundation
import Queue

class Demo {

  var portNumber: Int16
  var userName: String
  var password: String
  var queue: Queue? {
    didSet {
      printListenerMessage()
    }
  }
  
  init(portNumber: Int16, userName: String, password: String) {
    self.portNumber = portNumber
    self.userName = userName
    self.password = password
  }
  
  private func printListenerMessage() {
    let message = """
    The queue is running on port : \(portNumber)
    Username : \(userName)
    Password : \(password)
    """
    print(message)
  }
}

// In Main.swift
let demoApp = Demo.init(portNumber: 8161, userName: "admin", password: "admin")
demoApp.queue = Queue()

Output

The queue is running on port : 8161
Username : admin
Password : admin

I hope this is correct and match the question :)
Code: https://github.com/tabvn/ued/blob/master/careercup/Microsoft/SDE-2s.cpp

Output:

New subscriber: 
Username: admin
Password: admin
The queue is running on port: 8161
Received message:New message.
Received message:New message.
Received message:New message.
Received message:New message.
Received message:New message.

#include <iostream>
#include <thread>
#include <vector>
#include <string>
#include <chrono>


struct Subscriber
{
	std::string username;
	std::string password;
	void(*callback)(std::string message);

	Subscriber(std::string username, std::string password, void(*cb)(std::string message) ){

		this->username = username;
		this->password = password;
		this->callback = cb;
	}
};

struct Queue{
	std::string name;
	std::vector<Subscriber*> subscribers;
	Queue(std::string name){
		this->name = name;
	}
};

struct Event{

	std::vector<Queue*> queues;

	Queue* addQueue(std::string name){

		Queue *q = new Queue(name);
		this->queues.push_back(q);
		return q;
	}

	Queue *getQueue(std::string name){
		for (int i = 0; i < this->queues.size(); ++i){
			if(this->queues[i]->name == name){
				return this->queues[i];
			}
		}
		return NULL;
	}
	void addSubscriber(Queue *q, Subscriber *subscriber){

		q->subscribers.push_back(subscriber);

		// Print message when new subscriber joined.
		std::cout << "New subscriber: "<< std::endl;
		std::cout << "Username: " << subscriber->username << std::endl;
		std::cout << "Password: " << subscriber->password << std::endl;

	}
	void publish(std::string message, std::string queueName){

		Queue *queue = this->getQueue(queueName);

		if(queue != NULL){
			for (int i = 0; i < queue->subscribers.size(); ++i){
				queue->subscribers[i]->callback(message);
			}
		}

	
	}

	void listen(int port){
		std::cout << "The queue is running on port: " << port << std::endl;
		while(true){
			
		}
	}

};

/*
* This is function callback when receive message of the queue
*/
void messageReceivedCallback(std::string message){
	std::cout << "Received message:" << message << std::endl;
}


Event even;
/**
* Start event service and wait for message
**/
void runEvent(){

	Queue *queue = even.addQueue("Demo"); // create new queue demo for subscribers
	
	//New subscriber
	Subscriber *subscriber = new Subscriber("admin", "admin", messageReceivedCallback);
	even.addSubscriber(queue, subscriber);
	
	even.listen(8161);



}

/**
*/
void pushMessage(){

	// loop and send message every 2 seconds
	while(true){

		std::this_thread::sleep_for (std::chrono::seconds(2));

		even.publish("New message.", "Demo");
	}
}

int main(int argc, char const *argv[]){
		
	std::thread eventThread(runEvent);
	std::thread pushMessageThread(pushMessage);
	eventThread.join();
	pushMessageThread.join();

	return 0;
}

Java has a very easy implementation to subscribing a queue. Using annotation
We can pull all the properties: port, hostname, virtual host, username, password in application.yml

@RabbitListener("Queue_Name")
public void listen(Message message) {
//unmarshal it to the object here and perform operations.
}