WMQ INSTALLATION

To install WMQ in debian distributions is needed to install rpm.



sudo apt install rpm
dpkg -l rpm
sudo ./mqlicense.sh -text_only
rpm -ivh --nodeps --force-debian MQSeriesRuntime-*.rpm
sudo rpm -ivh --nodeps --force-debian MQSeriesRuntime-*.rpm
sudo rpm -ivh --nodeps --force-debian MQSeriesServer-*.rpm MQSeriesJRE-*.rpm MQSeriesJava-*.rpm
vim /tmp/mqconfig.4914.log
sudo rpm -ivh --nodeps --force-debian MQSeriesExplorer-*.rpm
sudo rpm -ivh --nodeps --force-debian MQSeriesSamples-*.rpm
sudo rpm -ivh --nodeps --force-debian MQSeriesMan-*.rpm

You must create user and group mqm 

sudo groups mqm.

It is convenien to add users to this new group. To do the PoC simplier poosible add password to the user mq. and use it for JMS classes to open the connection.

BASIC STEPS

Create a MQ Manager .
 Create a Queue.
Create a listener (possible to do it in one este whith Mq Explorer).
Create a channel.

MQ COMANDS

   /opt/mqm/bin/crtmqm TESTMGR, Create a que manager
  /opt/mqm/bin/strmqm TESTMGR  Start a que manager

MQ EXPLORER 

Handy tool to avoid comand use.

TROUBLESHOTING

Logs are not directly visible, you need to translate them.

/opt/mqm/bin/strmqm TESTMGR
 .

 TWO CONCEPTS

• mq queues . 

  Point to point comunications. Very frecuent to comunicate opens systems with Mainframe which a common use for WMQ in SOA architectures.

• mq topics 

  One publish and multiple subscribers

BASIC JAVA stand alone  MQ END POINT

Take the jars located inside of MQ Installation and create two basic main programs to run separetely first the sender JmsProductor and then the JmsConsumidor

you can do a simply copy paste and run them witht the jars.


package org.jms.test;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import javax.jms.Connection;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.jms.TextMessage;

import com.ibm.msg.client.jms.JmsConnectionFactory;
import com.ibm.msg.client.jms.JmsFactoryFactory;
import com.ibm.msg.client.wmq.WMQConstants;

public class JmsProductor {

  private static String host = "localhost";
  private static int port = 1415;
  private static String channel = "PROVA";

  private static String queueManagerName = "PROVA";
  private static String destinationName = "PROVA";
  private static boolean isTopic = false;
  private static boolean clientTransport = true;

  // System exit status value (assume unset value to be 1)
  private static int status = 1;

  /**
   * Main method
   *
   * @param args
   */
  public static void main(String[] args) {
    // Parse the arguments
    //parseArgs(args);

    // Variables
    Connection connection = null;
    Session session = null;
    Destination destination = null;
    MessageProducer producer = null;

    try {
      // Create a connection factory
      JmsFactoryFactory ff = JmsFactoryFactory.getInstance(WMQConstants.WMQ_PROVIDER);
      JmsConnectionFactory cf = ff.createConnectionFactory();

      // Set the properties
      cf.setStringProperty(WMQConstants.WMQ_HOST_NAME, host);
      cf.setIntProperty(WMQConstants.WMQ_PORT, port);
      cf.setStringProperty(WMQConstants.WMQ_CHANNEL, channel);
      if (clientTransport) {
          cf.setIntProperty(WMQConstants.WMQ_CONNECTION_MODE, WMQConstants.WMQ_CM_CLIENT);
      }
      else {
          cf.setIntProperty(WMQConstants.WMQ_CONNECTION_MODE, WMQConstants.WMQ_CM_BINDINGS);
      }
      cf.setStringProperty(WMQConstants.WMQ_QUEUE_MANAGER, queueManagerName);
      cf.setStringProperty(WMQConstants.USERID,"jordi");
      cf.setStringProperty(WMQConstants.PASSWORD,"zzzz");
     // cf.setBooleanProperty(WMQConstants.USER_AUTHENTICATION_MQCSP, false);
  

      // Create JMS objects
      connection = cf.createConnection();
      session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
      if (isTopic) {
        destination = session.createTopic(destinationName);
      }
      else {
        destination = session.createQueue(destinationName);
      }
      producer = session.createProducer(destination);

      // Start the connection
      connection.start();
      String line;
      BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
      do {
        System.out.print("Enter some text to be sent in a message <ENTER to finish>:");
        System.out.flush();
        line = in.readLine();
        if (line!=null){
          if(line.trim().length()==0){
            break;
          }
            TextMessage message = session.createTextMessage(line);
            // And, send the message
            producer.send(message);
            System.out.println("Sent message:\n" + message);
          }
        }
      while (line != null);

      recordSuccess();
    }
    catch (JMSException | IOException jmsex) {
      recordFailure(jmsex);
    }
    finally {
      if (producer != null) {
        try {
          producer.close();
        }
        catch (JMSException jmsex) {
          System.out.println("Producer could not be closed.");
          recordFailure(jmsex);
        }
      }

      if (session != null) {
        try {
          session.close();
        }
        catch (JMSException jmsex) {
          System.out.println("Session could not be closed.");
          recordFailure(jmsex);
        }
      }

      if (connection != null) {
        try {
          connection.close();
        }
        catch (JMSException jmsex) {
          System.out.println("Connection could not be closed.");
          recordFailure(jmsex);
        }
      }
    }
    System.exit(status);
    return;
  } // end main()

