ansible-ruby 1.0.0

data/lib/ansible/ruby/modules/generated/core/files/assemble.rb

@@ -0,0 +1,42 @@
+# See LICENSE.txt at root of repository
+# GENERATED FILE - DO NOT EDIT!!
+require 'ansible/ruby/modules/base'
+
+module Ansible
+  module Ruby
+    module Modules
+      class Assemble < Base
+        # @return [String] An already existing directory full of source files.
+        attribute :src
+        validates :src, presence: true, type: String
+
+        # @return [String] A file to create using the concatenation of all of the source files.
+        attribute :dest
+        validates :dest, presence: true, type: String
+
+        # @return [:yes, :no, nil] Create a backup file (if C(yes)), including the timestamp information so you can get the original file back if you somehow clobbered it incorrectly.
+        attribute :backup
+        validates :backup, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+
+        # @return [String, nil] A delimiter to separate the file contents.
+        attribute :delimiter
+        validates :delimiter, type: String
+
+        # @return [:True, :False, nil] If False, it will search for src at originating/master machine, if True it will go to the remote/target machine for the src. Default is True.
+        attribute :remote_src
+        validates :remote_src, inclusion: {:in=>[:True, :False], :message=>"%{value} needs to be :True, :False"}, allow_nil: true
+
+        # @return [Object, nil] Assemble files only if C(regex) matches the filename. If not set, all files are assembled. All "\\" (backslash) must be escaped as "\\\\" to comply yaml syntax. Uses Python regular expressions; see U(http://docs.python.org/2/library/re.html).
+        attribute :regexp
+
+        # @return [Boolean, nil] A boolean that controls if files that start with a '.' will be included or not.
+        attribute :ignore_hidden
+        validates :ignore_hidden, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+
+        # @return [String, nil] The validation command to run before copying into place.  The path to the file to validate is passed in via '%s' which must be present as in the sshd example below. The command is passed securely so shell features like expansion and pipes won't work.
+        attribute :validate
+        validates :validate, type: String
+      end
+    end
+  end
+end

data/lib/ansible/ruby/modules/generated/core/files/copy.rb

@@ -0,0 +1,41 @@
+# See LICENSE.txt at root of repository
+# GENERATED FILE - DO NOT EDIT!!
+require 'ansible/ruby/modules/base'
+
+module Ansible
+  module Ruby
+    module Modules
+      class Copy < Base
+        # @return [String, nil] Local path to a file to copy to the remote server; can be absolute or relative. If path is a directory, it is copied recursively. In this case, if path ends with "/", only inside contents of that directory are copied to destination. Otherwise, if it does not end with "/", the directory itself with all contents is copied. This behavior is similar to Rsync.
+        attribute :src
+        validates :src, type: String
+
+        # @return [Object, nil] When used instead of 'src', sets the contents of a file directly to the specified value. This is for simple values, for anything complex or with formatting please switch to the template module.
+        attribute :content
+
+        # @return [String] Remote absolute path where the file should be copied to. If src is a directory, this must be a directory too.
+        attribute :dest
+        validates :dest, presence: true, type: String
+
+        # @return [:yes, :no, nil] Create a backup file including the timestamp information so you can get the original file back if you somehow clobbered it incorrectly.
+        attribute :backup
+        validates :backup, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+
+        # @return [:yes, :no, nil] the default is C(yes), which will replace the remote file when contents are different than the source. If C(no), the file will only be transferred if the destination does not exist.
+        attribute :force
+        validates :force, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+
+        # @return [Object, nil] When doing a recursive copy set the mode for the directories. If this is not set we will use the system defaults. The mode is only set on directories which are newly created, and will not affect those that already existed.
+        attribute :directory_mode
+
+        # @return [:True, :False, nil] If False, it will search for src at originating/master machine, if True it will go to the remote/target machine for the src. Default is False.,Currently remote_src does not support recursive copying.
+        attribute :remote_src
+        validates :remote_src, inclusion: {:in=>[:True, :False], :message=>"%{value} needs to be :True, :False"}, allow_nil: true
+
+        # @return [:yes, :no, nil] This flag indicates that filesystem links, if they exist, should be followed.
+        attribute :follow
+        validates :follow, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+      end
+    end
+  end
+end

data/lib/ansible/ruby/modules/generated/core/files/fetch.rb

