ansible action plugin | 张志明的个人博客

ansible plugin属于ansible 的高阶用法，他与ansible module不同，我们普通的module ，或者我们自己编写的module更多的是在目标主机运行，而ansible action plugin 则是在ansible的执行机器运行（也就是本机执行）

另外一个是ansible会先执行action plugin 然后再执行 ansible module ，我们可以认为是action plugin 是在执行具体的module之前，进行了本地渲染

一个非常典型的例子就是ansilbe 的 template其实就是一个action plugin ，他的实质是 ansible 先调用template action plugin 进行本地的渲染，包括模板生产到当前机器，然后通过copy module 再复制到远端的目标主机，其中本地通过模板生成文件的过程，是在调用copy 之前的，这就是action plugin的工作

ansible 存在好多的plugin , action plugin 仅仅是其中的一种，具体的有：

我们可以编写自己的action plugin 来帮我们实现一些module 无法单独实现或者过于复杂的操作，后边会更新另外一篇编写自己的action plugin的例子，这里附上ansible template实现的具体源码：

# Copyright: (c) 2015, Michael DeHaan <michael.dehaan@gmail.com>
# Copyright: (c) 2018, Ansible Project
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)

from __future__ import (absolute_import, division, print_function)
__metaclass__ = type

import os
import shutil
import stat
import tempfile

from ansible import constants as C
from ansible.config.manager import ensure_type
from ansible.errors import AnsibleError, AnsibleFileNotFound, AnsibleAction, AnsibleActionFail
from ansible.module_utils._text import to_bytes, to_text, to_native
from ansible.module_utils.parsing.convert_bool import boolean
from ansible.module_utils.six import string_types
from ansible.plugins.action import ActionBase
from ansible.template import generate_ansible_template_vars


