jolt 0.9.123__py3-none-any.whl → 0.9.435__py3-none-any.whl

jolt/plugins/http.py

@@ -1,5 +1,6 @@
 from requests.auth import HTTPBasicAuth
 from requests.exceptions import ConnectTimeout, RequestException
+from urllib.parse import urlparse, urlunparse
 import keyring
 import getpass
 
@@ -9,6 +10,7 @@ from jolt import cache
 from jolt import log
 from jolt import config
 from jolt import filesystem as fs
+from jolt import tools
 from jolt.error import raise_error_if, JoltError
 
 
@@ -21,10 +23,9 @@ class Http(cache.StorageProvider):
     def __init__(self, cache):
         super(Http, self).__init__()
         self._cache = cache
-        self._uri = config.get(NAME, "uri")
+        self._uri = config.get(NAME, "uri", "http://cache")
+        self._uri = self._uri.rstrip("/")
         raise_error_if(not self._uri, "HTTP URI not configured")
-        if self._uri[-1] != "/":
-            self._uri += "/"
         self._upload = config.getboolean(NAME, "upload", True)
         self._download = config.getboolean(NAME, "download", True)
         self._disabled = False
@@ -49,65 +50,62 @@ class Http(cache.StorageProvider):
 
         return HTTPBasicAuth(username, password)
 
-    def _get_url(self, node, artifact):
-        return "{uri}/{name}/{file}".format(
+    def _get_url(self, artifact):
+        return artifact.tools.expand(
+            "{uri}/{name}/{file}",
             uri=self._uri,
-            name=node.name,
+            name=artifact.task.name,
             file=fs.path.basename(artifact.get_archive_path()))
 
     @utils.retried.on_exception((RequestException, JoltError))
-    def download(self, node, force=False):
+    def download(self, artifact, force=False):
         if self._disabled:
             return False
         if not self._download and not force:
             return False
-        with self._cache.get_artifact(node) as artifact:
-            url = self._get_url(node, artifact)
-            if node.tools.download(url, artifact.get_archive_path(), exceptions=False, timeout=TIMEOUT):
-                return True
-        return False
+        url = self._get_url(artifact)
+        return artifact.tools.download(
+            url,
+            artifact.get_archive_path(),
+            exceptions=False,
+            timeout=TIMEOUT)
 
     def download_enabled(self):
         return not self._disabled and self._download
 
     @utils.retried.on_exception((RequestException))
-    def upload(self, node, force=False):
+    def upload(self, artifact, force=False):
         if self._disabled:
             return True
         if not self._upload and not force:
             return True
-        with self._cache.get_artifact(node) as artifact:
-            url = self._get_url(node, artifact)
-            archive = artifact.get_archive()
-            return node.tools.upload(
-                archive, url,
-                exceptions=False,
-                auth=self._get_auth(),
-                timeout=TIMEOUT)
-        return False
+        url = self._get_url(artifact)
+        archive = artifact.get_archive()
+        return artifact.tools.upload(
+            archive, url,
+            exceptions=False,
+            auth=self._get_auth(),
+            timeout=TIMEOUT)
 
     def upload_enabled(self):
         return not self._disabled and self._upload
 
     @utils.retried.on_exception((RequestException))
-    def location(self, node):
+    def location(self, artifact):
         if self._disabled:
             return False
-        with self._cache.get_artifact(node) as artifact:
-            from requests.api import head
-
-            url = self._get_url(node, artifact)
-            try:
-                response = head(url, stream=True, timeout=TIMEOUT_HEAD)
-            except ConnectTimeout:
-                self._disabled = True
-                log.warning("[HTTP] failed to establish server connection, disabled")
-                return False
-
-            log.debug("[HTTP] Head: {0}", url)
-            log.debug("[HTTP] Response: {0}", response.status_code)
-            return url if response.status_code == 200 else ''
-        return False
+
+        url = self._get_url(artifact)
+        try:
+            response = tools.http_session.head(url, stream=True, timeout=TIMEOUT_HEAD, auth=self._get_auth())
+        except ConnectTimeout:
+            self._disabled = True
+            log.warning("[HTTP] failed to establish server connection, disabled")
+            return False
+
+        log.debug("[HTTP] Head ({}): {}", response.status_code, url)
+        url = urlunparse(urlparse(url))
+        return url if response.status_code == 200 else ''
 
 
 @cache.RegisterStorage

jolt/plugins/libtool.py

@@ -0,0 +1,63 @@
+from jolt import attributes
+
+
+class Libtool(object):
+    def __init__(self, tools):
+        self.tools = tools
+
+    def relocate(self, artifact, dirs=["lib"], prefix=None):
+        prefix = str(artifact.strings.install_prefix) if prefix is None else prefix
+        for dir in dirs:
+            with self.tools.cwd(artifact.path, dir):
+                for file in self.tools.glob("*.la"):
+                    self.tools.replace_in_file(file, prefix, artifact.final_path)
+
+
+def relocate(dirs=["lib"]):
+    """
+    Relocate libtool archive files (.la) published by task.
+
+    When an artifact is published, all .la files found in the specified
+    directories will have their install prefix updated to the artifact's final path.
+    The original install prefix is stored in the artifact's strings metadata
+    under the key 'libtool_prefix' for use during unpacking.
+
+      :param dirs: List of directories inside the artifact to relocate .la files in.
+
+    """
+
+    def decorate(cls):
+        original_publish = cls.publish
+        original_unpack = cls.unpack
+
+        def publish(self, artifact, tools):
+            original_publish(self, artifact, tools)
+            lt = Libtool(tools)
+            lt.relocate(artifact, dirs, prefix=artifact.strings.install_prefix)
+            artifact.libtool_prefix = artifact.final_path
+
+        def unpack(self, artifact, tools):
+            original_unpack(self, artifact, tools)
+            lt = Libtool(tools)
+            lt.relocate(artifact, dirs, prefix=artifact.strings.libtool_prefix)
+            artifact.strings.libtool_prefix = None
+
+        cls.publish = publish
+        cls.unpack = unpack
+
+        return cls
+
+    return decorate
+
+
+def requires():
+    """ Decorator to add Libtool requirement to a task. """
+
+    import jolt.pkgs.libtool
+
+    def decorate(cls):
+        cls = attributes.requires("requires_libtool")(cls)
+        cls.requires_libtool = ["libtool"]
+        return cls
+
+    return decorate