[MRG+1] Split julia support into pre julia 1.0 and post julia 1.0

repo2docker/app.py

@@ -30,7 +30,7 @@
 from . import __version__
 from .buildpacks import (
     PythonBuildPack, DockerBuildPack, LegacyBinderDockerBuildPack,
-    CondaBuildPack, JuliaBuildPack, RBuildPack, NixBuildPack
+    CondaBuildPack, JuliaBuildPack, JuliaLegacyBuildPack, RBuildPack, NixBuildPack
 )
 from . import contentproviders
 from .utils import ByteSpecification, chdir
@@ -86,6 +86,7 @@ def _default_log_level(self):
             LegacyBinderDockerBuildPack,
             DockerBuildPack,
             JuliaBuildPack,
+            JuliaLegacyBuildPack,
             NixBuildPack,
             RBuildPack,
             CondaBuildPack,

repo2docker/buildpacks/__init__.py

@@ -2,6 +2,7 @@
 from .python import PythonBuildPack
 from .conda import CondaBuildPack
 from .julia import JuliaBuildPack
+from .julialegacy import JuliaLegacyBuildPack
 from .docker import DockerBuildPack
 from .legacy import LegacyBinderDockerBuildPack
 from .r import RBuildPack

repo2docker/buildpacks/julia.py

@@ -0,0 +1,131 @@
+"""Generates a Dockerfile based on an input matrix for Julia"""
+import os
+import toml
+from .python import PythonBuildPack
+
+
+class JuliaBuildPack(PythonBuildPack):
+    """
+    Julia build pack which uses conda.
+    """
+
+    minor_julias = {
+        '1.0': '1.0.3',
+        '1.1': '1.1.0',
+    }
+    major_julias = {
+        '1': '1.1.0',
+    }
+
+    @property
+    def julia_version(self):
+        # TODO Read version out of the file
+        # TODO Handle JuliaProject.toml
+        project_toml = toml.load(self.binder_path('Project.toml'))
+        if 'compat' in project_toml:
+            if 'julia' in project_toml['compat']:
+                return project_toml['compat']['julia']
+        return self.major_julias['1']
+
+    def get_build_env(self):
+        """Get additional environment settings for Julia and Jupyter
+
+        Returns:
+            an ordered list of environment setting tuples
+
+            The tuples contain a string of the environment variable name and
+            a string of the environment setting:
+            - `JULIA_PATH`: base path where all Julia Binaries and libraries
+                will be installed
+            - `JULIA_HOME`: path where all Julia Binaries will be installed
+            - `JULIA_PKGDIR`: path where all Julia libraries will be installed
+            - `JULIA_DEPOT_PATH`: path where Julia libraries are installed.
+                                  Similar to JULIA_PKGDIR, used in 1.0.
+            - `JULIA_VERSION`: default version of julia to be installed
+            - `JUPYTER`: environment variable required by IJulia to point to
+                the `jupyter` executable
+
+            For example, a tuple may be `('JULIA_VERSION', '0.6.0')`.
+
+        """
+        return super().get_build_env() + [
+            ('JULIA_PATH', '${APP_BASE}/julia'),
+            ('JULIA_HOME', '${JULIA_PATH}/bin'),  # julia <= 0.6
+            ('JULIA_BINDIR', '${JULIA_HOME}'),  # julia >= 0.7
+            ('JULIA_PKGDIR', '${JULIA_PATH}/pkg'),
+            ('JULIA_DEPOT_PATH', '${JULIA_PKGDIR}'), # julia >= 0.7
+            ('JULIA_VERSION', self.julia_version),
+            ('JUPYTER', '${NB_PYTHON_PREFIX}/bin/jupyter')
+        ]
+
+    def get_path(self):
+        """Adds path to Julia binaries to user's PATH.
+
+         Returns:
+             an ordered list of path strings. The path to the Julia
+             executable is added to the list.
+
+        """
+        return super().get_path() + ['${JULIA_HOME}']
+
+    def get_build_scripts(self):
+        """
+        Return series of build-steps common to "ALL" Julia repositories
+
+        All scripts found here should be independent of contents of a
+        particular repository.
+
+        This creates a directory with permissions for installing julia packages
+        (from get_assemble_scripts).
+
+        """
+        return super().get_build_scripts() + [
+            (
+                "root",
+                r"""
+                mkdir -p ${JULIA_PATH} && \
+                curl -sSL "https://julialang-s3.julialang.org/bin/linux/x64/${JULIA_VERSION%[.-]*}/julia-${JULIA_VERSION}-linux-x86_64.tar.gz" | tar -xz -C ${JULIA_PATH} --strip-components 1
+                """
+            ),
+            (
+                "root",
+                r"""
+                mkdir -p ${JULIA_PKGDIR} && \
+                chown ${NB_USER}:${NB_USER} ${JULIA_PKGDIR}
+                """
+            ),
+        ]            
+
+    def get_assemble_scripts(self):
+        """
+        Return series of build-steps specific to "this" Julia repository
+
+        Instantiate and then precompile all packages in the repos julia
+        environment.
+
+        The parent, CondaBuildPack, will add the build steps for
+        any needed Python packages found in environment.yml.
+        """
+        return super().get_assemble_scripts() + [
+            (
+                "${NB_USER}",
+                r"""
+                julia -e "using Pkg; Pkg.add(\"IJulia\"); using IJulia; installkernel(\"Julia\", \"--project=${REPO_DIR}\", env=Dict(\"JUPYTER_DATA_DIR\"=>\"${NB_PYTHON_PREFIX}/share/jupyter\"));" && \
+                julia --project=${REPO_DIR} -e 'using Pkg; Pkg.instantiate(); pkg"precompile"'
+                """
+            )
+        ]
+
+    def detect(self):
+        """
+        Check if current repo should be built with the Julia Build pack
+
+        super().detect() is not called in this function - it would return
+        false unless an `environment.yml` is present and we do not want to
+        require the presence of a `environment.yml` to use Julia.
+
+        Instead we just check if the path to `Project.toml` or
+        `JuliaProject.toml` exists.
+
+        """
+        return os.path.exists(self.binder_path('Project.toml')) or os.path.exists(self.binder_path('JuliaProject.toml'))

