367 lines
16 KiB
Python
Executable File
367 lines
16 KiB
Python
Executable File
#!/usr/bin/env python
|
|
|
|
import re
|
|
import os
|
|
import os.path
|
|
import sys
|
|
import time
|
|
import shutil
|
|
import socket
|
|
import subprocess
|
|
import logging
|
|
import optparse
|
|
|
|
|
|
def log ( message ):
|
|
print( message )
|
|
logging.info( message )
|
|
return
|
|
|
|
|
|
class ErrorMessage ( Exception ):
|
|
|
|
def __init__ ( self, code, *arguments ):
|
|
self._code = code
|
|
self._errors = [ 'Malformed call to ErrorMessage()'
|
|
, '{}'.format(arguments) ]
|
|
text = None
|
|
if len(arguments) == 1:
|
|
if isinstance(arguments[0],Exception): text = str(arguments[0]).split('\n')
|
|
else:
|
|
self._errors = arguments[0]
|
|
elif len(arguments) > 1:
|
|
text = list(arguments)
|
|
if text:
|
|
self._errors = []
|
|
while len(text[0]) == 0: del text[0]
|
|
lstrip = 0
|
|
if text[0].startswith('[ERROR]'): lstrip = 8
|
|
for line in text:
|
|
if line[0:lstrip ] == ' '*lstrip or \
|
|
line[0:lstrip-1] == '[ERROR]':
|
|
self._errors += [ line[lstrip:] ]
|
|
else:
|
|
self._errors += [ line.lstrip() ]
|
|
|
|
def __str__ ( self ):
|
|
if not isinstance(self._errors,list):
|
|
return "[ERROR] %s" % self._errors
|
|
formatted = "\n"
|
|
for i in range(len(self._errors)):
|
|
if i == 0: formatted += "[ERROR] {}".format( self._errors[i] )
|
|
else: formatted += " {}".format( self._errors[i] )
|
|
if i+1 < len(self._errors): formatted += "\n"
|
|
return formatted
|
|
|
|
def addMessage ( self, message ):
|
|
if not isinstance(self._errors,list):
|
|
self._errors = [ self._errors ]
|
|
if isinstance(message,list):
|
|
for line in message:
|
|
self._errors += [ line ]
|
|
else:
|
|
self._errors += [ message ]
|
|
|
|
def terminate ( self ):
|
|
print( self )
|
|
sys.exit(self._code)
|
|
|
|
def _getCode ( self ): return self._code
|
|
|
|
code = property(_getCode)
|
|
|
|
|
|
class Configuration ( object ):
|
|
|
|
def __init__ ( self ):
|
|
self.onSource = False
|
|
self.onLepka = False
|
|
self.onDocker = False
|
|
hostname = socket.gethostname()
|
|
if hostname.startswith('lepka'): self.onLepka = True
|
|
else: self.onDocker = True
|
|
scriptDir = os.path.abspath(os.getcwd())
|
|
if scriptDir.endswith( 'coriolis/documentation' ) and not self.onLepka:
|
|
self.onLepka = False
|
|
self.onSource = True
|
|
if self.onDocker:
|
|
log( 'Using *Docker* configuration.' )
|
|
self.pelicanDir = '/data/git/coriolis.lip6.fr/pelican'
|
|
self.apacheDir = '/var/www/html'
|
|
if self.onLepka:
|
|
log( 'Using *Lepka* configuration.' )
|
|
#self.pelicanDir = os.path.join( os.environ['HOME'], 'cms/coriolis.lip6.fr/pelican' )
|
|
self.pelicanDir = scriptDir
|
|
self.apacheDir = '/dsk/l1/httpd/coriolis'
|
|
if self.onSource:
|
|
log( 'Using *Source* configuration.' )
|
|
self.pelicanDir = scriptDir
|
|
self.apacheDir = None
|
|
self.localDocDir = '/dsk/l1/jpc/coriolis-2.x/Linux.el9/Release.Shared/install/share/doc/coriolis2/en/html/doc'
|
|
self.remoteDocDir = '/data'
|
|
self.remoteGitDir = '/data/git'
|
|
self.remotePelicanDir = os.path.join( self.remoteGitDir, 'coriolis.lip6.fr/pelican' )
|
|
self.pluginsDir = os.path.join( self.remoteGitDir, 'pelican-plugins' )
|
|
self.logDir = os.path.join( self.pelicanDir, 'logs' )
|
|
self.target = 'coriolis-d'
|
|
|
|
|
|
class Command ( object ):
|
|
|
|
def __init__ ( self, command ):
|
|
self.command = command
|
|
self.outlog = None
|
|
self.errlog = None
|
|
|
|
def asString ( self ):
|
|
s = ''
|
|
for i in range(len(self.command)):
|
|
if i: s += ' '
|
|
if ' ' in self.command[i]: s += '"'+self.command[i]+'"'
|
|
else: s += self.command[i]
|
|
return s
|
|
|
|
def execute ( self ):
|
|
sys.stdout.flush()
|
|
sys.stderr.flush()
|
|
log( self.asString() )
|
|
child = subprocess.Popen( self.command, stdin =subprocess.PIPE
|
|
, stdout=subprocess.PIPE
|
|
, stderr=subprocess.PIPE )
|
|
self.outlog, self.errlog = child.communicate()
|
|
if len(self.outlog): logging.info ( self.outlog.decode('utf-8') )
|
|
if len(self.errlog): logging.error( self.errlog.decode('utf-8'))
|
|
status = child.returncode
|
|
status >>= 8
|
|
if status != 0:
|
|
ErrorMessage( status, "{} (status:{}).".format(error,status) ).terminate()
|
|
return status
|
|
|
|
@staticmethod
|
|
def rmtree ( path ):
|
|
command = 'rm -rf {}'.format( path )
|
|
try:
|
|
log( command )
|
|
shutil.rmtree( path )
|
|
except shutil.Error as e:
|
|
logging.error( str(e) )
|
|
return 1
|
|
return 0
|
|
|
|
@staticmethod
|
|
def copytree ( src, dst ):
|
|
command = 'cp -r {} {}'.format( src, dst )
|
|
try:
|
|
log( command )
|
|
shutil.copytree( src, dst )
|
|
except OSError as e:
|
|
logging.error( e )
|
|
return 1
|
|
except shutil.Error as errors:
|
|
for error in errors:
|
|
logging.error( 'cp {} {}: {}'.format(src,dst,error) )
|
|
return 1
|
|
return 0
|
|
|
|
|
|
class SshCommand ( object ):
|
|
|
|
def __init__ ( self, scriptlet ):
|
|
self.scriptlet = scriptlet
|
|
|
|
def execute ( self, target ):
|
|
command = [ 'ssh', '-x', target, self.scriptlet ]
|
|
Command( command ).execute()
|
|
|
|
|
|
class Document ( object ):
|
|
|
|
def __init__ ( self, conf, document ):
|
|
self.conf = conf
|
|
self.document = os.path.basename( document )
|
|
self.rdir = os.path.dirname ( document )
|
|
|
|
def toPdf ( self ):
|
|
pdfDir = '{}/content/pdfs' .format( self.conf.pelicanDir )
|
|
stylesheet = '{}/etc/SoC-ReST.tex'.format( self.conf.pelicanDir )
|
|
documentPdf = '{}.pdf'.format( self.document )
|
|
documentRst = '{}.rst'.format( self.document )
|
|
documentTex = '{}.tex'.format( self.document )
|
|
documentRawTex = '{}-raw.tex'.format( self.document )
|
|
documentTmps = [ documentTex
|
|
, documentRawTex
|
|
, '{}.log'.format( self.document )
|
|
, '{}.out'.format( self.document )
|
|
, '{}.aux'.format( self.document )
|
|
, '{}.toc'.format( self.document )
|
|
]
|
|
targetPdf = os.path.join( pdfDir, documentPdf )
|
|
|
|
cwd = os.getcwd()
|
|
os.chdir( os.path.join(self.conf.pelicanDir,self.rdir) )
|
|
os.environ[ 'TEXINPUTS' ] = '{}/etc/images//:./images//:'.format( self.conf.pelicanDir )
|
|
Command( [ 'rst2latex', '--use-latex-toc'
|
|
, '--stylesheet={}'.format( stylesheet )
|
|
, documentRst
|
|
, documentRawTex
|
|
] ).execute()
|
|
pMulticol = re.compile( r' \\& \\\\multicolumn\{2\}\{l\|\}\{' )
|
|
fdi = open( documentRawTex, 'r' )
|
|
fdo = open( documentTex , 'w' )
|
|
for line in fdi.readlines():
|
|
fdo.write( pMulticol.sub(' \\& \\\\multicolumn{2}{p{0.6\\\\DUtablewidth}|}{',line) )
|
|
fdi.close()
|
|
fdo.close()
|
|
Command( [ 'pdflatex', '-halt-on-error', documentTex ] ).execute()
|
|
Command( [ 'pdflatex', '-halt-on-error', documentTex ] ).execute()
|
|
for file in documentTmps:
|
|
if os.path.isfile( file ):
|
|
os.unlink( file )
|
|
if not os.path.isdir( pdfDir ):
|
|
log( 'mkdir {}'.format( pdfDir ))
|
|
os.mkdir( pdfDir )
|
|
if os.path.exists( targetPdf ): os.unlink( targetPdf )
|
|
log( 'mv {} {}'.format( documentPdf, pdfDir ))
|
|
shutil.move( documentPdf, pdfDir )
|
|
os.chdir( cwd )
|
|
|
|
|
|
class Site ( object ):
|
|
|
|
def __init__ ( self, conf ):
|
|
self.conf = conf
|
|
|
|
def build ( self ):
|
|
print( 'cd {}'.format( self.conf.pelicanDir ))
|
|
os.chdir( self.conf.pelicanDir )
|
|
status = Command( [ 'pelican', '-vD', '--ignore-cache', 'content' ] ).execute()
|
|
if status: return status
|
|
if self.conf.onLepka:
|
|
Command.rmtree ( self.conf.apacheDir )
|
|
Command.copytree( './output', self.conf.apacheDir )
|
|
Command.copytree( self.conf.localDocDir, os.path.join(self.conf.apacheDir,'doc') )
|
|
|
|
def gitPush ( self ):
|
|
print( 'cd {}'.format( self.conf.pelicanDir ))
|
|
os.chdir( self.conf.pelicanDir )
|
|
lines = ''
|
|
cmd = Command( ['git', 'status', 'content', 'common', 'theme'] )
|
|
cmd.execute()
|
|
if cmd.outlog: lines = cmd.outlog.split('\n')
|
|
if lines[-2] != 'nothing to commit, working directory clean':
|
|
message = [ 'There are some uncommited changes in the site contents.' ] + lines
|
|
print( ErrorMessage( 1, message ))
|
|
Command( ['git', 'push'] ).execute()
|
|
return True
|
|
|
|
def gitCommitPdfs ( self ):
|
|
print( 'cd {}'.format( self.conf.pelicanDir ))
|
|
os.chdir( self.conf.pelicanDir )
|
|
lines = ''
|
|
cmd = Command( ['git', 'status', 'content/pdfs'] )
|
|
cmd.execute()
|
|
if cmd.outlog: lines = cmd.outlog.decode('utf-8').split('\n')
|
|
if lines[-2] != 'nothing to commit, working directory clean':
|
|
message = 'Updated PDFs, %s.' % time.strftime( '%B %d, %Y (%H:%M)' )
|
|
Command( ['git', 'add' , 'content/pdfs'] ).execute()
|
|
Command( ['git', 'commit', '-m', message ] ).execute()
|
|
return True
|
|
|
|
def remoteBuild ( self ):
|
|
Command( [ 'ssh', '-x', '-o', 'StrictHostKeyChecking no'
|
|
, self.conf.target, "echo 'Force SSH key loading.'" ] ).execute()
|
|
Command( [ 'rsync', '--rsh=/usr/bin/ssh', '-avH'
|
|
, self.conf.localDocDir
|
|
, '{}:{}'.format(self.conf.target,self.conf.remoteDocDir) ] ).execute()
|
|
remoteScript = \
|
|
' if [ ! -d {remotePelicanDir} ]; then' \
|
|
' cd {remoteGitDir};' \
|
|
' git clone gitsoc@bop-t:coriolis.lip6.fr;' \
|
|
' sudo pelican-themes -s {remotePelicanDir}/themes/nest-coriolis;' \
|
|
' sudo chown -R pelican:pelican /var/www/html;' \
|
|
' fi;' \
|
|
' cd {remotePelicanDir};' \
|
|
' git pull;' \
|
|
' if [ ! -d {pluginsDir} ]; then' \
|
|
' cd {remoteGitDir};' \
|
|
' git clone https://github.com/getpelican/pelican-plugins;' \
|
|
' cd pelican-plugins;' \
|
|
' patch -p1 -i {remotePelicanDir}/patchs/0001-bootstrap-rst.no-math.patch;' \
|
|
' fi;' \
|
|
' cd {remotePelicanDir};' \
|
|
' ./build.py -p;' \
|
|
.format( pluginsDir = self.conf.pluginsDir
|
|
, remoteGitDir = self.conf.remoteGitDir
|
|
, remotePelicanDir = self.conf.remotePelicanDir
|
|
)
|
|
SshCommand( remoteScript ).execute( self.conf.target )
|
|
|
|
|
|
if __name__ == '__main__':
|
|
usage = \
|
|
'\n' \
|
|
'\nThe "build.py" script rebuild the "coriolis.lip6.fr" website hosted' \
|
|
'\nat the Sorbonne Universite/LIP6. It can work in the following modes:' \
|
|
'\n' \
|
|
'\n1. Fully install the website on a freshly generated docker image.' \
|
|
'\n2. Update the "coriolis.lip6.fr" website.' \
|
|
'\n3. Generate a static website on my laptop ("lepka").' \
|
|
'\n4. Generate the static documentation shipped with coriolis (in git).' \
|
|
'\n' \
|
|
'\nNOTE: About the "<-C|--coriolis> remote rebuild option."' \
|
|
'\n Your ${HOME}/.ssh/config file must contain an alias for the' \
|
|
'\n "coriolis-d" host, as shown below:' \
|
|
'\n' \
|
|
'\n Host coriolis-d' \
|
|
'\n User pelican' \
|
|
'\n HostName localhost' \
|
|
'\n HostKeyAlias coriolis-d' \
|
|
'\n Port 2250' \
|
|
'\n CheckHostIP no' \
|
|
'\n ForwardAgent yes' \
|
|
'\n ForwardX11 no' \
|
|
'\n RemoteForward 2227 localhost:2227' \
|
|
'\n' \
|
|
'\n It logs as user "pelican" using the ssh port 2250 and creates' \
|
|
'\n a tunnel between port 2227 on the remote host (the web server)' \
|
|
'\n and port 2227 on the local host (your machine). You *must* have' \
|
|
'\n an ssh tunnel between your machine and "bop" on the local port' \
|
|
'\n 2227 for this to work. The "2227" tunnel between the web server' \
|
|
'\n and "bop" is used to perform "git pull".' \
|
|
'\n' \
|
|
'\n./build.py <options>'
|
|
parser = optparse.OptionParser( usage )
|
|
parser.add_option( '-p', '--pelican' , action='store_true', dest='doPelican' , help='Run pelican.' )
|
|
parser.add_option( '-P', '--pdfs' , action='store_true', dest='doPdfs' , help='Generate the PDFs.' )
|
|
parser.add_option( '-C', '--coriolis', action='store_true', dest='doCoriolis', help='Build/update the web site on the server (docker).' )
|
|
parser.add_option( '-g', '--git' , action='store_true', dest='doCommit' , help='Commit the PDFs.' )
|
|
(options, args) = parser.parse_args()
|
|
conf = Configuration()
|
|
if not os.path.isdir( conf.logDir ):
|
|
os.mkdir( conf.logDir )
|
|
logging.basicConfig( filename='logs/build-{}.log'.format(time.strftime( '%Y%m%d-%H%M' ))
|
|
, encoding='utf-8'
|
|
, format='%(asctime)s:%(levelname)s| %(message)s'
|
|
, level=logging.INFO
|
|
, force=True
|
|
)
|
|
documents = [ Document( conf, 'content/pages/users-guide/UsersGuide' )
|
|
, Document( conf, 'content/pages/python-tutorial/PythonTutorial' )
|
|
, Document( conf, 'content/pages/python-cpp/PythonCpp' )
|
|
, Document( conf, 'content/pages/design-flow/DesignFlow' )
|
|
, Document( conf, 'content/pages/stratus/Stratus' )
|
|
, Document( conf, 'content/pages/check-toolkit/CheckToolkit' )
|
|
, Document( conf, 'content/pages/rds/RDS' )
|
|
]
|
|
coriolis = Site( conf )
|
|
if options.doPdfs:
|
|
for document in documents: document.toPdf()
|
|
if options.doCommit:
|
|
coriolis.gitCommitPdfs()
|
|
if options.doPelican:
|
|
coriolis.build()
|
|
if options.doCoriolis:
|
|
coriolis.gitPush()
|
|
coriolis.remoteBuild()
|
|
sys.exit( 0 )
|