@@ -0,0 +1,31 @@
+# See LICENSE.txt at root of repository
+# GENERATED FILE - DO NOT EDIT!!
+require 'ansible/ruby/modules/base'
+
+module Ansible
+  module Ruby
+    module Modules
+      class Fetch < Base
+        # @return [String] The file on the remote system to fetch. This I(must) be a file, not a directory. Recursive fetching may be supported in a later release.
+        attribute :src
+        validates :src, presence: true, type: String
+
+        # @return [String] A directory to save the file into. For example, if the I(dest) directory is C(/backup) a I(src) file named C(/etc/profile) on host C(host.example.com), would be saved into C(/backup/host.example.com/etc/profile)
+        attribute :dest
+        validates :dest, presence: true, type: String
+
+        # @return [:yes, :no, nil] Makes it fails when the source file is missing.
+        attribute :fail_on_missing
+        validates :fail_on_missing, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+
+        # @return [:yes, :no, nil] Verify that the source and destination checksums match after the files are fetched.
+        attribute :validate_checksum
+        validates :validate_checksum, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+
+        # @return [String, nil] Allows you to override the default behavior of appending hostname/path/to/file to the destination.  If dest ends with '/', it will use the basename of the source file, similar to the copy module. Obviously this is only handy if the filenames are unique.
+        attribute :flat
+        validates :flat, type: String
+      end
+    end
+  end
+end

data/lib/ansible/ruby/modules/generated/core/files/file.rb

@@ -0,0 +1,35 @@
+# See LICENSE.txt at root of repository
+# GENERATED FILE - DO NOT EDIT!!
+require 'ansible/ruby/modules/base'
+
+module Ansible
+  module Ruby
+    module Modules
+      class File < Base
+        # @return [Object] path to the file being managed.  Aliases: I(dest), I(name)
+        attribute :path
+        validates :path, presence: true
+
+        # @return [:file, :link, :directory, :hard, :touch, :absent, nil] If C(directory), all immediate subdirectories will be created if they do not exist, since 1.7 they will be created with the supplied permissions. If C(file), the file will NOT be created if it does not exist, see the M(copy) or M(template) module if you want that behavior.  If C(link), the symbolic link will be created or changed. Use C(hard) for hardlinks. If C(absent), directories will be recursively deleted, and files or symlinks will be unlinked. If C(touch) (new in 1.4), an empty file will be created if the C(path) does not exist, while an existing file or directory will receive updated file access and modification times (similar to the way `touch` works from the command line).
+        attribute :state
+        validates :state, inclusion: {:in=>[:file, :link, :directory, :hard, :touch, :absent], :message=>"%{value} needs to be :file, :link, :directory, :hard, :touch, :absent"}, allow_nil: true
+
+        # @return [String, nil] path of the file to link to (applies only to C(state=link)). Will accept absolute, relative and nonexisting paths. Relative paths are not expanded.
+        attribute :src
+        validates :src, type: String
+
+        # @return [:yes, :no, nil] recursively set the specified file attributes (applies only to state=directory)
+        attribute :recurse
+        validates :recurse, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+
+        # @return [:yes, :no, nil] force the creation of the symlinks in two cases: the source file does not exist (but will appear later); the destination exists and is a file (so, we need to unlink the "path" file and create symlink to the "src" file in place of it).
+        attribute :force
+        validates :force, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+
+        # @return [:yes, :no, nil] This flag indicates that filesystem links, if they exist, should be followed.
+        attribute :follow
+        validates :follow, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+      end
+    end
+  end
+end

data/lib/ansible/ruby/modules/generated/core/files/find.rb