class ActionModule(ActionBase):

    TRANSFERS_FILES = True
    DEFAULT_NEWLINE_SEQUENCE = "\n"

    def run(self, tmp=None, task_vars=None):
        ''' handler for template operations '''

        if task_vars is None:
            task_vars = dict()

        result = super(ActionModule, self).run(tmp, task_vars)
        del tmp  # tmp no longer has any effect

        # Options type validation
        # stings
        for s_type in ('src', 'dest', 'state', 'newline_sequence', 'variable_start_string', 'variable_end_string', 'block_start_string',
                       'block_end_string'):
            if s_type in self._task.args:
                value = ensure_type(self._task.args[s_type], 'string')
                if value is not None and not isinstance(value, string_types):
                    raise AnsibleActionFail("%s is expected to be a string, but got %s instead" % (s_type, type(value)))
                self._task.args[s_type] = value

        # booleans
        try:
            follow = boolean(self._task.args.get('follow', False), strict=False)
            trim_blocks = boolean(self._task.args.get('trim_blocks', True), strict=False)
            lstrip_blocks = boolean(self._task.args.get('lstrip_blocks', False), strict=False)
        except TypeError as e:
            raise AnsibleActionFail(to_native(e))

        # assign to local vars for ease of use
        source = self._task.args.get('src', None)
        dest = self._task.args.get('dest', None)
        state = self._task.args.get('state', None)
        newline_sequence = self._task.args.get('newline_sequence', self.DEFAULT_NEWLINE_SEQUENCE)
        variable_start_string = self._task.args.get('variable_start_string', None)
        variable_end_string = self._task.args.get('variable_end_string', None)
        block_start_string = self._task.args.get('block_start_string', None)
        block_end_string = self._task.args.get('block_end_string', None)
        output_encoding = self._task.args.get('output_encoding', 'utf-8') or 'utf-8'

        # Option `lstrip_blocks' was added in Jinja2 version 2.7.
        if lstrip_blocks:
            try:
                import jinja2.defaults
            except ImportError:
                raise AnsibleError('Unable to import Jinja2 defaults for determining Jinja2 features.')

            try:
                jinja2.defaults.LSTRIP_BLOCKS
            except AttributeError:
                raise AnsibleError("Option `lstrip_blocks' is only available in Jinja2 versions >=2.7")

        wrong_sequences = ["\\n", "\\r", "\\r\\n"]
        allowed_sequences = ["\n", "\r", "\r\n"]

        # We need to convert unescaped sequences to proper escaped sequences for Jinja2
        if newline_sequence in wrong_sequences:
            newline_sequence = allowed_sequences[wrong_sequences.index(newline_sequence)]

        try:
            # logical validation
            if state is not None:
                raise AnsibleActionFail("'state' cannot be specified on a template")
            elif source is None or dest is None:
                raise AnsibleActionFail("src and dest are required")
            elif newline_sequence not in allowed_sequences:
                raise AnsibleActionFail("newline_sequence needs to be one of: \n, \r or \r\n")
            else:
                try:
                    source = self._find_needle('templates', source)
                except AnsibleError as e:
                    raise AnsibleActionFail(to_text(e))

            mode = self._task.args.get('mode', None)
            if mode == 'preserve':
                mode = '0%03o' % stat.S_IMODE(os.stat(source).st_mode)

            # Get vault decrypted tmp file
            try:
                tmp_source = self._loader.get_real_file(source)
            except AnsibleFileNotFound as e:
                raise AnsibleActionFail("could not find src=%s, %s" % (source, to_text(e)))
            b_tmp_source = to_bytes(tmp_source, errors='surrogate_or_strict')

            # template the source data locally & get ready to transfer
            try:
                with open(b_tmp_source, 'rb') as f:
                    try:
                        template_data = to_text(f.read(), errors='surrogate_or_strict')
                    except UnicodeError:
                        raise AnsibleActionFail("Template source files must be utf-8 encoded")

                # set jinja2 internal search path for includes
                searchpath = task_vars.get('ansible_search_path', [])
                searchpath.extend([self._loader._basedir, os.path.dirname(source)])

                # We want to search into the 'templates' subdir of each search path in
                # addition to our original search paths.
                newsearchpath = []
                for p in searchpath:
                    newsearchpath.append(os.path.join(p, 'templates'))
                    newsearchpath.append(p)
                searchpath = newsearchpath

                # add ansible 'template' vars
                temp_vars = task_vars.copy()
                temp_vars.update(generate_ansible_template_vars(source, dest))

                with self._templar.set_temporary_context(searchpath=searchpath, newline_sequence=newline_sequence,
                                                         block_start_string=block_start_string, block_end_string=block_end_string,
                                                         variable_start_string=variable_start_string, variable_end_string=variable_end_string,
                                                         trim_blocks=trim_blocks, lstrip_blocks=lstrip_blocks,
                                                         available_variables=temp_vars):
                    resultant = self._templar.do_template(template_data, preserve_trailing_newlines=True, escape_backslashes=False)
            except AnsibleAction:
                raise
            except Exception as e:
                raise AnsibleActionFail("%s: %s" % (type(e).__name__, to_text(e)))
            finally:
                self._loader.cleanup_tmp_file(b_tmp_source)

            new_task = self._task.copy()
            # mode is either the mode from task.args or the mode of the source file if the task.args
            # mode == 'preserve'
            new_task.args['mode'] = mode

            # remove 'template only' options:
            for remove in ('newline_sequence', 'block_start_string', 'block_end_string', 'variable_start_string', 'variable_end_string',
                           'trim_blocks', 'lstrip_blocks', 'output_encoding'):
                new_task.args.pop(remove, None)

            local_tempdir = tempfile.mkdtemp(dir=C.DEFAULT_LOCAL_TMP)

            try:
                result_file = os.path.join(local_tempdir, os.path.basename(source))
                with open(to_bytes(result_file, errors='surrogate_or_strict'), 'wb') as f:
                    f.write(to_bytes(resultant, encoding=output_encoding, errors='surrogate_or_strict'))

                new_task.args.update(
                    dict(
                        src=result_file,
                        dest=dest,
                        follow=follow,
                    ),
                )
                copy_action = self._shared_loader_obj.action_loader.get('copy',
                                                                        task=new_task,
                                                                        connection=self._connection,
                                                                        play_context=self._play_context,
                                                                        loader=self._loader,
                                                                        templar=self._templar,
                                                                        shared_loader_obj=self._shared_loader_obj)
                result.update(copy_action.run(task_vars=task_vars))
            finally:
                shutil.rmtree(to_bytes(local_tempdir, errors='surrogate_or_strict'))

        except AnsibleAction as e:
            result.update(e.result)
        finally:
            self._remove_tmp_path(self._connection._shell.tmpdir)

        return result

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)

