ansible 中的模板 jinja2模板引擎（三）

男娘i 2023-07-23 03:37 20阅读 0赞

## 一、转义的一些操作 ##

前文中我们已经总结了jinja2模板的一些基础用法，比如，变量和表达式被包含在"\{ \{ \}\}“中，控制语句被包含在”\{% %\}"， 注释被包含在"\{\# \#\}“中，也就是说，在模板文件中，一旦遇到”\{ \{ \}\}"、"\{% %\}“或者”\{\# \#\}"，jinja2模板引擎就会进行相应的处理，最终生成的文件内容中并不会包含"\{ \{ \}\}“或者”\{% %\}“这些字符，但是如果，最终生成的文件中就是需要有”\{ \{ \}\}"这一类的字符，该怎么办呢？有如下几种方法。

1.引号转义  
最简单的方法就是直接在"\{ \{ \}\}"中使用引号将这类符号引起，当做纯粹的字符串进行处理，示例模板内容如下：

[root@server4 jinja2-3]# vim test1.j2
    [root@server4 jinja2-3]# cat test1.j2 
    { {   '{ {'  }}
    { {   '}}'  }}
    { {  '{ { test redhat }}' }}
    { {  '{% test redhat %}' }}
    { {  '{# test redhat #}' }}

[root@server4 jinja2-3]# ansible testB -m template -a "src=test1.j2 dest=/opt/test"

上述模板最终生成的内容如下：

