Escribir módulos de importación

Puede escribir sus propios ops en rulebooks. Se llaman módulos de importación, pero piense en ellos como bibliotecas.

Estas bibliotecas deben registrarse en su repositorio git, justo al lado de su .clarive.yml. Recomendamos usar el directorio .clarive para ellas, pero puede usar cualquier directorio realmente.

Aquí hay una estructura de repositorio propuesta:

 .clarive.yml
 .clarive/
 .clarive/myop.py         # estos deben ser archivos ejecutables
 .clarive/anotherop.rb
 src/                     # el resto de su aplicación, no relacionado con Clarive
 ...

Una vez que envíe la estructura anterior, su rulebook .clarive.yml podrá usar los ops de .clarive/ así:

import:
   - myproject/myrepo/.clarive/
build:
    - myop:
         some_arg: "do this"
    - anotherop:
         some_arg: "do that"

Hacer ops ejecutables¶

Para que funcionen los ops de módulos de importación, deben estar confirmados en su repositorio como ejecutables +x.

También necesita decirle a Clarive cómo ejecutarlos. Use el encabezado shebang para definir el ejecutable:

#!/usr/bin/env python

print( "hello from python" );

Cada op se ejecutará en un entorno de contenedor docker. Para controlar qué contenedor ejecuta cada op, establezca el parámetro image: en la lista de importación:

import:

   - path: myproject/myrepo/.clarive/myop.py
     image: python

   - path: myproject/myrepo/.clarive/anotherop.rb
     image: ruby

Si no establece una imagen, se ejecutarán en el contenedor rulebook predeterminado de Clarive, clarive/rulebook-runner.

Nombrar Ops¶

Los ops importados tendrán el mismo nombre que el archivo del que se importan, menos la extensión. Si el archivo se llama myfile.py, el op se llamará myfile: en el rulebook.

Nombres de archivo duplicados pero con extensión diferente darán un error: duplicate moniker.

También puede importar sus ops en un namespace, para que estén prefijados.

import:

   - path: myproject/myrepo/.clarive/
     into: foo

do:
   - foo/myop:
       some_arg: "here"

Leer argumentos de entrada¶

Sus ops pueden necesitar datos de entrada para funcionar. Clarive siempre envía datos de entrada. Depende de su módulo op leerlos.

Los argumentos de entrada se envían a través de entrada estándar como un objeto hash en formato JSON.

Por lo tanto, para leerlo, necesita:

leer una cadena desde la entrada estándar.
analizarla como JSON con un analizador JSON.

#!/usr/bin/env python

import os
import json

input = json.loads( raw_input() )

Y ahora tiene un diccionario en su módulo python, listo para ser usado.

Devolver argumentos de salida¶

Si necesita que su op devuelva datos estructurados de vuelta a su rulebook, debe convertir datos a JSON e imprimirlos en la salida estándar.

La salida de datos JSON impresa debe tener como prefijo el valor de la variable de entorno CLARIVE_RETURN.

Obtenga el valor de entorno para CLARIVE_RETURN
Codifique el JSON con CLARIVE_RETURN y su estructura de datos.
Imprima los resultados en la salida estándar.

print( json.dumps({ os.environ["CLARIVE_RETURN"]: { myarg: "return data" }) )

Ejemplos¶

Aquí hay algunos ejemplos completos de módulos de importación:

Probar en el REPL¶

Puede usar el REPL para probar sus módulos de importación.

Al probar en el REPL, debe extraer primero el repositorio con el op workspace:. Si no lo extrae del repositorio, el op import: intentará hacerlo por usted.

workspace:
   - myproject/myrepo
import:
   - myproject/myrepo/.clarive/

Es equivalente a esto:

import:
   - myproject/myrepo/.clarive/

Pero pierde control sobre la rama extraída:

workspace:
   - myproject/myrepo:mybranch
import:
   - myproject/myrepo/.clarive/