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 _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 _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 _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 ):
""" 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 _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 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 _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._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 _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 _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
def _Download( self ):
""" Git clone rat-dev."""
self._DownloadPipe += PackageUtil.ExecuteSimpleCommand( "git", ["clone", "[email protected]:snoplus/rat.git", self.GetInstallPath()], None, os.getcwd(), True ) # Force verbose
return