### BAJAR EL PROYECTO DE GITHUB ###

git clone https://github.com/burzak/capacitacion.git
git checkout master
git pull upstream master
git push origin master
git branch examen-juanma
git checkout examen-juanma

											####   DOCKER - RABBITMQ  ####

docker pull rabbitmq:management

docker create -it -p 10000:15672 -p 10001:5672 --name mirabbit rabbitmq:management

docker start mirabbit

	# En la carpeta del proyecto

php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
php -r "if (hash_file('sha384', 'composer-setup.php') === '48e3236262b34d30969dca3c37281b3b4bbe3221bda826ac6a9a62d6444cdb0dcd0615698a5cbe587c3f0fe57a54d8f5') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"
php composer-setup.php
php -r "unlink('composer-setup.php');"

php composer.phar require php-amqplib/php-amqplib

	# composer.json

{
    "require": {
        "php-amqplib/php-amqplib": ">=2.6.1"

    },
    "autoload": {
        "psr-4": {
            "PhpAmqpLib\\": "PhpAmqpLib/"
        }
    }
}

	# composer update

php composer.phar update
php composer.phar dumpautoload -o

	# send.php

<?php

require_once __DIR__ . '/vendor/autoload.php';

use PhpAmqpLib\Connection\AMQPStreamConnection;
use PhpAmqpLib\Message\AMQPMessage;

$lines = trim(fgets(STDIN));
$connection = new AMQPStreamConnection('10.90.242.122', 10001, 'guest', 'guest');
$channel = $connection->channel();
$channel->queue_declare('mensajes', false, false, false, false);

$msg = new AMQPMessage($lines);
$channel->basic_publish($msg, '', 'mensajes');
echo " [x] Sent letras\n";
$channel->close();
$connection->close();

?>

	# recieve.php

<?php
require_once __DIR__ . '/vendor/autoload.php';

use PhpAmqpLib\Connection\AMQPStreamConnection;

$connection = new AMQPStreamConnection('10.90.242.122', 10001, 'guest', 'guest');
$channel = $connection->channel();
$channel->queue_declare('chat10', false, false, false, false);
echo " [*] Waiting for messages. To exit press CTRL+C\n";

$callback = function ($msg) {
    echo ' [x] Received ', $msg->body, "\n";
};

$channel->basic_consume('chat10', '', false, true, false, false, $callback);
while (count($channel->callbacks)) {
    $channel->wait();
}
$channel->close();
$connection->close();

?>

										### Teoría replicación ###

[master-master]: master-master.png
[master-slave]: master-slave.png

	# Escenario Ficticio para master-master

    Para resguardar la información, yo replicaría con el método master-master
    agregando XXXX nodos. Lo haría de esta manera porque en este tipo de sistema
    distribuido es fundamental una alta disponibilidad de la información. Este
    método de replicación permite que los datos esten alojados en distintas
    computadoras y actualizados por cualquiera de estas computadoras. De esta
    manera cualquier nodo puede responder peticiones de los clientes.
    Desventajas :
        Este sistema podría tener problemas de consistencia. Al permitir escribir en cualquier nodo, por ejemplo si estoy modifiando un dato en una base y alguien está leyendo el mismo dato en otra base
        no va a tener la última versión del mimso.

[master-master]

	# Escenario Ficticio para master-slave

    Para resguardar la información, yo replicaría con el método master-slave
    agregando XXXX esclavos.
    La replicación master slave consiste en utilizar una base de datos para la
    escritura y otra o varias bases de datos para la lectura.
    Esto nos permite tener varias copias sincronizas de nuestra base de datos
    principal, cualquier cambio en el maestro (master) se replicará  en los
    esclavos (slaves), esta configuración nos proporciona escalabilidad y backup,
    entre otras cosas, como por ejemplo hacer consultas sobre la réplica sin
    afectar a la base de datos principal.
        Desventajas:
            Tiempo de inactividad y posible perdida de datos cuando falla un maestro.

[master-slave]

											### THREADS ###

    # 3 metodos:
        start(para prender el tread)
        run(el que ejecuta el codigo)
        join(espera que el proceso termine)

import threading
import random
import time

superlista = []
for n in range(1000):
    superlista.append(n)

print('Resultado deberia ser: ', (999*1000)/2)
class SuperContador(threading.Thread):
    def __init__(self, inicio, end, lista):
        super().__init__()
        self.inicio = inicio
        self.end = end
        self.lista = lista
        self.total = 0


    def run(self):
        for n in range(self.inicio, self.end+1):
            self.total += self.lista[n]
            time.sleep(1.0/100.0)

    def dameTotal(self):
        return self.total

procesos = []

procesos.append(SuperContador(0, 199, superlista))
procesos.append(SuperContador(200, 399, superlista))
procesos.append(SuperContador(400, 599, superlista))
procesos.append(SuperContador(600, 799, superlista))
procesos.append(SuperContador(800, 999, superlista))

for proceso in procesos:
    proceso.start()

