@fixed

app.py

@@ -1,3 +1,4 @@
+# coding: utf-8
 import os
 import json
 import requests
@@ -21,10 +22,14 @@ logging.basicConfig(format='%(asctime)s %(message)s')
 logging.getLogger().addHandler(logging.StreamHandler(sys.stdout))
 
 
+def executeSudoCmd(myCmd):
+    myCmd = sudoCmd(myCmd)
+    executeCmd(myCmd)
+
 
 def sudoCmd(cmd):
-    cmd.replace("'","\'")
-    return 'sudo sh -c \'' + cmd + '\''
+    return sudoPath + cmd
+    #return sudoPath + ' /bin/sh -c \'' + cmd.replace('\'', "\\'") + '\''
 
 """
  print and save content
@@ -90,6 +95,65 @@ def getArgValue(name):
 
     return value
 
+def unlockSourceCmd(jupyterName):
+    return chattrPath + ' -i \'' +  buildPath(['home',jupyterName,'source']) + '\''
+
+def lockSourceCmd(jupyterName):
+    return chattrPath + ' +i \'' +  buildPath(['home',jupyterName,'source']) + '\''
+
+def rmCmd(path):
+    return rmPath + '-rf ' + path
+
+def chownCmd(path,user):
+    return chownPath + ' -R ' + user + ':' + user + ' \'' + path + '\''
+
+def chmodCmd(path,chmod):
+    return chmodPath + ' ' + chmod + ' \'' + path + '\''
+
+def mvCmd(pathFrom,pathTo,userTo):
+    return [
+        mvPath + ' \'' + pathFrom + '\' \'' + pathTo + '\'',
+        chownCmd(pathTo,userTo)
+    ]
+def mkdirCmd(path,user,chmod=770):
+    if type(chmod).__name__ == 'int' :
+        chmod = str(chmod)
+
+    result = [
+        mkdirPath + ' -p \'' + path + '\'',
+    ]
+    if user != None:
+        result.append(chownCmd(path,user))
+    if chmod != None:
+         result.append(chmodCmd(path,chmod))
+         
+    return result
+
+def executeSudoCmds(cmds):
+    end = []
+    for cmd in cmds:
+        if type(cmd).__name__ == 'list' :
+            for subCmd in cmd:
+                end.append(subCmd)
+
+        else:
+            end.append(cmd)
+    dump(end)
+
+    cmd = sudoPath + (' ' + cmdsSeparator + ' ' + sudoPath).join(end)
+    executeCmd(cmd)
+    #executeSudoCmd('; '.join(end))
+
+def executeCmd(cmd):
+    dump(cmd)
+    os.system(cmd)
+
+def copyCmd(pathFrom,pathTo,userTo):
+    return [
+        cpPath + ' -r \'' + pathFrom + '\' \'' + pathTo + '\'',
+        chownCmd(pathTo,userTo)
+    ]
+
 # configurations par défaut
 
 # hote par défaut: 0.0.0.0
@@ -122,6 +186,9 @@ chmodPath = '/bin/chmod '
 grepPath = '/bin/grep '
 mkdirPath = '/bin/mkdir '
 
+
+cmdsSeparator = '&&'
+
 # début configuration --
 """
 configurations
@@ -205,10 +272,10 @@ api = Api(app)
 currentUserName = os.popen('echo "$USER"').read().rstrip()
 
 def changeFolderRightForGroup(jupyterUsername):
-    return sudoPath + ' ' + usermodPath + ' -a -G ' + jupyterUsername + ' ' + currentUserName
+    return usermodPath + ' -a -G ' + jupyterUsername + ' ' + currentUserName
 
 def addCurrentUserToJupyterUserGroup(jupyterUsername):
-    return sudoPath + ' ' + chmodPath + ' 770 ' + buildPath(['home',jupyterUsername])
+    return chmodPath + ' 770 ' + buildPath(['home',jupyterUsername])
 
 
 
