def CheckState(self):
""" Check if downloaded and installed."""
# First test if globally installed, requires at least 2.8.1
if PackageUtil.FindLibrary(self._Name) is not None:
# Now check the version
versionString = PackageUtil.ExecuteSimpleCommand(
"cmake", ["--version"], None, os.getcwd()).split()[2]
versionNumbers = versionString.split(".")
if len(versionNumbers) == 2: #Patched version
if int(versionNumbers[0]) >= 2 and int(
versionNumbers[1][0]
) >= 9: # Issues with this long term, e.g. cmake 3 or 2.10
# Installed is correct version
self._SetMode(2)
return
elif len(versionNumbers) == 3: #Base version
if int(versionNumbers[0]) >= 2 and int(
versionNumbers[1]
) >= 8 and int(
versionNumbers[2]
) >= 1: # Issues with this long term, e.g. cmake 3 or 2.10
# Installed is correct version
self._SetMode(2)
return
self._InstallPath = os.path.join(PackageUtil.kInstallPath, self._Name)
# If here then must manually install
if os.path.exists(
os.path.join(PackageUtil.kCachePath, "cmake-2.8.8.tar.gz")):
self._SetMode(1) # Downloaded
if os.path.exists(os.path.join(self.GetInstallPath(), "bin/cmake")):
self._SetMode(2) # Installed as well
return
def _Install(self):
""" Derived classes should override this to install the package, should install only when finished. Return True on success."""
import shutil
sys = os.uname()[0] + "-g++"
self._InstallPipe += PackageUtil.UnTarFile(self._SourceTar,
self.GetInstallPath(), 1)
for dataTar in self._DataTars:
self._InstallPipe += PackageUtil.UnTarFile(
dataTar, os.path.join(self.GetInstallPath(), "data"), 0)
self.WriteGeant4ConfigFile()
self._InstallPipe += PackageUtil.ExecuteSimpleCommand(
'./Configure', [
'-incflags', '-build', '-d', '-e', '-f',
"geant4-snoing-config.sh"
], None, self.GetInstallPath())
self._InstallPipe += PackageUtil.ExecuteSimpleCommand(
'./Configure', [
'-incflags', '-install', '-d', '-e', '-f',
"geant4-snoing-config.sh"
], None, self.GetInstallPath())
try:
self._InstallPipe += PackageUtil.ExecuteSimpleCommand(
'./Configure', [], None, self.GetInstallPath())
except Exception: # Geant4 configure always fails, it is annoying
pass
if not os.path.exists(os.path.join(self.GetInstallPath(), 'env.sh')):
shutil.copy(
os.path.join(self.GetInstallPath(),
'.config/bin/' + sys + '/env.sh'),
os.path.join(self.GetInstallPath(), 'env.sh'))
shutil.copy(
os.path.join(self.GetInstallPath(),
'.config/bin/' + sys + '/env.csh'),
os.path.join(self.GetInstallPath(), 'env.csh'))
return
def _IsInstalled(self):
""" Check if the package has been installed."""
installed = PackageUtil.LibraryExists( os.path.join( self.GetInstallPath(), "lib"), "libG4event" ) or \
PackageUtil.LibraryExists( os.path.join( self.GetInstallPath(), "lib64" ), "libG4event" )
if PackageUtil.kGraphical:
installed = installed and ( PackageUtil.LibraryExists( os.path.join( self.GetInstallPath(), "lib" ), "libG4OpenGL" ) or \
PackageUtil.LibraryExists( os.path.join( self.GetInstallPath(), "lib64" ), "libG4OpenGL" ) )
return installed
def _IsInstalled(self):
""" Has sfml been installed."""
libDir = os.path.join(self.GetInstallPath(), "lib")
libs = ["audio", "graphics", "network", "system", "window"]
return PackageUtil.All([
PackageUtil.LibraryExists(libDir, "libsfml-%s" % lib)
for lib in libs
])
def _Install( self ):
""" Install clhep."""
self._InstallPipe += PackageUtil.UnTarFile( self._TarName, self.GetInstallPath(), 2 )
self._InstallPipe += PackageUtil.ExecuteSimpleCommand( './configure', ['--prefix=%s' % self.GetInstallPath() ],
None, self.GetInstallPath() )
self._InstallPipe += PackageUtil.ExecuteSimpleCommand( 'make', [], None, self.GetInstallPath() )
self._InstallPipe += PackageUtil.ExecuteSimpleCommand( 'make', ["install"], None, self.GetInstallPath() )
return
def _IsInstalled(self):
""" Rat releases and dev share a common install check."""
# Check rat, root, RATLib and RATDSLib
sys = os.uname()[0]
return os.path.exists( os.path.join( self.GetInstallPath(), "bin/rat_%s-g++" % sys ) ) \
and os.path.exists( os.path.join( self.GetInstallPath(), "bin/root" ) ) \
and PackageUtil.LibraryExists( os.path.join( self.GetInstallPath(), "lib" ), "librat_%s-g++" % sys ) \
and PackageUtil.LibraryExists( os.path.join( self.GetInstallPath(), "lib" ), "libRATEvent_%s-g++" % sys )
def CheckState( self ):
""" Check the python-dev install state."""
# First check for python config
if PackageUtil.FindLibrary( "python-config" ) is not None:
# Now can test for linking
installed, self._CheckPipe = PackageUtil.TestConfigLibrary( "python-config", "Python.h" )
self._Installed = installed
return
def _Download(self):
""" Derived classes should override this to download the package."""
self._DownloadPipe = PackageUtil.DownloadFile(
"http://geant4.web.cern.ch/geant4/support/source/" +
self._SourceTar)
for dataTar in self._DataTars:
self._DownloadPipe += PackageUtil.DownloadFile(
"http://geant4.web.cern.ch/geant4/support/source/" + dataTar)
return
def _Install(self):
""" Install bzip2."""
PackageUtil.UnTarFile(self._TarName, self.GetInstallPath(), 1)
self._InstallPipe += PackageUtil.ExecuteSimpleCommand(
"make", ["-f", "Makefile-libbz2_so"], None, self.GetInstallPath())
self._InstallPipe += PackageUtil.ExecuteSimpleCommand(
"make", ["install", "PREFIX=" + self.GetInstallPath()], None,
self.GetInstallPath())
return
def _Install( self ):
""" Derived classes should override this to install the package, should install only when finished."""
env = os.environ
sourcePath = os.path.join( PackageUtil.kInstallPath, "%s-source" % self._Name )
self._InstallPipe += PackageUtil.UnTarFile( self._TarName, sourcePath, 1 )
self._InstallPipe += PackageUtil.ExecuteSimpleCommand( "./configure", [ "--prefix=%s" %( self.GetInstallPath() ) ], env, sourcePath )
self._InstallPipe += PackageUtil.ExecuteSimpleCommand( "make", [], env, sourcePath )
self._InstallPipe += PackageUtil.ExecuteSimpleCommand( "make", [ "install" ], env, sourcePath )
return
def CheckState( self ):
""" Need to test the library linking and inclusion of the header."""
if self._Framework == False:
installed, self._CheckPipe = PackageUtil.TestLibrary( self._LibName, self._Header )
else:
installed, self._CheckPipe = PackageUtil.TestFramework( self._LibName, self._Header )
if installed:
self._Installed = True
return
def _Install( self ):
""" Install sfml."""
env = os.environ
installPath = self.GetInstallPath()
PackageUtil.UnTarFile( self._TarName, self.GetInstallPath(), 1 )
cmakeCommand = "cmake"
if self._DependencyPaths["cmake"] is not None: # Special cmake installed
cmakeCommand = "%s/bin/cmake" % self._DependencyPaths["cmake"]
self._InstallPipe += PackageUtil.ExecuteSimpleCommand( cmakeCommand, [ "-DCMAKE_INSTALL_PREFIX:PATH=$PWD" ], env, self.GetInstallPath() )
self._InstallPipe += PackageUtil.ExecuteSimpleCommand( "make", [], env, self.GetInstallPath() )
return
def _Install(self):
""" Install the 2.8 version."""
self._InstallPipe += PackageUtil.UnTarFile("cmake-2.8.8.tar.gz",
self.GetInstallPath(), 1)
self._InstallPipe += PackageUtil.ExecuteSimpleCommand(
"./bootstrap", ["--prefix=%s" % self.GetInstallPath()], None,
self.GetInstallPath())
self._InstallPipe += PackageUtil.ExecuteSimpleCommand(
"make", [], None, self.GetInstallPath())
self._InstallPipe += PackageUtil.ExecuteSimpleCommand(
"make", ["install"], None, self.GetInstallPath())
return
def CheckSystem():
""" Check for G4 in the environment and check if mac."""
# Check the environment is clean
env = os.environ
for envbit in env: #check clean environment
inenv = env[envbit].find('G4')
if inenv!=-1:
Log.Error( "G4... environment variables are present, please run in a clean environment." )
sys.exit(1)
# Check g++ is installed (python and g++ are the only prerequisites)
if PackageUtil.FindLibrary( "g++" ) is None:
Log.Error( "g++ must be installed for snoing to work, try installing build essentials or xcode." )
sys.exit(1)
system = os.uname()[0]
if system == 'Darwin':
PackageUtil.kMac = True
#Check which environments exist
if "LIBRARY_PATH" not in os.environ:
os.environ["LIBRARY_PATH"]=""
if "CPLUS_INCLUDE_PATH" not in os.environ:
os.environ["CPLUS_INCLUDE_PATH"]=""
#Append fink or macports directories, if not already appended
try:
finkLoc = PackageUtil.ExecuteSimpleCommand("which",["fink"],None,os.getcwd())
except Exceptions.PackageException:
finkLoc = None
try:
portLoc = PackageUtil.ExecuteSimpleCommand("which",["port"],None,os.getcwd())
except Exceptions.PackageException:
portLoc = None
finkDir = None
if finkLoc!="" and portLoc!="":
Log.Warn("Both fink and macports installed, going with fink in dir: %s"%finkLoc)
if finkLoc!="":
finkDir = finkLoc.strip().replace("/bin/fink","")
elif portLoc!="":
finkDir = portLoc.strip().replace("/bin/port","")
if finkDir is not None:
os.environ["PATH"]="%s:%s"%(os.path.join(finkDir,"bin"),os.environ["PATH"])
os.environ["LIBRARY_PATH"]="%s:%s"%(os.path.join(finkDir,"lib"),os.environ["LIBRARY_PATH"])
os.environ["CPLUS_INCLUDE_PATH"]="%s:%s"%(os.path.join(finkDir,"include"),os.environ["CPLUS_INCLUDE_PATH"])
#XCode in 10.7 installs X11 to /usr/X11
if os.path.exists("/usr/X11"):
os.environ["PATH"] = "/usr/X11/bin:%s" % os.environ["PATH"]
os.environ["LIBRARY_PATH"] = "/usr/X11/lib:%s" % os.environ["LIBRARY_PATH"]
os.environ["CPLUS_INCLUDE_PATH"] = "/usr/X11/include:%s" % os.environ["CPLUS_INCLUDE_PATH"]
#Frameworks
if os.path.exists("/System/Library/Frameworks"):
os.environ["CPLUS_INCLUDE_PATH"] = "/System/Library/Frameworks:%s" % os.environ["CPLUS_INCLUDE_PATH"]
else:
PackageUtil.kMac = False
def _Download(self):
""" Derived classes should override this to download the package. Return True on success."""
if self._Username is not None:
print "Github password:"******"https://github.com/snoplus/rat/tarball/" + self._TarName, \
self._Username, password )
elif self._Token is not None:
self._DownloadPipe += PackageUtil.DownloadFile( "https://api.github.com/repos/snoplus/rat/tarball/" + self._TarName, \
token = self._Token )
else:
Log.Error("No Authentication method supplied.")
raise Exception()
return
def _Install(self):
""" Install the 3.1.1 version."""
sourcePath = os.path.join(PackageUtil.kInstallPath,
"%s-source" % self._Name)
self._InstallPipe += PackageUtil.UnTarFile(self._TarName, sourcePath,
1)
self._InstallPipe += PackageUtil.ExecuteSimpleCommand(
"./configure", [], None, sourcePath)
self._InstallPipe += PackageUtil.ExecuteSimpleCommand(
"make", [], None, sourcePath)
self._InstallPipe += PackageUtil.ExecuteSimpleCommand(
"make", ["install", "prefix=%s" % self.GetInstallPath()], None,
sourcePath)
return
def _Install( self ):
""" Install clhep, using cmake."""
sourcePath = os.path.join( PackageUtil.kInstallPath, "%s-source" % self._Name )
PackageUtil.UnTarFile( self._SourceTar, sourcePath, 2 )
if not os.path.exists( self.GetInstallPath() ):
os.makedirs( self.GetInstallPath() )
cmakeOpts = [ "-DCMAKE_INSTALL_PREFIX=%s" % self.GetInstallPath() ]
cmakeOpts.extend( [ sourcePath ] )
cmakeCommand = "cmake"
if self._DependencyPaths["cmake"] is not None: # Special cmake installed
cmakeCommand = "%s/bin/cmake" % self._DependencyPaths["cmake"]
self._InstallPipe += PackageUtil.ExecuteSimpleCommand( cmakeCommand, cmakeOpts, None, self.GetInstallPath() )
self._InstallPipe += PackageUtil.ExecuteSimpleCommand( "make", [], None, self.GetInstallPath() )
self._InstallPipe += PackageUtil.ExecuteSimpleCommand( "make", ['install'], None, self.GetInstallPath() )
return
def _Install(self):
""" Release installs must untar first."""
self._InstallPipe += PackageUtil.UnTarFile(
self._TarName, self.GetInstallPath(),
1) # Strip the first directory
super(RatRelease, self)._Install()
return
def _IsInstalled( self ):
""" Returns true if the header, library and binary files are in the proper location."""
header = os.path.isfile( os.path.join( self.GetInstallPath(), "include", "curl", "curl.h" ) )
lib = PackageUtil.LibraryExists( os.path.join( self.GetInstallPath(), "lib" ), "libcurl" )
exe = os.path.isfile( os.path.join( self.GetInstallPath(), "bin", "curl" ) )
config = os.path.isfile( os.path.join( self.GetInstallPath(), "bin", "curl-config" ) )
return header and lib and exe and config
def _Install(self):
""" Install Snogoggles."""
self.WriteEnvFile()
self._InstallPipe += PackageUtil.ExecuteComplexCommand(
"source env_%s.sh\ncd %s\nscons" %
(self._Name, self.GetInstallPath()))
return
def _Install(self):
""" Install Avaons."""
envFile = EnvFileBuilder.EnvFileBuilder()
envFile.AppendPath(
os.path.join(self._DependencyPaths[self._CurlDependency], "bin"))
envFile.AppendPath(
os.path.join(self._DependencyPaths[self._SconsDependency],
"script"))
envFile.AppendPythonPath(
os.path.join(self._DependencyPaths[self._SconsDependency],
"engine"))
envFile.AddEnvironment("ROOTSYS",
self._DependencyPaths[self._RootDependency])
envFile.AddEnvironment("RATROOT",
self._DependencyPaths[self._RatDependency])
envFile.AddEnvironment("G4SYSTEM", os.uname()[0] + "-g++") # Temp
if self._DependencyPaths[self._BZipDependency] is not None:
envFile.AddEnvironment("BZIPROOT",
self._DependencyPaths[self._BZipDependency])
envFile.AddEnvironment(
"AVALANCHEROOT", self._DependencyPaths[self._AvalancheDependency])
envFile.AddEnvironment("ZEROMQROOT",
self._DependencyPaths[self._ZeromqDependency])
envFile.WriteEnvFiles(self.GetInstallPath(), "env")
commandText = """#!/bin/bash\ncd %s\nsource env.sh\nscons\n""" % self.GetInstallPath(
)
self._InstallPipe += PackageUtil.ExecuteComplexCommand(commandText)
return
def _Update( self ):
""" Special updater for rat-dev, delete env file write a new then git pull and scons."""
os.remove( os.path.join( PackageUtil.kInstallPath, "env_%s.sh" % self._Name ) )
os.remove( os.path.join( PackageUtil.kInstallPath, "env_%s.csh" % self._Name ) )
self.WriteEnvFile()
commandText = """#!/bin/bash\nsource %s\ncd %s\ngit pull\nscons -c\nscons""" % ( os.path.join( PackageUtil.kInstallPath, "env_%s.sh" % self._Name ), self.GetInstallPath() )
self._InstallPipe += PackageUtil.ExecuteComplexCommand( commandText, True )
return
def _Download(self):
""" Download avalanche (git clone)."""
self._DownloadPipe += PackageUtil.ExecuteSimpleCommand(
"git", [
"clone", "[email protected]:pgjones/Avaons.git",
self.GetInstallPath()
], None, os.getcwd())
return
def _Install(self):
""" Derived classes should override this to install the package, should install only when finished. Return True on success."""
self.WriteEnvFile()
# Write the command file and source it...
commandText = """#!/bin/bash\nsource %s\ncd %s\n./configure\nsource env.sh\nscons""" % (
os.path.join(PackageUtil.kInstallPath,
"env_%s.sh" % self._Name), self.GetInstallPath())
self._InstallPipe += PackageUtil.ExecuteComplexCommand(commandText)
return
def _IsDownloaded(self):
""" Check tar files have been downloaded."""
downloaded = PackageUtil.All([
os.path.isfile(os.path.join(PackageUtil.kCachePath, tar))
for tar in self._DataTars
])
downloaded = downloaded and os.path.exists(
os.path.join(PackageUtil.kCachePath, self._SourceTar))
return downloaded
def _Install(self):
""" Derived classes should override this to install the package, should install only when finished. Return True on success."""
self._InstallPipe += PackageUtil.UnTarFile(self._TarName,
self.GetInstallPath(), 1)
sys = os.uname()[0]
if PackageUtil.kGrid:
self._InstallPipe += PackageUtil.ExecuteSimpleCommand(
'./configure', [
'--enable-minuit2', '--enable-roofit', '--enable-python',
'--disable-castor', '--disable-rfio', '--disable-x11'
] + PackageUtil.arguments, None, self.GetInstallPath())
else:
self._InstallPipe += PackageUtil.ExecuteSimpleCommand(
'./configure',
['--enable-minuit2', '--enable-roofit', '--enable-python'] +
PackageUtil.arguments, None, self.GetInstallPath())
self._InstallPipe += PackageUtil.ExecuteSimpleCommand(
'make', [], None, self.GetInstallPath())
return
def CheckState(self):
""" Check the Xm state, slightly more involved on macs."""
sys = os.uname()[0]
if sys == 'Darwin':
flags = []
if os.path.exists("/sw/include/Xm"):
flags = ["-I%s" % "/sw/include/Xm", "-L%s" % "/sw/lib"]
elif os.path.exists("/usr/OpenMotif"):
flags = [
"-I%s" % "/usr/OpenMotif/include",
"-L%s" % "/usr/OpenMotif/lib"
]
installed, self._CheckPipe = PackageUtil._TestLibrary(
"Xm.h", flags)
self._Installed = installed
else:
installed, self._CheckPipe = PackageUtil.TestLibrary(
"Xm", "Xm/Xm.h")
self._Installed = installed
return
def _Install( self ):
""" Install Avalanche."""
env = os.environ
env['PATH'] = os.path.join( self._DependencyPaths[self._RootDependency], "bin" ) + ":" + env['PATH']
env['ROOTSYS'] = self._DependencyPaths[self._RootDependency]
curl = self._DependencyPaths[self._CurlDependency] # Shorten the text
zmq = self._DependencyPaths[self._ZeromqDependency] # Shorten the text
self._InstallPipe += PackageUtil.ExecuteSimpleCommand( "make",
['CXXFLAGS=-L%s/lib -I%s/include -L%s/lib -I%s/include' % (zmq, zmq, curl, curl) ],
env,
os.path.join( self.GetInstallPath(), "lib/cpp" ) )
return
def _Install(self):
""" Install geant4, using cmake."""
sourcePath = os.path.join(PackageUtil.kInstallPath,
"%s-source" % self._Name)
PackageUtil.UnTarFile(self._SourceTar, sourcePath, 1)
self._patch_timeout()
if not os.path.exists(self.GetInstallPath()):
os.makedirs(self.GetInstallPath())
cmakeOpts = [ "-DCMAKE_INSTALL_PREFIX=%s" % self.GetInstallPath(), \
"-DCLHEP_ROOT_DIR=%s" % self._DependencyPaths[self._ClhepDependency], \
"-DXERCESC_ROOT_DIR=%s" % self._DependencyPaths[self._XercesDependency], \
"-DGEANT4_INSTALL_DATA=ON", \
"-DCLHEP_CONFIG_EXECUTABLE=%s" % os.path.join( self._DependencyPaths[self._ClhepDependency], "bin/clhep-config" ) ]
env = None
if PackageUtil.kGraphical:
cmakeOpts.extend([
"-DGEANT4_USE_XM=ON", "-DGEANT4_USE_OPENGL_X11=ON",
"-DGEANT4_USE_RAYTRACER_X11=ON"
])
env = {
'G4VIS_BUILD_VRML_DRIVER': "1",
'G4VIS_BUILD_OPENGLX_DRIVER': "1",
'G4VIS_BUILD_OPENGLXM_DRIVER': "1",
'G4VIS_BUILD_DAWN_DRIVER': "1"
}
cmakeOpts.extend([sourcePath])
cmakeCommand = "cmake"
if self._DependencyPaths[
"cmake"] is not None: # Special cmake installed
cmakeCommand = "%s/bin/cmake" % self._DependencyPaths["cmake"]
self._InstallPipe += PackageUtil.ExecuteSimpleCommand(
cmakeCommand, cmakeOpts, env, self.GetInstallPath())
self._InstallPipe += PackageUtil.ExecuteSimpleCommand(
"make", [], env, self.GetInstallPath())
self._InstallPipe += PackageUtil.ExecuteSimpleCommand(
"make", ['install'], env, self.GetInstallPath())
return
def CheckState( self ):
""" Check the Xm state, slightly more involved on macs."""
sys = os.uname()[0]
if sys == 'Darwin':
flags = []
if os.path.exists( "/sw/include/Xm" ):
flags = [ "-I%s" % "/sw/include/Xm", "-L%s" % "/sw/lib" ]
elif os.path.exists( "/usr/OpenMotif" ):
flags = [ "-I%s" % "/usr/OpenMotif/include", "-L%s" % "/usr/OpenMotif/lib" ]
installed, self._CheckPipe = PackageUtil._TestLibrary( "Xm.h", flags )
self._Installed = installed
else:
installed, self._CheckPipe = PackageUtil.TestLibrary( "Xm", "Xm/Xm.h" )
self._Installed = installed
return
def _Download( self ):
""" Download snogoggles (git clone)."""
self._DownloadPipe += PackageUtil.ExecuteSimpleCommand( "git", ["clone", "[email protected]:snoplus/snogoggles.git", \
self.GetInstallPath()], None, os.getcwd(), True ) # Force verbose
return