El Recetario de Reglas

Este documento es un conjunto (algo) aleatorio de recetas en caso de que simplemente prefiera un enfoque de aprender con ejemplos.

¡Feliz cocina!

¡Hola Mundo!¶

do:
  - echo: "Hello World!"

Ejecutar el Hola Mundo anterior¶

La forma más fácil es usar el REPL web en su instalación de Clarive.

Simplemente apunte su navegador aquí:

https://yourclariveserver/r/repl

Escriba algo de código y presione Ctrl-Enter (Windows/Linux) o Cmd-Enter (Mac) para ejecutarlo.

Poner comentarios en su código¶

do:
   # ahora algo de hello-worldly
   - print: Hello
   - print: World!    # aquí mi comentario también está bien

Declarar variables programáticamente¶

vars:
   myvar: World
do:
   - echo: Hello ${myvar}

Iterar sobre un array¶

vars:
   - myarray:
       - 1
       - 2
       - 3
do:
   - foreach:
       var: mycounter
       in: ${myarray}
       do:
          - echo: Hello number ${mycounter}

Crear y cambiar un Topic¶

do:
   - mid = create_topic:
          category: Enhancement
          data:
            description: |
                 Just a short description
          status: New
          title: My topic title

   - update_topic:
         mid: ${mid}
         data:
            title: 'Changed it just now'

   - change_status:
        mid: ${mid}
        to: Fixed

Llamar a un servicio web¶

do:
   - request:
      url: http://jsonplaceholder.typicode.com/posts
      method: POST
      returning: res
   - print: hello ${res.content}

Mostrar el servidor al que está desplegando en el log del job¶

Use variables en decoradores para personalizar su salida de log.

deploy:
   - foreach:
       var: host
       in: [ 'server1', 'server2' ]
       do:
           - ship [shipping to server ${host}]:
                 host: ${host}
                 from: local/path/file.txt
                 to: /tmp/remotepath/

Enviar un solo archivo a un servidor remoto¶

do:
   # primero creamos un archivo local en /clarive/local/path/file.txt
   - write_file:
        file: local/path/file.txt
        body: hello world

   # ahora enviamos local/* pero quitamos el prefijo 'local/'
   - ship:
       from: local/path/file.txt
       to: /tmp/remotepath/
       host: localhost

Enviar un directorio completo a un servidor remoto¶

do:
   - mkdir -p mylocaldir/subdir
   - touch mylocaldir/subdir/my_file

   # ahora enviamos local/* pero quitamos el prefijo 'local/'
   - ship:
       from: mylocaldir
       to: /tmp/remotepath/
       host: localhost

Enviar un directorio relativo a un servidor remoto¶

do:
   # primero creamos un archivo local en /clarive/local/path/file.txt
   - write_file:
        file: local/path/file.txt
        body: hello world

   # ahora enviamos local/* pero quitamos el prefijo 'local/'
   - ship:
       from: local/
       anchor_path: local/
       to: /tmp/remotepath/
       host: localhost
       include:
          - \.txt$    # solo archivos que terminan en \.txt

Importar un módulo¶

import:
   - .clarive/mymodule.yml

Unir un array en una cadena¶

do:
   - users =:
       - user1
       - user2
   - echo: |
        {{ users.map( function(val){ return `<li>${val}</li>` }).join('\n')  }}

Usar ES6/Babel en ClaJS¶

Usar el transpilador Babel en plantillas handlebar:

do:
   - foo =:
       - user1
       - user2
   - echo: |
        {{
            "use transpiler(babel)";
            foo.map( ( val ) => `<li>${val}</li>` ).join('\n')
        }}

Y en un bloque completo de código ClaJS:

do: |
   "use transpiler(babel)";

   class Builder {
       foo(x) {
           return `value=${x}`
       }
   }

   let obj = new Builder();
   print( obj.foo( 123 ) );

Publicar un archivo en el log del job¶

build:
  - tar cvzf dist-files.tgz dist/
  - log:
       msg: build completed
       file: dist-files.tgz

Comprimir un directorio¶

El parámetro base no es requerido. Por defecto está configurado en /, lo que significa que comienza relativo a from.

do:
   - zip:
       from: /tmp/zzz/
       to: /tmp/rr.zip
       base: /

Si desea anteponer una base diferente, simplemente agréguela a base.

do:
   - zip:
       from: /tmp/zzz/
       to: /tmp/rr.zip
       base: myprefix/this/dir

Comprimir un directorio con una marca de tiempo diferente¶