@@ -229,16 +296,13 @@ def onRunCallback():
     # ajoute l'utilisateur courant au groupe de l'utilisateur jupyter
     for jupyterUser in allJupyterUsers:
         cmds.append(changeFolderRightForGroup(jupyterUser))
-    separator = ' && '
-    dump(separator.join(cmds))
-    dump(os.popen(separator.join(cmds)).read())
+    executeSudoCmds(cmds)
 
     # change les droits des dossiers pour leur attribuer les groupes
     cmds = []
     for jupyterUser in allJupyterUsers:
         cmds.append(addCurrentUserToJupyterUserGroup(jupyterUser))
-    dump(separator.join(cmds))
-    os.system(separator.join(cmds))
+    executeSudoCmds(cmds)
 
 onRunCallback()
 
@@ -270,7 +334,7 @@ va dans le repertoire de l'utilisateur
 @param username
 """
 def goToUser(username):
-    return runAsUser(username,'cd /home/' + username)
+    return 'cd /home/' + username
 
 
 """
@@ -417,16 +481,16 @@ ecrit un fichier
 
 """
 def write(username,path,content):
+    # écrit le fichier temporaire
     tempPath = '/tmp/' + uuid.uuid4().hex
     f = open(tempPath, "w")
     f.write(content)
     f.close()
 
-    myCmd = sudoPath + ' ' + mvPath + ' \'' + tempPath + '\' \'' + path + '\''
-    myCmd += ' && ' + sudoPath + ' ' + chownPath + ' ' + username + ':' + username + ' \'' + path + '\''
-
-    dump(myCmd)
-    os.system(myCmd)
+    # déplace le fichier temporaire dans le bon dossier
+    myCmds = []
+    myCmds.append(mvCmd(tempPath,path,username))
+    executeSudoCmds(myCmds)
 
 """
 