resultado = 0
for proceso in procesos:
    proceso.join()
    resultado += proceso.dameTotal()



print('El resultado es: ', resultado)

												###  CQRS ###

<?php
class Cola {
  private $_data = array();
  public function encolar($element) {
    $this->_data[] = $element;
  }
  public function desencolar() {
    return array_shift($this->_data);
  }
  public function estaVacia() {
    //return count($this->_data) == 0;
    if(count($this->_data) == 0){
      return true;
    }
    return false;
  }
}
class Persona {
  private $nombre;
  private $dni;
  public function __construct($nombre, $dni) {
    $this->nombre = $nombre;
    $this->dni = $dni;
  }
  public function dameNombre() { return $this->nombre; }
  public function dameDNI() { return $this->dni; }
}
class DB {
  private $db = array();
  public function insert($id, $obj) {
    $this->db[$id] = $obj;
  }
  public function delete($id) {
      unset($this->db[$id]);
  }
  public function get($id) {
      return $this->db[$id];
  }
  public function getAll() {
      return $this->db;

  }
}
class DBMongo
{
  private $collection;

  public function __construct($dbName, $collectionName)
  {
      $connection = new MongoDB\Client("mongodb://localhost:27017");
      $this->collection = $connection->$dbName->$collectionName;
  }
  public function getElemento($dni)
  {
      if($this->collection->findOne(['dni' => $dni])['dni'] == $dni){
          return $this->collection->findOne(['dni' => $dni]);
      }else{
          echo 'No existe el registro';
      }
  }
  public function insert($id, Persona $person)
  {
      if($this->collection->findOne(['dni' => $person->getId()])){
          //echo 'Ya existe este registro';
          return false;
      }else{
          $result = $this->collection->insertOne($person->serializador());
          return $result->getInsertedCount();
      }
  }
  public function delete($id)
  {
      if($this->collection->findOne(['dni' => $id])){
          //echo 'Registro eliminado';
          return $this->collection->deleteOne(['dni' => $id]);
      }else{
          //echo 'No se puede borrar, registro inexistente';
          return false;
      }
  }
  public function drop(){
      $this->collection->drop();
  }

}
class Cluster {
  private $dbs = array();
  private $cola;
  public function __construct(Cola $cola) {
    $this->cola = $cola;
  }
  public function guardar(Persona $persona) {
    $a_donde = $persona->dameDNI() % count($this->dbs);
    $this->dbs[$a_donde]->insert($persona->dameDni(), $persona);
  }
  public function borrar(Persona $persona) {
    $a_donde = $persona->dameDNI() % count($this->dbs);
    $this->dbs[$a_donde]->delete($persona->dameDni());
  }
  public function agregarDB($db) {
    $this->dbs[] = $db;
    foreach ($this->dbs as $dbKey => $db) {
      foreach ($db->getAll() as $keyUsuario => $usuario) {

        $a_donde = $usuario->dameDNI() % count($this->dbs);
        if ($a_donde != $dbKey) {
          $this->cola->encolar($usuario);
        }
      }
    }

  }
  public function migrar() {
    while(!$this->cola->estaVacia()) {
      $usuario = $this->cola->desencolar();
      $viejoLugar = $usuario->dameDNI() % (count($this->dbs)-1);
      $nuevoLugar = $usuario->dameDNI() % count($this->dbs);
      $this->dbs[$nuevoLugar]->insert($usuario->dameDni(), $usuario);
      $this->dbs[$viejoLugar]->delete($usuario->dameDNI());
    }
  }
  public function mostarResumen() {
    foreach ($this->dbs as $dbKey => $db) {
      echo "DB: $dbKey - Cantidad: ".count($db->getAll())."\n";
    }
  }
}
$cola = new Cola();
//var_dump($cola);
$cluster = new Cluster($cola);
$db = new DB();
$cluster->agregarDB($db);
$cluster->migrar();
$db = new DB();
$cluster->agregarDB($db);
$cluster->migrar();
$db = new DB();
$cluster->agregarDB($db);
$cluster->migrar();


$cluster->guardar(new Persona("Pepe", 32));
$cluster->guardar(new Persona("Matias", 10));
$cluster->guardar(new Persona("Julian", 9));
$cluster->guardar(new Persona("Jose", 44));
$cluster->guardar(new Persona("Adrian", 55));
$cluster->guardar(new Persona("KP", 60));
$cluster->guardar(new Persona("Tomy", 70));
$cluster->mostarResumen();
echo '-------------------' . "\n";
$db3 = new DB();
$cluster->agregarDB($db3);
$cluster->migrar();


$cluster->mostarResumen();

?>

												## HACER PULL REQUEST

Una vez hechos todos los cambios
Hacer gitignore de vendor

git add .
git commit -m "Subiendo exámen Juan Martin Gonzalez"
git push origin examen-juanma

Hacer click en "Compare & Pull Request"
Escribir cambios del Pull Request.
Si todo está bien, enviar con el botón "Send Pull Request".