A veces desea establecer una marca de tiempo en un zip diferente de la que ofrece el sistema. Eso puede lograrse con la opción time.

do:
   - zip:
       from: /tmp/zzz/
       to: /tmp/rr.zip
       time: 2012-10-11 22:01:00

Empaquetar un directorio con ruta relativa y marca de tiempo¶

do:
   - tar:
       from: /tmp/zzz/
       to: /tmp/mytar.tar
       base: /myprefix
       time: "2017-09-18 10:22:10"

Empaquetar un directorio incluyendo y excluyendo archivos¶

Las inclusiones se procesan antes que las reglas de exclusión. En lo siguiente, los archivos o directorios que contienen la cadena file- en cualquier parte de su ruta completa se incluyen, pero los archivos con la extensión .txt se excluyen.

La coincidencia de patrones include/exclude no tiene en cuenta el prefijo base.

do:
   - tar:
       from: /tmp/zzz/
       to: /tmp/rr.tar
       include:
          - file-
       exclude:
          - \.txt

Analizar un archivo XML en el stash¶

Para este archivo XML dado:

<xml>
  <somenode>
      hello world
  </somenode>
</xml>

Lo analizaríamos con este código:

do:
   - parse_file:
        file: /path/to/file.xml
        type: xml
        returning: myvar
   - print: "Here we go: ${myvar.xml.somenode}"

Analizar un archivo XML en el stash, eliminando el nodo raíz¶

La opción KeepRoot elimina el nodo raíz.

do:
   - parse_file:
        file: /path/to/file.xml
        type: xml
        options:
           KeepRoot: 1
        returning: myvar
   - print: "Here we go: ${myvar.somenode}"   # note que la parte .xml ya no es necesaria

Analizar un archivo YAML en el stash¶

Dado este file.yml de entrada

aa: 10
bb: 20
foo:
   - 12
   - 13

do:
   - parse_file:
        file: /path/to/file.yml
        type: yaml
        returning: myvar
   - print: "Here are the ${myvar.value[1]} reasons why"   # ... 13 reasons why

Analizar un archivo INI¶

foo=100
bar=200
log_file=/long/path/file.log
[temporary]
tmp_dir=/tmp
tmp_port=8787

Analícelo con:

do:
   - parse_file:
        file: /path/to/file.ini
        type: ini
        returning: myvar
   - echo: tmp_dir is ${myvar.temporary.tmp_dir}

Analizar un archivo Properties¶

Aquí hay un archivo properties directamente de Wikipedia:

# You are reading the ".properties" entry.
! The exclamation mark can also mark text as comments.
# The key characters =, and : should be written with
# a preceding backslash to ensure that they are properly loaded.

# However, there is no need to preceede the value characters =, and : by a backslash.
website = https://en.wikipedia.org/
language = English

# The backslash below tells the application to continue reading
# the value onto the next line.
message = Welcome to \
          Wikipedia!

# Add spaces to the key
key\ with\ spaces = This is the value that could be looked up with the key "key with spaces".

# Unicode
tab : \u0009

# If you want your property to include a backslash, it should be escaped by another backslash
path=c:\\wiki\\templates

Analícelo con:

do:
   - parse_file:
        file: /path/to/file.properties
        type: properties
        returning: myprops
   - echo: tmp_dir is ${myprops.message}

Analizar un archivo JSON¶

{ "foo": [ { "bar": true } ] }

Puede analizarse con el siguiente rulebook:

do:
   - parse:
        file: /tmp/tt/file.json
        type: json
        returning: aaa
   - echo: "true is ${aaa.foo[0].bar}"  # true is 1

Analizar desde una cadena en lugar de un archivo¶

El contenido analizado no tiene que estar almacenado necesariamente en un archivo. Podría simplemente venir de una variable o una cadena pasada como el atributo body.

vars:
   - jsondata: |
        { "foo": [ { "bar": true } ] }
   - xml_content: |
        <xml>
           <foo name="beautiful" />
        </xml>
do:
   - parse:
        body: ${jsondata}
        type: json
        returning: json_parsed
   - parse:
        body: ${xml_content}
        type: xml
        returning: xml_parsed
   - echo: "XML is ${xml_parsed.xml.foo.name}"

Reemplazar una cadena en un archivo usando sed¶

Simplemente use el op sed.

do:
   - write_file:
       file: subdir/foobar.txt
       body: foo=$${pie}       # así es como escapamos variables para que la regla no las analice

   - pie =: pizza

   - sed:
       path: subdir/
   - foo = parse:
       file: subdir/foobar.txt

   - echo: ${foo}              # aquí está pizza