Ministerul Educației al Republicii Moldova

Universitatea Tehnică a Moldovei

Facultatea Calculatoare, Informatica și Micorelectronică

Departamentul Ingineria Software si Automatica

Raport
Lucrarea de laborator nr. 2
La disciplina: Aplicatii Distribuite Avansate

Tema: Decuplarea componentelor unui sistem cu ajutorul brokerului de

mesaje.

A efectuat:

A verificat: lect.,univ.

Torica Eugeniu

Chișinău 2020
Sarcina:
1) Să se separe aplicaţia curentă în două aplicaţii:
 a) Componenta Producător – va fi responsabilă de citirea datelor din fişierul
”input.txt” şi publicarea numerelor în formă de mesaje în brokerul de mesaje
(RabbitMQ). Mesajele vor fi consumate de către componenta Consumator.
Componenta Producător va primi rezultatele de calcul care vor fi efectuate de
componenta Consumator şi le va înscrie în fişierul ”outputs.txt”.
b) Componenta Consumator – va fi responsabilă de consumul datelor din brokerul de
mesaje şi efectuarea calculului. Calculul trebuie să fie efectual de funcţia sleepy
fibonacci

2) Să se scrie o componentă Consumator într-un limbaj diferit de limbajul C. Trebuie să aveţi

două componente Consumator scrise în limbaje diferite.

3) Efectuaţi calculul pentru scenariul cînd există cînd rulează în paralel patru componente
Consumator.

4) Descrieţi succint alegerile făcute în implementarea acestui laborator. Comparaţi

implementarea curentă cu cea făcută pe baza librăriei OpenMPI. Descrieţi avantajele şi
dezavantajele fiecărei abordări.

Acest laborator are obiectivul de a face studenţii familiari cu metodele de decuplare

funcţională, temporală şi tehnologică a componentelor unui sistem cu ajutorul unui broker de
mesaje.
Pentru a solution sarcina data am folosit paternul Remote Procedure Call or RPC.
Pentru a ilustra modul în care poate fi utilizat un serviciu RPC, vom crea o clasă simplă
Client. Va expune o metodă numită “call” care trimite o cerere RPC și se blochează până
când nu primește răspunsul:
In imagine avem reprezentate 4 instante a clasei Server, care consuma mesajele din Brocker.

Dupa ce pornim RPC Client , care trimite requesturile spre Broker, observam ca mesajele
sunt consumate de toate cele 4 instante de Server.
CLasa Client:

package com.example.rabbitmq;
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.UUID;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeoutException;

@SpringBootApplication
public class RPCClient implements AutoCloseable {

private Connection connection;

private Channel channel;
private String requestQueueName = "rpc_queue";

public RPCClient() throws IOException, TimeoutException {

ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");

connection = factory.newConnection();
channel = connection.createChannel();
channel.basicQos(1);
}

public static void save(String fileName, List <String> list) throws

FileNotFoundException {
PrintWriter pw = new PrintWriter(new FileOutputStream(fileName));
for (String mess : list)
pw.write(mess);
 pw.close();
}

public static void main(String[] argv) throws FileNotFoundException {

List<String> responseMessages = new ArrayList<>();

Scanner scanner = new Scanner(new File("input.txt"));

int [] tall = new int [50];
int nr = 0;

while(scanner.hasNextInt()){
tall[nr++] = scanner.nextInt();
}

try (RPCClient fibonacciRpc = new RPCClient()) {

for (Integer i : tall) {
String i_str = Integer.toString(i);
System.out.println(" [x] Requesting fib(" + i_str + ")");
String response = fibonacciRpc.call(i_str);
System.out.println(" [.] Got '" + response + "'");
/** add responses to List**/
responseMessages.add(response);
}
/** save responses to an output file **/
save( "output.txt",responseMessages);
} catch (IOException | TimeoutException | InterruptedException e) {
e.printStackTrace();
}

public String call(String message) throws IOException, InterruptedException {

final String corrId = UUID.randomUUID().toString();
/** In order to receive a response we need to send a 'callback' queue
address with the request. **/
String replyQueueName = channel.queueDeclare().getQueue();
AMQP.BasicProperties props = new AMQP.BasicProperties
.Builder()
.correlationId(corrId)/** unique value for every request**/
.replyTo(replyQueueName)/**queue created just for the request,**/
.build();

channel.basicPublish("", requestQueueName, props, message.getBytes("UTF-

8"));

final BlockingQueue<String> response = new ArrayBlockingQueue<>(1);

String ctag = channel.basicConsume(replyQueueName, true, (consumerTag,

delivery) -> {
if (delivery.getProperties().getCorrelationId().equals(corrId)) {
response.offer(new String(delivery.getBody(), "UTF-8"));
}
}, consumerTag -> {
});

String result = response.take();

channel.basicCancel(ctag);
return result;
}

public void close() throws IOException {

connection.close();
}

package com.example.rabbitmq;

import com.rabbitmq.client.*;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class RPCServer {

private static final String RPC_QUEUE_NAME = "rpc_queue";

private static Long fib(int n) {

if (n == 0) return 0L;
if (n == 1) return 1L;
return (fib(n - 1) + fib(n - 2));
}

public static void main(String[] argv) throws Exception {

ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");

try (Connection connection = factory.newConnection();

Channel channel = connection.createChannel()) {
channel.queueDeclare(RPC_QUEUE_NAME, false, false, false, null);
channel.queuePurge(RPC_QUEUE_NAME);

channel.basicQos(1);

System.out.println(" [x] Awaiting RPC requests");

Object monitor = new Object();

DeliverCallback deliverCallback = (consumerTag, delivery) -> {
AMQP.BasicProperties replyProps = new AMQP.BasicProperties
.Builder()
.correlationId(delivery.getProperties().getCorrelationId())
.build();

String response = "";

try {
String message = new String(delivery.getBody(), "UTF-8");
int n = Integer.parseInt(message);

System.out.println(" [.] fib(" + message + ")");

response += fib(n);
} catch (RuntimeException e) {
System.out.println(" [.] " + e.toString());
} finally {
channel.basicPublish("", delivery.getProperties().getReplyTo(),
replyProps, response.getBytes("UTF-8"));
channel.basicAck(delivery.getEnvelope().getDeliveryTag(),
false);
// RabbitMq consumer worker thread notifies the RPC server
owner thread
synchronized (monitor) {
monitor.notify();
}
}
};

channel.basicConsume(RPC_QUEUE_NAME, false, deliverCallback,

(consumerTag -> { }));
// Wait and be prepared to consume the message from RPC client.
while (true) {
synchronized (monitor) {
try {
monitor.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}}}