  /**
   * Process a JMSException and any associated inner exceptions.
   *
   * @param jmsex
   */
  private static void processJMSException(JMSException jmsex) {
    System.out.println(jmsex);
    Throwable innerException = jmsex.getLinkedException();
    if (innerException != null) {
      System.out.println("Inner exception(s):");
    }
    while (innerException != null) {
      System.out.println(innerException);
      innerException = innerException.getCause();
    }
    return;
  }

  /**
   * Record this run as successful.
   */
  private static void recordSuccess() {
    System.out.println("SUCCESS");
    status = 0;
    return;
  }

  /**
   * Record this run as failure.
   *
   * @param ex
   */
  private static void recordFailure(Exception ex) {
    if (ex != null) {
      if (ex instanceof JMSException) {
        processJMSException((JMSException) ex);
      }
      else {
        System.out.println(ex);
      }
    }
    System.out.println("FAILURE");
    status = -1;
    return;
  }

  /**
   * Parse user supplied arguments.
   *
   * @param args
   */
 

  /**
   * Display usage help.
   */
  private static void printUsage() {
    System.out.println("\nUsage:");
    System.out
        .println("JmsProducer -m queueManagerName -d destinationName [-h host -p port -l channel] [-u userid -w passWord]");
    return;
  }

} // end class

 
 package org.jms.test;

import javax.jms.Connection;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.Session;

import com.ibm.msg.client.jms.JmsConnectionFactory;
import com.ibm.msg.client.jms.JmsFactoryFactory;
import com.ibm.msg.client.wmq.WMQConstants;


public class JmsConsumidor {

  private static String host = "localhost";
  private static int port = 1415;
  private static String channel = "PROVA";
  private static String user = "jordi";
  private static String password = "megafriki0";
  private static String queueManagerName = "PROVA";
  private static String destinationName = "PROVA";
  private static boolean isTopic = false;
  private static boolean clientTransport = true;

  private static int timeout = 15000; // in ms or 15 seconds

  // System exit status value (assume unset value to be 1)
  private static int status = 1;

  /**
   * Main method
   *
   * @param args
   */
  public static void main(String[] args) {
    // Parse the arguments
    //parseArgs(args);

    // Variables
    Connection connection = null;
    Session session = null;
    Destination destination = null;
    MessageConsumer consumer = null;

    try {
      // Create a connection factory
      JmsFactoryFactory ff = JmsFactoryFactory.getInstance(WMQConstants.WMQ_PROVIDER);
      JmsConnectionFactory cf = ff.createConnectionFactory();

      // Set the properties
      cf.setStringProperty(WMQConstants.WMQ_HOST_NAME, host);
      cf.setIntProperty(WMQConstants.WMQ_PORT, port);
      cf.setStringProperty(WMQConstants.WMQ_CHANNEL, channel);
      if (clientTransport) {
          cf.setIntProperty(WMQConstants.WMQ_CONNECTION_MODE, WMQConstants.WMQ_CM_CLIENT);
      }
      else {
          cf.setIntProperty(WMQConstants.WMQ_CONNECTION_MODE, WMQConstants.WMQ_CM_BINDINGS);
      }
      cf.setStringProperty(WMQConstants.WMQ_QUEUE_MANAGER, queueManagerName);
      if (user != null) {
        cf.setStringProperty(WMQConstants.USERID, "jordi");
        cf.setStringProperty(WMQConstants.PASSWORD, "zzzz");
        cf.setBooleanProperty(WMQConstants.USER_AUTHENTICATION_MQCSP, true);
      }

      // Create JMS objects
      connection = cf.createConnection();
      session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
      if (isTopic) {
        destination = session.createTopic(destinationName);
      }
      else {
        destination = session.createQueue(destinationName);
      }
      consumer = session.createConsumer(destination);

      // Start the connection
      connection.start();

      // And, receive the message
      Message message;
      do {
        message = consumer.receive(timeout);
        if (message != null) {
          System.out.println("Received message:\n" + message);
        }
      }
      while (message != null);

      System.out.format("No message received in %d seconds!\n", timeout / 1000);
      recordSuccess();
    }
    catch (JMSException jmsex) {
      recordFailure(jmsex);
    }
    finally {
      if (consumer != null) {
        try {
          consumer.close();
        }
        catch (JMSException jmsex) {
          System.out.println("Consumer could not be closed.");
          recordFailure(jmsex);
        }
      }

      if (session != null) {
        try {
          session.close();
        }
        catch (JMSException jmsex) {
          System.out.println("Session could not be closed.");
          recordFailure(jmsex);
        }
      }

      if (connection != null) {
        try {
          connection.close();
        }
        catch (JMSException jmsex) {
          System.out.println("Connection could not be closed.");
          recordFailure(jmsex);
        }
      }
    }
    System.exit(status);
    return;
  } // end main()

