def build(container_format='singularity', os_release='ubuntu', os_version='20.04', gpu=True, cuda_version='11.0', desktop=True):
config.set_container_format(container_format)
if gpu:
image = f'nvcr.io/nvidia/cuda:{cuda_version}-devel-{os_release}{os_version}'
else:
image = f'{os_release}:{os_version}'
stage0 = Stage(name='stage0')
stage0 += baseimage(image=image, _bootstrap='docker')
stage0 += environment(variables={
'LC_ALL': 'en_AU.UTF-8',
'LANGUAGE': 'en_AU.UTF-8',
})
stage0 += label(metadata={'maintainer': 'Luhan Cheng', 'email': '*****@*****.**'})
stage0 += shell(commands=[
'rm -f /bin/sh && ln -s /bin/bash /bin/sh',
'rm -f /usr/bin/sh && ln -s /usr/bin/bash /usr/bin/sh',
'/bin/bash',
])
if gpu:
stage0 += environment(variables=from_prefix('/usr/local/cuda'))
stage0 += packages(apt=['wget', 'git', 'software-properties-common', 'build-essential', 'locales', 'zlib1g-dev'])
stage0 += shell(commands=['locale-gen en_AU.UTF-8'])
if desktop:
stage0 += comment('Installing vglrun and TurboVNC')
stage0 += packages(apt=['ubuntu-desktop', 'vim', 'mesa-utils', 'python3-pip', 'python3-pyqt5', 'pyqt5-dev', 'python3-tk'])
stage0 += shell(commands=[
'wget https://swift.rc.nectar.org.au/v1/AUTH_810/CVL-Singularity-External-Files/turbovnc_2.2.5_amd64.deb && dpkg -i turbovnc_2.2.5_amd64.deb && rm turbovnc_2.2.5_amd64.deb',
'wget https://swift.rc.nectar.org.au/v1/AUTH_810/CVL-Singularity-External-Files/virtualgl_2.6.4_amd64.deb && dpkg -i virtualgl_2.6.4_amd64.deb && rm virtualgl_2.6.4_amd64.deb',
'apt update',
'apt -y upgrade'
])
return stage0
def build(container_format='singularity',
os_release='ubuntu',
os_version='20.04'):
config.set_container_format(container_format)
image = f'{os_release}:{os_version}'
stage0 = Stage(name='stage0')
stage0 += baseimage(image=image, _bootstrap='docker')
stage0 += environment(variables={
'LC_ALL': 'en_AU.UTF-8',
'LANGUAGE': 'en_AU.UTF-8',
})
stage0 += label(metadata={
'maintainer': 'Luhan Cheng',
'email': '*****@*****.**'
})
stage0 += shell(commands=[
'rm -f /bin/sh && ln -s /bin/bash /bin/sh',
'rm -f /usr/bin/sh && ln -s /usr/bin/bash /usr/bin/sh',
'/bin/bash',
])
stage0 += packages(apt=[
'wget', 'git', 'software-properties-common', 'build-essential',
'locales', 'zlib1g-dev'
])
stage0 += shell(commands=['locale-gen en_AU.UTF-8'])
stage0 += comment('Installing vglrun and TurboVNC')
stage0 += packages(apt=[
'ubuntu-desktop', 'vim', 'mesa-utils', 'python3-pip', 'python3-pyqt5',
'pyqt5-dev', 'python3-tk'
])
stage0 += shell(commands=[
'wget https://swift.rc.nectar.org.au/v1/AUTH_810/CVL-Singularity-External-Files/turbovnc_2.2.5_amd64.deb && dpkg -i turbovnc_2.2.5_amd64.deb && rm turbovnc_2.2.5_amd64.deb',
'wget https://swift.rc.nectar.org.au/v1/AUTH_810/CVL-Singularity-External-Files/virtualgl_2.6.4_amd64.deb && dpkg -i virtualgl_2.6.4_amd64.deb && rm virtualgl_2.6.4_amd64.deb',
'apt update', 'apt -y upgrade'
])
# coin3d
stage0 += packages(apt=[
'mesa-common-dev', 'libglu1-mesa-dev', 'freeglut3-dev', 'autoconf',
'autogen', 'doxygen'
])
compiler = gnu(version="10")
stage0 += compiler
stage0 += boost()
stage0 += generic_cmake(
repository="https://github.com/coin3d/coin",
recursive=True,
cmake_opts=[
'-G "Unix Makefiles"', "-DCMAKE_BUILD_TYPE=Release",
"-DCOIN_BUILD_DOCUMENTATION=OFF",
"-DCMAKE_INSTALL_PREFIX=/usr/local/coin3d"
],
postinstall=['cd cpack.d', 'cpack --config debian.cmake'])
return stage0
def build(container_format='singularity',
os_release='ubuntu',
os_version='20.04',
cuda_version='11.0'):
config.set_container_format(container_format)
image = f'nvcr.io/nvidia/cuda:{cuda_version}-devel-{os_release}{os_version}'
stage0 = Stage(name='stage0')
stage0 += baseimage(image=image, _bootstrap='docker')
stage0 += environment(variables={
'LC_ALL': 'en_AU.UTF-8',
'LANGUAGE': 'en_AU.UTF-8',
})
stage0 += label(metadata={
'maintainer': 'Luhan Cheng',
'email': '*****@*****.**'
})
stage0 += shell(commands=[
'rm -f /bin/sh && ln -s /bin/bash /bin/sh',
'rm -f /usr/bin/sh && ln -s /usr/bin/bash /usr/bin/sh',
'/bin/bash',
])
stage0 += environment(variables=from_prefix('/usr/local/cuda'))
stage0 += packages(apt=[
'wget', 'git', 'software-properties-common', 'build-essential',
'locales', 'zlib1g-dev'
])
stage0 += shell(commands=['locale-gen en_AU.UTF-8'])
stage0 += comment('Installing vglrun and TurboVNC')
stage0 += packages(apt=[
'ubuntu-desktop', 'vim', 'mesa-utils', 'python3-pip', 'python3-pyqt5',
'pyqt5-dev', 'python3-tk'
])
stage0 += shell(commands=[
'wget https://swift.rc.nectar.org.au/v1/AUTH_810/CVL-Singularity-External-Files/turbovnc_2.2.5_amd64.deb && dpkg -i turbovnc_2.2.5_amd64.deb && rm turbovnc_2.2.5_amd64.deb',
'wget https://swift.rc.nectar.org.au/v1/AUTH_810/CVL-Singularity-External-Files/virtualgl_2.6.4_amd64.deb && dpkg -i virtualgl_2.6.4_amd64.deb && rm virtualgl_2.6.4_amd64.deb',
'apt update', 'apt -y upgrade'
])
stage0 += packages(apt=[
"qt5-qmake", 'qtmultimedia5-dev', 'libqt5multimediawidgets5',
'libqt5multimedia5-plugins', 'libqt5multimedia5', 'libglew-dev',
'glew-utils', 'libqglviewer-dev-qt5', 'libnetcdf-dev',
'libnetcdf-cxx-legacy-dev', 'freeglut3-dev', 'libassimp-dev'
])
stage0 += shell(commands=[
'mkdir -p /opt/', "cd /opt",
'git clone --branch v-2.7linux https://github.com/nci/drishti.git',
'cd drishti/drishti', 'qmake -qt=5',
'export LDFLAGS="$LDFLAGS -L/usr/lib/x86_64-linux-gnu/ -lassimp"',
'ln -s /usr/lib/x86_64-linux-gnu/libQGLViewer-qt5.so /usr/lib/x86_64-linux-gnu/libQGLViewer.so',
'make'
])
return stage0
def build(container_format='singularity',
os_release='ubuntu',
os_version='20.04'):
config.set_container_format(container_format)
image = f'{os_release}:{os_version}'
stage0 = Stage(name='stage0')
stage0 += baseimage(image=image, _bootstrap='docker')
stage0 += environment(variables={
'LC_ALL': 'en_AU.UTF-8',
'LANGUAGE': 'en_AU.UTF-8',
})
stage0 += label(metadata={
'maintainer': 'Luhan Cheng',
'email': '*****@*****.**'
})
stage0 += shell(commands=[
'rm -f /bin/sh && ln -s /bin/bash /bin/sh',
'rm -f /usr/bin/sh && ln -s /usr/bin/bash /usr/bin/sh', '/bin/bash',
'ln -s /usr/lib/x86_64-linux-gnu/libffi.so.7 /usr/lib/x86_64-linux-gnu/libffi.so.6'
])
stage0 += packages(apt=[
'wget', 'git', 'software-properties-common', 'build-essential',
'locales', 'zlib1g-dev'
])
stage0 += shell(commands=['locale-gen en_AU.UTF-8'])
stage0 += comment('Installing vglrun and TurboVNC')
stage0 += packages(apt=[
'ubuntu-desktop', 'vim', 'mesa-utils', 'python3-pip', 'python3-pyqt5',
'pyqt5-dev', 'python3-tk'
])
stage0 += shell(commands=[
'wget https://swift.rc.nectar.org.au/v1/AUTH_810/CVL-Singularity-External-Files/turbovnc_2.2.5_amd64.deb && dpkg -i turbovnc_2.2.5_amd64.deb && rm turbovnc_2.2.5_amd64.deb',
'wget https://swift.rc.nectar.org.au/v1/AUTH_810/CVL-Singularity-External-Files/virtualgl_2.6.4_amd64.deb && dpkg -i virtualgl_2.6.4_amd64.deb && rm virtualgl_2.6.4_amd64.deb',
'apt update', 'apt -y upgrade'
])
stage0 += primitives.copy(src='./ChimeraX-1.2.5.tar.gz',
dest='/opt/ChimeraX-1.2.5.tar.gz')
stage0 += shell(commands=[
'tar xfv /opt/ChimeraX-1.2.5.tar.gz -C /opt',
'rm /opt/ChimeraX-1.2.5.tar.gz'
])
stage0 += environment(
variables=from_prefix('/opt/chimerax-1.2.5-rc-2021.05.24'))
return stage0
def build(container_format='singularity', os_release='ubuntu', os_version='20.04'):
config.set_container_format(container_format)
image = f'{os_release}:{os_version}'
stage0 = Stage(name='stage0')
stage0 += baseimage(image=image, _bootstrap='docker')
stage0 += environment(variables={
'LC_ALL': 'en_AU.UTF-8',
'LANGUAGE': 'en_AU.UTF-8',
})
stage0 += label(metadata={'maintainer': 'Luhan Cheng', 'email': '*****@*****.**'})
stage0 += shell(commands=[
'rm -f /bin/sh && ln -s /bin/bash /bin/sh',
'rm -f /usr/bin/sh && ln -s /usr/bin/bash /usr/bin/sh',
'/bin/bash',
])
stage0 += packages(apt=['wget', 'git', 'software-properties-common', 'build-essential', 'locales', 'zlib1g-dev', 'bc', 'cmake',
'bison', 'flex', 'libx11-dev', 'x11proto-core-dev', 'libxi6', 'libxi-dev', 'libxmu6', 'libxmu-dev',
'libxmu-headers', 'libgl1-mesa-dev', 'libglu1-mesa-dev', 'libjpeg-dev', 'libevent-dev', 'libncurses-dev',
'pkg-config', 'libopenblas-dev'])
stage0 += shell(commands=['locale-gen en_AU.UTF-8'])
stage0 += comment('Installing vglrun and TurboVNC')
stage0 += packages(apt=['ubuntu-desktop', 'vim', 'mesa-utils', 'python3-pip', 'python3-pyqt5', 'pyqt5-dev', 'python3-tk'])
stage0 += shell(commands=[
'wget https://swift.rc.nectar.org.au/v1/AUTH_810/CVL-Singularity-External-Files/turbovnc_2.2.5_amd64.deb && dpkg -i turbovnc_2.2.5_amd64.deb && rm turbovnc_2.2.5_amd64.deb',
'wget https://swift.rc.nectar.org.au/v1/AUTH_810/CVL-Singularity-External-Files/virtualgl_2.6.4_amd64.deb && dpkg -i virtualgl_2.6.4_amd64.deb && rm virtualgl_2.6.4_amd64.deb',
'apt update',
'apt -y upgrade'
])
stage0 += generic_cmake(
repository='https://github.com/BIC-MNI/minc-toolkit-v2.git',
branch='release-1.9.18.1',
recursive=True,
prefix='/opt/minc/1.9.18',
preconfigure=['sed -i -e \'s/http\:\/\/mirrors\.ibiblio\.org\/gnu\/ftp\/gnu\/gsl/http\:\/\/ftp\.\sun\.ac\.za\/ftp\/pub\/mirrors\/ftp\.gnu\.org\/gsl/g\' cmake-modules/BuildGSL.cmake', ],
cmake_opts=['-DCMAKE_BUILD_TYPE:STRING=Release', '-DCMAKE_INSTALL_PREFIX:PATH=/opt/minc/1.9.18', '-DMT_BUILD_ABC:BOOL=ON',
'-DMT_BUILD_ANTS:BOOL=ON', '-DMT_BUILD_C3D:BOOL=ON', '-DMT_BUILD_ELASTIX:BOOL=ON', '-DMT_BUILD_IM:BOOL=OFF',
'-DMT_BUILD_ITK_TOOLS:BOOL=ON', '-DMT_BUILD_LITE:BOOL=OFF', '-DMT_BUILD_SHARED_LIBS:BOOL=ON', '-DMT_BUILD_VISUAL_TOOLS:BOOL=ON',
'-DMT_USE_OPENMP:BOOL=ON', '-DUSE_SYSTEM_FFTW3D:BOOL=OFF', '-DUSE_SYSTEM_FFTW3F:BOOL=OFF', '-DUSE_SYSTEM_GLUT:BOOL=OFF',
'-DUSE_SYSTEM_GSL:BOOL=OFF', '-DUSE_SYSTEM_HDF5:BOOL=OFF', '-DUSE_SYSTEM_ITK:BOOL=OFF', '-DUSE_SYSTEM_NETCDF:BOOL=OFF',
'-DUSE_SYSTEM_NIFTI:BOOL=OFF', '-DUSE_SYSTEM_PCRE:BOOL=OFF', '-DUSE_SYSTEM_ZLIB:BOOL=OFF']
)
stage0 += environment(variables=from_prefix('/opt/minc/1.9.18.1'))
return stage0
def build(container_format='singularity',
os_release='ubuntu',
os_version='20.04'):
config.set_container_format(container_format)
image = f'{os_release}:{os_version}'
stage0 = Stage(name='stage0')
stage0 += baseimage(image=image, _bootstrap='docker')
stage0 += environment(variables={
'LC_ALL': 'en_AU.UTF-8',
'LANGUAGE': 'en_AU.UTF-8',
})
stage0 += label(metadata={
'maintainer': 'Luhan Cheng',
'email': '*****@*****.**'
})
stage0 += shell(commands=[
'rm -f /bin/sh && ln -s /bin/bash /bin/sh',
'rm -f /usr/bin/sh && ln -s /usr/bin/bash /usr/bin/sh',
'/bin/bash',
])
stage0 += packages(apt=[
'wget', 'git', 'software-properties-common', 'build-essential',
'locales', 'zlib1g-dev'
])
stage0 += shell(commands=['locale-gen en_AU.UTF-8'])
stage0 += comment('Installing vglrun and TurboVNC')
stage0 += packages(apt=[
'ubuntu-desktop', 'vim', 'mesa-utils', 'python3-pip', 'python3-pyqt5',
'pyqt5-dev', 'python3-tk', 'cmake', 'libgtk2.0-dev', 'libasound2-dev',
'libavformat-dev', 'libjack-jackd2-dev', 'uuid-dev'
])
stage0 += shell(commands=[
'wget https://swift.rc.nectar.org.au/v1/AUTH_810/CVL-Singularity-External-Files/turbovnc_2.2.5_amd64.deb && dpkg -i turbovnc_2.2.5_amd64.deb && rm turbovnc_2.2.5_amd64.deb',
'wget https://swift.rc.nectar.org.au/v1/AUTH_810/CVL-Singularity-External-Files/virtualgl_2.6.4_amd64.deb && dpkg -i virtualgl_2.6.4_amd64.deb && rm virtualgl_2.6.4_amd64.deb',
'apt update', 'apt -y upgrade'
])
stage0 += shell(commands=['pip install conan'])
stage0 += generic_cmake(repository='https://github.com/audacity/audacity/',
branch='Audacity-3.0.5')
return stage0
def build(container_format='singularity', os_release='ubuntu', os_version='20.04'):
config.set_container_format(container_format)
image = f'{os_release}:{os_version}'
stage0 = Stage(name='stage0')
stage0 += baseimage(image=image, _bootstrap='docker')
stage0 += environment(variables={
'LC_ALL': 'en_AU.UTF-8',
'LANGUAGE': 'en_AU.UTF-8',
})
stage0 += label(metadata={'maintainer': 'Luhan Cheng', 'email': '*****@*****.**'})
stage0 += shell(commands=['rm /usr/bin/sh', 'ln -s /usr/bin/bash /usr/bin/sh', '/usr/bin/bash'])
stage0 += packages(apt=['wget', 'git', 'software-properties-common', 'build-essential', 'locales', 'zlib1g-dev'])
stage0 += shell(commands=['locale-gen en_AU.UTF-8'])
stage0 += comment('Installing vglrun and TurboVNC')
stage0 += packages(apt=['ubuntu-desktop', 'vim', 'mesa-utils', 'python3-pip', 'python3-pyqt5', 'pyqt5-dev', 'python3-tk'])
stage0 += shell(commands=[
'wget https://swift.rc.nectar.org.au/v1/AUTH_810/CVL-Singularity-External-Files/turbovnc_2.2.5_amd64.deb && dpkg -i turbovnc_2.2.5_amd64.deb && rm turbovnc_2.2.5_amd64.deb',
'wget https://swift.rc.nectar.org.au/v1/AUTH_810/CVL-Singularity-External-Files/virtualgl_2.6.4_amd64.deb && dpkg -i virtualgl_2.6.4_amd64.deb && rm virtualgl_2.6.4_amd64.deb',
'apt update',
'apt -y upgrade'
])
stage0 += shell(commands=[
'curl -sL https://deb.nodesource.com/setup_12.x | bash -',
'apt install -y nodejs npm'
])
prefix = '/var/www'
stage0 += shell(commands=[
f'mkdir {prefix} && cd {prefix}',
'git clone --branch 1.16.10-release https://github.com/gmod/jbrowse .',
'./setup.sh',
])
stage0 += environment(variables={
'PATH': f'{prefix}/bin:$PATH'
})
stage0 += runscript(commands=[
f'cd {prefix}',
'npm run start $*'
])
return stage0
def build(container_format='singularity', os_release='ubuntu', os_version='20.04', cuda_version='11.0'):
config.set_container_format(container_format)
image = f'{os_release}:{os_version}'
stage0 = Stage(name='stage0')
stage0 += baseimage(image=image, _bootstrap='docker')
stage0 += environment(variables={
'LC_ALL': 'en_AU.UTF-8',
'LANGUAGE': 'en_AU.UTF-8',
})
stage0 += label(metadata={'maintainer': 'Luhan Cheng', 'email': '*****@*****.**'})
stage0 += shell(commands=['rm /usr/bin/sh', 'ln -s /usr/bin/bash /usr/bin/sh', '/usr/bin/bash'])
stage0 += packages(apt=['wget', 'git', 'software-properties-common', 'build-essential', 'locales'])
stage0 += shell(commands=['locale-gen en_AU.UTF-8'])
stage0 += comment('Installing vglrun and TurboVNC')
stage0 += packages(apt=['ubuntu-desktop', 'vim', 'mesa-utils', 'python3-pip', 'python3-pyqt5', 'pyqt5-dev', 'python3-tk'])
stage0 += shell(commands=[
'wget https://swift.rc.nectar.org.au/v1/AUTH_810/CVL-Singularity-External-Files/turbovnc_2.2.5_amd64.deb && dpkg -i turbovnc_2.2.5_amd64.deb && rm turbovnc_2.2.5_amd64.deb',
'wget https://swift.rc.nectar.org.au/v1/AUTH_810/CVL-Singularity-External-Files/virtualgl_2.6.4_amd64.deb && dpkg -i virtualgl_2.6.4_amd64.deb && rm virtualgl_2.6.4_amd64.deb',
'apt update',
'apt -y upgrade'
])
stage0 += conda(
eula=True,
packages=['python=3.8.5', 'openjdk', 'pip'],
)
stage0 += environment(variables=from_prefix('/usr/local/anaconda'))
stage0 += shell(commands=['pip install --upgrade minerl'])
stage0 += shell(commands=[
'wget https://launcher.mojang.com/download/Minecraft.deb && dpkg -i Minecraft.deb && rm Minecraft.deb',
])
stage0 += runscript(commands=['source /usr/local/anaconda/etc/profile.d/conda.sh', '/usr/local/anaconda/bin/python3 $*'])
return stage0
def build(container_format='singularity',
os_release='ubuntu',
os_version='20.04',
cuda_version='11.0.3'):
config.set_container_format(container_format)
# image = f'{os_release}:{os_version}'
image = f'nvcr.io/nvidia/cuda:{cuda_version}-devel-{os_release}{os_version}'
stage0 = Stage(name='stage0')
stage0 += baseimage(image=image, _bootstrap='docker')
stage0 += environment(variables={
'LC_ALL': 'en_AU.UTF-8',
'LANGUAGE': 'en_AU.UTF-8',
})
stage0 += label(metadata={
'maintainer': 'Luhan Cheng',
'email': '*****@*****.**'
})
stage0 += shell(commands=[
'rm -f /bin/sh && ln -s /bin/bash /bin/sh',
'rm -f /usr/bin/sh && ln -s /usr/bin/bash /usr/bin/sh',
'/bin/bash',
])
stage0 += packages(apt=[
'wget', 'git', 'software-properties-common', 'build-essential',
'locales', 'zlib1g-dev'
])
stage0 += shell(commands=['locale-gen en_AU.UTF-8'])
stage0 += packages(apt=[
'freeglut3-dev', 'build-essential', 'libx11-dev', 'libxmu-dev',
'libxi-dev', 'libglu1-mesa', 'libglu1-mesa-dev', 'mesa-utils',
'libgl1-mesa-glx'
])
stage0 += environment(variables=from_prefix('/usr/local/cuda'))
stage0 += comment('Installing vglrun and TurboVNC')
stage0 += packages(apt=[
'ubuntu-desktop', 'vim', 'mesa-utils', 'python3-pip', 'python3-pyqt5',
'pyqt5-dev', 'python3-tk'
])
stage0 += shell(commands=[
'wget https://swift.rc.nectar.org.au/v1/AUTH_810/CVL-Singularity-External-Files/turbovnc_2.2.5_amd64.deb && dpkg -i turbovnc_2.2.5_amd64.deb && rm turbovnc_2.2.5_amd64.deb',
'wget https://swift.rc.nectar.org.au/v1/AUTH_810/CVL-Singularity-External-Files/virtualgl_2.6.4_amd64.deb && dpkg -i virtualgl_2.6.4_amd64.deb && rm virtualgl_2.6.4_amd64.deb',
'apt update', 'apt -y upgrade'
])
stage0 += packages(apt=[
'make', 'libopenmpi-dev', 'python3-tk', 'libfftw3-dev', 'libhdf5-dev',
'libtiff-dev', 'libjpeg-dev', 'libsqlite3-dev', 'openjdk-8-jdk'
])
stage0 += environment(
variables={
'LD_LIBRARY_PATH':
"$LD_LIBRARY_PATH:/usr/lib/x86_64-linux-gnu/hdf5/serial",
})
prefix = '/usr/local/scipion'
stage0 += shell(commands=[
'python3 -m pip install --user scipion-installer',
f'python3 -m scipioninstaller {prefix} -j 4'
])
stage0 += environment(variables=from_prefix(prefix))
return stage0
def build(container_format='singularity',
openmpi_version='2.0.4',
gnu_version='10',
cfdem_prefix='/usr/local/cfdem',
cfdem_version='3.8.0',
liggghts_prefix='/usr/local/ligghts',
lpp_prefix='/usr/local/lpp',
image='ubuntu:20.04',
mlton_version='on-20210117-release',
gmp_version='6.2.1'):
config.set_container_format(container_format)
stage0 = Stage(name='stage0')
stage0 += baseimage(image=image, _bootstrap='docker')
stage0 += label(metadata={
'maintainer': 'Luhan Cheng',
'email': '*****@*****.**'
})
stage0 += shell(commands=[
'rm /usr/bin/sh', 'ln -s /usr/bin/bash /usr/bin/sh', '/usr/bin/bash'
])
stage0 += packages(apt=[
'locales', 'wget', 'software-properties-common', 'git',
'build-essential', 'flex', 'bison', 'cmake', 'zlib1g-dev', 'gnuplot',
'libreadline-dev', 'libncurses-dev', 'libxt-dev', 'libscotch-dev',
'libptscotch-dev', 'libvtk6-dev', 'python-numpy', 'python-dev',
'qt5-default', 'git-core', 'libboost-system-dev',
'libboost-thread-dev', 'libqt5x11extras5-dev', 'qttools5-dev', 'curl',
'libgl1-mesa-dev', 'libosmesa6-dev', 'libssh2-1', 'libtool'
])
compilers = gnu(version=gnu_version)
stage0 += compilers
openmpi_building_block = openmpi(version=openmpi_version,
toolchain=compilers.toolchain,
cuda=False)
stage0 += openmpi_building_block
stage0 += generic_autotools(
url=f'https://gmplib.org/download/gmp/gmp-{gmp_version}.tar.xz',
prefix='/usr/local/gmp',
directory=f'gmp-{gmp_version}/',
)
stage0 += environment(variables=from_library('/usr/local/gmp'))
stage0 += generic_build(repository='https://github.com/MLton/mlton.git',
branch=mlton_version,
build=['make -j'],
install=['make PREFIX=/usr/local/mlton'])
if cfdem_version == '3.8.0':
OF_release = '5.x'
OF_commitHashtag = '538044ac05c4672b37c7df607dca1116fa88df88'
else:
raise Exception(
'Check https://github.com/CFDEMproject/CFDEMcoupling-PUBLIC/blob/master/src/lagrangian/cfdemParticle/cfdTools/versionInfo.H'
)
stage0 += comment('Obtain CFDEM source')
stage0 += shell(commands=[
f'mkdir -p {cfdem_prefix} {liggghts_prefix} {lpp_prefix}',
f'git clone --branch {cfdem_version} https://github.com/CFDEMproject/CFDEMcoupling-PUBLIC.git {cfdem_prefix}',
f'git clone --branch {cfdem_version} https://github.com/CFDEMproject/LIGGGHTS-PUBLIC.git {liggghts_prefix}',
f'git clone https://github.com/CFDEMproject/LPP.git {lpp_prefix}'
])
stage0 += comment('Install OpenFoam')
openfoam_prefix = f'/usr/local/OpenFOAM-{OF_release}'
thirdparty_prefix = f'/usr/local/ThirdParty-{OF_release}'
stage0 += shell(commands=[
f'mkdir -p {openfoam_prefix} {thirdparty_prefix}',
f'git clone https://github.com/OpenFOAM/OpenFOAM-{OF_release}.git {openfoam_prefix} && cd {openfoam_prefix} && git checkout {OF_commitHashtag}',
f'git clone https://github.com/OpenFOAM/ThirdParty-{OF_release}.git {thirdparty_prefix}',
])
stage0 += shell(commands=[
f'echo "source {openfoam_prefix}/etc/bashrc" >> ~/.bashrc',
])
# DLIB_PATH = '/usr/lib/x86_64-linux-gnu'
# INCLUDE_PATH = '/usr/include'
stage0 += shell_with_log(commands=[
f'{thirdparty_prefix}/Allwmake -j', # this breaks with openmpi >= 3, error: static assertion failed: "MPI_Type_extent was removed in MPI-3.0. Use MPI_Type_get_extent instead."
# f'{thirdparty_prefix}/makeParaView -mpi -mesa -mesa-lib {DLIB_PATH}/libOSMesa.so -mesa-include {INCLUDE_PATH}/GL -verbose',
f'{thirdparty_prefix}/makeParaView -mpi'
'wmRefresh'
])
stage0 += shell(commands=[
f'{openfoam_prefix}/Allwmake -j',
])
# /usr/bin/g++ -fPIC -O3 -DNDEBUG -Wl,--no-undefined -lc -shared -Wl,-soname,libvtkCommonSystem-pv5.4.so.1 -o ../../../lib/libvtkCommonSystem-pv5.4.so.1 CMakeFiles/vtkCommonSystem.dir/vtkClientSocket.cxx.o CMakeFiles/vtkCommonSystem.dir/vtkDirectory.cxx.o CMakeFiles/vtkCommonSystem.dir/vtkServerSocket.cxx.o CMakeFiles/vtkCommonSystem.dir/vtkSocket.cxx.o CMakeFiles/vtkCommonSystem.dir/vtkSocketCollection.cxx.o CMakeFiles/vtkCommonSystem.dir/vtkThreadMessager.cxx.o CMakeFiles/vtkCommonSystem.dir/vtkTimerLog.cxx.o -Wl,-rpath,/usr/local/ThirdParty-5.x/build/linux64Gcc/ParaView-5.4.0/lib: ../../../lib/libvtkCommonCore-pv5.4.so.1 ../../../lib/libvtksys-pv5.4.so.1 -lpthread -ldl
return stage0
def build(container_format='singularity',
os_release='ubuntu',
os_version='20.04',
cuda_version='11.0'):
config.set_container_format(container_format)
image = f'nvcr.io/nvidia/cuda:{cuda_version}-devel-{os_release}{os_version}'
stage0 = Stage(name='stage0')
stage0 += baseimage(image=image, _bootstrap='docker')
stage0 += environment(variables={
'LC_ALL': 'en_AU.UTF-8',
'LANGUAGE': 'en_AU.UTF-8',
})
stage0 += label(metadata={
'maintainer': 'Luhan Cheng',
'email': '*****@*****.**'
})
stage0 += shell(commands=[
'rm -f /bin/sh && ln -s /bin/bash /bin/sh',
'rm -f /usr/bin/sh && ln -s /usr/bin/bash /usr/bin/sh',
'/bin/bash',
])
stage0 += environment(variables=from_prefix('/usr/local/cuda'))
stage0 += packages(apt=[
'wget', 'git', 'software-properties-common', 'build-essential',
'locales', 'zlib1g-dev'
])
stage0 += shell(commands=['locale-gen en_AU.UTF-8'])
stage0 += comment('Installing vglrun and TurboVNC')
stage0 += packages(apt=[
'ubuntu-desktop', 'vim', 'mesa-utils', 'python3-pip', 'python3-pyqt5',
'pyqt5-dev', 'python3-tk'
])
stage0 += shell(commands=[
'wget https://swift.rc.nectar.org.au/v1/AUTH_810/CVL-Singularity-External-Files/turbovnc_2.2.5_amd64.deb && dpkg -i turbovnc_2.2.5_amd64.deb && rm turbovnc_2.2.5_amd64.deb',
'wget https://swift.rc.nectar.org.au/v1/AUTH_810/CVL-Singularity-External-Files/virtualgl_2.6.4_amd64.deb && dpkg -i virtualgl_2.6.4_amd64.deb && rm virtualgl_2.6.4_amd64.deb',
'apt update', 'apt -y upgrade'
])
stage0 += comment('Installing pre-requisites')
stage0 += primitives.copy(
src="./ccp4-7.1.014-shelx-arpwarp-linux64.tar.gz",
dest="/opt/ccp4-7.1.014-shelx-arpwarp-linux64.tar.gz")
stage0 += shell(commands=[
'cd /opt && tar -xf ccp4-7.1.014-shelx-arpwarp-linux64.tar.gz && rm ccp4-7.1.014-shelx-arpwarp-linux64.tar.gz',
'touch $HOME/.agree2ccp4v6',
'cd ccp4-7.1',
'./BINARY.setup',
])
stage0 += environment(variables=add_binary('/opt/ccp4-7.1/bin'))
stage0 += comment('Installing CCP-EM')
stage0 += primitives.copy(src="./ccpem-1.5.0-linux-x86_64.tar.gz",
dest="/opt/ccpem-1.5.0-linux-x86_64.tar.gz")
stage0 += primitives.copy(src="./input.txt", dest="/opt/input.txt")
stage0 += shell(commands=[
'touch $HOME/.agree2ccpemv1',
'cd /opt && tar -xf ccpem-1.5.0-linux-x86_64.tar.gz && rm ccpem-1.5.0-linux-x86_64.tar.gz',
'cd ccpem-1.5.0', './install_ccpem.sh',
'cat /opt/input.txt | bash install_modeller.sh'
])
return stage0
def build(container_format='singularity',
os='ubuntu20.04',
cuda_version='11.0',
gpu_version='V100',
mkl_version='2020.0-088',
version='psmp',
tag='8.1.0'):
image = f'nvcr.io/nvidia/cuda:{cuda_version}-devel-{os}'
config.set_container_format(container_format)
stage0 = Stage(name='stage0')
stage0 += baseimage(image=image, _bootstrap='docker')
stage0 += label(metadata={
'maintainer': 'Luhan Cheng',
'email': '*****@*****.**'
})
stage0 += comment(
'Toolchain installation translated from https://github.com/cp2k/cp2k/blob/master/tools/toolchain/Dockerfile.cuda_mkl'
)
stage0 += packages(apt=[
'git', 'gfortran', 'mpich', 'libmpich-dev',
'software-properties-common', 'python-dev'
])
stage0 += python()
stage0 += shell(commands=[
f'git clone --depth 1 --branch v{tag} https://github.com/cp2k/cp2k.git /cp2k',
'cd /cp2k', 'git submodule update --init --recursive'
])
stage0 += shell(
commands=['/cp2k/tools/toolchain/install_requirements_ubuntu.sh'])
stage0 += environment(
variables={
'CUDA_PATH': '/usr/local/cuda',
'LD_LIBRARY_PATH': '/usr/local/cuda/:${LD_LIBRARY_PATH}',
'MKLROOT': '/opt/intel/compilers_and_libraries/linux/mkl',
**from_prefix('/usr/local/cuda')
})
stage0 += mkl(eula=True, version=mkl_version)
stage0 += workdir(directory='/opt/cp2k-toolchain')
stage0 += shell(commands=[
'cd /opt/cp2k-toolchain',
'mkdir scripts && cp -r /cp2k/tools/toolchain/scripts/* ./scripts/',
'cp /cp2k/tools/toolchain/install_cp2k_toolchain.sh .',
])
stage0 += shell(commands=[
'cd /opt/cp2k-toolchain',
f'./install_cp2k_toolchain.sh --mpi-mode=openmpi --math-mode=mkl --with-reflapack=no --with-scalapack=no --with-elpa=no --gpu-ver={gpu_version}',
'rm -rf ./build'
])
stage0 += shell(commands=[
'cp /opt/cp2k-toolchain/install/arch/* /cp2k/arch/', 'cd /cp2k',
"sed 's/source /. /g' /opt/cp2k-toolchain/install/setup > /opt/cp2k-toolchain/install/setup ",
'. /opt/cp2k-toolchain/install/setup',
f'make ARCH=local VERSION="{version}" | tee /var/tmp/log.txt'
])
stage0 += environment(variables={'PATH': '/cp2k/exe/local:$PATH'})
stage0 += shell(commands=[
'ln -s /usr/lib/x86_64-linux-gnu/libncursesw.so.6 /usr/lib/x86_64-linux-gnu/libncursesw.so.5',
'ln -s /usr/lib/x86_64-linux-gnu/libtinfo.so.6 /usr/lib/x86_64-linux-gnu/libtinfo.so.5'
])
stage0 += environment(
variables={
'LD_LIBRARY_PATH': '/usr/lib/x86_64-linux-gnu/:$LD_LIBRARY_PATH'
})
return stage0
def main(): # pragma: no cover
cli = Cli_Args()
args = cli.parse_args()
if args.deploy != '':
args.build = True
args.convert = True
cwd = os.getcwd()
c = list(
itertools.product(args.format, args.ogs, args.pm, args.ompi,
args.cmake_args))
if not args.print and not args.cleanup:
print('Creating {} image definition(s)...'.format(len(c)))
for build in c:
__format = build[0]
ogs_version = build[1]
ogscm.config.set_package_manager(build[2])
ompi = build[3]
cmake_args = build[4].strip().split(' ')
# args checking
if len(c) > 1 and args.file != '':
print(
'--file can only be used when generating a single image definition'
)
quit(1)
if (len(c) > 1 and args.sif_file != '') or (args.sif_file != ''
and args.convert == False):
print('--sif_file can only be used when generating a single image '
'definition and --convert is given')
quit(1)
if (ogs_version == 'off' or ogs_version
== 'clean') and len(cmake_args) > 0 and cmake_args[0] != '':
cmake_args = []
print('--cmake_args cannot be used with --ogs off! Ignoring!')
if __format == 'singularity':
if args.runtime_only:
args.runtime_only = False
print(
'--runtime-only cannot be used with --format singularity! '
'Ignoring!')
if args.upload:
print('--upload cannot be used with --format singularity! '
'Ignoring!')
if args.convert:
print('--convert cannot be used with --format singularity! '
'Ignoring!')
info = container_info(build, args)
if args.cleanup:
info.cleanup()
exit(0)
info.make_dirs()
if ompi != 'off':
if args.base_image == 'ubuntu:20.04':
args.base_image = 'centos:8'
print(
'Setting base_image to \'centos:8\'. OpenMPI is supported on CentOS only.'
)
# Create definition
hpccm.config.set_container_format(__format)
# ------------------------------ recipe -------------------------------
Stage0 = hpccm.Stage()
Stage0 += raw(docker='# syntax=docker/dockerfile:experimental')
if args.runtime_only:
Stage0.name = 'build'
Stage0 += baseimage(image=args.base_image, _as='build')
Stage0 += comment(f"Generated with ogs-container-maker {__version__}",
reformat=False)
Stage0 += packages(ospackages=['wget', 'tar', 'curl', 'make'])
# base compiler
if args.compiler != 'off':
if args.compiler_version == '':
if args.compiler == 'clang':
args.compiler_version = '8'
else:
if hpccm.config.g_linux_distro == linux_distro.CENTOS:
args.compiler_version = '10' # required for std::filesystem
else:
args.compiler_version = None # Use default
if args.compiler == 'clang':
compiler = llvm(extra_repository=True,
extra_tools=True,
version=args.compiler_version)
else:
compiler = gnu(fortran=False,
extra_repository=True,
version=args.compiler_version)
toolchain = compiler.toolchain
Stage0 += compiler
# Upgrade stdc++ lib after installing new compiler
# https://stackoverflow.com/a/46613656/80480
if args.compiler == 'gcc' and args.compiler_version is not None:
Stage0 += packages(apt=['libstdc++6'])
# Prepare runtime stage
Stage1 = hpccm.Stage()
Stage1.baseimage(image=args.base_image)
# Install scif in all stages
Stage0 += pip(packages=['scif'], pip='pip3')
Stage1 += pip(packages=['scif'], pip='pip3')
if ompi != 'off':
mpicc = object
if False: # eve:
# Stage0 += ofed() OR mlnx_ofed(); is installed later on from debian archive
# Stage0 += knem()
Stage0 += ucx(version='1.5.1',
cuda=False) # knem='/usr/local/knem'
Stage0 += packages(ospackages=['libpmi2-0-dev'
]) # req. for --with-pmi
# req. for --with-psm2
Stage0 += packages(ospackages=['libnuma1'])
psm_deb_url = 'http://snapshot.debian.org/archive/debian/20181231T220010Z/pool/main'
psm2_version = '11.2.68-4'
Stage0 += shell(commands=[
'cd /tmp',
f'wget -nv {psm_deb_url}/libp/libpsm2/libpsm2-2_{psm2_version}_amd64.deb',
f'wget -nv {psm_deb_url}/libp/libpsm2/libpsm2-dev_{psm2_version}_amd64.deb',
'dpkg --install *.deb'
])
# libibverbs
# Available versions: http://snapshot.debian.org/binary/ibacm/
# ibverbs_version = '21.0-1'
# works on eve, eve has 17.2-3 installed nut this version is not available in snapshot.debian
ib_deb_url = 'http://snapshot.debian.org/archive/debian/20180430T215634Z/pool/main'
ibverbs_version = '17.1-2'
ibverbs_packages = [
'ibacm', 'ibverbs-providers', 'ibverbs-utils',
'libibumad-dev', 'libibumad3', 'libibverbs-dev',
'libibverbs1', 'librdmacm-dev', 'librdmacm1', 'rdma-core',
'rdmacm-utils'
]
ibverbs_cmds = ['cd /tmp']
for package in ibverbs_packages:
ibverbs_cmds.extend([
f'wget -nv {ib_deb_url}/r/rdma-core/{package}_{ibverbs_version}_amd64.deb'
])
ibverbs_cmds.append('dpkg --install *.deb')
Stage0 += packages(ospackages=[
'libnl-3-200', 'libnl-route-3-200', 'libnl-route-3-dev',
'udev', 'perl'
])
Stage0 += shell(commands=ibverbs_cmds)
mpicc = openmpi(
version=ompi,
cuda=False,
toolchain=toolchain,
ldconfig=True,
ucx='/usr/local/ucx',
configure_opts=[
'--disable-getpwuid',
'--sysconfdir=/mnt/0',
'--with-slurm', # used on taurus
'--with-pmi=/usr/include/slurm-wlm',
'CPPFLAGS=\'-I /usr/include/slurm-wlm\'',
'--with-pmi-libdir=/usr/lib/x86_64-linux-gnu',
# '--with-pmix',
'--with-psm2',
'--disable-pty-support',
'--enable-mca-no-build=btl-openib,plm-slurm',
# eve:
'--with-sge',
'--enable-mpirun-prefix-by-default',
'--enable-orterun-prefix-by-default',
])
else:
ucx_version = '1.8.1'
Stage0 += ucx(version=ucx_version, cuda=False)
Stage0 += slurm_pmi2(version='17.02.11')
pmix_version = True
if version.parse(ompi) >= version.parse('4'):
Stage0 += pmix(version='3.1.5')
pmix_version = '/usr/local/pmix'
mpicc = openmpi(version=ompi,
cuda=False,
infiniband=False,
pmi='/usr/local/slurm-pmi2',
pmix=pmix_version,
ucx='/usr/local/ucx')
toolchain = mpicc.toolchain
Stage0 += mpicc
# OpenMPI expects this program to exist, even if it's not used.
# Default is "ssh : rsh", but that's not installed.
Stage0 += shell(commands=[
'mkdir /mnt/0',
"echo 'plm_rsh_agent = false' >> /mnt/0/openmpi-mca-params.conf"
])
Stage0 += label(
metadata={
'org.opengeosys.mpi': 'openmpi',
'org.opengeosys.mpi.version': ompi
})
if args.mpi_benchmarks:
# osu_app = scif(name='osu', file=f"{info.out_dir}/osu.scif")
Stage0 += osu_benchmarks(toolchain=toolchain)
Stage0 += shell(commands=[
'mkdir -p /usr/local/mpi-examples',
'cd /usr/local/mpi-examples',
'curl -O https://raw.githubusercontent.com/hpc/charliecloud/674b3b4e4ad243be5565f200d8f5fb92b7544480/examples/mpihello/hello.c',
'curl -O https://computing.llnl.gov/tutorials/mpi/samples/C/mpi_bandwidth.c',
'curl -O https://raw.githubusercontent.com/mpitutorial/mpitutorial/gh-pages/tutorials/mpi-send-and-receive/code/ring.c',
'mpicc -o /usr/local/bin/mpi-hello /usr/local/mpi-examples/hello.c',
'mpicc -o /usr/local/bin/mpi-ring /usr/local/mpi-examples/ring.c',
'mpicc -o /usr/local/bin/mpi-bandwidth /usr/local/mpi-examples/mpi_bandwidth.c',
])
Stage1 += copy(_from='build',
src='/usr/local/bin/mpi-*',
dest='/usr/local/bin/')
# Stage0 += mlnx_ofed()
if ogs_version != 'clean':
Stage0 += ogs_base()
if args.gui:
Stage0 += packages(apt=[
'mesa-common-dev', 'libgl1-mesa-dev', 'libglu1-mesa-dev',
'libxt-dev'
],
yum=[
'mesa-libOSMesa-devel', 'mesa-libGL-devel',
'mesa-libGLU-devel', 'libXt-devel'
])
Stage1 += packages(
apt=[
'libosmesa6', 'libgl1-mesa-glx', 'libglu1-mesa', 'libxt6',
'libopengl0'
],
yum=['mesa-libOSMesa', 'mesa-libGL', 'mesa-libGLU', 'libXt'])
if ogs_version != 'clean':
if ogscm.config.g_package_manager == package_manager.CONAN:
Stage0 += cmake(eula=True, version='3.16.6')
conan_user_home = '/opt/conan'
if args.dev:
conan_user_home = ''
Stage0 += pm_conan(user_home=conan_user_home)
Stage0 += environment(variables={'CONAN_SYSREQUIRES_SUDO': 0})
elif ogscm.config.g_package_manager == package_manager.SYSTEM:
Stage0 += cmake(eula=True, version='3.16.6')
Stage0 += boost(version='1.66.0', bootstrap_opts=['headers'])
Stage0 += environment(
variables={'BOOST_ROOT': '/usr/local/boost'})
vtk_cmake_args = [
'-DModule_vtkIOXML=ON', '-DModule_vtkIOXdmf3=ON',
'-DVTK_Group_Rendering=OFF', '-DVTK_Group_StandAlone=OFF'
]
if args.gui:
Stage0 += packages(apt=[
'libgeotiff-dev', 'libshp-dev', 'libnetcdf-c++4-dev',
'libqt5x11extras5-dev', 'libqt5xmlpatterns5-dev',
'qt5-default'
],
yum=[
'libgeotiff-devel',
'shapelib-devel', 'netcdf-devel',
'qt5-qtbase-devel',
'qt5-qtxmlpatterns-devel',
'qt5-qtx11extras-devel'
])
Stage1 += packages(apt=[
'geotiff-bin', 'shapelib', 'libnetcdf-c++4',
'libqt5x11extras5', 'libqt5xmlpatterns5', 'qt5-default'
],
yum=[
'libgeotiff', 'shapelib', 'netcdf',
'qt5-qtbase', 'qt5-qtxmlpatterns',
'qt5-qtx11extras'
])
vtk_cmake_args = [
'-DModule_vtkIOXdmf3=ON',
'-DVTK_BUILD_QT_DESIGNER_PLUGIN=OFF',
'-DVTK_Group_Qt=ON', '-DVTK_QT_VERSION=5'
]
if hpccm.config.g_linux_distro == linux_distro.CENTOS:
# otherwise linker error, maybe due to gcc 10?
vtk_cmake_args.extend([
'-DBUILD_SHARED_LIBS=OFF',
'-DCMAKE_POSITION_INDEPENDENT_CODE=ON'
])
if args.insitu:
if args.gui:
print('--gui can not be used with --insitu!')
exit(1)
Stage0 += paraview(cmake_args=['-DPARAVIEW_USE_PYTHON=ON'],
edition='CATALYST',
ldconfig=True,
toolchain=toolchain,
version="v5.8.1")
else:
if toolchain.CC == 'mpicc':
vtk_cmake_args.extend([
'-D Module_vtkIOParallelXML=ON',
'-D Module_vtkParallelMPI=ON'
])
Stage0 += generic_cmake(
cmake_opts=vtk_cmake_args,
devel_environment={'VTK_ROOT': '/usr/local/vtk'},
directory='VTK-8.2.0',
ldconfig=True,
prefix='/usr/local/vtk',
toolchain=toolchain,
url=
'https://www.vtk.org/files/release/8.2/VTK-8.2.0.tar.gz'
)
if ompi != 'off':
Stage0 += packages(yum=['diffutils'])
Stage0 += generic_autotools(
configure_opts=[
f'CC={toolchain.CC}', f'CXX={toolchain.CXX}',
'--CFLAGS=\'-O3\'', '--CXXFLAGS=\'-O3\'',
'--FFLAGS=\'-O3\'', '--with-debugging=no',
'--with-fc=0', '--download-f2cblaslapack=1'
],
devel_environment={'PETSC_DIR': '/usr/local/petsc'},
directory='petsc-3.11.3',
ldconfig=True,
preconfigure=[
"sed -i -- 's/python/python3/g' configure"
],
prefix='/usr/local/petsc',
toolchain=toolchain,
url='http://ftp.mcs.anl.gov/pub/petsc/release-snapshots/'
'petsc-lite-3.11.3.tar.gz')
Stage0 += generic_cmake(
devel_environment={
'Eigen3_ROOT': '/usr/local/eigen',
'Eigen3_DIR': '/usr/local/eigen'
},
directory='eigen-3.3.7',
prefix='/usr/local/eigen',
url=
'https://gitlab.com/libeigen/eigen/-/archive/3.3.7/eigen-3.3.7.tar.gz'
)
if args.cvode:
Stage0 += generic_cmake(
cmake_opts=[
'-D EXAMPLES_INSTALL=OFF', '-D BUILD_SHARED_LIBS=OFF',
'-D CMAKE_POSITION_INDEPENDENT_CODE=ON'
],
devel_environment={'CVODE_ROOT': '/usr/local/cvode'},
directory='cvode-2.8.2',
prefix='/usr/local/cvode',
url='https://github.com/ufz/cvode/archive/2.8.2.tar.gz')
if args.cppcheck:
Stage0 += generic_cmake(
devel_environment={'PATH': '/usr/local/cppcheck/bin:$PATH'},
directory='cppcheck-809a769c690d8ab6fef293e41a29c8490512866e',
prefix='/usr/local/cppcheck',
runtime_environment={'PATH': '/usr/local/cppcheck/bin:$PATH'},
url=
'https://github.com/danmar/cppcheck/archive/809a769c690d8ab6fef293e41a29c8490512866e.tar.gz'
)
if args.iwyy and args.compiler == 'clang':
Stage0 += packages(ospackages=[
'libncurses5-dev', 'zlib1g-dev',
f"llvm-{args.compiler_version}-dev",
f"libclang-{args.compiler_version}-dev"
])
Stage0 += generic_cmake(
cmake_opts=[
f"-D IWYU_LLVM_ROOT_PATH=/usr/lib/llvm-{args.compiler_version}"
],
devel_environment={'PATH': '/usr/local/iwyy/bin:$PATH'},
directory=
f"include-what-you-use-clang_{args.compiler_version}.0",
prefix='/usr/local/iwyy',
runtime_environment={'PATH': '/usr/local/iwyy/bin:$PATH'},
url="https://github.com/include-what-you-use/include-what-"
f"you-use/archive/clang_{args.compiler_version}.0.tar.gz")
if args.docs:
Stage0 += packages(
ospackages=['doxygen', 'graphviz', 'texlive-base'])
if args.gcovr:
Stage0 += pip(pip='pip3', packages=['gcovr'])
if args.dev:
Stage0 += packages(ospackages=[
'neovim', 'gdb', 'silversearcher-ag', 'ssh-client', 'less'
])
if args.pip:
Stage0 += pip(packages=args.pip, pip='pip3')
Stage1 += pip(packages=args.pip, pip='pip3')
if args.packages:
Stage0 += packages(ospackages=args.packages)
if args.tfel:
Stage0 += generic_cmake(
directory='tfel-TFEL-3.3.0',
ldconfig=True,
url='https://github.com/thelfer/tfel/archive/TFEL-3.3.0.tar.gz',
prefix='/usr/local/tfel')
Stage0 += environment(variables={'TFELHOME': '/usr/local/tfel'})
definition_file_path = os.path.join(info.out_dir, info.definition_file)
if args.ccache:
Stage0 += ccache(cache_size='15G')
if ogs_version != 'off' and ogs_version != 'clean':
mount_args = ''
if args.ccache:
mount_args = f'{mount_args} --mount=type=cache,target=/opt/ccache,id=ccache'
if args.cvode:
cmake_args.append('-DOGS_USE_CVODE=ON')
if args.gui:
cmake_args.append('-DOGS_BUILD_GUI=ON')
if args.insitu:
cmake_args.append('-DOGS_INSITU=ON')
Stage0 += raw(docker=f"ARG OGS_COMMIT_HASH={info.commit_hash}")
scif_file = f"{info.out_dir}/ogs.scif"
if info.ogsdir:
context_path_size = len(ogs_version)
print(f"chdir to {ogs_version}")
os.chdir(ogs_version)
mount_args = f'{mount_args} --mount=type=bind,target=/scif/apps/ogs/src,rw'
scif_file = f"{info.out_dir[context_path_size+1:]}/ogs.scif"
definition_file_path = f"{info.out_dir[context_path_size+1:]}/{info.definition_file}"
ogs_app = scif(_arguments=mount_args, name='ogs', file=scif_file)
ogs_app += ogs(repo=info.repo,
branch=info.branch,
commit=info.commit_hash,
git_version=info.git_version,
toolchain=toolchain,
prefix='/scif/apps/ogs',
cmake_args=cmake_args,
parallel=args.parallel,
remove_build=True,
remove_source=True)
Stage0 += ogs_app
stages_string = str(Stage0)
if args.runtime_only:
Stage1 += Stage0.runtime(exclude=['boost'])
if args.compiler == 'gcc' and args.compiler_version != None:
Stage1 += packages(apt=['libstdc++6'])
stages_string += "\n\n" + str(Stage1)
# ---------------------------- recipe end -----------------------------
with open(definition_file_path, 'w') as f:
print(stages_string, file=f)
if args.print:
print(stages_string)
else:
print(
f'Created definition {os.path.abspath(definition_file_path)}')
# Create image
if not args.build:
continue
if __format == 'singularity':
subprocess.run(
f"sudo `which singularity` build --force {info.images_out_dir}/{info.img_file}.sif"
f"{definition_file_path}",
shell=True)
subprocess.run(
f"sudo chown $USER:$USER {info.images_out_dir}/{info.img_file}.sif",
shell=True)
# TODO: adapt this to else
continue
build_cmd = (f"DOCKER_BUILDKIT=1 docker build {args.build_args} "
f"-t {info.tag} -f {definition_file_path} .")
print(f"Running: {build_cmd}")
subprocess.run(build_cmd, shell=True)
inspect_out = subprocess.check_output(
f"docker inspect {info.tag} | grep Id",
shell=True).decode(sys.stdout.encoding)
image_id = re.search('sha256:(\w*)', inspect_out).group(1)
image_id_short = image_id[0:12]
if args.upload:
subprocess.run(f"docker push {info.tag}", shell=True)
if args.sif_file:
image_file = f'{info.images_out_dir}/{args.sif_file}'
else:
image_file = f'{info.images_out_dir}/{info.img_file}-{image_id_short}.sif'
if args.convert and not os.path.exists(image_file):
subprocess.run(
f"cd {cwd} && singularity build --force {image_file} docker-daemon:{info.tag}",
shell=True)
# Deploy image
if not args.deploy:
continue
deploy_config_filename = f'{cwd}/config/deploy_hosts.yml'
if not os.path.isfile(deploy_config_filename):
print(
f'ERROR: {deploy_config_filename} not found but required for deploying!'
)
exit(1)
with open(deploy_config_filename, 'r') as ymlfile:
deploy_config = yaml.load(ymlfile, Loader=yaml.FullLoader)
if not args.deploy == 'ALL' and not args.deploy in deploy_config:
print(f'ERROR: Deploy host "{args.deploy}" not found in config!')
exit(1)
deploy_hosts = {}
if args.deploy == 'ALL':
deploy_hosts = deploy_config
else:
deploy_hosts[args.deploy] = deploy_config[args.deploy]
for deploy_host in deploy_hosts:
deploy_info = deploy_hosts[deploy_host]
print(f'Deploying to {deploy_info} ...')
proxy_cmd = ''
user_cmd = ''
if 'user' in deploy_info:
user_cmd = f"{deploy_info['user']}@"
if 'proxy' in deploy_info:
proxy_cmd = f"-e 'ssh -A -J {user_cmd}{deploy_info['proxy']}'"
print(proxy_cmd)
print(
subprocess.check_output(
f"rsync -c -v {proxy_cmd} {image_file} {user_cmd}{deploy_info['host']}:{deploy_info['dest_dir']}",
shell=True).decode(sys.stdout.encoding))