pax_global_header00006660000000000000000000000064127676541340014531gustar00rootroot0000000000000052 comment=cd99ede1dec84fa664a3b1e0ac21516599db9bdd puppet-python-2.4.1/000077500000000000000000000000001276765413400143715ustar00rootroot00000000000000puppet-python-2.4.1/.editorconfig000066400000000000000000000004661276765413400170540ustar00rootroot00000000000000# editorconfig.org root = true [*] charset = utf-8 end_of_line = lf indent_size = 4 tab_width = 4 indent_style = tab insert_final_newline = true trim_trailing_whitespace = true [*.txt] trim_trailing_whitespace = false [*.{md,json,yml}] trim_trailing_whitespace = false indent_style = space indent_size = 2 puppet-python-2.4.1/.fixtures.yml000066400000000000000000000004001276765413400170350ustar00rootroot00000000000000fixtures: repositories: 'stdlib': repo: 'git://github.com/puppetlabs/puppetlabs-stdlib.git' ref: '4.6.0' 'epel': repo: 'git://github.com/stahnma/puppet-module-epel.git' ref: '1.0.2' symlinks: python: "#{source_dir}" puppet-python-2.4.1/.gitignore000066400000000000000000000004311276765413400163570ustar00rootroot00000000000000# Editors project.xml project.properties /nbproject/private/ .buildpath .project .settings* sftp-config.json .idea # Modules pkg/ Gemfile.lock vendor/ spec/fixtures/ .bundle/ .vagrant/ coverage/ # Beaker .vagrant/ log/ junit/ # OS X metadata .DS_Store # Windows junk Thumbs.db puppet-python-2.4.1/.rspec000066400000000000000000000000371276765413400155060ustar00rootroot00000000000000--format documentation --color puppet-python-2.4.1/.sync.yml000066400000000000000000000000041276765413400161400ustar00rootroot00000000000000--- puppet-python-2.4.1/.travis.yml000066400000000000000000000005471276765413400165100ustar00rootroot00000000000000--- language: ruby sudo: false bundler_args: --without development before_install: - rm Gemfile.lock || true - gem update bundler rvm: - 2.0 - 2.1 - 2.2 script: bundle exec rake test --trace env: - PUPPET_VERSION="~> 4.4.0" STRICT_VARIABLES=yes - PUPPET_VERSION="~> 4.5.0" STRICT_VARIABLES=yes - PUPPET_VERSION="~> 4.6.1" STRICT_VARIABLES=yes puppet-python-2.4.1/CHANGELOG.md000066400000000000000000000041711276765413400162050ustar00rootroot00000000000000## Unreleased - ## 2016-09-04 2.4.1 This release contains data to support OpenBSd 6.0. ## 2016-09-04 2.4.0 This release contains test fixes for FreeBSD and changes to package installation on FreeBSD. ### Features - Fix testing for FreeBSD - Installing virtualenv uses the package now in place of pip on FreeBSD - Pip is no longer a requirement for installing pip on FreeBSD ## 2016-08-29 2.3.1 This release contains a fix for 2.3.0 incorrectly handling resource dependencies. ## 2016-08-29 2.3.0 This release replaces the pip installation on FreeBSD for python3 versions. ### Features - Installation of pip3 on FreeBSD no longer uses an exec resource - Include more Puppet versions in testing ## 2016-07-20 2.2.1 This release contains updates to the hierarchy. #### Features - Drop using os.release.minor from the hierarchy for more portability ## 2016-05-31 2.2.0 This release contains updates to virtualenv and pip handling under python3 on certain platforms. #### Features - Drop support for Debian oldstable #### Fixes - Installation of pip3 on CentOS now uses get-pip.py from the pypa.io - Installation of virtualenv under python3 now requires pip when required - Package names on several platforms are updated for accuracy for virtualenv - Improvements to testing for pip + virtualenv ## 2016-05-29 2.1.0 ### Summary This release contains updates to support OpenBSD 5.9 and some testing improvements. #### Features - OpenBSD 5.9 support - Testing improvements for python3 package name ## 2016-05-22 2.0.2 ### Summary This release contains minor ordering issues provisioning a new FreeBSD host. #### Fixes - Fix ordering on pip and virtualenv installation ## 2016-05-19 2.0.1 ### Summary This release contains minor lint fixes and some class documentation updates. #### Fixes - Lint for quoting errors - Convert more class documentation to puppet strings format ## 2016-05-18 2.0.0 ### Summary This release contains a near rewrite of the module. #### Notable changes - Native puppet4 - drop support for Gunicorn - Add OpenBSD support - Add FreeBSD support - Add CentOS7 Support - Drop support for SCL - Add changelog puppet-python-2.4.1/Gemfile000066400000000000000000000007231276765413400156660ustar00rootroot00000000000000source "https://rubygems.org" group :test do gem "rake" gem "puppet", ENV['PUPPET_VERSION'] || '~> 4.5.0' gem "rspec" gem "rspec-puppet", :git => 'https://github.com/rodjek/rspec-puppet.git' gem 'rspec-core' gem 'rspec-mocks' gem 'rspec-expectations' gem "puppetlabs_spec_helper" gem "metadata-json-lint" gem "rspec-puppet-facts" end group :development do gem "travis" gem "travis-lint" gem "vagrant-wrapper" gem "puppet-blacksmith" end puppet-python-2.4.1/LICENSE000066400000000000000000000261371276765413400154070ustar00rootroot00000000000000 Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright © [2012-2014] [Sergey Stankevich] Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. puppet-python-2.4.1/README.md000066400000000000000000000171011276765413400156500ustar00rootroot00000000000000# Puppet-python [![Puppet Forge](https://img.shields.io/puppetforge/v/zleslie/python.svg)](https://forge.puppet.com/zleslie/python) [![Build Status](https://travis-ci.org/xaque208/puppet-python.svg?branch=master)](https://travis-ci.org/xaque208/puppet-python) Puppet module for installing and managing python, pip, and virtualenv. *This module was forked from [stankevich/puppet-python](https://github.com/stankevich/puppet-python)* ## Installation ```shell puppet module install zleslie-python ``` ## Usage ### python To install python, and optionally the pip, dev and virtualenv packages, use the `python` class. See the class documentation for more detail. ```puppet class { 'python' : version => 'system', pip => true, dev => true, virtualenv => true, } ``` ### python::pip Installs and manages packages from pip. **pkgname** - the name of the package to install. Required. **ensure** - present/latest/absent. You can also specify the version. Default: present **virtualenv** - virtualenv to run pip in. Default: system (no virtualenv) **url** - URL to install from. Default: none **owner** - The owner of the virtualenv to ensure that packages are installed with the correct permissions (must be specified). Default: root **proxy** - Proxy server to use for outbound connections. Default: none **environment** - Additional environment variables required to install the packages. Default: none **egg** - The egg name to use. Default: `$name` of the class, e.g. cx_Oracle **install_args** - Array of additional flags to pass to pip during installaton. Default: none **uninstall_args** - Array of additional flags to pass to pip during uninstall. Default: none **timeout** - Timeout for the pip install command. Defaults to 1800. ```puppet python::pip { 'cx_Oracle' : pkgname => 'cx_Oracle', ensure => '5.1.2', virtualenv => '/var/www/project1', owner => 'appuser', proxy => 'http://proxy.domain.com:3128', environment => 'ORACLE_HOME=/usr/lib/oracle/11.2/client64', install_args => ['-e'], timeout => 1800, } ``` ### python::requirements Installs and manages Python packages from requirements file. **virtualenv** - virtualenv to run pip in. Default: system-wide **proxy** - Proxy server to use for outbound connections. Default: none **owner** - The owner of the virtualenv to ensure that packages are installed with the correct permissions (must be specified). Default: root **src** - The `--src` parameter to `pip`, used to specify where to install `--editable` resources; by default no `--src` parameter is passed to `pip`. **group** - The group that was used to create the virtualenv. This is used to create the requirements file with correct permissions if it's not present already. ```puppet python::requirements { '/var/www/project1/requirements.txt' : virtualenv => '/var/www/project1', proxy => 'http://proxy.domain.com:3128', owner => 'appuser', group => 'apps', } ``` ### python::virtualenv Creates Python virtualenv. **ensure** - present/absent. Default: present **version** - Python version to use. Default: system default **requirements** - Path to pip requirements.txt file. Default: none **proxy** - Proxy server to use for outbound connections. Default: none **systempkgs** - Copy system site-packages into virtualenv. Default: don't **distribute** - Include distribute in the virtualenv. Default: true **venv_dir** - The location of the virtualenv if resource path not specified. Must be absolute path. Default: resource name **owner** - Specify the owner of this virtualenv **group** - Specify the group for this virtualenv **index** - Base URL of Python package index. Default: none **cwd** - The directory from which to run the "pip install" command. Default: undef **timeout** - The maximum time in seconds the "pip install" command should take. Default: 1800 ```puppet python::virtualenv { '/var/www/project1' : ensure => present, version => 'system', requirements => '/var/www/project1/requirements.txt', proxy => 'http://proxy.domain.com:3128', systempkgs => true, distribute => false, venv_dir => '/home/appuser/virtualenvs', owner => 'appuser', group => 'apps', cwd => '/var/www/project1', timeout => 0, } ``` ### python::pyvenv Creates Python3 virtualenv. **ensure** - present/absent. Default: present **version** - Python version to use. Default: system default **systempkgs** - Copy system site-packages into virtualenv. Default: don't **venv_dir** - The location of the virtualenv if resource path not specified. Must be absolute path. Default: resource name **owner** - Specify the owner of this virtualenv **group** - Specify the group for this virtualenv **path** - Specifies the PATH variable that contains `pyvenv` executable. Default: [ '/bin', '/usr/bin', '/usr/sbin' ] **environment** - Specify any environment variables to use when creating pyvenv ```puppet python::pyvenv { '/var/www/project1' : ensure => present, version => 'system', systempkgs => true, venv_dir => '/home/appuser/virtualenvs', owner => 'appuser', group => 'apps', } ``` ### python::dotfile Manages arbitrary python dotiles with a simple config hash. **ensure** - present/absent. Default: present **filename** - Default: $title **mode** - Default: 0644 **owner** - Default: root **group** - Default: root **config** Config hash. This will be expanded to an ini-file. Default: {} ```puppet python::dotfile { '/var/lib/jenkins/.pip/pip.conf': ensure => present, owner => 'jenkins', group => 'jenkins', config => { 'global' => { 'index-url => 'https://mypypi.acme.com/simple/' 'extra-index-url => https://pypi.risedev.at/simple/ } } } ``` ### hiera configuration This module supports configuration through hiera. The following example creates two python3 virtualenvs. The configuration also pip installs a package into each environment. ```yaml python::python_pyvenvs: "/opt/env1": version: "system" "/opt/env2": version: "system" python::python_pips: "nose": virtualenv: "/opt/env1" "coverage": virtualenv: "/opt/env2" ``` ## Release Notes **Version 1.7.10 Notes** Installation of python-pip previously defaulted to `false` and was not installed. This default is now `true` and python-pip is installed. To prevent the installation of python-pip specify `pip => false` as a parameter when instantiating the `python` puppet class. **Version 1.1.x Notes** Version `1.1.x` makes several fundamental changes to the core of this module, adding some additional features, improving performance and making operations more robust in general. Please note that several changes have been made in `v1.1.x` which make manifests incompatible with the previous version. However, modifying your manifests to suit is trivial. Please see the notes below. Currently, the changes you need to make are as follows: * All pip definitions MUST include the owner field which specifies which user owns the virtualenv that packages will be installed in. Adding this greatly improves performance and efficiency of this module. * You must explicitly specify pip => true in the python class if you want pip installed. As such, the pip package is now independent of the dev package and so one can exist without the other. ## Authors [Sergey Stankevich](https://github.com/stankevich) | [Shiva Poudel](https://github.com/shivapoudel) | [Peter Souter](https://github.com/petems) | [Garrett Honeycutt](http://learnpuppet.com) puppet-python-2.4.1/Rakefile000066400000000000000000000022141276765413400160350ustar00rootroot00000000000000require 'puppetlabs_spec_helper/rake_tasks' require 'puppet/version' require 'puppet/vendor/semantic/lib/semantic' unless Puppet.version.to_f < 3.6 require 'puppet-lint/tasks/puppet-lint' require 'puppet-syntax/tasks/puppet-syntax' # These gems aren't always present, for instance # on Travis with --without development begin require 'puppet_blacksmith/rake_tasks' rescue LoadError end Rake::Task[:lint].clear PuppetLint.configuration.relative = true PuppetLint.configuration.send("disable_80chars") PuppetLint.configuration.log_format = "%{path}:%{linenumber}:%{check}:%{KIND}:%{message}" PuppetLint.configuration.fail_on_warnings = true exclude_paths = [ "bundle/**/*", "pkg/**/*", "vendor/**/*", "spec/**/*", ] PuppetLint.configuration.ignore_paths = exclude_paths PuppetSyntax.exclude_paths = exclude_paths desc "Run acceptance tests" RSpec::Core::RakeTask.new(:acceptance) do |t| t.pattern = 'spec/acceptance' end desc "Populate CONTRIBUTORS file" task :contributors do system("git log --format='%aN' | sort -u > CONTRIBUTORS") end desc "Run syntax, lint, and spec tests." task :test => [ :syntax, :lint, :spec, :metadata_lint, ] puppet-python-2.4.1/data/000077500000000000000000000000001276765413400153025ustar00rootroot00000000000000puppet-python-2.4.1/data/common.yaml000066400000000000000000000001351276765413400174550ustar00rootroot00000000000000--- python::version: 'system' python::pip: true python::dev: false python::virtualenv: false puppet-python-2.4.1/data/os/000077500000000000000000000000001276765413400157235ustar00rootroot00000000000000puppet-python-2.4.1/data/os/Debian.yaml000066400000000000000000000001151276765413400177660ustar00rootroot00000000000000--- python::version: '3' python::valid_versions: - '3' - '3.4' - '2.7' puppet-python-2.4.1/data/os/FreeBSD.yaml000066400000000000000000000001561276765413400200230ustar00rootroot00000000000000--- python::version: '3' python::valid_versions: - '2' - '27' - '3' - '32' - '33' - '34' - '35' puppet-python-2.4.1/data/os/OpenBSD/000077500000000000000000000000001276765413400171555ustar00rootroot00000000000000puppet-python-2.4.1/data/os/OpenBSD/OpenBSD/000077500000000000000000000000001276765413400204075ustar00rootroot00000000000000puppet-python-2.4.1/data/os/OpenBSD/OpenBSD/5.8.yaml000066400000000000000000000001161276765413400216030ustar00rootroot00000000000000--- python::version: '3.4.3' python::valid_versions: - '2.7.10' - '3.4.3' puppet-python-2.4.1/data/os/OpenBSD/OpenBSD/5.9.yaml000066400000000000000000000001161276765413400216040ustar00rootroot00000000000000--- python::version: '3.4.4' python::valid_versions: - '2.7.11' - '3.4.4' puppet-python-2.4.1/data/os/OpenBSD/OpenBSD/6.0.yaml000066400000000000000000000001321276765413400215720ustar00rootroot00000000000000--- python::version: '3.5.2' python::valid_versions: - '2.7.12' - '3.4.5' - '3.5.2' puppet-python-2.4.1/data/os/RedHat.yaml000066400000000000000000000001201276765413400177470ustar00rootroot00000000000000--- python::version: '3' python::valid_versions: - '3' python::use_epel: true puppet-python-2.4.1/data/os/RedHat/000077500000000000000000000000001276765413400170725ustar00rootroot00000000000000puppet-python-2.4.1/data/os/RedHat/CentOS/000077500000000000000000000000001276765413400202255ustar00rootroot00000000000000puppet-python-2.4.1/data/os/RedHat/CentOS/7.yaml000066400000000000000000000000551276765413400212570ustar00rootroot00000000000000--- python::valid_versions: - '3' - '34' puppet-python-2.4.1/functions/000077500000000000000000000000001276765413400164015ustar00rootroot00000000000000puppet-python-2.4.1/functions/dev_name.pp000066400000000000000000000005431276765413400205220ustar00rootroot00000000000000# This function contains the python development package name determination # logic. function python::dev_name() { case $facts['osfamily'] { 'RedHat': { $dev_name = "${::python::install::python_name}-devel" } 'Debian': { $dev_name = "${::python::install::python_name}-dev" } default: { $dev_name = undef } } } puppet-python-2.4.1/functions/ensure_pip.pp000066400000000000000000000012411276765413400211110ustar00rootroot00000000000000function python::ensure_pip($ensure) { $pip_name = python::pip_name() case $facts['osfamily'] { 'RedHat': { if $ensure == present { if $python::use_epel == true { include 'epel' #Class['epel'] -> Package[$pip_name] } } if $ensure == present and $::python::version =~ /^3/ { exec { 'install_pip3': command => '/bin/curl https://bootstrap.pypa.io/get-pip.py | /bin/python3', creates => '/bin/pip3', require => Package[$python::install::python_name], } } } } if $pip_name { package { $pip_name: ensure => $::python::install::pip_ensure } } } puppet-python-2.4.1/functions/ensure_virtualenv.pp000066400000000000000000000012571276765413400225270ustar00rootroot00000000000000function python::ensure_virtualenv($ensure) { $virtualenv_name = python::virtualenv_name() if $virtualenv_name { if $facts['osfamily'] == 'RedHat' and $::python::version =~ /^3/ { if $ensure == 'present' { python::require_pip() package { $virtualenv_name: ensure => $ensure, provider => 'pip3', require => Exec['install_pip3'], } } else { package { $virtualenv_name: ensure => $ensure, provider => 'pip3', } } } else { package { $virtualenv_name: ensure => $ensure, require => Package[$python::install::python_name], } } } } puppet-python-2.4.1/functions/pip_name.pp000066400000000000000000000014721276765413400205360ustar00rootroot00000000000000# This function contains the pip package name determination logic. # function python::pip_name() { case $::kernel { 'Linux': { if $::python::version == 'system' { $pip_name = 'python-pip' } elsif $::python::version =~ /^3.*/ { if $facts['osfamily'] == 'RedHat' { # As of 2016-05-31 RedHat osfamilies curl get-pip.py to install python3 $pip_name = undef } else { $pip_name = 'python3-pip' } } else { $pip_name = 'python-pip' } } 'FreeBSD': { if $::python::version == 'system' { $pip_name = "py27-pip" } elsif $::python::version =~ /^[23].*/ { $pip_name = "py${::python::version}-pip" } else { $pip_name = undef } } default: { $pip_name = undef } } } puppet-python-2.4.1/functions/python_name.pp000066400000000000000000000011511276765413400212610ustar00rootroot00000000000000# This function contains the python package name determination logic. # function python::python_name() { case $facts['kernel'] { 'OpenBSD': { # Installing Python on OpenBSD is always done with the package # name 'python'. The ensure value determines the version. $python_name = $::python::version ? { 'pypy' => fail('pypi not supported on OpenBSD'), default => 'python', } } default: { $python_name = $::python::version ? { 'system' => 'python', 'pypy' => 'pypy', default => "python${python::version}", } } } } puppet-python-2.4.1/functions/require_pip.pp000066400000000000000000000007411276765413400212700ustar00rootroot00000000000000# This function handles the logic of checking if pip is enabled on the python # class and failing if it is not. This allows the user to require that pip is # installed in a clean way and allow for consistent messaging. # # @example # python::require_pip() # function python::require_pip() { unless $::python::pip { fail("Installing virtualenv on ${::operatingsystem} ${::operatingsystemmajrelease} with ${::python::version} requires that 'python::pip' be set true") } } puppet-python-2.4.1/functions/virtualenv_name.pp000066400000000000000000000020611276765413400221400ustar00rootroot00000000000000# This function contains the python package name determination logic. # function python::virtualenv_name() { case $facts['kernel'] { 'Linux': { if $facts['operatingisystem'] == 'Debian' { if $::python::version =~ /^3/ { $virtualenv_name = 'python3-virtualenv' } else { $virtualenv_name = 'python-virtualenv' } } elsif $facts['osfamily'] == 'RedHat' { if $::python::version =~ /^3/ { # Use the pip name when on python3 $virtualenv_name = 'virtualenv' } else { $virtualenv_name = 'python-virtualenv' } } else { if $::python::version =~ /^3/ { $virtualenv_name = 'python3-virtualenv' } else { $virtualenv_name = 'python-virtualenv' } } } 'FreeBSD': { if $::python::version == 'system' { $pip_name = "py27-virtualenv" } elsif $::python::version =~ /^[23].*/ { $pip_name = "py${::python::version}-virtualenv" } else { $pip_name = undef } } } } puppet-python-2.4.1/hiera.yaml000066400000000000000000000007751276765413400163560ustar00rootroot00000000000000--- version: 4 datadir: data hierarchy: - name: "family/name/full" path: "os/%{facts.os.family}/%{facts.os.name}/%{facts.os.release.full}" backend: yaml - name: "family/name/major" path: "os/%{facts.os.family}/%{facts.os.name}/%{facts.os.release.major}" backend: yaml - name: "family/name" path: "os/%{facts.os.family}/%{facts.os.name}" backend: yaml - name: "family" path: "os/%{facts.os.family}" backend: yaml - name: "common" backend: yaml path: "common" puppet-python-2.4.1/lib/000077500000000000000000000000001276765413400151375ustar00rootroot00000000000000puppet-python-2.4.1/lib/facter/000077500000000000000000000000001276765413400164035ustar00rootroot00000000000000puppet-python-2.4.1/lib/facter/pip_version.rb000066400000000000000000000003601276765413400212640ustar00rootroot00000000000000# Make pip version available as a fact Facter.add("pip_version") do setcode do if Facter::Util::Resolution.which('pip') Facter::Util::Resolution.exec('pip --version 2>&1').match(/^pip (\d+\.\d+\.?\d*).*$/)[1] end end end puppet-python-2.4.1/lib/facter/python_version.rb000066400000000000000000000012721276765413400220200ustar00rootroot00000000000000# Make python versions available as facts def get_python_version(executable) if Facter::Util::Resolution.which(executable) results = Facter::Util::Resolution.exec("#{executable} -V 2>&1").match(/^.*(\d+\.\d+\.\d+)$/) if results results[1] end end end Facter.add("python_version") do setcode do get_python_version 'python' end end Facter.add("python2_version") do setcode do default_version = get_python_version 'python' if default_version.nil? or !default_version.start_with?('2') get_python_version 'python2' else default_version end end end Facter.add("python3_version") do setcode do get_python_version 'python3' end end puppet-python-2.4.1/lib/facter/virtualenv_version.rb000066400000000000000000000004101276765413400226670ustar00rootroot00000000000000# Make virtualenv version available as a fact Facter.add("virtualenv_version") do setcode do if Facter::Util::Resolution.which('virtualenv') Facter::Util::Resolution.exec('virtualenv --version 2>&1').match(/^(\d+\.\d+\.?\d*).*$/)[0] end end end puppet-python-2.4.1/manifests/000077500000000000000000000000001276765413400163625ustar00rootroot00000000000000puppet-python-2.4.1/manifests/config.pp000066400000000000000000000005751276765413400201770ustar00rootroot00000000000000# == Define: python::config # # # === Examples # # include python::config # # === Authors # # Sergey Stankevich # Ashley Penney # Fotis Gimian # class python::config { Class['python::install'] -> Python::Pip <| |> Class['python::install'] -> Python::Requirements <| |> Class['python::install'] -> Python::Virtualenv <| |> Python::Virtualenv <| |> -> Python::Pip <| |> } puppet-python-2.4.1/manifests/dotfile.pp000066400000000000000000000024671276765413400203620ustar00rootroot00000000000000# == Define: python::dotfile # # Manages any python dotfiles with a simple config hash. # # === Parameters # # [*ensure*] # present|absent. Default: present # # [*filename*] # Filename. Default: $title # # [*mode*] # File mode. Default: 0644 # # [*owner*] # [*group*] # Owner/group. Default: `root`/`root` # # [*config*] # Config hash. This will be expanded to an ini-file. Default: {} # # === Examples # # python::dotfile { '/var/lib/jenkins/.pip/pip.conf': # ensure => present, # owner => 'jenkins', # group => 'jenkins', # config => { # 'global' => { # 'index-url => 'https://mypypi.acme.com/simple/' # 'extra-index-url => https://pypi.risedev.at/simple/ # } # } # } # # define python::dotfile ( $ensure = 'present', $filename = $title, $owner = 'root', $group = '0', $mode = '0644', $config = {}, ) { $parent_dir = dirname($filename) exec { "create ${title}'s parent dir": command => "install -o ${owner} -g ${group} -d ${parent_dir}", path => [ '/usr/bin', '/bin', '/usr/local/bin', ], creates => $parent_dir, } file { $filename: ensure => $ensure, owner => $owner, group => $group, mode => $mode, content => template("${module_name}/inifile.erb"), require => Exec["create ${title}'s parent dir"], } } puppet-python-2.4.1/manifests/init.pp000066400000000000000000000026761276765413400177010ustar00rootroot00000000000000# This class installs and manages python, python-dev, and python-virtualenv. # # @param version Python version to install. Beware that valid values for this # differ by the osfamily/operatingsystem you are using. # Default: system default # Allowed values: # - provider == pip: everything pip allows as a version after the 'python==' # - else: 'system', 'pypy', 3/3.3/... # - Be aware that 'system' means default, usually python 2.X. # - 3/3.3/... means you are going to install the python3/python3.3/... # package, if available on your osfamily. # # @param pip Boolean to install python-pip. Default: true # @param dev Boolean to install python-dev. Default: false # @param virtualenv Boolean to Install python-virtualenv. Default: false # @param use_epel Boolean to determine if the epel class is used. Default: true # @param valid_versions Array of strings for platform versions available # # @example # class { 'python': # version => 'system', # pip => true, # dev => true, # virtualenv => true, # } # class python ( Boolean $pip, Boolean $dev, Boolean $virtualenv, String $version, Array $valid_versions = [], Boolean $use_epel = false, ) { unless $version == 'system' or $version in $valid_versions { fail("Python version ${version} not supported on ${facts['os']['name']}: ${valid_versions} ${facts['os']}") } contain python::install contain python::config } puppet-python-2.4.1/manifests/install.pp000066400000000000000000000017021276765413400203710ustar00rootroot00000000000000# This class installs core python packages. This should only be used by # including the 'python' class. # # @example # include python::install # class python::install { $python_name = python::python_name() $python_dev = python::dev_name() $dev_ensure = $python::dev ? { true => present, default => absent, } $pip_ensure = $python::pip ? { true => present, default => absent, } $virtualenv_ensure = $python::virtualenv ? { true => present, default => absent, } if $python_dev { package { $python_dev: ensure => $dev_ensure } } if $python::use_epel == true { include 'epel' Class['epel'] -> Package[$python_name] } python::ensure_pip($pip_ensure) python::ensure_virtualenv($virtualenv_ensure) case $facts['kernel'] { 'OpenBSD': { package { $python_name: ensure => $::python::version } } default: { package { $python_name: ensure => present } } } } puppet-python-2.4.1/manifests/pip.pp000066400000000000000000000210441276765413400175140ustar00rootroot00000000000000# This class handles the installation and management of pip packages. # # @param ensure # @param virtualenv # @param url URL to install from. Default: none # @param owner The owner of the virtualenv being manipulated. Default: root # @param proxy Proxy server to use for outbound connections. Default: none # @param editable Boolean. If true the package is installed as an editable resource. # @param environment Additional environment variables required to install the packages. Default: none # @param timeout The maximum time in seconds the "pip install" command should take. Default: 1800 # @param install_args String. Any additional installation arguments that will be supplied when running pip install. # @param uninstall_args String. Any additional arguments that will be supplied when running pip uninstall. # @param log_dir String. Log directory. # # @example # python::pip { 'flask': # virtualenv => '/var/www/project1', # proxy => 'http://proxy.domain.com:3128', # } # define python::pip ( $pkgname = $name, $ensure = present, $virtualenv = 'system', $url = false, $owner = 'root', $proxy = false, $egg = false, $editable = false, $environment = [], $timeout = 1800, $install_args = '', $uninstall_args = '', $log_dir = '/tmp', ) { # Parameter validation if ! $virtualenv { fail('python::pip: virtualenv parameter must not be empty') } if $virtualenv == 'system' and $owner != 'root' { fail('python::pip: root user must be used when virtualenv is system') } $cwd = $virtualenv ? { 'system' => '/', default => $virtualenv, } validate_absolute_path($cwd) $log = $virtualenv ? { 'system' => $log_dir, default => $virtualenv, } $pip_env = $virtualenv ? { 'system' => 'pip', default => "${virtualenv}/bin/pip", } $proxy_flag = $proxy ? { false => '', default => "--proxy=${proxy}", } if $editable == true { $install_editable = ' -e ' } else { $install_editable = '' } #TODO: Do more robust argument checking, but below is a start if ($ensure == absent) and ($install_args != '') { fail('python::pip cannot provide install_args with ensure => absent') } if ($ensure == present) and ($uninstall_args != '') { fail('python::pip cannot provide uninstall_args with ensure => present') } # Check if searching by explicit version. if $ensure =~ /^((19|20)[0-9][0-9]-(0[1-9]|1[1-2])-([0-2][1-9]|3[0-1])|[0-9]+\.[0-9]+(\.[0-9]+)?)$/ { $grep_regex = "^${pkgname}==${ensure}\$" } else { $grep_regex = $pkgname ? { /==/ => "^${pkgname}\$", default => "^${pkgname}==", } } $egg_name = $egg ? { false => $pkgname, default => $egg } $source = $url ? { false => $pkgname, /^(\/|[a-zA-Z]\:)/ => $url, /^(git\+|hg\+|bzr\+|svn\+)(http|https|ssh|svn|sftp|ftp|lp)(:\/\/).+$/ => $url, default => "${url}#egg=${egg_name}", } # We need to jump through hoops to make sure we issue the correct pip command # depending on wheel support and versions. # # Pip does not support wheels prior to version 1.4.0 # Pip wheels require setuptools/distribute > 0.8 # Python 2.6 and older does not support setuptools/distribute > 0.8 # Pip >= 1.5 tries to use wheels by default, even if wheel package is not # installed, in this case the --no-use-wheel flag needs to be passed # Versions prior to 1.5 don't support the --no-use-wheel flag # # To check for this we test for wheel parameter using help and then using # version, this makes sure we only use wheels if they are supported and # installed # Explicit version out of VCS when PIP supported URL is provided if $source =~ /^(git\+|hg\+|bzr\+|svn\+)(http|https|ssh|svn|sftp|ftp|lp)(:\/\/).+$/ { if $ensure != present and $ensure != latest { exec { "pip_install_${name}": command => "${pip_env} wheel --help > /dev/null 2>&1 && { ${pip_env} wheel --version > /dev/null 2>&1 || wheel_support_flag='--no-use-wheel'; } ; { ${pip_env} --log ${log}/pip.log install ${install_args} \$wheel_support_flag ${proxy_flag} ${install_args} ${install_editable} ${source}@${ensure}#egg=${egg_name} || ${pip_env} --log ${log}/pip.log install ${install_args} ${proxy_flag} ${install_args} ${install_editable} ${source}@${ensure}#egg=${egg_name} ;}", unless => "${pip_env} freeze | grep -i -e ${grep_regex}", user => $owner, cwd => $cwd, environment => $environment, path => ['/usr/local/bin','/usr/bin','/bin', '/usr/sbin'], timeout => $timeout, } } else { exec { "pip_install_${name}": command => "${pip_env} wheel --help > /dev/null 2>&1 && { ${pip_env} wheel --version > /dev/null 2>&1 || wheel_support_flag='--no-use-wheel'; } ; { ${pip_env} --log ${log}/pip.log install ${install_args} \$wheel_support_flag ${proxy_flag} ${install_args} ${install_editable} ${source} || ${pip_env} --log ${log}/pip.log install ${install_args} ${proxy_flag} ${install_args} ${install_editable} ${source} ;}", unless => "${pip_env} freeze | grep -i -e ${grep_regex}", user => $owner, cwd => $cwd, environment => $environment, path => ['/usr/local/bin','/usr/bin','/bin', '/usr/sbin'], timeout => $timeout, } } } else { case $ensure { /^((19|20)[0-9][0-9]-(0[1-9]|1[1-2])-([0-2][1-9]|3[0-1])|[0-9]+\.[0-9]+(\.[0-9]+)?)$/: { # Version formats as per http://guide.python-distribute.org/specification.html#standard-versioning-schemes # Explicit version. exec { "pip_install_${name}": command => "${pip_env} wheel --help > /dev/null 2>&1 && { ${pip_env} wheel --version > /dev/null 2>&1 || wheel_support_flag='--no-use-wheel'; } ; { ${pip_env} --log ${log}/pip.log install ${install_args} \$wheel_support_flag ${proxy_flag} ${install_args} ${install_editable} ${source}==${ensure} || ${pip_env} --log ${log}/pip.log install ${install_args} ${proxy_flag} ${install_args} ${install_editable} ${source}==${ensure} ;}", unless => "${pip_env} freeze | grep -i -e ${grep_regex}", user => $owner, cwd => $cwd, environment => $environment, path => ['/usr/local/bin','/usr/bin','/bin', '/usr/sbin'], timeout => $timeout, } } present: { # Whatever version is available. exec { "pip_install_${name}": command => "${pip_env} wheel --help > /dev/null 2>&1 && { ${pip_env} wheel --version > /dev/null 2>&1 || wheel_support_flag='--no-use-wheel'; } ; { ${pip_env} --log ${log}/pip.log install \$wheel_support_flag ${proxy_flag} ${install_args} ${install_editable} ${source} || ${pip_env} --log ${log}/pip.log install ${proxy_flag} ${install_args} ${install_editable} ${source} ;}", unless => "${pip_env} freeze | grep -i -e ${grep_regex}", user => $owner, cwd => $cwd, environment => $environment, path => ['/usr/local/bin','/usr/bin','/bin', '/usr/sbin'], timeout => $timeout, } } latest: { # Latest version. exec { "pip_install_${name}": command => "${pip_env} wheel --help > /dev/null 2>&1 && { ${pip_env} wheel --version > /dev/null 2>&1 || wheel_support_flag='--no-use-wheel'; } ; { ${pip_env} --log ${log}/pip.log install --upgrade \$wheel_support_flag ${proxy_flag} ${install_args} ${install_editable} ${source} || ${pip_env} --log ${log}/pip.log install --upgrade ${proxy_flag} ${install_args} ${install_editable} ${source} ;}", unless => "${pip_env} search ${proxy_flag} ${source} | grep -i INSTALLED | grep -i latest", user => $owner, cwd => $cwd, environment => $environment, path => ['/usr/local/bin','/usr/bin','/bin', '/usr/sbin'], timeout => $timeout, } } default: { # Anti-action, uninstall. exec { "pip_uninstall_${name}": command => "echo y | ${pip_env} uninstall ${uninstall_args} ${proxy_flag}", onlyif => "${pip_env} freeze | grep -i -e ${grep_regex}", user => $owner, cwd => $cwd, environment => $environment, path => ['/usr/local/bin','/usr/bin','/bin', '/usr/sbin'], timeout => $timeout, } } } } } puppet-python-2.4.1/manifests/pyvenv.pp000066400000000000000000000044441276765413400202600ustar00rootroot00000000000000# This class create a Python3 virtualenv using pyvenv. # # # @param ensure present|absent. Default: present # # @param version Python version to use. Default: system default # # @param systempkgsCopy system site-packages into virtualenv. Default: don't # # @param venv_dir Directory to install virtualenv to. Default: $name # # @param owner The owner of the virtualenv being manipulated. Default: root # # @param group The group relating to the virtualenv being manipulated. Default: root # # @param mode Optionally specify directory mode. Default: 0755 # # @param path Specifies the PATH variable. Default: [ '/bin', '/usr/bin', '/usr/sbin' ] # @param environment Optionally specify environment variables for pyvenv # # @example # python::venv { '/var/www/project1': # ensure => present, # version => 'system', # systempkgs => true, # } # define python::pyvenv ( $ensure = present, $version = 'system', $systempkgs = false, $venv_dir = $name, $owner = 'root', $group = '0', $mode = '0755', $path = [ '/bin', '/usr/bin', '/usr/sbin', '/usr/local/bin' ], $environment = [], ) { if $ensure == 'present' { $virtualenv_cmd = $version ? { 'system' => 'pyvenv', default => "pyvenv-${version}", } if ( $systempkgs == true ) { $system_pkgs_flag = '--system-site-packages' } else { $system_pkgs_flag = '' } file { $venv_dir: ensure => directory, owner => $owner, group => $group, mode => $mode } exec { "python_virtualenv_${venv_dir}": command => "${virtualenv_cmd} --clear ${system_pkgs_flag} ${venv_dir}", user => $owner, creates => "${venv_dir}/bin/activate", path => $path, cwd => '/tmp', environment => $environment, unless => "grep '^[\\t ]*VIRTUAL_ENV=[\\\\'\\\"]*${venv_dir}[\\\"\\\\'][\\t ]*$' ${venv_dir}/bin/activate", #Unless activate exists and VIRTUAL_ENV is correct we re-create the virtualenv require => File[$venv_dir], } } elsif $ensure == 'absent' { file { $venv_dir: ensure => absent, force => true, recurse => true, purge => true, } } else { fail( "Illegal ensure value: ${ensure}. Expected (present or absent)") } } puppet-python-2.4.1/manifests/requirements.pp000066400000000000000000000067541276765413400214620ustar00rootroot00000000000000# This class installs and manages Python packages from requirements file. # # @param requirements Path to the requirements file. Defaults to the resource # name # # @param virtualenv virtualenv to run pip in. Default: system-wide # # @param owner The owner of the virtualenv being manipulated. Default: root # # @param group The group relating to the virtualenv being manipulated. Default: # root # # @param proxy Proxy server to use for outbound connections. Default: none # # @param src Pip --src parameter; if the requirements file contains --editable # resources, this parameter specifies where they will be installed. See the pip # documentation for more. Default: none (i.e. use the pip default). # # @param environment Additional environment variables required to install the # packages. Default: none # # @param forceupdate Run a pip install requirements even if we don't receive an # event from the requirements file - Useful for when the requirements file is # written as part of a resource other than file (E.g vcsrepo) # # @param cwd The directory from which to run the "pip install" command. # Default: undef # # @param extra_pip_args Extra arguments to pass to pip after the requirements # file # # @param fix_requirements_owner Change owner and group of requirements file. # Default: true # # @param log_dir String. Log directory. # # @param timeout The maximum time in seconds the "pip install" command should # take. Default: 1800 # # @example # python::requirements { '/var/www/project1/requirements.txt': # virtualenv => '/var/www/project1', # proxy => 'http://proxy.domain.com:3128', # } # define python::requirements ( $requirements = $name, $virtualenv = 'system', $owner = 'root', $group = '0', $proxy = false, $src = false, $environment = [], $forceupdate = false, $cwd = undef, $extra_pip_args = '', $fix_requirements_owner = true, $log_dir = '/tmp', $timeout = 1800, ) { if $virtualenv == 'system' and ($owner != 'root' or $group != '0') { fail('python::pip: root user must be used when virtualenv is system') } if $fix_requirements_owner { $owner_real = $owner $group_real = $group } else { $owner_real = undef $group_real = undef } $log = $virtualenv ? { 'system' => $log_dir, default => $virtualenv, } $pip_env = $virtualenv ? { 'system' => 'pip', default => "${virtualenv}/bin/pip", } $proxy_flag = $proxy ? { false => '', default => "--proxy=${proxy}", } $src_flag = $src ? { false => '', default => "--src=${src}", } # This will ensure multiple python::virtualenv definitions can share the # the same requirements file. if !defined(File[$requirements]) { file { $requirements: ensure => present, mode => '0644', owner => $owner_real, group => $group_real, audit => content, replace => false, content => '# Puppet will install and/or update pip packages listed here', } } exec { "python_requirements${name}": provider => shell, command => "${pip_env} --log ${log}/pip.log install ${proxy_flag} ${src_flag} -r ${requirements} ${extra_pip_args}", refreshonly => !$forceupdate, timeout => $timeout, cwd => $cwd, user => $owner, subscribe => File[$requirements], environment => $environment, } } puppet-python-2.4.1/manifests/virtualenv.pp000066400000000000000000000156131276765413400211300ustar00rootroot00000000000000# This class handles creating Python virtualenvs # # @param ensure # present|absent. Default: present # # @param version # Python version to use. Default: system default # # @param requirements # Path to pip requirements.txt file. Default: none # # @param systempkgs # Copy system site-packages into virtualenv. Default: don't # If virtualenv version < 1.7 this flag has no effect since # # @param venv_dir # Directory to install virtualenv to. Default: $name # # @param distribute # Include distribute in the virtualenv. Default: true # # @param index # Base URL of Python package index. Default: none (http://pypi.python.org/simple/) # # @param owner # The owner of the virtualenv being manipulated. Default: root # # @param group # The group relating to the virtualenv being manipulated. Default: root # # @param mode # Optionally specify directory mode. Default: 0755 # # @param [*proxy*] # Proxy server to use for outbound connections. Default: none # # @param [*environment*] # Additional environment variables required to install the packages. Default: none # # @param [*path*] # Specifies the PATH variable. Default: [ '/bin', '/usr/bin', '/usr/sbin' ] # # @param [*cwd*] # The directory from which to run the "pip install" command. Default: undef # # @param [*timeout*] # The maximum time in seconds the "pip install" command should take. Default: 1800 # # @param [*extra_pip_args*] # Extra arguments to pass to pip after requirements file. Default: blank # # @example # python::virtualenv { '/var/www/project1': # ensure => present, # version => 'system', # requirements => '/var/www/project1/requirements.txt', # proxy => 'http://proxy.domain.com:3128', # systempkgs => true, # index => 'http://www.example.com/simple/' # } # define python::virtualenv ( String $ensure = present, String $version = 'system', Boolean $requirements = false, Boolean $systempkgs = false, String $venv_dir = $name, Boolean $distribute = true, Boolean $index = false, String $owner = 'root', String $group = '0', String $mode = '0755', Boolean $proxy = false, Array $environment = [], Array $path = [ '/bin', '/usr/bin', '/usr/sbin', '/usr/local/bin' ], $cwd = undef, Integer $timeout = 1800, String $extra_pip_args = '', $virtualenv = undef ) { include ::python unless $::python::virtualenv == true { fail('to use a virtualenv, you must set $python::virtualenv to true') } if $ensure == 'present' { $python = $version ? { 'system' => 'python', 'pypy' => 'pypy', default => "python${version}", } if $virtualenv == undef { if $facts['osfamily'] == 'RedHat' { $used_virtualenv = 'virtualenv' } else { $used_virtualenv = $version ? { 'system' => 'virtualenv', default => "virtualenv-${version}", } } } else { $used_virtualenv = $virtualenv } $proxy_flag = $proxy ? { false => '', default => "--proxy=${proxy}", } $proxy_command = $proxy ? { false => '', default => "&& export http_proxy=${proxy}", } # Virtualenv versions prior to 1.7 do not support the # --system-site-packages flag, default off for prior versions # Prior to version 1.7 the default was equal to --system-site-packages # and the flag --no-site-packages had to be passed to do the opposite if $::virtualenv_version { if (( versioncmp($::virtualenv_version,'1.7') > 0 ) and ( $systempkgs == true )) { $system_pkgs_flag = '--system-site-packages' } elsif (( versioncmp($::virtualenv_version,'1.7') < 0 ) and ( $systempkgs == false )) { $system_pkgs_flag = '--no-site-packages' } else { $system_pkgs_flag = $systempkgs ? { true => '--system-site-packages', false => '--no-site-packages', default => fail('Invalid value for systempkgs. Boolean value is expected') } } } $distribute_pkg = $distribute ? { true => 'distribute', default => 'setuptools', } $pypi_index = $index ? { false => '', default => "-i ${index}", } # Python 2.6 and older does not support setuptools/distribute > 0.8 which # is required for pip wheel support, pip therefor requires --no-use-wheel flag # if the # pip version is more recent than 1.4.1 but using an old python or # setuputils/distribute version # To check for this we test for wheel parameter using help and then using # version, this makes sure we only use wheels if they are supported file { $venv_dir: ensure => directory, owner => $owner, group => $group, mode => $mode } $pip_cmd = "${venv_dir}/bin/pip" exec { "python_virtualenv_${venv_dir}": command => "true ${proxy_command} && ${used_virtualenv} ${system_pkgs_flag} -p ${python} ${venv_dir} && ${pip_cmd} wheel --help > /dev/null 2>&1 && { ${pip_cmd} wheel --version > /dev/null 2>&1 || wheel_support_flag='--no-use-wheel'; } ; { ${pip_cmd} --log ${venv_dir}/pip.log install ${pypi_index} ${proxy_flag} \$wheel_support_flag --upgrade pip ${distribute_pkg} || ${pip_cmd} --log ${venv_dir}/pip.log install ${pypi_index} ${proxy_flag} --upgrade pip ${distribute_pkg} ;}", user => $owner, creates => "${venv_dir}/bin/activate", path => $path, cwd => '/tmp', environment => $environment, unless => "grep '^[\\t ]*VIRTUAL_ENV=[\\\\'\\\"]*${venv_dir}[\\\"\\\\'][\\t ]*$' ${venv_dir}/bin/activate", #Unless activate exists and VIRTUAL_ENV is correct we re-create the virtualenv require => File[$venv_dir], } if $requirements { exec { "python_requirements_initial_install_${requirements}_${venv_dir}": command => "${pip_cmd} wheel --help > /dev/null 2>&1 && { ${pip_cmd} wheel --version > /dev/null 2>&1 || wheel_support_flag='--no-use-wheel'; } ; ${pip_cmd} --log ${venv_dir}/pip.log install ${pypi_index} ${proxy_flag} \$wheel_support_flag -r ${requirements} ${extra_pip_args}", refreshonly => true, timeout => $timeout, user => $owner, subscribe => Exec["python_virtualenv_${venv_dir}"], environment => $environment, cwd => $cwd } python::requirements { "${requirements}_${venv_dir}": requirements => $requirements, virtualenv => $venv_dir, proxy => $proxy, owner => $owner, group => $group, cwd => $cwd, require => Exec["python_virtualenv_${venv_dir}"], extra_pip_args => $extra_pip_args, } } } elsif $ensure == 'absent' { file { $venv_dir: ensure => absent, force => true, recurse => true, purge => true, } } } puppet-python-2.4.1/metadata.json000066400000000000000000000026151276765413400170500ustar00rootroot00000000000000{ "name": "zleslie-python", "version": "2.4.1", "author": "zleslie", "summary": "Python Module", "license": "Apache-2.0", "source": "git://github.com/zleslie/puppet-python.git", "project_page": "https://github.com/xaque208/puppet-python", "issues_url": "https://github.com/xaque208/puppet-python/issues", "description": "Puppet module for Python", "tags": [ "python", "pip", "virtualenv" ], "operatingsystem_support": [ { "operatingsystem": "CentOS", "operatingsystemrelease": [ "7" ] }, { "operatingsystem": "Debian", "operatingsystemrelease": [ "8" ] }, { "operatingsystem": "Ubuntu", "operatingsystemrelease": [ "16.04", "15.04" ] }, { "operatingsystem": "SLES", "operatingsystemrelease": [ "11.3" ] }, { "operatingsystem": "FreeBSD", "operatingsystemrelease": [ "10" ] }, { "operatingsystem": "OpenBSD", "operatingsystemrelease": [ "6.0", "5.9", "5.8" ] } ], "requirements": [ { "name": "puppet", "version_requirement": ">=4.4.0 < 5.0.0" } ], "dependencies": [ {"name":"puppetlabs/stdlib","version_requirement":">= 4.6.0 < 6.0.0"}, {"name":"stahnma/epel","version_requirement":">= 1.0.1 < 2.0.0"} ], "data_provider": "hiera" } puppet-python-2.4.1/spec/000077500000000000000000000000001276765413400153235ustar00rootroot00000000000000puppet-python-2.4.1/spec/acceptance/000077500000000000000000000000001276765413400174115ustar00rootroot00000000000000puppet-python-2.4.1/spec/acceptance/class_spec.rb000066400000000000000000000006071276765413400220600ustar00rootroot00000000000000require 'spec_helper_acceptance' describe 'python class' do context 'default parameters' do # Using puppet_apply as a helper it 'should work with no errors' do pp = <<-EOS class { 'python': } EOS # Run it twice and test for idempotency apply_manifest(pp, :catch_failures => true) apply_manifest(pp, :catch_changes => true) end end end puppet-python-2.4.1/spec/acceptance/facts_test_spec.rb000066400000000000000000000025351276765413400231140ustar00rootroot00000000000000require 'spec_helper_acceptance' describe 'python class' do context 'facts' do install_python = <<-EOS class { 'python' : version => 'system', pip => true, virtualenv => true, } EOS fact_notices = <<-EOS notify{"pip_version: ${::pip_version}":} notify{"system_python_version: ${::system_python_version}":} notify{"python_version: ${::python_version}":} notify{"virtualenv_version: ${::virtualenv_version}":} EOS it 'should output python facts when not installed' do apply_manifest(fact_notices, :catch_failures => true) do |r| expect(r.stdout).to match(/python_version: \S+/) expect(r.stdout).to match(/pip_version: \S+/) expect(r.stdout).to match(/virtualenv_version: \S+/) expect(r.stdout).to match(/system_python_version: \S+/) end end it 'sets up python' do apply_manifest(install_python, :catch_failures => true) end it 'should output python facts when installed' do apply_manifest(fact_notices, :catch_failures => true) do |r| expect(r.stdout).to match(/python_version: \S+/) expect(r.stdout).to match(/pip_version: \S+/) expect(r.stdout).to match(/virtualenv_version: \S+/) expect(r.stdout).to match(/system_python_version: \S+/) end end end end puppet-python-2.4.1/spec/acceptance/nodesets/000077500000000000000000000000001276765413400212355ustar00rootroot00000000000000puppet-python-2.4.1/spec/acceptance/nodesets/centos-59-x64.yml000066400000000000000000000003701276765413400241250ustar00rootroot00000000000000HOSTS: centos-59-x64: roles: - master platform: el-5-x86_64 box : centos-59-x64-vbox4210-nocm box_url : http://puppet-vagrant-boxes.puppetlabs.com/centos-59-x64-vbox4210-nocm.box hypervisor : vagrant CONFIG: type: git puppet-python-2.4.1/spec/acceptance/nodesets/centos-64-x64-pe.yml000066400000000000000000000004321276765413400245220ustar00rootroot00000000000000HOSTS: centos-64-x64: roles: - master - database - dashboard platform: el-6-x86_64 box : centos-64-x64-vbox4210-nocm box_url : http://puppet-vagrant-boxes.puppetlabs.com/centos-64-x64-vbox4210-nocm.box hypervisor : vagrant CONFIG: type: pe puppet-python-2.4.1/spec/acceptance/nodesets/centos-65-x64.yml000066400000000000000000000003721276765413400241240ustar00rootroot00000000000000HOSTS: centos-65-x64: roles: - master platform: el-6-x86_64 box : centos-65-x64-vbox436-nocm box_url : http://puppet-vagrant-boxes.puppetlabs.com/centos-65-x64-virtualbox-nocm.box hypervisor : vagrant CONFIG: type: foss puppet-python-2.4.1/spec/acceptance/nodesets/debian-70rc1-x64.yml000066400000000000000000000004071276765413400244540ustar00rootroot00000000000000HOSTS: debian-70rc1-x64: roles: - master platform: debian-70rc1-x64 box : debian-70rc1-x64-vbox4210-nocm box_url : http://puppet-vagrant-boxes.puppetlabs.com/debian-70rc1-x64-vbox4210-nocm.box hypervisor : vagrant CONFIG: type: foss puppet-python-2.4.1/spec/acceptance/nodesets/debian-73-x64.yml000066400000000000000000000004211276765413400240450ustar00rootroot00000000000000HOSTS: debian-73-x64: roles: - master platform: debian-7-amd64 box : debian-73-x64-virtualbox-nocm box_url : http://puppet-vagrant-boxes.puppetlabs.com/debian-73-x64-virtualbox-nocm.box hypervisor : vagrant CONFIG: log_level: debug type: gitpuppet-python-2.4.1/spec/acceptance/nodesets/default.yml000066400000000000000000000005051276765413400234040ustar00rootroot00000000000000HOSTS: ubuntu-server-12042-x64: roles: - master platform: ubuntu-server-12.04-amd64 box : ubuntu-server-12042-x64-vbox4210-nocm box_url : http://puppet-vagrant-boxes.puppetlabs.com/ubuntu-server-12042-x64-vbox4210-nocm.box hypervisor : vagrant CONFIG: type: foss vagrant_ssh_port_random: true puppet-python-2.4.1/spec/acceptance/nodesets/ubuntu-server-10044-x64.yml000066400000000000000000000004361276765413400256760ustar00rootroot00000000000000HOSTS: ubuntu-server-10044-x64: roles: - master platform: ubuntu-10.04-amd64 box : ubuntu-server-10044-x64-vbox4210-nocm box_url : http://puppet-vagrant-boxes.puppetlabs.com/ubuntu-server-10044-x64-vbox4210-nocm.box hypervisor : vagrant CONFIG: type: foss puppet-python-2.4.1/spec/acceptance/nodesets/ubuntu-server-12042-x64.yml000066400000000000000000000004361276765413400256760ustar00rootroot00000000000000HOSTS: ubuntu-server-12042-x64: roles: - master platform: ubuntu-12.04-amd64 box : ubuntu-server-12042-x64-vbox4210-nocm box_url : http://puppet-vagrant-boxes.puppetlabs.com/ubuntu-server-12042-x64-vbox4210-nocm.box hypervisor : vagrant CONFIG: type: foss puppet-python-2.4.1/spec/acceptance/nodesets/ubuntu-server-1404-x64.yml000066400000000000000000000004201276765413400256070ustar00rootroot00000000000000HOSTS: ubuntu-server-1404-x64: roles: - master platform: ubuntu-14.04-amd64 box : puppetlabs/ubuntu-14.04-64-nocm box_url : https://vagrantcloud.com/puppetlabs/ubuntu-14.04-64-nocm hypervisor : vagrant CONFIG: log_level : debug type: git puppet-python-2.4.1/spec/acceptance/virtualenv_spec.rb000066400000000000000000000014221276765413400231460ustar00rootroot00000000000000require 'spec_helper_acceptance' describe 'python class' do context 'default parameters' do # Using puppet_apply as a helper it 'should work with no errors' do pp = <<-EOS class { 'python' : version => 'system', pip => true, virtualenv => true, } -> python::virtualenv { 'venv' : ensure => present, systempkgs => false, venv_dir => '/opt/venv', owner => 'root', group => 'root', } -> python::pip { 'rpyc' : ensure => '3.2.3', virtualenv => '/opt/venv', } EOS # Run it twice and test for idempotency apply_manifest(pp, :catch_failures => true) apply_manifest(pp, :catch_changes => true) end end end puppet-python-2.4.1/spec/classes/000077500000000000000000000000001276765413400167605ustar00rootroot00000000000000puppet-python-2.4.1/spec/classes/python_spec.rb000066400000000000000000000135711276765413400216470ustar00rootroot00000000000000require 'spec_helper' describe 'python' do on_supported_os.each do |os, facts| context "on #{os}" do let(:facts) { facts } context "with system version" do let(:params) {{ :pip => false, :dev => false, :virtualenv => false, :version => 'system' }} it { is_expected.to compile.with_all_deps } it { is_expected.to contain_class("python::install") } context 'with dev' do let(:params) {{ :version => 'system', :dev => true, :pip => false, :virtualenv => false, }} case facts[:osfamily] when 'RedHat' it { is_expected.to contain_package('python-devel') } when 'Debian' it { is_expected.to contain_package('python-dev') } else end end context 'with pip' do let(:params) {{ :version => 'system', :pip => true, :dev => false, :virtualenv => false, }} case facts[:kernel] when 'Linux' it { is_expected.to contain_package('python-pip') } when 'FreeBSD' it { is_expected.to contain_package('py27-pip') } else it { is_expected.to_not contain_package('py27-pip') } it { is_expected.to_not contain_package('python-pip') } it { is_expected.to_not contain_package('python3-pip') } end end context 'with virtualenv' do let(:params) {{ :version => 'system', :virtualenv => true, :dev => false, :pip => false, }} case facts[:operatingsystem] when 'Debian' it { is_expected.to contain_package('python-virtualenv') } when 'FreeBSD' it { is_expected.to contain_package('py27-virtualenv') } else end end end context "with a python3 version" do three_version = case facts[:operatingsystem] when 'FreeBSD' case facts[:operatingsystemmajrelease] when '10' '34' end when 'OpenBSD' case facts[:kernelversion] when '5.8' '3.4.3' when '5.9' '3.4.4' when '6.0' '3.5.2' end when 'Debian' case facts[:operatingsystemmajrelease] when '8' '3.4' end when 'CentOS' case facts[:operatingsystemmajrelease] when '7' '3' end when 'RedHat' case facts[:operatingsystemmajrelease] when '7' '3' end else nil end if three_version.nil? puts "skipping python3 tests on #{facts[:os]}" next end let(:params) {{ :pip => false, :dev => false, :virtualenv => false, :version => three_version, }} it { is_expected.to compile.with_all_deps } it { is_expected.to contain_class("python::install") } case facts[:operatingsystem] when 'FreeBSD' it { is_expected.to contain_package('python34')} when 'OpenBSD' it { is_expected.to contain_package('python').with_ensure(three_version)} when 'Debian' it { is_expected.to contain_package('python3.4')} end context 'when dev enabled is enabled' do let(:params) {{ :pip => false, :dev => true, :virtualenv => false, :version => three_version, }} case facts[:osfamily] when 'RedHat' it { is_expected.to contain_package('python3-devel') } when 'Debian' it { is_expected.to contain_package('python3.4-dev') } else end end context 'when pip is enabled' do let(:params) {{ :pip => true, :dev => false, :virtualenv => false, :version => three_version, }} case facts[:osfamily] when 'RedHat' case facts[:operatingsystemmajrelease] when '7' it { is_expected.to contain_exec('install_pip3').with_command('/bin/curl https://bootstrap.pypa.io/get-pip.py | /bin/python3')} end when 'Debian' it { is_expected.to contain_package('python3-pip') } when 'FreeBSD' it { is_expected.to contain_package("py34-pip") } else it { is_expected.to_not contain_package('py27-pip') } it { is_expected.to_not contain_package('python-pip') } end end context 'when virtualenv is enabled' do let(:params) {{ :pip => false, :dev => false, :virtualenv => true, :version => three_version, }} case facts[:operatingsystem] when 'Debian' it { is_expected.to contain_package('python3-virtualenv') } when 'FreeBSD' it { is_expected.to contain_package('py34-virtualenv') } when 'RedHat' it { is_expected.to raise_error() } else end end context 'when virtualenv and pip are enabled' do let(:params) {{ :pip => true, :dev => false, :virtualenv => true, :version => three_version, }} case facts[:operatingsystem] when 'FreeBSD' it { is_expected.to contain_package("py34-virtualenv") } when 'RedHat' it { is_expected.to contain_package("virtualenv").with_provider('pip3') } else end end end end end end puppet-python-2.4.1/spec/defines/000077500000000000000000000000001276765413400167405ustar00rootroot00000000000000puppet-python-2.4.1/spec/defines/pip_spec.rb000066400000000000000000000054751276765413400211020ustar00rootroot00000000000000require 'spec_helper' describe 'python::pip', :type => :define do let (:title) { 'rpyc' } context "on Debian OS" do let :facts do { :id => 'root', :kernel => 'Linux', :lsbdistcodename => 'squeeze', :osfamily => 'Debian', :operatingsystem => 'Debian', :operatingsystemrelease => '6', :path => '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin', :concat_basedir => '/dne', } end describe "virtualenv as" do context "fails with non qualified path" do let (:params) {{ :virtualenv => "venv" }} it { is_expected.to raise_error(/"venv" is not an absolute path./) } end context "suceeds with qualified path" do let (:params) {{ :virtualenv => "/opt/venv" }} it { is_expected.to contain_exec("pip_install_rpyc").with_cwd('/opt/venv') } end context "defaults to system" do let (:params) {{ }} it { is_expected.to contain_exec("pip_install_rpyc").with_cwd('/') } end end describe "proxy as" do context "defaults to empty" do let (:params) {{ }} it { is_expected.to contain_exec("pip_install_rpyc").without_command(/--proxy/) } end context "does not add proxy to search command if set to latest and proxy is unset" do let (:params) {{ :ensure => 'latest' }} it { is_expected.to contain_exec("pip_install_rpyc").without_command(/--proxy/) } it { is_expected.to contain_exec("pip_install_rpyc").without_unless(/--proxy/) } end context "adds proxy to install command if proxy set" do let (:params) {{ :proxy => "http://my.proxy:3128" }} it { is_expected.to contain_exec("pip_install_rpyc").with_command("pip wheel --help > /dev/null 2>&1 && { pip wheel --version > /dev/null 2>&1 || wheel_support_flag='--no-use-wheel'; } ; { pip --log /tmp/pip.log install $wheel_support_flag --proxy=http://my.proxy:3128 rpyc || pip --log /tmp/pip.log install --proxy=http://my.proxy:3128 rpyc ;}") } end context "adds proxy to search command if set to latest" do let (:params) {{ :proxy => "http://my.proxy:3128", :ensure => 'latest' }} it { is_expected.to contain_exec("pip_install_rpyc").with_command("pip wheel --help > /dev/null 2>&1 && { pip wheel --version > /dev/null 2>&1 || wheel_support_flag='--no-use-wheel'; } ; { pip --log /tmp/pip.log install --upgrade $wheel_support_flag --proxy=http://my.proxy:3128 rpyc || pip --log /tmp/pip.log install --upgrade --proxy=http://my.proxy:3128 rpyc ;}") } it { is_expected.to contain_exec("pip_install_rpyc").with_unless('pip search --proxy=http://my.proxy:3128 rpyc | grep -i INSTALLED | grep -i latest') } end end end endpuppet-python-2.4.1/spec/defines/pyvenv_spec.rb000066400000000000000000000007371276765413400216350ustar00rootroot00000000000000require 'spec_helper' describe 'python::pyvenv', :type => :define do let (:title) { '/opt/env' } it { should contain_file( '/opt/env') should contain_exec( "python_virtualenv_/opt/env").with_command("pyvenv --clear /opt/env") } describe 'when ensure' do context "is absent" do let (:params) {{ :ensure => 'absent' }} it { should contain_file( '/opt/env').with_ensure('absent').with_purge( true) } end end end puppet-python-2.4.1/spec/defines/requirements_spec.rb000066400000000000000000000025301276765413400230220ustar00rootroot00000000000000require 'spec_helper' describe 'python::requirements', :type => :define do let (:title) { '/requirements.txt' } context "on Debian OS" do let :facts do { :id => 'root', :kernel => 'Linux', :lsbdistcodename => 'squeeze', :osfamily => 'Debian', :operatingsystem => 'Debian', :operatingsystemrelease => '6', :path => '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin', :concat_basedir => '/dne', } end describe "requirements as" do context "/requirements.txt" do let (:params) {{ :requirements => "/requirements.txt" }} it { is_expected.to contain_file("/requirements.txt").with_mode('0644') } end describe "with owner" do context "bob:bob" do let (:params) {{ :owner => 'bob', :group => 'bob' }} it do expect { should compile }.to raise_error(/root user must be used when virtualenv is system/) end end end describe "with owner" do context "default" do it { is_expected.to contain_file("/requirements.txt").with_owner('root').with_group('0') } end end end end end puppet-python-2.4.1/spec/spec_helper.rb000066400000000000000000000006001276765413400201350ustar00rootroot00000000000000require 'rspec-puppet' require 'puppetlabs_spec_helper/module_spec_helper' require 'rspec-puppet-facts' include RspecPuppetFacts fixture_path = File.expand_path(File.join(__FILE__, '..', 'fixtures')) RSpec.configure do |c| c.module_path = File.join(fixture_path, 'modules') c.manifest_dir = File.join(fixture_path, 'manifests') end at_exit { RSpec::Puppet::Coverage.report! } puppet-python-2.4.1/spec/spec_helper_acceptance.rb000066400000000000000000000016361276765413400223150ustar00rootroot00000000000000require 'beaker-rspec' UNSUPPORTED_PLATFORMS = [ 'windows' ] unless ENV['RS_PROVISION'] == 'no' or ENV['BEAKER_provision'] == 'no' hosts.each do |host| if host.is_pe? install_pe else install_puppet end end end RSpec.configure do |c| # Project root proj_root = File.expand_path(File.join(File.dirname(__FILE__), '..')) # Readable test descriptions c.formatter = :documentation # Configure all nodes in nodeset c.before :suite do # Install module and dependencies hosts.each do |host| shell("rm -rf /etc/puppet/modules/python/") copy_module_to(host, :source => proj_root, :module_name => 'python') shell("/bin/touch #{default['puppetpath']}/hiera.yaml") on host, puppet('module install puppetlabs-stdlib'), { :acceptable_exit_codes => [0,1] } on host, puppet('module install stahnma-epel'), { :acceptable_exit_codes => [0,1] } end end end puppet-python-2.4.1/spec/unit/000077500000000000000000000000001276765413400163025ustar00rootroot00000000000000puppet-python-2.4.1/spec/unit/facter/000077500000000000000000000000001276765413400175465ustar00rootroot00000000000000puppet-python-2.4.1/spec/unit/facter/pip_version_spec.rb000066400000000000000000000016551276765413400234510ustar00rootroot00000000000000require "spec_helper" describe Facter::Util::Fact do before { Facter.clear } let(:pip_version_output) { <<-EOS pip 6.0.6 from /opt/boxen/homebrew/Cellar/python/2.7.9/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/pip-6.0.6-py2.7.egg (python 2.7) EOS } describe "pip_version" do context 'returns pip version when pip present' do it do Facter::Util::Resolution.stubs(:exec) Facter::Util::Resolution.expects(:which).with("pip").returns(true) Facter::Util::Resolution.expects(:exec).with("pip --version 2>&1").returns(pip_version_output) Facter.value(:pip_version).should == "6.0.6" end end context 'returns nil when pip not present' do it do Facter::Util::Resolution.stubs(:exec) Facter::Util::Resolution.expects(:which).with("pip").returns(false) Facter.value(:pip_version).should == nil end end end end puppet-python-2.4.1/spec/unit/facter/python_version_spec.rb000066400000000000000000000065561276765413400242070ustar00rootroot00000000000000require "spec_helper" describe Facter::Util::Fact do before { Facter.clear } let(:python2_version_output) { <<-EOS Python 2.7.9 EOS } let(:python3_version_output) { <<-EOS Python 3.3.0 EOS } describe "python_version" do context 'returns Python version when `python` present' do it do Facter::Util::Resolution.stubs(:exec) Facter::Util::Resolution.expects(:which).with("python").returns(true) Facter::Util::Resolution.expects(:exec).with("python -V 2>&1").returns(python2_version_output) Facter.value(:python_version).should == "2.7.9" end end context 'returns nil when `python` not present' do it do Facter::Util::Resolution.stubs(:exec) Facter::Util::Resolution.expects(:which).with("python").returns(false) Facter.value(:python_version).should == nil end end end describe "python2_version" do context 'returns Python 2 version when `python` is present and Python 2' do it do Facter::Util::Resolution.stubs(:exec) Facter::Util::Resolution.expects(:which).with("python").returns(true) Facter::Util::Resolution.expects(:exec).with("python -V 2>&1").returns(python2_version_output) Facter.value(:python2_version).should == '2.7.9' end end context 'returns Python 2 version when `python` is Python 3 and `python2` is present' do it do Facter::Util::Resolution.stubs(:exec) Facter::Util::Resolution.expects(:which).with("python").returns(true) Facter::Util::Resolution.expects(:exec).with("python -V 2>&1").returns(python3_version_output) Facter::Util::Resolution.expects(:which).with("python2").returns(true) Facter::Util::Resolution.expects(:exec).with("python2 -V 2>&1").returns(python2_version_output) Facter.value(:python2_version).should == '2.7.9' end end context 'returns nil when `python` is Python 3 and `python2` is absent' do it do Facter::Util::Resolution.stubs(:exec) Facter::Util::Resolution.expects(:which).with("python").returns(true) Facter::Util::Resolution.expects(:exec).with("python -V 2>&1").returns(python3_version_output) Facter::Util::Resolution.expects(:which).with("python2").returns(false) Facter.value(:python2_version).should == nil end end context 'returns nil when `python2` and `python` are absent' do it do Facter::Util::Resolution.stubs(:exec) Facter::Util::Resolution.expects(:which).with("python").returns(false) Facter::Util::Resolution.expects(:which).with("python2").returns(false) Facter.value(:python2_version).should == nil end end end describe "python3_version" do context 'returns Python 3 version when `python3` present' do it do Facter::Util::Resolution.stubs(:exec) Facter::Util::Resolution.expects(:which).with("python3").returns(true) Facter::Util::Resolution.expects(:exec).with("python3 -V 2>&1").returns(python3_version_output) Facter.value(:python3_version).should == "3.3.0" end end context 'returns nil when `python3` not present' do it do Facter::Util::Resolution.stubs(:exec) Facter::Util::Resolution.expects(:which).with("python3").returns(false) Facter.value(:python3_version).should == nil end end end end puppet-python-2.4.1/spec/unit/facter/virtualenv_version_spec.rb000066400000000000000000000015451276765413400250560ustar00rootroot00000000000000require "spec_helper" describe Facter::Util::Fact do before { Facter.clear } let(:virtualenv_version_output) { <<-EOS 12.0.7 EOS } describe "virtualenv_version" do context 'returns virtualenv version when virtualenv present' do it do Facter::Util::Resolution.stubs(:exec) Facter::Util::Resolution.expects(:which).with("virtualenv").returns(true) Facter::Util::Resolution.expects(:exec).with("virtualenv --version 2>&1").returns(virtualenv_version_output) Facter.value(:virtualenv_version).should == "12.0.7" end end context 'returns nil when virtualenv not present' do it do Facter::Util::Resolution.stubs(:exec) Facter::Util::Resolution.expects(:which).with("virtualenv").returns(false) Facter.value(:virtualenv_version).should == nil end end end end puppet-python-2.4.1/templates/000077500000000000000000000000001276765413400163675ustar00rootroot00000000000000puppet-python-2.4.1/templates/inifile.erb000066400000000000000000000002721276765413400205010ustar00rootroot00000000000000# this file is managed by puppet <%- @config.sort.map do |section,conf| -%> [<%= section -%>] <%- conf.sort.map do |key,value| -%> <%= key %> = <%= value %> <%- end -%> <%- end -%> puppet-python-2.4.1/tests/000077500000000000000000000000001276765413400155335ustar00rootroot00000000000000puppet-python-2.4.1/tests/init.pp000066400000000000000000000001321276765413400170330ustar00rootroot00000000000000class { 'python': version => 'system', dev => true, virtualenv => true, } puppet-python-2.4.1/tests/pip.pp000066400000000000000000000003111276765413400166570ustar00rootroot00000000000000class { 'python': version => 'system', dev => true, virtualenv => true, } python::pip { 'flask': virtualenv => '/var/www/project1', proxy => 'http://proxy.domain.com:3128', } puppet-python-2.4.1/tests/pyvenv.pp000066400000000000000000000002551276765413400174250ustar00rootroot00000000000000class { 'python': pip => false, version => '3', } python::pyvenv { "/opt/uwsgi": } python::pip { "uwsgi": ensure => "latest", virtualenv => "/opt/uwsgi" } puppet-python-2.4.1/tests/requirements.pp000066400000000000000000000006171276765413400206230ustar00rootroot00000000000000class { 'python': version => 'system', dev => true, virtualenv => true, } python::requirements { '/var/www/project1/requirements.txt': virtualenv => '/var/www/project1', proxy => 'http://proxy.domain.com:3128', } python::requirements { '/var/www/project1/requirements.txt': virtualenv => 'system', proxy => 'http://proxy.domain.com:3128', timeout => 2400, } puppet-python-2.4.1/tests/virtualenv.pp000066400000000000000000000005001276765413400202660ustar00rootroot00000000000000class { 'python': version => 'system', dev => true, virtualenv => true, } python::virtualenv { '/var/www/project1': ensure => present, version => 'system', requirements => '/var/www/project1/requirements.txt', proxy => 'http://proxy.domain.com:3128', systempkgs => true, }