from __future__ import (absolute_import, division, print_function)

__metaclass__ = type

import os

import shutil

import stat

import tempfile

from ansible import constants as C

from ansible.config.manager import ensure_type

from ansible.errors import AnsibleError, AnsibleFileNotFound, AnsibleAction, AnsibleActionFail

from ansible.module_utils._text import to_bytes, to_text, to_native

from ansible.module_utils.parsing.convert_bool import boolean

from ansible.module_utils.six import string_types

from ansible.plugins.action import ActionBase

from ansible.template import generate_ansible_template_vars

class ActionModule(ActionBase):

TRANSFERS_FILES = True

DEFAULT_NEWLINE_SEQUENCE = "\n"

def run(self, tmp=None, task_vars=None):

''' handler for template operations '''

if task_vars is None:

task_vars = dict()

result = super(ActionModule, self).run(tmp, task_vars)

del tmp # tmp no longer has any effect

# Options type validation

# stings

for s_type in ('src', 'dest', 'state', 'newline_sequence', 'variable_start_string', 'variable_end_string', 'block_start_string',

'block_end_string'):

if s_type in self._task.args:

value = ensure_type(self._task.args[s_type], 'string')

if value is not None and not isinstance(value, string_types):

raise AnsibleActionFail("%s is expected to be a string, but got %s instead" % (s_type, type(value)))

self._task.args[s_type] = value

# booleans

try:

follow = boolean(self._task.args.get('follow', False), strict=False)

trim_blocks = boolean(self._task.args.get('trim_blocks', True), strict=False)

lstrip_blocks = boolean(self._task.args.get('lstrip_blocks', False), strict=False)

except TypeError as e:

raise AnsibleActionFail(to_native(e))

# assign to local vars for ease of use

source = self._task.args.get('src', None)

dest = self._task.args.get('dest', None)

state = self._task.args.get('state', None)

newline_sequence = self._task.args.get('newline_sequence', self.DEFAULT_NEWLINE_SEQUENCE)

variable_start_string = self._task.args.get('variable_start_string', None)

variable_end_string = self._task.args.get('variable_end_string', None)

block_start_string = self._task.args.get('block_start_string', None)

block_end_string = self._task.args.get('block_end_string', None)

output_encoding = self._task.args.get('output_encoding', 'utf-8') or 'utf-8'

# Option `lstrip_blocks' was added in Jinja2 version 2.7.

if lstrip_blocks:

try:

import jinja2.defaults

except ImportError:

raise AnsibleError('Unable to import Jinja2 defaults for determining Jinja2 features.')

try:

jinja2.defaults.LSTRIP_BLOCKS

except AttributeError:

raise AnsibleError("Option `lstrip_blocks' is only available in Jinja2 versions >=2.7")

wrong_sequences = ["\\n", "\\r", "\\r\\n"]

allowed_sequences = ["\n", "\r", "\r\n"]

# We need to convert unescaped sequences to proper escaped sequences for Jinja2

if newline_sequence in wrong_sequences:

newline_sequence = allowed_sequences[wrong_sequences.index(newline_sequence)]

try:

# logical validation

if state is not None:

raise AnsibleActionFail("'state' cannot be specified on a template")

elif source is None or dest is None:

raise AnsibleActionFail("src and dest are required")

elif newline_sequence not in allowed_sequences:

raise AnsibleActionFail("newline_sequence needs to be one of: \n, \r or \r\n")

else:

try:

source = self._find_needle('templates', source)