[root@server3 ~]# cat /opt/test
    { { 
    }}
    { {  test redhat }}
    { % test redhat %}
    { # test redhat #}

2.raw块转义  
但是如果有较多这样的符号都需要保持原样（不被jinja2解析），那么使用上述方法可能比较麻烦，因为行多量大，大段的符号需要注意就比较烦人，所以，如果有较大的段落时，可以借助"\{% raw %\}"块，来实现刚才的需求，示例如下：

[root@server4 jinja2-3]# vim test2.j2
    [root@server4 jinja2-3]# cat test2.j2 
    { % raw %}
      { {  test }}
      { % test %}
      { # test #}
      { % if %}
      { % for %}
    { % endraw %}
    [root@server4 jinja2-3]# ansible testB -m template -a "src=test2.j2 dest=/opt/test"

如上例所示，"\{% raw %\}“与”\{% endraw %\}“之间的所有”\{ \{ \}\}"、"\{% %\}“或者”\{\# \#\}"都不会被jinja2解析，上例模板被渲染后，raw块中的符号都会保持原样，最终生成内容如下：

[root@server3 ~]# cat /opt/test
    
      { {  test }}
      { % test %}
      { # test #}
      { % if %}
      { % for %}

3.手动指定符号  
默认情况下，变量和表达式被包含在"\{ \{ \}\}“中，控制语句被包含在”\{% %\}"，其实，我们也可以在调用模板引擎时，手动的指定一些符号，这些符号可以替换默认的"\{ \{ \}\}“和”\{% %\}"，当我们在ansible中调用templdate模块时，可以使用variable\_start\_string参数指定一个符号，这个符号用于替换"\{ \{ \}\}“中的”\{ \{"，同时，可以使用variable\_end\_string参数指定一个符号，这个符号用于替换"\{ \{ \}\}“中的”\}\}"，示例如下：

[root@server4 jinja2-3]# vim test3.j2
    [root@server4 jinja2-3]# cat test3.j2 
    { % set test='abc' %}
    
    (( test ))
    
    { {  test }}
    { {  test1 }}
    { {  'test' }}
    { {  'test1' }}

上述内容为示例模板的内容，当我们调用templdate模块时，执行如下命令，注意，如下命令表示使用"((“代替”\{ \{"，使用"))“代替”\}\}"。

[root@server4 jinja2-3]# ansible testB -m template -a "src=test3.j2 variable_start_string='((' variable_end_string='))' dest=/opt/test"

执行上述命令后，最终生成的文件内容如下：

[root@server3 ~]# cat /opt/test
    
    abc
    
    { {  test }}
    { {  test1 }}
    { {  'test' }}
    { {  'test1' }}

如你所见，当我们使用了指定的符号替换了默认的"\{ \{ \}\}“之后，”\{ \{ \}\}“字符将会保持原样，”\{ \{ \}\}“中的内容也不会再被jinja2模板引擎解析，我们指定的符号为”(( ))"，所以，jinja2引擎在遇到"(( ))"符号时，才会进行对应的解析渲染。

同理，我们可以使用block\_start\_string参数指定一个符号，这个符号用于替换"\{% %\}“中的”\{% "  
可以使用block\_end\_string参数指定一个符号，这个符号用于替换"\{% %\}“中的”%\}"

注意：刚才提到的这几个参数在2.4以及之后版本的ansible中可用。

如果你想要生成的文件通篇都是"\{ \{ \}\}“和”\{% %\}“这种符号，只有个别地方需要用到模板引擎的表达式和控制语句，那么不如直接使用刚才提到的参数，使用指定的符号将默认的符号替代，替代后，”\{ \{ \}\}“或”\{% %\}"都会保持原样，不会被解析。

## 二、宏相关总结 ##

1.宏的使用  
jinja2中也有类似函数的东西，它叫做"宏"，利用宏，我们可以方便快捷的重复的利用一段内容，并且把这段内容当做一个独立的逻辑单元，与其他语言中的函数一样，jinja2的宏也可以传入参数，先来看一个最简单的宏，示例模板如下

[root@server4 jinja2-3]# vim test4.j2
    [root@server4 jinja2-3]# cat test4.j2 
    { % macro testfunc() %}
       test string
    { % endmacro %}
    
    { {  testfunc() }}

[root@server4 jinja2-3]# ansible testB -m template -a "src=test4.j2 dest=/opt/test"

[root@server3 ~]# cat /opt/test
    
       test string

如上例所示，定义宏时需要使用"\{% macro %\}“开头，使用”\{% endmacro %\}“结束，上例中，我定义了一个名为testfunc的宏，与大多数语言中的函数一样，宏的括号中可以传入参数，但是上例的宏中并没有定义任何参数，testfunc中的内容没有什么意义，只是用于示例宏的用法，”\{% macro %\}“和”\{% endmacro %\}"之间的内容只是用来定义宏，如果想要真正的使用宏，还需要引用它，上例的最后一行就是在调用testfunc宏。

2.传参的宏  
看完最简单的宏，再来看一个传参的宏，示例如下：

[root@server4 jinja2-3]# vim test5.j2
    [root@server4 jinja2-3]# cat test5.j2 
    { % set testvar1='teststr1' %}
    { % set testvar2=2 %}
    
    { % macro testfunc(tv1,tv2) %}
        test string
        { { tv1}}
        { { tv2}}
    { % endmacro%}
    
    { {  testfunc(testvar1,testvar2) }}

[root@server4 jinja2-3]# ansible testB -m template -a "src=test5.j2 dest=/opt/test"

[root@server3 ~]# cat /opt/test
    
    
        test string
        teststr1
        2

如上例所示，我们在定义宏时，定义了两个参数，然后 在调用宏时，传入了提前定义好的testvar1变量和testvar2变量。

3.宏使用参数的默认值  
上述示例有一个很明显的问题，就是如果宏在定义的时候有对应的参数，在调用宏时就必须传入对应的参数，否则就会报错，其实，我们还可以在定义宏时，为对应的参数指定一个默认值，当在调用宏时没有显式的指定对应的参数时，宏就使用参数的默认值，示例模板如下：

[root@server4 jinja2-3]# vim test6.j2 
    [root@server4 jinja2-3]# cat test6.j2 
    { % macro testfunc(tv1=111) %}
        test string
        { { tv1}}
    { % endmacro%}
    
    { {  testfunc() }}
    { {  testfunc(666) }}

[root@server4 jinja2-3]# ansible testB -m template -a "src=test6.j2 dest=/opt/test"

渲染结果如下：

[root@server3 ~]# cat /opt/test
    
        test string
        111
    
        test string
        666

如上例所示，我们在定义宏时，为tv1参数定义了默认值111，然后调用了两次testfunc宏，第一次没有传入对应参数，使用了默认值，第二次调用宏时传入了对应参数，于是使用了传入的值

## 三、宏内部的特殊变量 ##

其实，在宏的内部，有三个默认的内置特殊变量可供我们使用，它们分别是varargs、kwargs、caller。

1.varargs  
我们可以在调用宏时，多传入几个额外的参数，这些额外的参数会作为一个元组保存在varargs变量上，我们可以通过获取varargs变量的值获取到额外传入的参数，示例如下：

[root@server4 jinja2-3]# vim test10.j2 
    [root@server4 jinja2-3]# cat test10.j2 
    { % macro testfunc(testarg1=1,testarg2=2) %}
       test string
       { { testarg1}}
       { { testarg2}}
       { { varargs}}
    { % endmacro %}
    
    { {  testfunc('a','b','c','d','e') }}

[root@server4 jinja2-3]# ansible testB -m template -a "src=test10.j2 dest=/opt/test"

上例中我们只定义了两个参数，但是在调用宏时，我们传入了5个参数，而在宏里面，我们输出了内置变量varargs，最终渲染后的效果如下：

[root@server3 ~]# cat /opt/test
    
       test string
       a
       b
       ('c', 'd', 'e')

既然varargs变量里面存储了多余的参数，那么如果宏压根就没有定义任何参数，我们却传入了一些参数，那么这些所有传入的参数都是“多余”出的参数，也可以使用varargs变量处理这些参数，示例如下：

[root@server4 jinja2-3]# vim test11.j2 
    [root@server4 jinja2-3]# cat test11.j2 
    { % macro testfunc() %}
       test string
       { %for i in varargs%}
       { { i}}
       { %endfor%}
       { {  '------' }}
    { % endmacro %}
    
    { {  testfunc() }}
    { {  testfunc('a','b','c','d','e') }}
    
    [root@server4 jinja2-3]# ansible testB -m template -a "src=test11.j2 dest=/opt/test"

如上例所示，定义宏时，并没有定义任何参数，但是在使用宏时，可以传入任意个数的参数，或者不传任何参数，这种使用方式类似于python中的可变参数，上例的最终渲染效果如下：

[root@server3 ~]# cat /opt/test
    
       test string
          ------
    
       test string
          a
          b
          c
          d
          e
          ------

2.kwargs  
聊完内置变量varargs，再来聊聊变量kwargs，kwargs变量与varargs变量的作用很像，但是kwargs变量只是针对’关键字参数’而言的，而varargs变量是针对’非关键字参数’而言的，看了如下示例你就会明白了

[root@server4 jinja2-3]# vim test12.j2 
    [root@server4 jinja2-3]# cat test12.j2 
    { % macro testfunc(tv1='tv1') %}
       test string
       { { varargs}}
       { { kwargs}}
    { % endmacro %}
    
    { {  testfunc('a',2,'test',testkeyvar='abc') }}

[root@server4 jinja2-3]# ansible testB -m template -a "src=test12.j2 dest=/opt/test"

如上例所示，我们在定义宏时，定义了一个参数tv1，并且设置了默认值，在宏中，我们输出了varargs变量和kwargs变量，在调用宏时，我们多传入了3个参数，最后一个参数是一个带有参数名的关键字参数，那么渲染上述模板，内容如下

[root@server3 ~]# cat /opt/test
    
       test string
       (2, 'test')
       { 'testkeyvar': 'abc'}

如上所示，多余的非关键字参数都会保存在varargs变量中，varargs变量的结构是一个元组，而多余的关键字参数都会保存在kwargs变量中，kwargs变量的结构是一个字典，kwargs变量实现的效果与Python的关键字参数效果类似。

3.caller  
了解了varargs变量和kwargs变量，现在来说说caller变量。

与其说是caller变量，不如称其为caller函数或者caller方法，caller可以帮助我们将宏中的内容进行替换，这样描述可能不太容易理解，不如先来看一个小例子：

{ % macro testfunc() %}
      test string
      { { caller()}}
    { % endmacro %}

如上例所示，我们定义了一个testfunc宏，在testfunc宏中，"\{ \{caller()\}\}“部分可以被"其他内容"替换，但是此刻，我们还没有调用testfunc宏，如果想要替换testfunc宏中的”\{ \{caller()\}\}"部分，则需要在调用testfunc宏时，使用"call语句块"进行调用，示例如下：

[root@server4 jinja2-3]# vim test13.j2 
    [root@server4 jinja2-3]# cat test13.j2 
    { % macro testfunc() %}
      test string
      { { caller()}}
    { % endmacro %}
    
    { % call testfunc() %}
    redhat~~~~~~~~~
    redhat 7.3------
    { %endcall%}

如上例所示，我们使用了"\{%call%\}“语句块调用了testfunc宏，”\{%call%\}“和”\{%endcall%\}“之间的内容将会替换testfunc宏中的”\{ \{caller()\}\}"部分，上例模板最终渲染效果如下

[root@server4 jinja2-3]# ansible testB -m template -a "src=test13.j2 dest=/opt/test"

[root@server3 ~]# cat /opt/test
    
      test string
      redhat~~~~~~~~~
    redhat 7.3------

是不是觉得跟传参数的效果一模一样，就像传了一个参数给testfunc宏一样，当我们要传入大段内容或者复杂的内容时，可以借助caller进行传递，当然，上例只是 为了让你能够更加直观的了解caller的用法，caller其实还能够帮助我们在一个宏中调用另一个宏，示例如下：

[root@server4 jinja2-3]# vim test14.j2 
    [root@server4 jinja2-3]# cat test14.j2 
    { % macro testfunc() %}
      test string
      { { caller()}}
    { % endmacro %}
    
    
    { % macro testfunc1() %}
      { %for i in range(3) %}
      { { i}}
      { %endfor%}
    { % endmacro %}
    
    
    { % call testfunc() %}
    { {  testfunc1() }}
    { %endcall%}

[root@server4 jinja2-3]# ansible testB -m template -a "src=test14.j2 dest=/opt/test"

[root@server3 ~]# cat /opt/test
    
    
    
    
      test string
          0
        1
        2

如上例所示，我们定义了两个宏，testfunc和testfunc1，我们将testfunc1传递到了testfunc中。

其实，"caller()"也可以接收参数，只要在call块中提前定义好，在caller中传入参数即可，示例如下：

[root@server4 jinja2-3]# vim test15.j2 
    [root@server4 jinja2-3]# cat test15.j2 
    { % macro testfunc() %}
      test string
      { { caller('redhattttt-----')}}
    { % endmacro %}
    
    { % call(testvar) testfunc() %}
    redhat1111~~~~~~~~~
    { { testvar}}
    { %endcall%}

如上例所示，call块中定义了testvar参数，call块中的内容使用了testvar参数，在testfunc宏中的调用caller时，传入了一个字符串作为参数，上例最终的渲染的效果如下：

[root@server4 jinja2-3]# ansible testB -m template -a "src=test15.j2 dest=/opt/test"

[root@server3 ~]# cat /opt/test
    
      test string
      redhat1111~~~~~~~~~
    redhattttt-----

当testfunc中的某些内容需要循环的进行替换时，这种方法非常有效。

## 四、宏的属性 ##

除了varargs、kwargs、caller这些内部变量，宏还有一些属性可以使用。

可用的宏属性如下，此处先对这些属性进行描述，之后会进行示例：

<table> 
 <thead> 
  <tr> 
   <th>宏属性</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>name属性</td> 
   <td>宏的名称。</td> 
  </tr> 
  <tr> 
   <td>arguments属性</td> 
   <td>宏中定义的所有参数的参数名，这些参数名组成了一个元组存放在arguments中。</td> 
  </tr> 
  <tr> 
   <td>defaults属性</td> 
   <td>宏中定义的参数如果有默认值，这些默认值组成了一个元组存放在defaults中。</td> 
  </tr> 
  <tr> 
   <td>catch_varargs属性</td> 
   <td>如果宏中使用了varargs变量，此属性的值为true。</td> 
  </tr> 
  <tr> 
   <td>catch_kwargs属性</td> 
   <td>如果宏中使用了kwargs变量，此属性的值为true。</td> 
  </tr> 
  <tr> 
   <td>caller属性</td> 
   <td>如果宏中使用了caller变量，此属性值为true。</td> 
  </tr> 
 </tbody> 
</table>

上述宏属性的使用示例如下，可以对比着渲染后的结果查看：

[root@server4 jinja2-3]# vim test16.j2 
    [root@server4 jinja2-3]# cat test16.j2 
    { % macro testfunc(tv1,tv2,tv3=3,tv4=4) %}
      test string
      { { tv1}}
      { { tv2}}
      { { tv3}}
      { { tv4}}
    { % endmacro %}
     
      { { testfunc.name}}
      { { testfunc.arguments}}
      { { testfunc.defaults}}
      { { testfunc.catch_varargs}}
      { { testfunc.catch_kwargs}}
      { { testfunc.caller}}
     
    { { '################################'}}
     
    { % macro testfunc1(tv1='a',tv2='b') %}
      test string
      { { tv1}}
      { { tv2}}
      { { varargs}}
      { { kwargs}}
    { % endmacro %}
     
      { { testfunc1.catch_varargs}}
      { { testfunc1.catch_kwargs}}
      { { testfunc1.caller}}
     
    { { '################################'}}
     
    { % macro testfunc2() %}
      test string
      { { caller()}}
    { % endmacro %}
     
      { { testfunc2.caller}}

[root@server4 jinja2-3]# ansible testB -m template -a "src=test16.j2 dest=/opt/test"

如你所见，我并没有调用宏，但是可以直接使用宏的属性，上例模板内容渲染后的结果如下：

[root@server3 ~]# cat /opt/test
     
      testfunc
      ('tv1', 'tv2', 'tv3', 'tv4')
      (3, 4)
      False
      False
      False
     
    ################################
     
     
      True
      True
      False
     
    ################################
     
     
      True