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
|
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You 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.
"""
Plugin management.
"""
import os
import tempfile
import subprocess
import sys
import zipfile
from datetime import datetime
import wagon
from . import exceptions
from ..utils import process as process_utils
_IS_WIN = os.name == 'nt'
class PluginManager(object):
def __init__(self, model, plugins_dir):
"""
:param plugins_dir: root directory in which to install plugins
"""
self._model = model
self._plugins_dir = plugins_dir
def install(self, source):
"""
Install a wagon plugin.
"""
metadata = wagon.show(source)
cls = self._model.plugin.model_cls
os_props = metadata['build_server_os_properties']
plugin = cls(
name=metadata['package_name'],
archive_name=metadata['archive_name'],
supported_platform=metadata['supported_platform'],
supported_py_versions=metadata['supported_python_versions'],
distribution=os_props.get('distribution'),
distribution_release=os_props['distribution_version'],
distribution_version=os_props['distribution_release'],
package_name=metadata['package_name'],
package_version=metadata['package_version'],
package_source=metadata['package_source'],
wheels=metadata['wheels'],
uploaded_at=datetime.now()
)
if len(self._model.plugin.list(filters={'package_name': plugin.package_name,
'package_version': plugin.package_version})):
raise exceptions.PluginAlreadyExistsError(
'Plugin {0}, version {1} already exists'.format(plugin.package_name,
plugin.package_version))
self._install_wagon(source=source, prefix=self.get_plugin_dir(plugin))
self._model.plugin.put(plugin)
return plugin
def load_plugin(self, plugin, env=None):
"""
Load the plugin into an environment.
Loading the plugin means the plugin's code and binaries paths will be appended to the
environment's ``PATH`` and ``PYTHONPATH``, thereby allowing usage of the plugin.
:param plugin: plugin to load
:param env: environment to load the plugin into; If ``None``, :obj:`os.environ` will be
used
"""
env = env or os.environ
plugin_dir = self.get_plugin_dir(plugin)
# Update PATH environment variable to include plugin's bin dir
bin_dir = 'Scripts' if _IS_WIN else 'bin'
process_utils.append_to_path(os.path.join(plugin_dir, bin_dir), env=env)
# Update PYTHONPATH environment variable to include plugin's site-packages
# directories
if _IS_WIN:
pythonpath_dirs = [os.path.join(plugin_dir, 'Lib', 'site-packages')]
else:
# In some linux environments, there will be both a lib and a lib64 directory
# with the latter, containing compiled packages.
pythonpath_dirs = [os.path.join(
plugin_dir, 'lib{0}'.format(b),
'python{0}.{1}'.format(sys.version_info[0], sys.version_info[1]),
'site-packages') for b in ('', '64')]
process_utils.append_to_pythonpath(*pythonpath_dirs, env=env)
def get_plugin_dir(self, plugin):
return os.path.join(
self._plugins_dir,
'{0}-{1}'.format(plugin.package_name, plugin.package_version))
@staticmethod
def validate_plugin(source):
"""
Validate a plugin archive.
A valid plugin is a `wagon <http://github.com/cloudify-cosmo/wagon>`__ in the zip format
(suffix may also be ``.wgn``).
"""
if not zipfile.is_zipfile(source):
raise exceptions.InvalidPluginError(
'Archive {0} is of an unsupported type. Only '
'zip/wgn is allowed'.format(source))
with zipfile.ZipFile(source, 'r') as zip_file:
infos = zip_file.infolist()
try:
package_name = infos[0].filename[:infos[0].filename.index('/')]
package_json_path = "{0}/{1}".format(package_name, 'package.json')
zip_file.getinfo(package_json_path)
except (KeyError, ValueError, IndexError):
raise exceptions.InvalidPluginError(
'Failed to validate plugin {0} '
'(package.json was not found in archive)'.format(source))
def _install_wagon(self, source, prefix):
pip_freeze_output = self._pip_freeze()
file_descriptor, constraint_path = tempfile.mkstemp(prefix='constraint-', suffix='.txt')
os.close(file_descriptor)
try:
with open(constraint_path, 'wb') as constraint:
constraint.write(pip_freeze_output)
# Install the provided wagon.
# * The --prefix install_arg will cause the plugin to be installed under
# plugins_dir/{package_name}-{package_version}, So different plugins don't step on
# each other and don't interfere with the current virtualenv
# * The --constraint flag points a file containing the output of ``pip freeze``.
# It is required, to handle cases where plugins depend on some python package with
# a different version than the one installed in the current virtualenv. Without this
# flag, the existing package will be **removed** from the parent virtualenv and the
# new package will be installed under prefix. With the flag, the existing version will
# remain, and the version requested by the plugin will be ignored.
wagon.install(
source=source,
install_args='--prefix="{prefix}" --constraint="{constraint}"'.format(
prefix=prefix,
constraint=constraint.name),
venv=os.environ.get('VIRTUAL_ENV'))
finally:
os.remove(constraint_path)
@staticmethod
def _pip_freeze():
"""Run pip freeze in current environment and return the output"""
bin_dir = 'Scripts' if os.name == 'nt' else 'bin'
pip_path = os.path.join(sys.prefix, bin_dir,
'pip{0}'.format('.exe' if os.name == 'nt' else ''))
pip_freeze = subprocess.Popen([pip_path, 'freeze'], stdout=subprocess.PIPE)
pip_freeze_output, _ = pip_freeze.communicate()
assert not pip_freeze.poll()
return pip_freeze_output
|