except AnsibleError as e:

raise AnsibleActionFail(to_text(e))

mode = self._task.args.get('mode', None)

if mode == 'preserve':

mode = '0%03o' % stat.S_IMODE(os.stat(source).st_mode)

# Get vault decrypted tmp file

try:

tmp_source = self._loader.get_real_file(source)

except AnsibleFileNotFound as e:

raise AnsibleActionFail("could not find src=%s, %s" % (source, to_text(e)))

b_tmp_source = to_bytes(tmp_source, errors='surrogate_or_strict')

# template the source data locally & get ready to transfer

try:

with open(b_tmp_source, 'rb') as f:

try:

template_data = to_text(f.read(), errors='surrogate_or_strict')

except UnicodeError:

raise AnsibleActionFail("Template source files must be utf-8 encoded")

# set jinja2 internal search path for includes

searchpath = task_vars.get('ansible_search_path', [])

searchpath.extend([self._loader._basedir, os.path.dirname(source)])

# We want to search into the 'templates' subdir of each search path in

# addition to our original search paths.

newsearchpath = []

for p in searchpath:

newsearchpath.append(os.path.join(p, 'templates'))

newsearchpath.append(p)

searchpath = newsearchpath

# add ansible 'template' vars

temp_vars = task_vars.copy()

temp_vars.update(generate_ansible_template_vars(source, dest))

with self._templar.set_temporary_context(searchpath=searchpath, newline_sequence=newline_sequence,

block_start_string=block_start_string, block_end_string=block_end_string,

variable_start_string=variable_start_string, variable_end_string=variable_end_string,

trim_blocks=trim_blocks, lstrip_blocks=lstrip_blocks,

available_variables=temp_vars):

resultant = self._templar.do_template(template_data, preserve_trailing_newlines=True, escape_backslashes=False)

except AnsibleAction:

raise

except Exception as e:

raise AnsibleActionFail("%s: %s" % (type(e).__name__, to_text(e)))

finally:

self._loader.cleanup_tmp_file(b_tmp_source)

new_task = self._task.copy()

# mode is either the mode from task.args or the mode of the source file if the task.args

# mode == 'preserve'

new_task.args['mode'] = mode

# remove 'template only' options:

for remove in ('newline_sequence', 'block_start_string', 'block_end_string', 'variable_start_string', 'variable_end_string',

'trim_blocks', 'lstrip_blocks', 'output_encoding'):

new_task.args.pop(remove, None)

local_tempdir = tempfile.mkdtemp(dir=C.DEFAULT_LOCAL_TMP)

try:

result_file = os.path.join(local_tempdir, os.path.basename(source))

with open(to_bytes(result_file, errors='surrogate_or_strict'), 'wb') as f:

f.write(to_bytes(resultant, encoding=output_encoding, errors='surrogate_or_strict'))

new_task.args.update(

dict(

src=result_file,

dest=dest,

follow=follow,

)

copy_action = self._shared_loader_obj.action_loader.get('copy',

task=new_task,

connection=self._connection,

play_context=self._play_context,

loader=self._loader,

templar=self._templar,

shared_loader_obj=self._shared_loader_obj)

result.update(copy_action.run(task_vars=task_vars))

finally:

shutil.rmtree(to_bytes(local_tempdir, errors='surrogate_or_strict'))

except AnsibleAction as e:

result.update(e.result)

finally:

self._remove_tmp_path(self._connection._shell.tmpdir)

return result

About
Latest Posts

Zhiming Zhang

Senior devops at Appannie

一个奔跑在运维路上的胖子

Latest posts by Zhiming Zhang (see all)

aws eks node 自动化扩展工具 Karpenter - 8月 10, 2022
ReplicationController and ReplicaSet in Kubernetes - 12月 20, 2021
public key fingerprint - 5月 27, 2021

2023年6月
一	二	三	四	五	六	日
« 八
			1	2	3	4
5	6	7	8	9	10	11
12	13	14	15	16	17	18
19	20	21	22	23	24	25
26	27	28	29	30