Autenticación en Bitbucket mediante SSH

Esta mini guia expone los pasos a seguir para configurar el acceso en Bitbucket mediante SSH, de forma que no sea necesaria la especificación de las credenciales cada vez que se realice una acción sobre un repositorio hospedado en dicho servicio. Incluye la configuración necesaria para los 2 tipos de repositorio soportados por Bitbucket (Git y Mercurial).

Es importante mencionar que la guia está enfocada a entornos Windows aunque los pasos son bastante similares en entornos Linux cambiando las instrucciones de consola por las del entorno de que toque.

Seguir leyendo Autenticación en Bitbucket mediante SSH

Anidar listas de objetos de negocio en un modelo Json mediante Swagger

Enlaces utilizados

https://editor.swagger.io/ Editor online de Swagger
http://docs.swagger.io/spec.html Swagger RESTful API Documentation Specification
https://jsonformatter.org/ Formateador online para ficheros Json
https://roger13.github.io/SwagDefGen/ Generador de definición de objetos Json

 

Implementación

Para poder anidar distintos objetos de negocio dentro del Swagger, el primer paso consiste en añadir éstos en la sección definitions del Swagger.

Aquí deben declararse todos los que se van a utilizar para crear la lista de objetos de tipo Element según el ejemplo que se ha desarrollado.

Una vez añadidas las definiciones se añade al Swagger el siguiente código:

ElementList:  
    type: array
    description: Elements List.
    items:
      $ref: '#/definitions/Element'

         
Type indica a Swagger que el elemento contenido es de tipo array.
Description describe la lista de elementos de la lista.
items:
    $ref: '#/definitions/Element'
      
Con esta sintaxis se indica a Swagger que cada elemento de la lista ElementList se corresponde con una definición de objeto de negocio cuya definición també aparecerá cuándo Swagger muestre el modelo general.

Se pueden anidar varios niveles en la creación de un objeto complejo.   En el caso de ejemplo que se describe en el apartado  siguiente se puede visualizar tres niveles: ElementList -> Element  que contiene a su vez  listas del tipo Acces e Invoice.

Ejemplo

Código de ejemplo:

swagger: '2.0'
paths:
  '/MainEndpoint/{element}':
    get:
      summary: Getting information of the service.
      description: >-
        Description of the swagger service.
      parameters:
        - name: element
          in: path
          required: true
          type: string
          description: Element Id separated by commas.
      responses:
        '200':
          description: Specific element.
          schema:
            properties:
              sources:
                type: array
                items:
                  $ref: '#/definitions/ElementList'
        default:
          description: Unexpected error
          schema:
            $ref: '#/definitions/Error'
      x-auth-type: None
      x-throttling-tier: Unlimited
  /MainEndpoint:
    get:
      summary: Get the whole elements.
      description: |
        Get all the elements available.
      responses:
        '200':
          description: All the elements
          schema:
            properties:
              sources:
                title: ElementList
                type: array
                items:
                  $ref: '#/definitions/ElementList'
        default:
          description: Unexpected error
          schema:
            $ref: '#/definitions/Error'          
      x-auth-type: None
      x-throttling-tier: Unlimited
definitions:
  Error:
    type: object
    properties:
      code:
        type: integer
        format: int32
      message:
        type: string
      fields:
        type: string  
  ElementList:  
    type: array
    description: Elements List.
    items:
      $ref: '#/definitions/Element'
  Element:
    type: object
    description: Element.
    properties: 
      elementCode:
        type: string
        example: 5000
      name: 
        type: string 
        example: Door
      address: 
        type: string 
        example: Jumper Street number 65
      elementaccess: 
        type: array
        description: Acces element.
        items:
          $ref: '#/definitions/Access'
      maxwidth: 
        type: integer
        format: int32
        example: 250
      maxheight: 
        type: integer
        format: int32
        example: 100
      saved: 
        type: boolean 
        example: 1
      informationpoint: 
        type: boolean      
        example: 0
      open: 
        type: string  
        example: 1
      close: 
        type: string 
        example: 1
      exterior: 
        type: boolean
        example: 0
      elevator: 
        type: boolean 
        example: 1
      elementinvoicelist: 
        type: array
        description: Element invoice.
        items:
          $ref: '#/definitions/Invoice'       
      argumentelement: 
        type: integer
        format: int32
        example: 30
  Invoice: 
      type: object
      properties: 
        invoicetype: 
          type: string
          example: Custom
        descinvoicetype: 
          type: string
          example: 7 days
        elementtype: 
          type: string
          example: ElementType
        amount: 
          type: number
          format: float
          example: 50,35
        minutes: 
          type: integer
          format: int32
          example: 15
  Access: 
      type: object
      properties: 
        accessid: 
          type: string
          example: 45
        accessaddress: 
          type: string
          example: Boeing Street number 126.
info:
  title: Endpoint Title
  version: v1
  description: >-
    Description related with the endpoint
	
securityDefinitions:
  default:
    type: oauth2
    authorizationUrl: 'https://127.0.0.1:8080/authorize'
    flow: implicit
    scopes: {}
basePath: /Base/PathService/Element/v1
host: '127.0.01:8080'
schemes:
  - https
  - http    

 

 

OCP7 11 – Hilos (02) – Control de Errores Inesperados

La clase Thread cuenta con un mecanismo de control de errores para casos en que se produzca un final inesperado a la ejecución de éste. A través del método setUncaughtExceptionHandler de la clase Thread es posible recoger la causa de esta finalización anómala dentro del hilo principal de la aplicación y actuar en consecuencia.