@@ -0,0 +1,58 @@
+# See LICENSE.txt at root of repository
+# GENERATED FILE - DO NOT EDIT!!
+require 'ansible/ruby/modules/base'
+
+module Ansible
+  module Ruby
+    module Modules
+      class Find < Base
+        # @return [String, nil] Select files whose age is equal to or greater than the specified time. Use a negative age to find files equal to or less than the specified time. You can choose seconds, minutes, hours, days, or weeks by specifying the first letter of any of those words (e.g., "1w").
+        attribute :age
+        validates :age, type: String
+
+        # @return [String, nil] One or more (shell or regex) patterns, which type is controled by C(use_regex) option.,The patterns restrict the list of files to be returned to those whose basenames match at least one of the patterns specified. Multiple patterns can be specified using a list.
+        attribute :patterns
+        validates :patterns, type: String
+
+        # @return [Object, nil] One or more re patterns which should be matched against the file content
+        attribute :contains
+
+        # @return [String] List of paths to the file or directory to search. All paths must be fully qualified.
+        attribute :paths
+        validates :paths, presence: true, type: String
+
+        # @return [:file, :directory, nil] Type of file to select
+        attribute :file_type
+        validates :file_type, inclusion: {:in=>[:file, :directory], :message=>"%{value} needs to be :file, :directory"}, allow_nil: true
+
+        # @return [:yes, :no, nil] If target is a directory, recursively descend into the directory looking for files.
+        attribute :recurse
+        validates :recurse, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+
+        # @return [String, nil] Select files whose size is equal to or greater than the specified size. Use a negative size to find files equal to or less than the specified size. Unqualified values are in bytes, but b, k, m, g, and t can be appended to specify bytes, kilobytes, megabytes, gigabytes, and terabytes, respectively. Size is not evaluated for directories.
+        attribute :size
+        validates :size, type: String
+
+        # @return [:atime, :mtime, :ctime, nil] Choose the file property against which we compare age. Default is mtime.
+        attribute :age_stamp
+        validates :age_stamp, inclusion: {:in=>[:atime, :mtime, :ctime], :message=>"%{value} needs to be :atime, :mtime, :ctime"}, allow_nil: true
+
+        # @return [Boolean, nil] Set this to true to include hidden files, otherwise they'll be ignored.
+        attribute :hidden
+        validates :hidden, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+
+        # @return [Boolean, nil] Set this to true to follow symlinks in path for systems with python 2.6+
+        attribute :follow
+        validates :follow, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+
+        # @return [Boolean, nil] Set this to true to retrieve a file's sha1 checksum
+        attribute :get_checksum
+        validates :get_checksum, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+
+        # @return [Boolean, nil] If false the patterns are file globs (shell) if true they are python regexes
+        attribute :use_regex
+        validates :use_regex, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+      end
+    end
+  end
+end

data/lib/ansible/ruby/modules/generated/core/files/ini_file.rb

@@ -0,0 +1,42 @@
+# See LICENSE.txt at root of repository
+# GENERATED FILE - DO NOT EDIT!!
+require 'ansible/ruby/modules/base'
+
+module Ansible
+  module Ruby
+    module Modules
+      class Ini_file < Base
+        # @return [String] Path to the INI-style file; this file is created if required
+        attribute :dest
+        validates :dest, presence: true, type: String
+
+        # @return [String] Section name in INI file. This is added if C(state=present) automatically when a single value is being set.
+        attribute :section
+        validates :section, presence: true, type: String
+
+        # @return [String, nil] if set (required for changing a I(value)), this is the name of the option.,May be omitted if adding/removing a whole I(section).
+        attribute :option
+        validates :option, type: String
+
+        # @return [String, nil] the string value to be associated with an I(option). May be omitted when removing an I(option).
+        attribute :value
+        validates :value, type: String
+
+        # @return [:yes, :no, nil] Create a backup file including the timestamp information so you can get the original file back if you somehow clobbered it incorrectly.
+        attribute :backup
+        validates :backup, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+
+        # @return [Object, nil] all arguments accepted by the M(file) module also work here
+        attribute :others
+
+        # @return [:present, :absent, nil] If set to C(absent) the option or section will be removed if present instead of created.
+        attribute :state
+        validates :state, inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
+
+        # @return [Boolean, nil] do not insert spaces before and after '=' symbol
+        attribute :no_extra_spaces
+        validates :no_extra_spaces, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+      end
+    end
+  end
+end

data/lib/ansible/ruby/modules/generated/core/files/lineinfile.rb

