File: PKG-INFO

package info (click to toggle)
python-vagrant 0.5.15-2
  • links: PTS, VCS
  • area: main
  • in suites: buster
  • size: 232 kB
  • sloc: python: 1,386; makefile: 18
file content (242 lines) | stat: -rw-r--r-- 10,326 bytes parent folder | download | duplicates (4)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
Metadata-Version: 1.1
Name: python-vagrant
Version: 0.5.15
Summary: Python bindings for interacting with Vagrant virtual machines.
Home-page: https://github.com/todddeluca/python-vagrant
Author: Todd Francis DeLuca
Author-email: todddeluca@yahoo.com
License: MIT
Description: ## Introduction
        
        Python-vagrant is a python module that provides a _thin_ wrapper around the
        `vagrant` command line executable, allowing programmatic control of Vagrant
        virtual machines (boxes).  This module is useful for:
        
        - Starting a Vagrant virtual machine (VM) (`up`).
        - Terminating a Vagrant VM (`destroy`).
        - Halting a Vagrant VM without destroying it (`halt`).
        - Querying the status of a VM or VMs (`status`).
        - Getting ssh configuration information useful for SSHing into the VM. (`host`, `port`, ...)
        - Running `vagrant` commands in a multi-VM environment
          (http://vagrantup.com/v1/docs/multivm.html) by using `vm_name` parameter.
        - Initializing the VM based on a named base box, using init().
        - Adding, Removing, and Listing boxes (`box add`, `box remove`, `box list`).
        - Provisioning VMs - up() accepts options like `no_provision`, `provision`, and `provision_with`, and there is a `provision()` method.
        - Using sandbox mode from the Sahara gem (https://github.com/jedi4ever/sahara).
        
        This project began because I wanted python bindings for Vagrant so I could
        programmatically access my vagrant box using Fabric.  Drop me a line to let me
        know how you use python-vagrant.  I'd love to share more use cases.  -Todd DeLuca
        
        
        ## Versioning and API Stability
        
        This package is _beta_ and its API is not guaranteed to be stable.  The API
        attempts to be congruent with the `vagrant` API terminology, to facilitate
        knowledge transfer for users already familiar with Vagrant.  Over time, the
        python-vagrant API has changed to better match the underling `vagrant` CLI and
        to evolve with the changes in that CLI.
        
        The package version numbering is in the form `0.X.Y`.  The initial `0` reflects
        the _beta_ nature of this project.  The number `X` is incremented when
        backwards-incompatible changes occur.  The number `Y` is incremented when
        backwards-compatible features or bug fixes are added.
        
        
        ## Requirements
        
        - Vagrant 1.4 or greater (currently tested with 1.7.2).  Using the latest
          version of Vagrant is strongly recommended.
        - Vagrant requires VirtualBox, VMWare, or another supported provider.
        - Python 2.7 (the only version this package has been tested with.) or Python
          3.3 or higher.
        - The Sahara gem for Vagrant is optional.  It will allow you to use
          `SandboxVagrant`.
        
        
        ## Installation
        
        ### Install from pypi.python.org
        
        Download and install python-vagrant:
        
            pip install python-vagrant
        
        ### Install from github.com
        
        Clone and install python-vagrant
        
            cd ~
            git clone git@github.com:todddeluca/python-vagrant.git
            cd python-vagrant
            python setup.py install
        
        
        ## Usage
        
        A contrived example of starting a vagrant box (using a Vagrantfile from the
        current directory) and running a fabric task on it:
        
            import vagrant
            from fabric.api import env, execute, task, run
        
            @task
            def mytask():
                run('echo $USER')
        
        
            v = vagrant.Vagrant()
            v.up()
            env.hosts = [v.user_hostname_port()]
            env.key_filename = v.keyfile()
            env.disable_known_hosts = True # useful for when the vagrant box ip changes.
            execute(mytask) # run a fabric task on the vagrant host.
        
        Another example showing how to use vagrant multi-vm feature with fabric:
        
            import vagrant
            from fabric.api import *
        
            @task
            def start(machine_name):
               """Starts the specified machine using vagrant"""
               v = vagrant.Vagrant()
               v.up(vm_name=machine_name)
               with settings(host_string= v.user_hostname_port(vm_name=machine_name),
                             key_filename = v.keyfile(vm_name=machine_name),
                             disable_known_hosts = True):
                    run("echo hello")
        
        By default python vagrant instances are quiet, meaning that they capture stdout
        and stderr.  For a "loud" instance, use `vagrant.Vagrant(quiet_stdout=False)`.
        Set `quiet_stderr=False` for an even louder version.
        
        ### Interacting With the Vagrant Subprocess
        
        The `Vagrant` class works by executing `vagrant` commands in a subprocess and
        interpreting the output.  Depending on the needs of the user, the communication
        to and from the subprocess can be tailored by altering its environment and
        where it sends its stdout and stderr.
        
        #### Silencing the Stdout or Stderr of the Vagrant Subprocess
        
        The stdout and stderr of the underlying vagrant process can be silenced by
        using the `out_cm` and `err_cm` parameters, or by using the `quiet_stdout` and
        `quiet_stderr` parameters of `Vagrant.__init__`.  
        
        Using `out_cm` and `err_cm` to redirect stdout and stderr to `/dev/null`:
        
            v = vagrant.Vagrant(out_cm=vagrant.devnull_cm, err_cm=vagrant.devnull_cm)
            v.up() # normally noisy
        
        Using `quiet_stdout` and `quiet_stderr` to redirect stdout and stderr to
        `/dev/null`:
        
            v = vagrant.Vagrant(quiet_stdout=True, quiet_stderr=True)
            v.up() # normally noisy
        
        These are functionally equivalent.
        
        #### Logging the Stdout or Stderr of the Vagrant Subprocess
        
        A user might wish to direct the stdout and stderr of a vagrant subprocess to
        a file, perhaps to log and analyze the results of an automated process.  This
        can be accomplished using the `out_cm` and `err_cm` parameters of
        `Vagrant.__init__`.
        
        For example, log the stdout and stderr of the subprocess to the file
        'deployment.log':
        
            log_cm = vagrant.make_file_cm('deployment.log')
            v = vagrant.Vagrant(out_cm=log_cm, err_cm=log_cm)
            v.up() # normally noisy
        
        #### Altering the Environment of the Vagrant Subprocess
        
        It's possible to communicate with the Vagrant subprocess using environment
        variables. The `Vagrantfile` could expect environment variables to be present
        and act accordingly. The environment variables can be set by `python-vagrant`.
        
        ```python
        import vagrant
        
        v = vagrant.Vagrant()
        
        os_env = os.environ.copy()
        os_env['USE_NFS'] = '1'
        
        v.env = os_env
        v.up()  # will pass env to the vagrant subprocess
        ```
        
        Alternatively, the environment can be passed at instantiation time.
        
        ```python
        import vagrant
        
        os_env = os.environ.copy()
        os_env['USE_NFS'] = '1'
        
        v = vagrant.Vagrant(env=env)
        assert v.env is env  # True
        v.up()  # will pass env to the vagrant subprocess
        ```
        
        ## Contribute
        
        If you use python and vagrant and this project does not do what you want,
        please open an issue or a pull request on github at
        https://github.com/todddeluca/python-vagrant.
        
        Please see CHANGELOG.md for a detailed list of contributions and authors.
        
        When making a pull request, please include unit tests that test your changes
        and make sure any existing tests still work.  See the Testing section below.
        
        
        ## Testing
        
        Running the full suite of tests might take 10 minutes or so.  It involves
        downloading boxes and starting and stopping virtual machines several times.
        
        Run the tests from the top-level directory of the repository:
        
            nosetests
        
        Here is an example of running an individual test:
        
            nosetests tests.test_vagrant:test_boxes
        
        
        Manual test of functionality for controlling where the vagrant subcommand
        output is sent -- console or devnull:
        
            >>> import vagrant
            >>> import os
            >>> vagrantfile = '/Users/tfd/proj/python-vagrant/tests/vagrantfiles/single_box'
            >>> # Demonstrate a quiet Vagrant.  Equivalent to out_cm=vagrant.devnull_cm
            ... v1 = vagrant.Vagrant(vagrantfile)
            >>> v1.destroy() # output to /dev/null
            >>> # Demonstrate a loud Vagrant.  Equivalent to out_cm=vagrant.stdout_cm
            ... v2 = vagrant.Vagrant(vagrantfile, quiet_stdout=False)
            >>> v2.destroy() # stdout sent to console
            ==> default: VM not created. Moving on...
            >>> # Demonstrate that out_cm takes precedence over quiet_stdout=True
            ... v3 = vagrant.Vagrant(vagrantfile, out_cm=vagrant.stdout_cm)
            >>> v3.destroy() # output to console
            ==> default: VM not created. Moving on...
            >>> # Demonstrate a quiet Vagrant using devnull_cm directly
            ... v4 = vagrant.Vagrant(vagrantfile, out_cm=vagrant.devnull_cm)
            >>> v4.destroy() # output to console
            >>> 
        
        
        
Keywords: python virtual machine box vagrant virtualbox vagrantfile
Platform: UNKNOWN
Classifier: License :: OSI Approved :: MIT License
Classifier: Development Status :: 4 - Beta
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: 3.4