A continuación se añade un ejemplo que ilustra su funcionamiento:

// Resto del código
Thread t = new Thread(new Runnable()) {

 @Override
 public void run() {
  // Código del thread que provoca
  // una finalización anómala en su
  // ejecución
 }
});
t.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler(){
  
 @Override
 public void uncaughtException(Thread t, Throwable e) {
  // Tratamiento del error producido en el Thread.
  // Por ejemplo, se puede registrar un error o emprender
  // una acción alternativa
 }
});

// Inicialización de la ejecución del Thread.
// Gracias al Listenr del thread no es necesario supervisar la finalización
// del thread para tratar el error pudiendo seguir la ejecución del programa
// principal
t.start(); 

// Resto del códigox

 

OCP7 08 – Aserciones

La aserción es un mecanismo que permite comprobar suposiciones en el código que ayudan a confirmar el buen funcionamiento del mismo y que este está libre de errores. En el siguiente post se muestra su funcionamiento básico y las situaciones en las que es apropiado su uso y en las que no.
Una expresión de tipo aserción se identifica por la palabra clave assert. Su sintaxis es la siguiente:
assert <expresión> [:]
Dónde:
  • expresión: Expresión booleana que indicará si la suposición se cumple o no. En caso de que no se cumpla, se lanzará un error de tipo AssertionError
  • valor: Opcional. Si se indica un valor en la expresión, este será adjuntado en el error AssertionError producido.

Seguir leyendo OCP7 08 – Aserciones

OCP7 11 – Hilos (03) – Mecanismos básicos en la plataforma Java

En este artículo se exponen los mecanismos básicos que proporciona la plataforma estándar de Java para la implementación de tareas concurrentes detallada para su versión 7. 
Se tratarán los siguientes conceptos:
  • Implementación de tareas mediante hilos de ejecución
  • Gestión del ciclo de vida de los hilos de ejecución mediante API

Seguir leyendo OCP7 11 – Hilos (03) – Mecanismos básicos en la plataforma Java

OCP7 08 – Excepciones (II)

Extensión de los tipos de excepción estándar

En la medida de lo posible se deberá hacer uso de la jerarquía de excepciones provistas por la JDK. En caso de querer crear nuevos tipos, se deberán tener en cuenta los siguientes puntos:
  • Extender de RuntimeException o una de sus subclases en caso de definir un tipo de error no recuperable (Excepción no comprobada).
  • Extender de Exception o una de sus subclases (a excepción de RuntimeException) en caso de definir un tipo de error recuperable (Excepción comprobada) que debe ser explícitamente declarado y capturado.
  • No extender directamente de la clase Throwable, ya que la mayoría de tratamientos de errores mediante bloques try/catch se hace como mínimo a nivel de Exception. En estos casos, las excepciones derivadas directamente de Throwable no serían capturadas por estos bloques lo que podría provocar efectos no previstos.

Seguir leyendo OCP7 08 – Excepciones (II)

OCP7 13 – Localización (II)

Las especificaciones para el uso de recursos en formato de fichero de propiedades a través de la API ResourceBundle de Java definen unas reglas para la nomenclatura y ubicación de dichos ficheros que hay que seguir de forma que la JVM pueda localizar y recuperar los recursos definidos en ellos. No obstante, dicha API proporciona mecanismos que permiten personalizar este proceso. En este POST se explica cómo hacerlo. Seguir leyendo OCP7 13 – Localización (II)

Spring Boot – Configuración del contenedor subyacente

Una de las principales características del framework Spring Boot es permite la ejecución de aplicaciones web sin necesidad de usar servidores de aplicaciones externos donde desplegarlas. Esto lo consigue mediante el uso de un contenedor incrustado en la misma aplicación (Tomcat, Jetty Undertow). Aunque el framework configura por defecto este contenedor con valores válidos en muchos de los casos, a veces las peculiaridades de las aplicaciones hacen que se tengan que modificar ciertos parámetros de la configuración, como por ejemplo el soporte para HTTPS o el tamaño máximo peticiones de las peticiones, por poner algunos ejemplos. En este post se explicará la manera de personalizar estos valores.

Seguir leyendo Spring Boot – Configuración del contenedor subyacente

SQL – Encapsulado de sentencias complejas

En muchas ocasiones el acceso a un conjunto de datos almacenado en base de datos requiere de una consulta especialmente compleja. En los casos en que se debe permitir acceso a sistemas externos a estos datos, la solución ideal pasa por implementar una capa de negocio intermedia entre la aplicación consumidora de la información y la base de datos, sea mediante servicios web, un data-grid u otra componente que permita abstraer la complejidad de la obtención de los datos para facilitarla al sistema externo.
Hay casos en que esto no es posible y por requerimientos de arquitectura en el sistema, las aplicaciones externas deben acceder directamente a la base de datos para obtener la información. En estos supuestos, es buena idea implementar una interfaz para la obtención de los datos, una API que permita crear una caja negra sobre la implementación real de la obtención de los datos. Con ello se consigue:
  • Las modificación de las estructuras subyacentes de la base de datos no afectan a la integración con el sistema externo al mantenerse la interfaz de obtención de datos.
  • Permite mantener el control de cómo se obtienen los datos, lo que minimiza la posibilidad de errores al estar centralizada en una única implementación.
  • Ante la aparición de errores, se minimiza el tiempo necesario para la corrección, ya que estaría localizada en un único punto: La implementación de la interfaz.
En este post se propone un posible mecanismo para construir estas interfaces de acceso aplicado a bases de datos Oracle.

Seguir leyendo SQL – Encapsulado de sentencias complejas