maintenance.espace

  1# -*- coding: utf-8
  2"""
  3Module d'interface avec un espace.
  4
  5Modifié le 12/03/23  @author: nicolair
  6
  7Un "espace" est un service de stockage analogue au s3 de Amazon mais proposé
  8par DigitalOcean. Ce module définit la classe `Espace`. Une instanciation de
  9cette classe réalise la mise à jour de l'espace pour refléter l'état local du
 10dépôt.
 11"""
 12import boto3
 13import os.path
 14# import copy
 15import mimetypes
 16
 17
 18class Espace:
 19    """
 20    Classe Espace.
 21
 22    """
 23
 24    def __init__(self, data, apublier_data):
 25        """
 26        Initialise la classe et met à jour l'espace.
 27
 28        Pour les fichiers publiables cad ceux de "apublier_data":
 29
 30        - récupère les clés associées et leur timestamp dans l'espace
 31        - si le fichier local est plus récent:
 32                      upload sur l'espace
 33        #### Paramètres:
 34        - data = `manifeste['espace']: dictionnaire codant les données de connexion. Exemple :
 35        
 36                {
 37                    "region_name" : "fra1",
 38                    "endpoint_url" : "https://fra1.digitaloceanspaces.com",
 39                    "bucket" : "maquisdoc-math",
 40                    "prefix" : "math-exos/"
 41                }
 42                
 43            Les données secrètes de connexion sont dans le fichier local
 44            `~/.aws/credentials`.
 45
 46        - apublier_data : liste de dictionnaires donnant les timestamps
 47        des fichiers susceptibles d'être publiés.
 48            
 49                [{chemin de fichier local : timestamp du fichier},]
 50
 51        #### Renvoie
 52
 53        None.
 54
 55        """
 56        connect_data = data['credentials']
 57        self.log = "\t Initialisation de la classe Espace \n"
 58        r_n = connect_data['region_name']
 59        e_u = connect_data['endpoint_url']
 60        self.bck_nom = connect_data['bucket']
 61        self.client = boto3.client('s3', region_name=r_n, endpoint_url=e_u)
 62        s3 = boto3.resource('s3', region_name=r_n, endpoint_url=e_u)
 63        self.bucket = s3.Bucket(connect_data['bucket'])
 64        self.prefix = connect_data['prefix']
 65        self.apublier = apublier_data  # dictio path: date
 66
 67        self.bck_times = self.get_times()  # dictio key: date
 68
 69        self.MAJ()
 70
 71    def get_times(self):
 72        """
 73        Renvoie un dictionnaire donnant les dates de modifications des
 74        fichiers de l'espace.
 75
 76               clé = key d'un fichier du dépôt dans l'espace
 77               valeur = date modification
 78        """
 79        key_times = {}
 80        for obj in self.bucket.objects.all():
 81            if (obj.key.startswith(self.prefix)
 82                    and len(obj.key) > len(self.prefix)):
 83                key_times[obj.key] = obj.last_modified
 84        self.log += '\t \t ' + str(len(key_times)) + " clés dans l'espace \n"
 85        return key_times
 86
 87    def del_objs(self, keys):
 88        """
 89        Supprime des objets et rend compte dans le journal.
 90        
 91        #### Paramètres:
 92        
 93        - `keys`: liste des clés à supprimer dans l'espace'
 94
 95        #### Renvoie
 96        
 97        None
 98        """
 99        objs = []
