Add initial support for jdbc like virtuals. Which return all providers instead of just one.

svn path=/projects/java-config-2/trunk/; revision=7546

5 files changed, 77 insertions, 38 deletions

diff --git a/src/java_config_2/EnvironmentManager.py b/src/java_config_2/EnvironmentManager.py
index 3cd96be..1d92096 100644
--- a/src/java_config_2/EnvironmentManager.py
+++ b/src/java_config_2/EnvironmentManager.py
@@ -24,7 +24,7 @@ class EnvironmentManager(object):
     # Location of the vm ev files
     vms_path = '/usr/share/java-config-2/vm'
     # Location of the package env files to load
-    pkg_path = '/usr/share/*/package.env'
+    pkg_path = '/usr/share/%s/package.env'
     virtual_path = '/usr/share/java-config-2/virtuals/'
 
     system_config_path="/etc/java-config-2/"
@@ -67,7 +67,7 @@ class EnvironmentManager(object):
     def load_package(self, name):
         try:
             name = name.replace(':', '-')
-            pkg = Package(name, '/usr/share/' + name + '/package.env')
+            pkg = Package(name, self.pkg_path % name )
             self.packages[name] = pkg
             return pkg
         except InvalidConfigError:
@@ -81,7 +81,7 @@ class EnvironmentManager(object):
                 raise UnexistingPackageError(name)
 
     def load_packages(self):
-        for package in iter(glob(self.pkg_path)):
+        for package in iter(glob(self.pkg_path) % "*" ):
             name = basename(dirname(package))
             if name in self.packages:
                 continue
@@ -117,7 +117,7 @@ class EnvironmentManager(object):
                 if vm:
                     self.active = vm
                     return vm
-        raise InvalidVMError
+        raise InvalidVMError("Unable to determine valid vm. Please see http://www.gentoo.org/doc/en/java.xml#doc_chap4")
 
     def set_active_vm(self, vm):
         self.active = vm
@@ -285,6 +285,17 @@ class EnvironmentManager(object):
         Filters out optional deps that are not present.
         """
         deps = pkg.deps();
+
+        #if hasattr(pkg, 'get_packages') and pkg.use_all_available():
+        #    vps = pkg.get_packages()
+        #    for vp in vps:
+        #        try:
+        #            vp_pkg = self.get_package(vp)
+        #            deps.append([vp])
+        #            deps.append( self.get_pkg_deps(vp) )
+        #            print deps
+        #        except UnexistingPackageError:
+        #            continue
         for opt_dep in pkg.opt_deps():
             try:
                 self.get_package(opt_dep[-1])
@@ -442,6 +453,7 @@ class EnvironmentManager(object):
     def have_provider(self, virtuals, virtualMachine, versionManager):
         result=True
         storeVM = self.get_active_vm()
+        print virtualMachine
         self.set_active_vm(virtualMachine)
         try:
             for virtualKey in virtuals.split():
diff --git a/src/java_config_2/FileParser.py b/src/java_config_2/FileParser.py
index eae6185..77e28b0 100644
--- a/src/java_config_2/FileParser.py
+++ b/src/java_config_2/FileParser.py
@@ -4,7 +4,7 @@
 # Distributed under the terms of the GNU General Public License v2
 # $Header: $
 
-from Errors import *
+from java_config_2.Errors import InvalidConfigError, PermissionError
 import os
 
 
diff --git a/src/java_config_2/Package.py b/src/java_config_2/Package.py
index 3491dd9..5cb3032 100644
--- a/src/java_config_2/Package.py
+++ b/src/java_config_2/Package.py
@@ -42,14 +42,14 @@ class Package:
         else:
             return None
 
-    def virtual_classpath(self):
-        """
-        Returns this package's virtual classpath
-        """
-        if self._config.has_key("VIRTUAL_CLASSPATH"):
-            return self._config["VIRTUAL_CLASSPATH"]
-        else:
-            return None
+    #def virtual_classpath(self):
+    #    """
+    #    Returns this package's virtual classpath
+    #    """
+    #    if self._config.has_key("VIRTUAL_CLASSPATH"):
+    #        return self._config["VIRTUAL_CLASSPATH"]
+    #    else:
+    #        return None
 
     def target(self):
         return self.query("TARGET")
diff --git a/src/java_config_2/VersionManager.py b/src/java_config_2/VersionManager.py
index fa849a6..197e84b 100644
--- a/src/java_config_2/VersionManager.py
+++ b/src/java_config_2/VersionManager.py
@@ -84,6 +84,7 @@ class VersionManager:
             atoms = " ".join(flatten(use_reduce(paren_reduce(atoms),uselist=use)))
         except KeyError:
             pass
+        print atoms
         return atoms
 
     def parse_depend_virtuals(self, atoms):
diff --git a/src/java_config_2/Virtual.py b/src/java_config_2/Virtual.py
index bf10e38..e05c09b 100644
--- a/src/java_config_2/Virtual.py
+++ b/src/java_config_2/Virtual.py
@@ -4,8 +4,9 @@
 # Distributed under the terms of the GNU General Public License v2
 # $Header: $
 