  /**
   * Process a JMSException and any associated inner exceptions.
   *
   * @param jmsex
   */
  private static void processJMSException(JMSException jmsex) {
    System.out.println(jmsex);
    Throwable innerException = jmsex.getLinkedException();
    if (innerException != null) {
      System.out.println("Inner exception(s):");
    }
    while (innerException != null) {
      System.out.println(innerException);
      innerException = innerException.getCause();
    }
    return;
  }

  /**
   * Record this run as successful.
   */
  private static void recordSuccess() {
    System.out.println("SUCCESS");
    status = 0;
    return;
  }

  /**
   * Record this run as failure.
   *
   * @param ex
   */
  private static void recordFailure(Exception ex) {
    if (ex != null) {
      if (ex instanceof JMSException) {
        processJMSException((JMSException) ex);
      }
      else {
        System.out.println(ex);
      }
    }
    System.out.println("FAILURE");
    status = -1;
    return;
  }

  /**
   * Parse user supplied arguments.
   *
   * @param args
   */
  private static void parseArgs(String[] args) {
    try {
      int length = args.length;
      if (length == 0) {
        throw new IllegalArgumentException("No arguments! Mandatory arguments must be specified.");
      }
      if ((length % 2) != 0) {
        throw new IllegalArgumentException("Incorrect number of arguments!");
      }

      int i = 0;

      while (i < length) {
        if ((args[i]).charAt(0) != '-') {
          throw new IllegalArgumentException("Expected a '-' character next: " + args[i]);
        }

        char opt = (args[i]).toLowerCase().charAt(1);

        switch (opt) {
          case 'h' :
            host = args[++i];
            clientTransport = true;
            break;
          case 'p' :
            port = Integer.parseInt(args[++i]);
            break;
          case 'l' :
            channel = args[++i];
            break;
          case 'm' :
            queueManagerName = args[++i];
            break;
          case 'd' :
            destinationName = args[++i];
            break;
          case 'u' :
            user = args[++i];
            break;
          case 'w' :
            password = args[++i];
            break;
          case 't' :
            try {
              int timeoutSeconds = Integer.parseInt(args[++i]);
              timeout = timeoutSeconds * 1000;
            }
            catch (NumberFormatException nfe) {
              throw new IllegalArgumentException("Timeout must be a whole number of seconds");
            }
            break;
          default : {
            throw new IllegalArgumentException("Unknown argument: " + opt);
          }
        }

        ++i;
      }

      if (queueManagerName == null) {
        throw new IllegalArgumentException("A queueManager name must be specified.");
      }

      if (destinationName == null) {
        throw new IllegalArgumentException("A destination name must be specified.");
      }

      if (((user == null) && (password != null)) ||
          ((user != null) && (password == null))) {
        throw new IllegalArgumentException("A userid and password must be specified together");
      }

      // Whether the destination is a queue or a topic. Apply a simple check.
      if (destinationName.startsWith("topic://")) {
        isTopic = true;
      }
      else {
        // Otherwise, let's assume it is a queue.
        isTopic = false;
      }
    }
    catch (Exception e) {
      System.out.println(e.getMessage());
      printUsage();
      System.exit(-1);
    }
    return;
  }

  /**
   * Display usage help.
   */
  private static void printUsage() {
    System.out.println("\nUsage:");
    System.out
        .println("JmsConsumer -m queueManagerName -d destinationName [-h host -p port -l channel] [-u user -w passWord] [-t timeout_seconds]");
    return;
  }

} // end class

  