repo2docker/buildpacks/julia/__init__.py → repo2docker/buildpacks/julialegacy/__init__.py

@@ -3,7 +3,7 @@
 from ..python import PythonBuildPack
 
 
-class JuliaBuildPack(PythonBuildPack):
+class JuliaLegacyBuildPack(PythonBuildPack):
     """
     Julia build pack which uses conda.
     """
@@ -150,21 +150,21 @@ def get_assemble_scripts(self):
 
     def get_build_script_files(self):
         files = {
-            'julia/install-repo-dependencies.jl': '/tmp/install-repo-dependencies.jl',
+            'julialegacy/install-repo-dependencies.jl': '/tmp/install-repo-dependencies.jl',
         }
         files.update(super().get_build_script_files())
         return files
 
     def detect(self):
         """
-        Check if current repo should be built with the Julia Build pack
+        Check if current repo should be built with the Julia Legacy Build pack
 
         super().detect() is not called in this function - it would return
         false unless an `environment.yml` is present and we do not want to
         require the presence of a `environment.yml` to use Julia.
 
-        Instead we just check if the path to `REQUIRE` exists
+        Instead we just check if the path to `REQUIRE` exists and that there is
+        no julia 1.0 style environment
 
         """
-        # TODO(nhdaly): Add support for Project.toml here as well.
-        return os.path.exists(self.binder_path('REQUIRE'))
+        return os.path.exists(self.binder_path('REQUIRE')) and not(os.path.exists(self.binder_path('Project.toml')) or os.path.exists(self.binder_path('JuliaProject.toml')))

setup.py

@@ -18,6 +18,7 @@
         'escapism',
         'jinja2',
         'ruamel.yaml>=0.15',
+        'toml',
     ],
     python_requires='>=3.4',
     author='Project Jupyter Contributors',

tests/julia/julia_version-1.1/Project.toml

@@ -0,0 +1,2 @@
+[deps]
+IteratorInterfaceExtensions = "82899510-4779-5014-852e-03e436cf321d"

tests/julia/julia_version-1.1/README.rst

@@ -1,5 +1,4 @@
-Julia - REQUIRE: test version for julia v1.1
+Julia - Project.toml: test version for julia v1.1
 ---------------
 
-Starting with julia v0.7 and up, the package manager has changed, so this tests
-that the julia version can be specified and packages installed correctly.
+Test a Project.toml file for julia.

tests/julia/julia_version-1.1/verify

@@ -1,17 +1,17 @@
 #!/usr/bin/env julia
 # Verify the version:
-if VERSION < v"1.1" || VERSION >= v"1.2"
+if VERSION < v"1" || VERSION >= v"2"
     exit(1)
 end
 
-try
-    # Test that the package was installed.
-    using Compat
+# try
+#     # Test that the package was installed.
+#     using IteratorInterfaceExtensions
 
-    # Verify that the environment variables are set correctly for julia 1.0+
-    @assert "julia" ∈ readdir(Sys.BINDIR)
-catch
-    exit(1)
-end
+#     # Verify that the environment variables are set correctly for julia 1.0+
+#     @assert "julia" ∈ readdir(Sys.BINDIR)
+# catch
+#     exit(1)
+# end
 
 exit(0)

tests/julia/julialegacy_version-1.1/README.rst

@@ -0,0 +1,5 @@
+Julia - REQUIRE: test version for julia v1.1
+---------------
+
+Starting with julia v0.7 and up, the package manager has changed, so this tests
+that the julia version can be specified and packages installed correctly.

tests/julia/julialegacy_version-1.1/verify

@@ -0,0 +1,17 @@
+#!/usr/bin/env julia
+# Verify the version:
+if VERSION < v"1.1" || VERSION >= v"1.2"
+    exit(1)
+end
+
+try
+    # Test that the package was installed.
+    using Compat
+
+    # Verify that the environment variables are set correctly for julia 1.0+
+    @assert "julia" ∈ readdir(Sys.BINDIR)
+catch
+    exit(1)
+end
+
+exit(0)