tr_fileabstraction.r2py

"""
<Program Name>
  tr_fileabstraction.r2py

<Started>
  March, 2011

<Author>
  Lukas Puehringer, University of Vienna
  lukas.puehringer@univie.ac.at

<Purpose>
  The file abstraction is a collection of wrapping functions
  that extend the Repy API file operations, adding a user property
  and a namespace translation.

"""
dy_import_module_symbols("base64.r2py")
dy_import_module_symbols("upper_dot_lower.py")

def _encode_path(path):
  # Base64 encode a path with a user prefix (urlsafe, -_)
  path_enc = base64_urlsafe_b64encode(path)

  # Replace trailing output padding equal sign(s) with dots
  # for RepyV2 valid filenames (part 1)
  path_enc = path_enc.replace("=", ".")

  # Replace upper case with dot-lower for RepyV2
  # valid filenames (part 2)
  return encode_dot_lower(path_enc)


def _decode_path(path_enc):
  # Convert dot-lower character converted characters back to upper case
  path = decode_dot_lower(path_enc)

  # Convert trailing dots back to equal signs
  path = path.replace(".", "=")

  # Base64 ecnode a urlsafe filename
  path = base64_urlsafe_b64decode(path)

  return fn


def _is_user_file(user, encoded_path):
  """
  <Purpose>
    Helper method to find out if a file belongs to a user.
    Identifies user ownership by decoding a base64 encoded path.
  <Arguments>
    user (string)
      Sandbox User Name
    encoded_path (string)
      The b64 encoded filename under which the file is
      stored in the vessel.
        (The decoded path is in the form:
        "<user>/<path>/<to>/<filename>")
  <Returns>
    user_path (string) | flase
      The decoded path or False if file does not belong to theuser.
  """

  path = _decode_path(encoded_path)

  if path.startswith(user):
    return True

  return False


def tr_listdir(user):
  """
  <Purpose>
    Emulates repy's listdir() method. But only lists files
    that are owned by the calling user.
  <Arguments>
    user (string)
      The sandbox user whose files should be listed.
  <Returns>
    file_list_user
      A list with the files' decoded paths, without the usernames.
  """

  file_list_user = []

  # Decode each path and return only paths that start with the username
  # Left strip the username and sort the result before returning
  for encoded_path in listfiles():
    path = _decode_path(encoded_path)

    if path.startswith(user):
      virtual_path = path[len(user):]
      file_list_user.append(virtual_path)

  return file_list_user.sort()

def tr_open(user, virtual_path, mode=False):
  """
  <Purpose>
    Emulates repy's open() method.
  <Arguments>
    user (string)
      The sandbox user whose file should be opened.
    virtual_path (string)
      the path which will be prefixed with the user name and
      b64 encoded before it is safed to the vessel.
    create (boolean)
      A Boolean flag which specifies if the file should be created
      if it does not exist.   If the file exists, this flag has no effect.
      (optional, default is false)
  <Exceptions>
    IOError
     if the file does not exist and is opened in wrong mode.
  <Returns>
    a repy file object.
  """

  encoded_path = _encode_path(user + virtual_path)

  try:
    return openfile(encoded_path, mode)
  except Exception as e:
    raise IOError("Exception (with type 'exceptions.IOError'): [Errno 2] " \
          + "No such file or directory: '" + virtual_path + "'")


def tr_removefile(user, virtual_path):
  """
  <Purpose>
    Emulates repy's removefile method.
  <Arguments>
    user (string)
      The sandbox user whose file should be removed.
    virtual_path (string)
      The virtual_real path of the file, not as it is stored in
      the vessel as it is known to the user.
   <Exceptions>
    IOError
      If the file does not exist.
  """
  encoded_path = _encode_path(user + virtual_path)

  try:
    removefile(encoded_path)
  except Exception:
    raise IOError("Exception (with type 'exceptions.IOError'): [Errno 2] " \
          + "No such file or directory: '" + virtual_path + "'")