100        for key in keys:
101            objs.append({'Key': key})
102        response = self.bucket.delete_objects(Delete={'Objects': objs})
103        if 'Deleted' in response:
104            self.log += "\n Journal des suppressions de l'espace: \n"
105            self.log += 'Deleted : '
106            for deleted in response['Deleted']:
107                self.log += deleted['Key'] + ', '
108
109    def upload_file(self, path, key):
110        """
111        Upload un fichier dans l'espace.
112
113        Avec un ACL public et un Content-Type déduit de l'extension.
114
115        #### Parametres
116        
117        - path : chemin du fichier à uploader dans l'espace.
118        - key : clé du fichier uploadé dans l'espace.
119
120        Renvoie
121        -------
122        None.
123
124        """
125        file_name = os.path.basename(path)
126        file_mime_type, encoding = mimetypes.guess_type(file_name)
127        self.bucket.upload_file(path, key,
128                                ExtraArgs={'ACL': 'public-read',
129                                           'ContentType': file_mime_type})
130
131    def MAJ(self):
132        """
133        Mise à jour de l'espace.
134
135        Avec self.bck_times et self.apublier:
136              - supprime dans l'espace les clés
137                  qui ne correspondent pas à un fichier
138              - si fichier plus récent que clé
139                  upload du fichier dans la clé
140        """
141        key_times = self.bck_times
142        fic_times = self.apublier
143
144        # supprimer les keys qui ne sont pas des fics
145        fics = [os.path.basename(t) for t in fic_times]
146        a_supprimer = []
147        for key in key_times:
148            if os.path.basename(key) not in fics:
149                a_supprimer.append(key)
150        self.log += "\t \t " + str(len(a_supprimer)) + " clés à supprimer \n"
151        self.del_objs(a_supprimer)
152
153        # mettre à jour les keys correspondant à des fics
154        self.log += "\t \t  clés à créer ou mettre à jour \n"
155        for path in fic_times:
156            file_name = os.path.basename(path)
157            key_a_updater = self.prefix + file_name
158            fic_a_updater_time = fic_times[path]
159            #self.log += '\t \t '  ajoute des espaces inutiles si rien à updater
160            if key_a_updater in key_times:
161                key_a_updater_time = key_times[key_a_updater].timestamp()
162                if fic_a_updater_time > key_a_updater_time:
163                    self.log += key_a_updater + " : upload (maj)\n "
164                    self.upload_file(path, key_a_updater)
165            else:
166                self.log += key_a_updater + " : upload (créer) \n "
167                self.upload_file(path, key_a_updater)
168        self.log += '\n'
169
170    """
171    Méthodes qui ne sont pas utilisées
172
173    def put_objs(self, keys):
174        #Place (put) les objets de la liste keys dans l'espace.
175        #Cette méthode n'est pas utilisé actuellement, remplacée par upload'
176
177        jrnl = ''
178        bck = self.bck_nom
179        acl = 'public-read'
180        ct = 'application/pdf'
181        for key in keys:
182            bdy = open(key, mode='rb')
183            response = self.client.put_object(ACL=acl, Body=bdy, Bucket=bck,
184                                              Key=key, ContentType=ct)
185            print(str(response))
186            jrnl += '\n ' + key + ' : ' + str(response) + '\n'
187        return jrnl
188
189    def get_private_objs(self):
190        #renvoie la liste des objets avec un acl privé
191
192        bck = self.bck_nom
193        response = self.client.list_objects_v2(Bucket=bck, MaxKeys=1000)
194        objs = [content['Key']for content in response['Contents']]
195        objs_p = copy.copy(objs)
196        for key in objs:
197            response = self.client.get_object_acl(Bucket=bck, Key=key)
198            for grant in response['Grants']:
199                permission = grant['Permission']
200                grantee = grant['Grantee']
201                # print(key, grantee)
202                if 'URI' in grantee:
203                    grp = os.path.basename(grantee['URI'])
204                    # print(key, grp, permission)
205                    if (grp == 'AllUsers') and (permission == 'READ'):
206                        objs_p.remove(key)
207        return objs_p
208
209    def list_buckets(self):
210        response = self.client.list_buckets()
211        spaces = [space['Name'] for space in response['Buckets']]
212        print("Spaces List: %s" % spaces)
213
214    def get_objs(self):
215        bck = self.bck_nom
216        response = self.client.list_objects_v2(Bucket=bck, MaxKeys=1000)
217        objs_t = [[content['Key'], content['LastModified'].timestamp()]
218                  for content in response['Contents']]
219        return objs_t
220
221    """