@@ -0,0 +1,50 @@
+# See LICENSE.txt at root of repository
+# GENERATED FILE - DO NOT EDIT!!
+require 'ansible/ruby/modules/base'
+
+module Ansible
+  module Ruby
+    module Modules
+      class Lineinfile < Base
+        # @return [String] The file to modify.
+        attribute :dest
+        validates :dest, presence: true, type: String
+
+        # @return [String, nil] The regular expression to look for in every line of the file. For C(state=present), the pattern to replace if found; only the last line found will be replaced. For C(state=absent), the pattern of the line to remove.  Uses Python regular expressions; see U(http://docs.python.org/2/library/re.html).
+        attribute :regexp
+        validates :regexp, type: String
+
+        # @return [:present, :absent, nil] Whether the line should be there or not.
+        attribute :state
+        validates :state, inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
+
+        # @return [String, nil] Required for C(state=present). The line to insert/replace into the file. If C(backrefs) is set, may contain backreferences that will get expanded with the C(regexp) capture groups if the regexp matches.
+        attribute :line
+        validates :line, type: String
+
+        # @return [:yes, :no, nil] Used with C(state=present). If set, line can contain backreferences (both positional and named) that will get populated if the C(regexp) matches. This flag changes the operation of the module slightly; C(insertbefore) and C(insertafter) will be ignored, and if the C(regexp) doesn't match anywhere in the file, the file will be left unchanged. If the C(regexp) does match, the last matching line will be replaced by the expanded line parameter.
+        attribute :backrefs
+        validates :backrefs, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+
+        # @return [:EOF, :"*regex*", nil] Used with C(state=present). If specified, the line will be inserted after the last match of specified regular expression. A special value is available; C(EOF) for inserting the line at the end of the file. If specified regular expression has no matches, EOF will be used instead. May not be used with C(backrefs).
+        attribute :insertafter
+        validates :insertafter, inclusion: {:in=>[:EOF, :"*regex*"], :message=>"%{value} needs to be :EOF, :\"*regex*\""}, allow_nil: true
+
+        # @return [:BOF, :"*regex*", nil] Used with C(state=present). If specified, the line will be inserted before the last match of specified regular expression. A value is available; C(BOF) for inserting the line at the beginning of the file. If specified regular expression has no matches, the line will be inserted at the end of the file.  May not be used with C(backrefs).
+        attribute :insertbefore
+        validates :insertbefore, inclusion: {:in=>[:BOF, :"*regex*"], :message=>"%{value} needs to be :BOF, :\"*regex*\""}, allow_nil: true
+
+        # @return [:yes, :no, nil] Used with C(state=present). If specified, the file will be created if it does not already exist. By default it will fail if the file is missing.
+        attribute :create
+        validates :create, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+
+        # @return [:yes, :no, nil] Create a backup file including the timestamp information so you can get the original file back if you somehow clobbered it incorrectly.
+        attribute :backup
+        validates :backup, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+
+        # @return [Object, nil] All arguments accepted by the M(file) module also work here.
+        attribute :others
+      end
+    end
+  end
+end

data/lib/ansible/ruby/modules/generated/core/files/replace.rb

@@ -0,0 +1,34 @@
+# See LICENSE.txt at root of repository
+# GENERATED FILE - DO NOT EDIT!!
+require 'ansible/ruby/modules/base'
+
+module Ansible
+  module Ruby
+    module Modules
+      class Replace < Base
+        # @return [String] The file to modify.
+        attribute :dest
+        validates :dest, presence: true, type: String
+
+        # @return [String] The regular expression to look for in the contents of the file. Uses Python regular expressions; see U(http://docs.python.org/2/library/re.html). Uses multiline mode, which means C(^) and C($) match the beginning and end respectively of I(each line) of the file.
+        attribute :regexp
+        validates :regexp, presence: true, type: String
+
+        # @return [String, nil] The string to replace regexp matches. May contain backreferences that will get expanded with the regexp capture groups if the regexp matches. If not set, matches are removed entirely.
+        attribute :replace
+        validates :replace, type: String
+
+        # @return [:yes, :no, nil] Create a backup file including the timestamp information so you can get the original file back if you somehow clobbered it incorrectly.
+        attribute :backup
+        validates :backup, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+
+        # @return [Object, nil] All arguments accepted by the M(file) module also work here.
+        attribute :others
+
+        # @return [:yes, :no, nil] This flag indicates that filesystem links, if they exist, should be followed.
+        attribute :follow
+        validates :follow, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+      end
+    end
+  end
+end

data/lib/ansible/ruby/modules/generated/core/files/stat.rb

@@ -0,0 +1,35 @@
+# See LICENSE.txt at root of repository
+# GENERATED FILE - DO NOT EDIT!!
+require 'ansible/ruby/modules/base'
+
+module Ansible
+  module Ruby
+    module Modules
+      class Stat < Base
+        # @return [String] The full path of the file/object to get the facts of
+        attribute :path
+        validates :path, presence: true, type: String
+
+        # @return [Boolean, nil] Whether to follow symlinks
+        attribute :follow
+        validates :follow, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+
+        # @return [Boolean, nil] Whether to return the md5 sum of the file.  Will return None if we're unable to use md5 (Common for FIPS-140 compliant systems)
+        attribute :get_md5
+        validates :get_md5, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+
+        # @return [Boolean, nil] Whether to return a checksum of the file (default sha1)
+        attribute :get_checksum
+        validates :get_checksum, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+
+        # @return [:sha1, :sha224, :sha256, :sha384, :sha512, nil] Algorithm to determine checksum of file. Will throw an error if the host is unable to use specified algorithm.
+        attribute :checksum_algorithm
+        validates :checksum_algorithm, inclusion: {:in=>[:sha1, :sha224, :sha256, :sha384, :sha512], :message=>"%{value} needs to be :sha1, :sha224, :sha256, :sha384, :sha512"}, allow_nil: true
+
+        # @return [Boolean, nil] Use file magic and return data about the nature of the file. this uses the 'file' utility found on most Linux/Unix systems.,This will add both `mime_type` and 'charset' fields to the return, if possible.
+        attribute :mime
+        validates :mime, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+      end
+    end
+  end
+end