JWT JSON WEB TOKENS

Conocidos como jut, Lo mejor para ver como funcionan es probarlos con un par de web. 

1º crear un JWR con esta web http://jwtbuilder.jamiekurtz.com/

2º validar el token con esta otra https://jwt.io.

Los algorimos HSXXX son cifrados simetricos utilizan una sola key para cifrar y desencifrar.

Los algoritmos RSXXX son asimetricos de dos claves, conocidas compo cifrado de clave publica y privada.

el JWT se añande como parametro en la cabezera de los mensajes HTTP headers similar a las cookies pero con otra clave y el schema como abajo

Authorization: Bearer <token>

Se graba en Base64 y tiene tres partes, 

eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJob2xhbXVuZG8iLCJpYXQiOjE0ODU1OTA0NzcsImV4cCI6MTQ4NTU5MTQ3MSwiYXVkIjoiaG9sYW11bmRvIiwic3ViIjoiaG9sYW11bmRvIiwiR2l2ZW5OYW1lIjoiam9yZGkiLCJTdXJuYW1lIjoiam9yZGkifQ.Yc0YCif2SqOGIOzI30plzM17c0bvrH39Ji0Q-ZIWI1M

La parete rosa decodificada es un 'header' que indica el protocola utilizado , la parte rojo es como el bloque de abajo y lo ultimo es un algoritmo Has256( parte roja + clave)

{"alg":"HS256","typ":"JWT"}

{
    "iss": "holamundo",
    "iat": 1485590477,
    "exp": 1485591471,
    "aud": "holamundo",
    "sub": "holamundo",
    "GivenName": "jordi",
    "Surname": "jordi"
}

$http $timeout.

En AngularJS y es JavaScript no tiene hilos, asi que no se puede secuanciar en un hilo tareas. Las tareas se ejecutan parcialmente a turnos. Por eso al llamar a objetos de recursos externos puede haber resultdos raros como cambios en el orden.

    $http.get(url\API1).
                then(function successCallback(response) {
 $scope.myvariable= 'hola';
 console.log($scope.myvariable);

        }, function errorCallback(response) {
}

    $http.get(url\API2).
                then(function successCallback(response) {
$scope.myvariable= 'adios';
console.log($scope.myvariable);
        }, function errorCallback(response) {
}

En AngularJS puede pasar que el Output sea primero adios,hola y no hola y adios quees lo esperado mirando la secuencia.

Una manera de resolver esto o al menos cambiarlo es el uso de $timeout pr ejem

     $timeout(function (){
       $scope.myvariable=  haceralgo();
     },5000);

Aunque lo mas seguro es sincronizar las llamadas en el then.success asi

    $http.get(url\API1).
                then(function successCallback(response) {
 $http.get(url\API2).then(function successCallback(response) {

 }

        }, function errorCallback(response) { }

Una instacion de OpenStack contiene al mennos 4 tipos de nodos.

• El contorlador. Controller node. Donde esta la 'identity' o autentificacion junto con las herramietas necesarias para el controlador como MariaDB o colas RabbitMQ
• Network controller nodes.
• Compute node. Aqui estan los hipervisions y sus maquinas
• Storage. Cinder y Swift

Pues todo esto. bueno Swift no se puede instalar en un portail con 8GB de Ram. Lo primero es instalar una instancia de Unbutu 16 Server.y asignarle minimo 4 GB. 

Establecer instacion con Bridge Adapter para que lo podamos ver desde fuera y para poder poner Ip fija, aunque no es estrictamente necesario y se puede evitar pero si tenemos dchp es lo mas practico si se quiere reutilizar la instalacion..Editar el fichero sudo vi /etc/networking/interfaces y añadir las lineas con los valores que toquen. En particular la ip puede ser la misma que se detecta y se ve con ifconfig. Y los valores se pueden sacar del anfitrion. Es buno reinicar del todo para estar seguro de que todo esta OK.

La maqjina deberia tener acceso a internet . Mejor lo pobamos con un curl www.googl.com

sudo apt-get update PRIMERO de todo.

• Use sudo apt-get install cloud-init
• git clone https://git.openstack.org/openstack-dev/devstack
• cd devstack
• cd /samples y copiar el local.config en devstack e informar al menos los campos de abajo.
• '[[local|localrc]]'
  ADMIN_PASSWORD=password
  DATABASE_PASSWORD=password
  RABBIT_PASSWORD=password
  SERVICE_PASSWORD=password
• Y por ultimo ./stack.sh Y A CORRER. 

Tarda un buen rato asi que paciencia.

Despues desde el anfitrion se abre un navegador y user admin y el pwd que se le haya puesto.