@@ -577,7 +641,6 @@ def initUserSpace(jupyterUsername,folder,notebookname,fromurl = None,content = '
     path = getNotebookPath(jupyterUsername,folder,notebookname)
     dump('initUserSpace')
    
-
     if fromurl != None:
         data = fromurl.split('/')
         sizeOfData = len(data)
@@ -592,44 +655,48 @@ def initUserSpace(jupyterUsername,folder,notebookname,fromurl = None,content = '
 
         # dossier ./source
         # débloquage de l'origine
-        copyCmd = sudoPath + ' ' + chattrPath + ' -i \'' +  buildPath(['home',fromJupyterUuid,'source']) + '\''
-        copyCmd += ' && ' + sudoPath + ' ' + chattrPath + ' -i \'' +  buildPath(['home',jupyterUsername,'source']) + '\''
-        # déplace le dossier
-        copyCmd += ' && ' + sudoPath + ' ' + mvPath + ' \'' + buildPath(['home',fromJupyterUuid,'source',fromFolder]) + '\' \'' + buildPath(['home',jupyterUsername,'source',folder]) + '\''
-        # corrige les droits
-        copyCmd += ' && ' + chownPath + ' -R ' + jupyterUsername + ' \'' + buildPath(['home',fromJupyterUuid,'source',folder]) + '\''
-        copyCmd += ' && ' + sudoPath + ' ' + chattrPath + ' +i \'' +  buildPath(['home',fromJupyterUuid,'source']) + '\''
-        copyCmd += ' && ' + sudoPath + ' ' + chattrPath + ' +i \'' +  buildPath(['home',jupyterUsername,'source']) + '\''
-        dump(copyCmd)
-        os.system(copyCmd)
-
-        dump( buildPath(['home',fromJupyterUuid,'source',fromFolder]))
-        dump( buildPath(['home',jupyterUsername,'source',folder]) )
+        mvCmds = []
+        mvCmds.append(unlockSourceCmd(fromJupyterUuid))
+        mvCmds.append(unlockSourceCmd(jupyterUsername))
         
+        # déplace le dossier
+        mvCmds.append(mvCmd(
+            buildPath(['home',fromJupyterUuid,'source',fromFolder]),
+            buildPath(['home',jupyterUsername,'source',folder])
+        ))
+
+        mvCmds.append(lockSourceCmd(fromJupyterUuid))
+        mvCmds.append(lockSourceCmd(jupyterUsername))
+
+        executeSudoCmds(mvCmds)
+
         # déplace le fichier du notebook s'il existe
-        moveCmd = sudoPath + ' ' + mvPath + ' \'' + buildPath(['home',jupyterUsername,'source',folder,fromNotebookName]) + '\' \'' + buildPath(['home',jupyterUsername,'source',folder,notebookname]) + '\''
-        dump(moveCmd)
-        os.system(moveCmd)
+        moveCmd = mvCmd(
+            buildPath(['home',jupyterUsername,'source',folder,fromNotebookName]),
+            buildPath(['home',jupyterUsername,'source',folder,notebookname]),
+            jupyterUsername
+        )
+        executeSudoCmds(moveCmd)
 
     else:
          # -- config notebook jupyter
         # creation des dossiers
 
         # dossier ./source
-        myCmd =  sudoPath + ' -u ' + jupyterUsername + ' ' + mkdirPath + ' -p \'' + buildPath(['home',jupyterUsername,'source']) + '\''
-        dump(myCmd) 
-        dump(os.system(myCmd))
+        mkdirCmds = mkdirCmd(buildPath(['home',jupyterUsername,'source']),jupyterUsername)
+        executeSudoCmds(mkdirCmds)
         
         # débloquage de source
-        myCmd = sudoPath + ' ' + chattrPath + ' -i \'' + buildPath(['home',jupyterUsername,'source']) + '\''
+        myCmds = []
+        myCmds.append(unlockSourceCmd(jupyterUsername))
+
         # dossier ./[folder]
-        myCmd += ' && ' + sudoPath + ' -u ' + jupyterUsername + ' ' + mkdirPath + ' \'' + buildPath(['home',jupyterUsername,'source',folder]) + '\''
+        myCmds.append(mkdirCmd(buildPath(['home',jupyterUsername,'source',folder]),jupyterUsername))
+
         # bloquage du source
-        myCmd += ' && ' + sudoPath + ' ' + ' ' + chattrPath + ' +i \'' + buildPath(['home',jupyterUsername,'source']) + '\''
+        myCmds.append(lockSourceCmd(jupyterUsername))
 
-        dump(myCmd)   
-        dump(os.popen(myCmd).read())
-        #os.system(myCmd)
+        executeSudoCmds(myCmds)
 
     if content != '': 
         write(jupyterUsername,buildPath(['home',jupyterUsername,'source',folder,notebookname]),content)
@@ -686,6 +753,38 @@ def index():
 def cleanQuotes(string):
     return urllib.parse.unquote_plus(string)
 
+def nbGraderInstallCmd(user,options):
+    result = [
+        goToUser(user),
+        jupyterPath + ' ' + nbextensionPath + ' install --user --py nbgrader',
+        jupyterPath + ' ' + nbextensionPath + ' disable --user --py nbgrader'
+    ]
+
+    for option in options:
+        result.append(jupyterPath + ' ' + nbextensionPath + ' enable --user ' + option)
+    
+    return result
+
+def writeConfigurations(jupyterUsername,useSource=True):
+    # config du notebook jupyter => changement de la racine d'exploration
+    mkdirCmds = mkdirCmd(buildPath(['home',jupyterUsername,'.jupyter']),jupyterUsername,770)
+    executeSudoCmds(mkdirCmds)
+
+    configContents = []
+    if useSource:
+        configContents.append('c.FileContentsManager.root_dir=\'' + buildPath(['home',jupyterUsername,'source']) + '\'')
+        configContents.append('c.NotebookApp.notebook_dir=\'' + buildPath(['home',jupyterUsername,'source']) + '\'')
+    
+    configContents.append('c.MappingKernelManager.cull_idle_timeout = ' + timeout)
+    configContents.append('c.MappingKernelManager.shutdown_no_activity_timeout = ' + timeout)
+    
+    write(jupyterUsername,buildPath(['home',jupyterUsername,'.jupyter','jupyter_notebook_config.py']),"\n".join(configContents) + "\n")
+
+    # vérouille les configurations
+    #myCmd = 'chattr +i ' +  buildPath(['home',jupyterUsername,'.jupyter'])
+    #myCmd += ' && chattr +i ' +  buildPath(['home',jupyterUsername,'.jupyter','jupyter_notebook_config.py'])
+    #os.system(myCmd)
+
 """
 url: [host]/trainer/<username>/<folder>/<notebookName>
 """
@@ -726,42 +825,18 @@ def createTrainerServer(username,folder,notebookname):
         # + change les droits du groupe sur le dossier de l'utilisateur
         jupyterUsername = getJupyterName(username)
         cmd = changeFolderRightForGroup(jupyterUsername)
-        dump(cmd)
-        os.system(cmd)
+        executeCmd(cmd)
 
         cmd = addCurrentUserToJupyterUserGroup(jupyterUsername)
-        dump(cmd)
-        os.system(cmd)
+        executeCmd(cmd)
 
         # configuration des extensions de l'utilisateur
         # config formateur de nbgrader
-        myCmd = goToUser(jupyterUsername)
-        myCmd += ' && ' + jupyterPath + ' ' + nbextensionPath + ' install --user --py nbgrader'
-        myCmd += ' && ' +  jupyterPath + ' ' + nbextensionPath + ' disable --user --py nbgrader'
-        myCmd += ' && ' +  jupyterPath + ' ' + nbextensionPath + ' enable --user create_assignment/main'
-        myCmd += ' && ' +  jupyterPath + ' ' + nbextensionPath + ' enable --user validate_assignment/main'
-        
-        myCmd = sudoCmd(myCmd)
-        dump(myCmd)
-        os.system(myCmd)
-
-        # config du notebook jupyter => changement de la racine d'exploration
-        myCmd = sudoPath + ' ' + mkdirPath + ' -p ' + buildPath(['home',jupyterUsername,'.jupyter'])
-        myCmd += ' && ' + sudoPath + ' ' + chownPath + ' ' + jupyterUsername + ' ' + buildPath(['home',jupyterUsername,'.jupyter'])
-        myCmd += ' && ' + sudoPath + ' ' + chmodPath + ' 770 ' + ' ' + buildPath(['home',jupyterUsername,'.jupyter'])
-        os.system(myCmd)
+        myCmds = nbGraderInstallCmd(jupyterUsername,['create_assignment/main','validate_assignment/main'])
+        executeSudoCmds(myCmds)
 
         #myCmd += ' && ' + sudoPath + ' -u ' + currentUserName + ' ' + chmodPath + ' 770 ' + buildPath(['home',jupyterUsername,'.jupyter'])
-        configContent = 'c.FileContentsManager.root_dir=\'' + buildPath(['home',jupyterUsername,'source']) + '\'' + "\n"
-        configContent += 'c.NotebookApp.notebook_dir=\'' + buildPath(['home',jupyterUsername,'source']) + '\'' + "\n"
-        configContent += 'c.MappingKernelManager.cull_idle_timeout = ' + timeout + "\n"
-        configContent += 'c.MappingKernelManager.shutdown_no_activity_timeout = ' + timeout + "\n"
-        write(jupyterUsername,buildPath(['home',jupyterUsername,'.jupyter','jupyter_notebook_config.py']),configContent)
-
-        # vérouille les configurations
-        myCmd = 'chattr +i ' +  buildPath(['home',jupyterUsername,'.jupyter'])
-        myCmd += ' && chattr +i ' +  buildPath(['home',jupyterUsername,'.jupyter','jupyter_notebook_config.py'])
-        os.system(myCmd)
+        writeConfigurations(jupyterUsername)
 
         #dump(os.popen(myCmd).read())
 
@@ -814,49 +889,26 @@ def createStudentServer(trainername,username,folder,notebookname):
     jupyterUsername = getJupyterName(username)
     trainerJupyterUsername = getJupyterName(trainername)
 
-#
-# cas d'une creation de compte utilisateur, il faut le configurer en tant que formateur
+    #
+    # cas d'une creation de compte utilisateur, il faut le configurer en tant que formateur
     if 'token' in result['resultUser'] and ((not 'status' in result['result']) or (result['result']['status'] != '400')):
         # ajout l'utilisateur courant au groupe du nouvel utiliosateur
         # + change les droits du groupe sur le dossier de l'utilisateur
         jupyterUsername = getJupyterName(username)
         cmd = changeFolderRightForGroup(jupyterUsername)
-        dump(cmd)
-        os.system(cmd)
+        executeCmd(cmd)
 
         cmd = addCurrentUserToJupyterUserGroup(jupyterUsername)
-        dump(cmd)
-        os.system(cmd)
+        executeCmd(cmd)
 
-        # configuration des extensions de l'utilisateur
-        # config formateur de nbgrader
-        myCmd = goToUser(jupyterUsername)
-        myCmd += ' && ' + nbextensionPath + ' install --user --py nbgrader'
-        myCmd += ' && ' + nbextensionPath + ' disable --user --py nbgrader'
-        myCmd = runAsUser(jupyterUsername,myCmd)
-        dump(myCmd)
-        os.system(myCmd)
+        myCmds = nbGraderInstallCmd(jupyterUsername,[])
+        executeSudoCmds(myCmds)
 
         # config du notebook jupyter => changement de la racine d'exploration
-        myCmd = sudoPath + ' ' + mkdirPath + ' -p ' + buildPath(['home',jupyterUsername,'.jupyter'])
-        myCmd += ' && ' + sudoPath + ' ' + chownPath + ' ' + jupyterUsername + ' ' + buildPath(['home',jupyterUsername,'.jupyter'])
-        myCmd += ' && ' + sudoPath + ' ' + chmodPath + ' 770 ' + ' ' + buildPath(['home',jupyterUsername,'.jupyter'])
-        os.system(myCmd)
+        mkdirCmds = mkdirCmd(buildPath(['home',jupyterUsername,'.jupyter']),jupyterUsername,770)
+        executeSudoCmds(mkdirCmds)
 
-        #myCmd += ' && ' + sudoPath + ' -u ' + currentUserName + ' ' + chmodPath + ' 770 ' + buildPath(['home',jupyterUsername,'.jupyter'])
-        configContent = 'c.FileContentsManager.root_dir=\'' + buildPath(['home',jupyterUsername,'source']) + '\'' + "\n"
-        configContent += 'c.NotebookApp.notebook_dir=\'' + buildPath(['home',jupyterUsername,'source']) + '\'' + "\n"
-        configContent += 'c.MappingKernelManager.cull_idle_timeout = ' + timeout + "\n"
-        configContent += 'c.MappingKernelManager.shutdown_no_activity_timeout = ' + timeout + "\n"
-        write(jupyterUsername,buildPath(['home',jupyterUsername,'.jupyter','jupyter_notebook_config.py']),configContent)
-
-        # vérouille les configurations
-        myCmd = 'chattr +i ' +  buildPath(['home',jupyterUsername,'.jupyter'])
-        myCmd += ' && chattr +i ' +  buildPath(['home',jupyterUsername,'.jupyter','jupyter_notebook_config.py'])
-        os.system(myCmd)
-
-        #configPath =  '/home/' + jupyterUsername + '}/.jupyter/jupyter_notebook_config.py'
-        #write('root',configPath,configContent)
+        writeConfigurations(jupyterUsername)
 
         # stop server instance
         # 400 = deja stoppe
@@ -866,20 +918,19 @@ def createStudentServer(trainername,username,folder,notebookname):
     initUserSpace(jupyterUsername,folder,notebookname,None)
 
     # copie du dossier formateur
-    fromPath = buildPath(['home',trainerJupyterUsername,'source',folder])
-    toPath = buildPath(['home',jupyterUsername,'source'])
-    
-    # dévérouillage des dossiers
-    copyCmd = ' ' + sudoPath + ' ' + chattrPath + ' -i \'' + buildPath(['home',jupyterUsername,'source']) + '\''
-    copyCmd += '&& ' + sudoPath + ' ' + chattrPath + ' -i \'' + buildPath(['home',trainerJupyterUsername,'source']) + '\''
-    # copie
-    copyCmd += '&& ' + sudoPath + ' ' + cpPath + ' -r \'' + fromPath + '\' \'' + toPath + '\''
-    copyCmd += ' && ' + sudoPath + ' ' + chownPath + ' -R ' + jupyterUsername + ' \'' + toPath + '\''
-    # vérouillage des dossiers
-    copyCmd += ' && ' + sudoPath + ' ' + chattrPath + ' +i \'' + buildPath(['home',jupyterUsername,'source']) + '\''
-    copyCmd += ' && ' + sudoPath + ' ' + chattrPath + ' +i \'' + buildPath(['home',trainerJupyterUsername,'source']) + '\''
-    dump(copyCmd)
-    os.system(copyCmd)
+    copyCmds = []
+    copyCmds.append(unlockSourceCmd(jupyterUsername))
+    copyCmds.append(unlockSourceCmd(trainerJupyterUsername))
+    copyCmds.append(
+        copyCmd(
+            buildPath(['home',trainerJupyterUsername,'source',folder]),
+            buildPath(['home',jupyterUsername,'source']),
+            jupyterUsername
+        )
+    )
+    copyCmds.append(lockSourceCmd(jupyterUsername))
+    copyCmds.append(lockSourceCmd(trainerJupyterUsername))
+    executeSudoCmds(copyCmds)
 
     # retourne l'url menant au notebook + les infos token utilisateur en cas d'ouverture de son serveur
     userToken = None
@@ -1150,21 +1201,22 @@ def cloneNotebook(fromuuid,touuid,fromfolder,tofolder,reset):
     dump(pathTo)
 
     # dévérouille les dossiers
-    cloneCommand =  sudoPath + ' ' + chattrPath + ' -i \'' + pathSourceFrom + '\''
-    cloneCommand +=  ' && ' + sudoPath + ' ' + chattrPath + ' -i \'' + pathSourceTo + '\''
+    cloneCommands = []
+    cloneCommands.append(unlockSourceCmd(jupyterUuidFrom))
+    cloneCommands.append(unlockSourceCmd(jupyterUuidTo))
+
     if os.path.isdir(pathFrom) : 
         if os.path.isdir(pathTo) and reset == '1' and pathFrom != pathTo: 
             # suppression
-            cloneCommand += ' && ' + sudoPath + ' ' + rmPath + ' -rf \'' + pathTo + '\''
+            cloneCommands.append(rmCmd(pathTo))
+
         # copie
-        cloneCommand  += ' && ' + sudoPath + ' ' + cpPath + ' -r \'' + pathFrom + '/\' \'' + pathTo + '/\''
-        cloneCommand  += ' && ' + sudoPath + ' ' + chownPath + ' -R ' + jupyterUuidTo + ' \'' + pathSourceTo + '\''
+        cloneCommands.append(copyCmd(pathFrom,buildPath(['home',jupyterUuidTo,'source','']),jupyterUuidTo))
 
-    cloneCommand +=  ' && ' + sudoPath + ' ' + chattrPath + ' +i \'' + pathSourceFrom + '\''
-    cloneCommand +=  ' && ' + sudoPath + ' ' + chattrPath + ' +i \'' + pathSourceTo + '\''
+    cloneCommands.append(lockSourceCmd(jupyterUuidFrom))
+    cloneCommands.append(lockSourceCmd(jupyterUuidTo))
 
-    dump(cloneCommand)
-    os.system(cloneCommand)
+    executeSudoCmds(cloneCommands)
 
     return json.dumps({ 'result':True,'folder': tofolder }),200