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
|
# -*- coding: UTF-8 -*-
# Copyright 2004-2007 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Header: $
from FileParser import *
from Package import *
import re, sys
class Virtual(Package):
"""
Class representing an installed java virtual.
"""
def __init__(self, name, manager, file = None):
self._file = file
self._name = name
self._manager = manager
# Store possible installed packages and vms in arrays
self.providing_packages = ""
self.providing_vms = ""
self._packages = []
self._vms = []
self.active_package = None
self.needs_jdk = False
self.min_target = None
self.min_vm_target = None
self.loaded = False
if self._file:
self._config = EnvFileParser(file).get_config()
if self._config.has_key("PROVIDERS"):
self.providing_packages = self._config["PROVIDERS"].replace(" ", ", ")
temp_packages = self._config["PROVIDERS"].split(' ')
else:
temp_packages = []
if self._config.has_key("VM"):
self.providing_vms = self._config["VM"].replace(" ", ", ")
else:
self._config = {}
temp_packages = []
# Refactored to make __init__ smaller.
self.load_providers(temp_packages)
def load_providers(self, temp_packages):
# Now load system pref. Really should support
# List of packages instead of single package.
all_prefs = self._manager.get_virtuals_pref().get_config()
if all_prefs.has_key(self.name()):
if all_prefs[self.name()] in temp_packages:
self._packages.append(all_prefs[self.name()])
else:
if all_prefs.has_key('PREFER_UPSTREAM'):
for package in temp_packages:
if re.compile(all_prefs['PREFER_UPSTREAM'] + '*').match(package):
self._package.append(package)
break
for element in temp_packages:
if not element in self._packages:
self._packages.append(element)
def file(self):
# Investigate if anything uses this
# and whether what it should therefore return.
return self._file
def description(self):
if not self.use_active_package():
if self._manager.get_active_vm():
return self._name + ", Using: " + self._manager.get_active_vm().name()
return self.get_active_package().description()
def get_packages(self):
return self._packages
def classpath(self):
"""
Returns this package's classpath
"""
if not self.use_active_package():
if not self._config.has_key("VM_CLASSPATH"):
return ""
if self._manager.get_active_vm():
return self._manager.get_active_vm().query('JAVA_HOME') + self._config["VM_CLASSPATH"]
raise ProviderUnavailableError( self._name, self._providing_vms, self._providing_packages )
return self.get_active_package().classpath()
def query(self, var):
"""
Return the value of the requested var from the env file
"""
if (var == "TARGET"):
if self.loaded:
return self.min_target, self.needs_jdk
else:
self.load()
return self.min_target, self.needs_jdk
if( var == "CLASSPATH" ):
return self.classpath()
return ""
def deps(self):
"""
Return all packages this package depends on
"""
if not self.use_active_package():
return []
return self.get_active_package().deps()
def opt_deps(self):
"""
Return all packages this package optionally depends on
"""
if not self.use_active_package():
return []
return self.get_active_package().opt_deps()
def provides(self):
"""
Return the virtuals this package provides
"""
if not self.use_active_package():
if self._get_active_vm():
return self._manager.get_active_vm().provides()
return self.get_active_package().provides()
def needs_vm(self):
"""
Return whether this Virtual requires a Virtual Machine.
"""
return not self.use_active_package()
def get_active_package(self):
"""
Return the active package package for the virtual.
"""
if not self.loaded:
self.load()
return self.active_package
def use_active_package(self):
"""
Return whether a package is to be used by the Virtual.
"""
if not self.loaded:
self.load()
if not self._vms and not self.active_package:
raise ProviderUnavailableError( self._name, self.providing_vms, self.providing_packages )
# If no vm's then use active_package
if not self._vms and self.active_package:
return True
if self._vms:
import VersionManager
verman = VersionManager.VersionManager()
vm = self._manager.get_active_vm()
if vm and verman.version_satisfies( self._config["VM"], vm ):
# This is acceptable so return false
return False
else:
if not self.active_package:
available = ""
for vm in self._vms:
available = vm.name() + "\n"
raise ProviderUnavailableError( self._name, self.providing_vms, self.providing_packages )
else:
return True
return False
def load(self):
# Active package is the first available package
for package in self._packages:
# Improvement: we could put the VM in the list of providers
if self._manager.get_package(package) is not None:
self.active_package = self._manager.get_package(package)
break
# Set the minimum target version to the active package's target.
if self.active_package:
self.min_target = self.active_package.query("TARGET")
# Load possible vms. These are vm's that are installed.
vms = self._manager.get_virtual_machines()
if self._config.has_key("VM") and self._config["VM"]:
import VersionManager
verman = VersionManager.VersionManager()
# We assume that there was only one virtual/[jre|jdk] declared.
r = verman.parse_depend(self._config["VM"])[0]
version = r["version"]
if r["type"] == "jdk":
self.needs_jdk = True
for vm_index in vms:
vm = vms[vm_index]
if self.needs_jdk and not vm.is_jre:
continue
if verman.version_satisfies( self._config["VM"], vm ):
self._vms.append(vm)
if self.min_target:
if cmp(vm.version(), self.min_target) < 0:
self.min_target = vm.version()
else:
self.min_target = vm.version()
if self.min_vm_target:
if cmp(vm.version(), self.min_vm_target) < 0:
self.min_vm_target = vm.version()
else:
self.min_vm_target = vm.version()
#Set loaded to true, so function can determine what is going on
self.loaded = True
#vim:set expandtab tabstop=4 shiftwidth=4 softtabstop=4 nowrap:
|
GitWeb