data/lib/ansible/ruby/modules/generated/core/files/synchronize.rb

@@ -0,0 +1,105 @@
+# See LICENSE.txt at root of repository
+# GENERATED FILE - DO NOT EDIT!!
+require 'ansible/ruby/modules/base'
+
+module Ansible
+  module Ruby
+    module Modules
+      class Synchronize < Base
+        # @return [Object] Path on the source host that will be synchronized to the destination; The path can be absolute or relative.
+        attribute :src
+        validates :src, presence: true
+
+        # @return [Object] Path on the destination host that will be synchronized from the source; The path can be absolute or relative.
+        attribute :dest
+        validates :dest, presence: true
+
+        # @return [Integer, nil] Port number for ssh on the destination host. Prior to ansible 2.0, the ansible_ssh_port inventory var took precedence over this value.
+        attribute :dest_port
+        validates :dest_port, type: Integer
+
+        # @return [:push, :pull, nil] Specify the direction of the synchronization. In push mode the localhost or delegate is the source; In pull mode the remote host in context is the source.
+        attribute :mode
+        validates :mode, inclusion: {:in=>[:push, :pull], :message=>"%{value} needs to be :push, :pull"}, allow_nil: true
+
+        # @return [:yes, :no, nil] Mirrors the rsync archive flag, enables recursive, links, perms, times, owner, group flags and -D.
+        attribute :archive
+        validates :archive, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+
+        # @return [:yes, :no, nil] Skip based on checksum, rather than mod-time & size; Note that that "archive" option is still enabled by default - the "checksum" option will not disable it.
+        attribute :checksum
+        validates :checksum, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+
+        # @return [:yes, :no, nil] Compress file data during the transfer. In most cases, leave this enabled unless it causes problems.
+        attribute :compress
+        validates :compress, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+
+        # @return [:yes, :no, nil] Skip creating new files on receiver.
+        attribute :existing_only
+        validates :existing_only, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+
+        # @return [:yes, :no, nil] Delete files that don't exist (after transfer, not before) in the C(src) path. This option requires C(recursive=yes).
+        attribute :delete
+        validates :delete, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+
+        # @return [:yes, :no, nil] Transfer directories without recursing
+        attribute :dirs
+        validates :dirs, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+
+        # @return [:yes, :no, nil] Recurse into directories.
+        attribute :recursive
+        validates :recursive, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+
+        # @return [:yes, :no, nil] Copy symlinks as symlinks.
+        attribute :links
+        validates :links, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+
+        # @return [:yes, :no, nil] Copy symlinks as the item that they point to (the referent) is copied, rather than the symlink.
+        attribute :copy_links
+        validates :copy_links, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+
+        # @return [:yes, :no, nil] Preserve permissions.
+        attribute :perms
+        validates :perms, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+
+        # @return [:yes, :no, nil] Preserve modification times
+        attribute :times
+        validates :times, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+
+        # @return [:yes, :no, nil] Preserve owner (super user only)
+        attribute :owner
+        validates :owner, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+
+        # @return [:yes, :no, nil] Preserve group
+        attribute :group
+        validates :group, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+
+        # @return [Object, nil] Specify the rsync command to run on the remote host. See C(--rsync-path) on the rsync man page.
+        attribute :rsync_path
+
+        # @return [Integer, nil] Specify a --timeout for the rsync command in seconds.
+        attribute :rsync_timeout
+        validates :rsync_timeout, type: Integer
+
+        # @return [Boolean, nil] put user@ for the remote paths. If you have a custom ssh config to define the remote user for a host that does not match the inventory user, you should set this parameter to "no".
+        attribute :set_remote_user
+        validates :set_remote_user, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+
+        # @return [:yes, :no, nil] Use the ssh_args specified in ansible.cfg
+        attribute :use_ssh_args
+        validates :use_ssh_args, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+
+        # @return [Object, nil] Specify additional rsync options by passing in an array.
+        attribute :rsync_opts
+
+        # @return [Boolean, nil] Tells rsync to keep the partial file which should make a subsequent transfer of the rest of the file much faster.
+        attribute :partial
+        validates :partial, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+
+        # @return [Boolean, nil] Verify destination host key.
+        attribute :verify_host
+        validates :verify_host, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+      end
+    end
+  end
+end