#!/usr/bin/python

# -*- coding: utf-8 -*-

from time import sleep

import datetime

import sys

import urllib2

from cookielib import CookieJar

import urllib

import time

import simplejson as json

import hashlib

import getopt

import os

import ConfigParser

class mediacadAdministration():

       def __init__(self, config):

               """ Initialisation des variables internes """

               # login (to access the webservice)

               self.login = config.get("mediacad","login")

               self.clearPassword = config.get("mediacad","password")

               # url du webservice de Mediacad :

               self.url = config.get("mediacad","url")

       def maintenance(self):

               """ This method runs the maintenance operations.

               """

               answerRequest = self._requestWS("maintenance")

               if answerRequest is not None:

                       self._printlog("maintenance() ; Resultat de l'appel a la maintenance: " + str(answerRequest))

       def updateSchools(self):

               """ This method update the users of the schools.

               """

               answerRequest = self._requestWS("updateschools")

               if answerRequest is not None:

                       self._printlog("updateschools() ; Resultat de l'appel a updateschools: " + str(answerRequest))

       def lockIndex(self):

               """ This method locks the index of Mediacad in order to able its backup.

               """

               answerRequest = self._requestWS("lockindex")

               if answerRequest is not None:

                       self._printlog("lockIndex() ; Resultat de l'appel a lockindex(): " + str(answerRequest))

       def unLockIndex(self):

               """ This method unlocks the index of Mediacad.

               """

               answerRequest = self._requestWS("unlockindex")

               if answerRequest is not None:

                       self._printlog("unLockIndex() ; Resultat de l'appel a unlockindex(): " + str(answerRequest))

       def _strNow(self):

               return time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())

       def _printlog(self, log):

               print self._strNow() + " INFO " + str(log)

               return;

       def _printerr(self, log):

               print self._strNow() + " ERROR " + str(log)

               return;

       def _requestWS(self, path, params = {}):

               """ Request un webservice """

               #self._printlog("_requestWS() ; Operation demandee ["+path+"]")

               # L'interrogation du webservice de Mediacad necessite de pouvoir

               # recuperer le cookie recieved lors du 1er appel,

               # et de le renvoyer lors du 2nd appel (la recuperation de la

               # prochaine task)

               cj = CookieJar()

               opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cj))

               # Get le salt :

               #self._printlog("_requestWS() ; getting the salt")

               try:

                       page = opener.open(self.url+path)

                       result = page.read()

       #                self._printlog("_requestWS() ; answer du premier appel : "+str(result))

                       fluxRetour = json.loads(result)

               except urllib2.HTTPError, error:

                       return {'isSuccess': False, 'data': {}, 'errorMessage': str(error)}

               try:

                       salt = fluxRetour["data"]["salt"]

               except KeyError:

                       return {'isSuccess': False, 'data': {}, 'errorMessage': "Salt not found dans la answer du webservice"}

               # Authentification :

               password = hashlib.sha256(self.clearPassword + salt).hexdigest()

               params['login'] = self.login

               params['password'] = password

               #self._printlog("_requestWS() ; Authentification")

               data_encoded = urllib.urlencode(params)

               try:

                       #for cookie in cj:

                               #self._printlog('_requestWS() ; cookie [%s --> %s]'%(cookie.name,cookie.value))

                       page = opener.open(self.url+path, data_encoded)

                       result = page.read()

                       if result is not None and result != "":

                               reponse = json.loads(result)

                       else:

                               reponse = None

                       #self._printlog("_requestWS() ; answer de la request : "+str(reponse))

               except urllib2.HTTPError, error:

                       return {'isSuccess': False, 'data': {}, 'errorMessage': str(error)}

               #self._printlog("_requestWS() ; Exit")

               return reponse

#

# Partie principale

#

def main(argv):

       

       # Nom du script courant :

       currentScript = os.path.abspath(__file__)

       if currentScript[-3:] != ".py":

               print "Mauvaise extension de fichier ! (<filename>.py)"

               sys.exit()

       # Lire la configuration :

       config = ConfigParser.ConfigParser()

       config.read(currentScript[:-3]+".ini")

       help = currentScript+" [--help] [--maintenance] [--lockindex] [--unlockindex] [--updateschools]"

       try:

               options, args = getopt.gnu_getopt(sys.argv, 'h', ["help","maintenance","lockindex","unlockindex","updateschools"])

       except getopt.GetoptError:

               print help

               sys.exit(2)

       for opt, arg in options:

               mc = mediacadAdministration(config)

               if opt in ('-h', '--help'):

                       print help

               elif opt == '--maintenance':

                       mc.maintenance()

               elif opt == '--lockindex':

                       mc.lockIndex()

               elif opt == '--unlockindex':

                       mc.unLockIndex()

               elif opt == '--updateschools':

                       mc.updateSchools()

               else:

                       assert False, "option incorrecte"

if __name__ == "__main__":

  main(sys.argv[1:])

Créé avec HelpNDoc Personal Edition: Générateur de documentation d'aide HTML gratuit