-from FileParser import *
-from Package import *
+from java_config_2.FileParser import *
+from java_config_2.Errors import EnvironmentUndefinedError
+from java_config_2.Package import *
 import re, sys
         
 class Virtual(Package):
@@ -18,8 +19,8 @@ class Virtual(Package):
         self._manager = manager
 
         # Store possible installed packages and vms in arrays
-        self.providing_packages = ""
-        self.providing_vms = ""
+        #self.providing_packages = ""
+        #self.providing_vms = ""
 
         # Arrays of packages/vms as strings, used to delay
         # using of real objects until EnvironmentManager
@@ -30,16 +31,14 @@ class Virtual(Package):
         self.active_package = None
         self.avaliable_vms = []
         
-        #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(" ", ", ")
+                #self.providing_packages = self._config["PROVIDERS"].replace(" ", ", ")
                 temp_packages = self._config["PROVIDERS"].split(' ')
             else:
                 temp_packages = []
@@ -78,7 +77,7 @@ class Virtual(Package):
             if self._manager.get_vm(vm):
                 self._vms.append(vm)
         if not self._packages and not self._vms:
-            raise ProviderUnavailableError( self._name, self.providing_vms, self.providing_packages )
+            raise ProviderUnavailableError( self._name, self.providing_vms, self._packages.join(' ') )
 
     def file(self):
         # Investigate if anything uses this
@@ -94,6 +93,11 @@ class Virtual(Package):
     def get_packages(self):
         return self._packages
 
+    def use_all_available(self):
+        if self._config.has_key('MULTI_PROVIDER'):
+            return 'true' == self._config['MULTI_PROVIDER'].lower()
+        return False
+
     def get_vms(self):
         return self._vms
 
@@ -116,18 +120,43 @@ class Virtual(Package):
         """
         Returns this package's classpath
         """
+        if not self.use_all_available():
+            try:
+                return self.get_provider().classpath()
+            except:
+                active_vm = self._manager.get_active_vm()
+                if active_vm and self.get_available_vms().count(active_vm.name()):
+                    if self._config.has_key("VM_CLASSPATH"):
+                        return self._manager.get_active_vm().query('JAVA_HOME') + self._config["VM_CLASSPATH"]
+                    #TODO figure out what is meant to happen here
+                else:
+                    raise ProviderUnavailableError( self._name, self.providing_vms, self._packages.join(' ') )
+        else:
+            cp = self.query_all_providers('CLASSPATH')
+            if self._config.has_key("VM_CLASSPATH"):
+                cp += ':' + self._manager.get_active_vm().query('JAVA_HOME') + self._config["VM_CLASSPATH"]
+            return cp
+                
+
+    def library_path(self):
         try:
-            classpath=self.get_provider().virtual_classpath()
-            if None == classpath:
-                classpath=self.get_provider().classpath()
-            return classpath
-        except:
-            active_vm = self._manager.get_active_vm()
-            if active_vm and self.get_available_vms().count(active_vm.name()):
-                if self._config.has_key("VM_CLASSPATH"):
-                    return self._manager.get_active_vm().query('JAVA_HOME') + self._config["VM_CLASSPATH"]
+            if self.use_all_available():
+                return self.query_all_providers('LIBRARY_PATH')
             else:
-                raise ProviderUnavailableError( self._name, self.providing_vms, self.providing_packages )
+                return self.get_provider().query('LIBRARY_PATH')
+        except EnvironmentUndefinedError:
+            return ""
+
+    def query_all_providers(self, var):
+        paths = []
+        for pkg in self._packages:
+            try:
+                opkg = self._manager.get_package(pkg)
+                paths.append(opkg.query(var))
+            except:
+                continue
+        return ":".join(paths).replace('::', ':').strip(':')
+
 
     def query(self, var):
         """
@@ -140,11 +169,8 @@ class Virtual(Package):
         if var == "TARGET":
             return self.min_target
         if var == "LIBRARY_PATH":
-            try:
-                path = self.get_provider().query(var)
-                return path
-            except EnvironmentUndefinedError:
-                return ""
+            return self.library_path()
+
         return self.get_provider().query(var)
 
     def deps(self):
@@ -179,7 +205,7 @@ class Virtual(Package):
             self.load()
 
         if not len(self._vms) and not self.active_package:
-            raise ProviderUnavailableError( self._name, self.providing_vms, self.providing_packages ) 
+            raise ProviderUnavailableError( self._name, self.providing_vms, self._packages.join(' ') ) 
 
         # If no vm's then use active_package
         if not len(self._vms) and self.active_package:
@@ -195,7 +221,7 @@ class Virtual(Package):
                     available = ""
                     for vm in self._vms:
                         available = vm + "\n"
-                        raise ProviderUnavailableError( self._name, self.providing_vms, self.providing_packages )
+                        raise ProviderUnavailableError( self._name, self.providing_vms, self._packages.join(' ') )
         return self.active_package
 
     def load(self):