osm_common/fslocal.py

   1 # -*- coding: utf-8 -*-
   2
   3 # Copyright 2018 Telefonica S.A.
   4 #
   5 # Licensed under the Apache License, Version 2.0 (the "License");
   6 # you may not use this file except in compliance with the License.
   7 # You may obtain a copy of the License at
   8 #
   9 #    http://www.apache.org/licenses/LICENSE-2.0
  10 #
  11 # Unless required by applicable law or agreed to in writing, software
  12 # distributed under the License is distributed on an "AS IS" BASIS,
  13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
  14 # implied.
  15 # See the License for the specific language governing permissions and
  16 # limitations under the License.
  17
  18 import os
  19 import logging
  20 # import tarfile
  21 from http import HTTPStatus
  22 from shutil import rmtree
  23 from osm_common.fsbase import FsBase, FsException
  24
  25 __author__ = "Alfonso Tierno <alfonso.tiernosepulveda@telefonica.com>"
  26
  27
  28 class FsLocal(FsBase):
  29
  30     def __init__(self, logger_name='fs', lock=False):
  31         super().__init__(logger_name, lock)
  32         self.path = None
  33
  34     def get_params(self):
  35         return {"fs": "local", "path": self.path}
  36
  37     def fs_connect(self, config):
  38         try:
  39             if "logger_name" in config:
  40                 self.logger = logging.getLogger(config["logger_name"])
  41             self.path = config["path"]
  42             if not self.path.endswith("/"):
  43                 self.path += "/"
  44             if not os.path.exists(self.path):
  45                 raise FsException("Invalid configuration param at '[storage]': path '{}' does not exist".format(
  46                     config["path"]))
  47         except FsException:
  48             raise
  49         except Exception as e:  # TODO refine
  50             raise FsException(str(e))
  51
  52     def fs_disconnect(self):
  53         pass  # TODO
  54
  55     def mkdir(self, folder):
  56         """
  57         Creates a folder or parent object location
  58         :param folder:
  59         :return: None or raises and exception
  60         """
  61         try:
  62             os.mkdir(self.path + folder)
  63         except FileExistsError:  # make it idempotent
  64             pass
  65         except Exception as e:
  66             raise FsException(str(e), http_code=HTTPStatus.INTERNAL_SERVER_ERROR)
  67
  68     def dir_rename(self, src, dst):
  69         """
  70         Rename one directory name. If dst exist, it replaces (deletes) existing directory
  71         :param src: source directory
  72         :param dst: destination directory
  73         :return: None or raises and exception
  74         """
  75         try:
  76             if os.path.exists(self.path + dst):
  77                 rmtree(self.path + dst)
  78
  79             os.rename(self.path + src, self.path + dst)
  80
  81         except Exception as e:
  82             raise FsException(str(e), http_code=HTTPStatus.INTERNAL_SERVER_ERROR)
  83
  84     def file_exists(self, storage, mode=None):
  85         """
  86         Indicates if "storage" file exist
  87         :param storage: can be a str or a str list
  88         :param mode: can be 'file' exist as a regular file; 'dir' exists as a directory or; 'None' just exists
  89         :return: True, False
  90         """
  91         if isinstance(storage, str):
  92             f = storage
  93         else:
  94             f = "/".join(storage)
  95         if os.path.exists(self.path + f):
  96             if not mode:
  97                 return True
  98             if mode == "file" and os.path.isfile(self.path + f):
  99                 return True
 100             if mode == "dir" and os.path.isdir(self.path + f):
 101                 return True
 102         return False
 103
 104     def file_size(self, storage):
 105         """
 106         return file size
 107         :param storage: can be a str or a str list
 108         :return: file size
 109         """
 110         if isinstance(storage, str):
 111             f = storage
 112         else:
 113             f = "/".join(storage)
 114         return os.path.getsize(self.path + f)
 115
 116     def file_extract(self, tar_object, path):
 117         """
 118         extract a tar file
 119         :param tar_object: object of type tar
 120         :param path: can be a str or a str list, or a tar object where to extract the tar_object
 121         :return: None
 122         """
 123         if isinstance(path, str):
 124             f = self.path + path
 125         else:
 126             f = self.path + "/".join(path)
 127         tar_object.extractall(path=f)
 128
 129     def file_open(self, storage, mode):
 130         """
 131         Open a file
 132         :param storage: can be a str or list of str
 133         :param mode: file mode
 134         :return: file object
 135         """
 136         try:
 137             if isinstance(storage, str):
 138                 f = storage
 139             else:
 140                 f = "/".join(storage)
 141             return open(self.path + f, mode)
 142         except FileNotFoundError:
 143             raise FsException("File {} does not exist".format(f), http_code=HTTPStatus.NOT_FOUND)
 144         except IOError:
 145             raise FsException("File {} cannot be opened".format(f), http_code=HTTPStatus.BAD_REQUEST)
 146
 147     def dir_ls(self, storage):
 148         """
 149         return folder content
 150         :param storage: can be a str or list of str
 151         :return: folder content
 152         """
 153         try:
 154             if isinstance(storage, str):
 155                 f = storage
 156             else:
 157                 f = "/".join(storage)
 158             return os.listdir(self.path + f)
 159         except NotADirectoryError:
 160             raise FsException("File {} does not exist".format(f), http_code=HTTPStatus.NOT_FOUND)
 161         except IOError:
 162             raise FsException("File {} cannot be opened".format(f), http_code=HTTPStatus.BAD_REQUEST)
 163
 164     def file_delete(self, storage, ignore_non_exist=False):
 165         """
 166         Delete storage content recursively
 167         :param storage: can be a str or list of str
 168         :param ignore_non_exist: not raise exception if storage does not exist
 169         :return: None
 170         """
 171         try:
 172             if isinstance(storage, str):
 173                 f = self.path + storage
 174             else:
 175                 f = self.path + "/".join(storage)
 176             if os.path.exists(f):
 177                 rmtree(f)
 178             elif not ignore_non_exist:
 179                 raise FsException("File {} does not exist".format(storage), http_code=HTTPStatus.NOT_FOUND)
 180         except (IOError, PermissionError) as e:
 181             raise FsException("File {} cannot be deleted: {}".format(f, e), http_code=HTTPStatus.INTERNAL_SERVER_ERROR)
 182
 183     def sync(self, from_path=None):
 184         pass  # Not needed in fslocal
 185
 186     def reverse_sync(self, from_path):
 187         pass  # Not needed in fslocal