Python vclib.check_path_access函数代码示例

  def rawdiff(self, path_parts1, rev1, path_parts2, rev2, type, options={}):
    p1 = self._getpath(path_parts1)
    p2 = self._getpath(path_parts2)
    r1 = self._getrev(rev1)
    r2 = self._getrev(rev2)
    if not vclib.check_path_access(self, path_parts1, vclib.FILE, rev1):
      raise vclib.ItemNotFound(path_parts1)
    if not vclib.check_path_access(self, path_parts2, vclib.FILE, rev2):
      raise vclib.ItemNotFound(path_parts2)

    args = vclib._diff_args(type, options)

    def _date_from_rev(rev):
      date, author, msg, changes = self.revinfo(rev)
      return date
    
    try:
      temp1 = temp_checkout(self, p1, r1)
      temp2 = temp_checkout(self, p2, r2)
      info1 = p1, _date_from_rev(r1), r1
      info2 = p2, _date_from_rev(r2), r2
      return vclib._diff_fp(temp1, temp2, info1, info2, self.diff_cmd, args)
    except core.SubversionException, e:
      _fix_subversion_exception(e)
      if e.apr_err == vclib.svn.core.SVN_ERR_FS_NOT_FOUND:
        raise vclib.InvalidRevision
      raise

 def _simple_auth_check(fsroot):
   """Return a 2-tuple: found_readable, found_unreadable."""
   found_unreadable = found_readable = 0
   if hasattr(fs, 'paths_changed2'):
     changes = fs.paths_changed2(fsroot)
   else:
     changes = fs.paths_changed(fsroot)
   paths = changes.keys()
   for path in paths:
     change = changes[path]
     pathtype = None
     if hasattr(change, 'node_kind'):
       if change.node_kind == core.svn_node_file:
         pathtype = vclib.FILE
       elif change.node_kind == core.svn_node_dir:
         pathtype = vclib.DIR
     parts = _path_parts(path)
     if pathtype is None:
       # Figure out the pathtype so we can query the authz subsystem.
       if change.change_kind == fs.path_change_delete:
         # Deletions are annoying, because they might be underneath
         # copies (make their previous location non-trivial).
         prev_parts = parts
         prev_rev = rev - 1
         parent_parts = parts[:-1]
         while parent_parts:
           parent_path = '/' + self._getpath(parent_parts)
           parent_change = changes.get(parent_path)
           if not (parent_change and \
                   (parent_change.change_kind == fs.path_change_add or
                    parent_change.change_kind == fs.path_change_replace)):
             del(parent_parts[-1])
             continue
           copyfrom_path, copyfrom_rev = \
             _get_change_copyinfo(fsroot, parent_path, parent_change)
           if copyfrom_path:
             prev_rev = copyfrom_rev
             prev_parts = _path_parts(copyfrom_path) + \
                          parts[len(parent_parts):]
             break
           del(parent_parts[-1])
         pathtype = self._gettype(self._getpath(prev_parts), prev_rev)
       else:
         pathtype = self._gettype(self._getpath(parts), rev)
     if vclib.check_path_access(self, parts, pathtype, rev):
       found_readable = 1
       copyfrom_path, copyfrom_rev = \
         _get_change_copyinfo(fsroot, path, change)
       if copyfrom_path and copyfrom_path != path:
         parts = _path_parts(copyfrom_path)
         if not vclib.check_path_access(self, parts, pathtype,
                                        copyfrom_rev):
           found_unreadable = 1
     else:
       found_unreadable = 1
     if found_readable and found_unreadable:
       break
   return found_readable, found_unreadable

    def _log_cb(changed_paths, revision, author,
                datestr, message, pool, retval=revs):
      date = _datestr_to_date(datestr)
      action_map = { 'D' : vclib.DELETED,
                     'A' : vclib.ADDED,
                     'R' : vclib.REPLACED,
                     'M' : vclib.MODIFIED,
                     }
      paths = (changed_paths or {}).keys()
      paths.sort(lambda a, b: _compare_paths(a, b))
      changes = []
      found_readable = found_unreadable = 0
      for path in paths:
        pathtype = None
        change = changed_paths[path]
        action = action_map.get(change.action, vclib.MODIFIED)
        ### Wrong, diddily wrong wrong wrong.  Can you say,
        ### "Manufacturing data left and right because it hurts to
        ### figure out the right stuff?"
        if change.copyfrom_path and change.copyfrom_rev:
          is_copy = 1
          base_path = change.copyfrom_path
          base_rev = change.copyfrom_rev
        elif action == vclib.ADDED or action == vclib.REPLACED:
          is_copy = 0
          base_path = base_rev = None
        else:
          is_copy = 0
          base_path = path
          base_rev = revision - 1

        ### Check authz rules (we lie about the path type)
        parts = _path_parts(path)
        if vclib.check_path_access(self, parts, vclib.FILE, revision):
          if is_copy and base_path and (base_path != path):
            parts = _path_parts(base_path)
            if vclib.check_path_access(self, parts, vclib.FILE, base_rev):
              is_copy = 0
              base_path = None
              base_rev = None
          changes.append(SVNChangedPath(path, revision, pathtype, base_path,
                                        base_rev, action, is_copy, 0, 0))
          found_readable = 1
        else:
          found_unreadable = 1

      if found_unreadable:
        message = None
        if not found_readable:
          author = None
          date = None
      revs.append([date, author, message, changes])

  def dirlogs(self, path_parts, rev, entries, options):
    """see vclib.Repository.dirlogs docstring

    rev can be a tag name or None. if set only information from revisions
    matching the tag will be retrieved

    Option values recognized by this implementation:

      cvs_subdirs
        boolean. true to fetch logs of the most recently modified file in each
        subdirectory

    Option values returned by this implementation:

      cvs_tags, cvs_branches
        lists of tag and branch names encountered in the directory
    """
    if self.itemtype(path_parts, rev) != vclib.DIR:  # does auth-check
      raise vclib.Error("Path '%s' is not a directory."
                        % (_path_join(path_parts)))

    subdirs = options.get('cvs_subdirs', 0)
    entries_to_fetch = []
    for entry in entries:
      if vclib.check_path_access(self, path_parts + [entry.name], None, rev):
        entries_to_fetch.append(entry)
    alltags = _get_logs(self, path_parts, entries_to_fetch, rev, subdirs)
    branches = options['cvs_branches'] = []
    tags = options['cvs_tags'] = []
    for name, rev in alltags.items():
      if Tag(None, rev).is_branch:
        branches.append(name)
      else:
        tags.append(name)

  def _get_dirents(self, path, rev):
    """Return a 2-type of dirents and locks, possibly reading/writing
    from a local cache of that information.  This functions performs
    authz checks, stripping out unreadable dirents."""

    dir_url = self._geturl(path)
    path_parts = _path_parts(path)    
    if path:
      key = str(rev) + '/' + path
    else:
      key = str(rev)

    # Ensure that the cache gets filled...
    dirents_locks = self._dirent_cache.get(key)
    if not dirents_locks:
      tmp_dirents, locks = list_directory(dir_url, _rev2optrev(rev),
                                          _rev2optrev(rev), 0, self.ctx)
      dirents = {}
      for name, dirent in tmp_dirents.items():
        dirent_parts = path_parts + [name]
        kind = dirent.kind 
        if (kind == core.svn_node_dir or kind == core.svn_node_file) \
           and vclib.check_path_access(self, dirent_parts,
                                       kind == core.svn_node_dir \
                                         and vclib.DIR or vclib.FILE, rev):
          lh_rev, c_rev = self._get_last_history_rev(dirent_parts, rev)
          dirent.created_rev = lh_rev
          dirents[name] = dirent
      dirents_locks = [dirents, locks]
      self._dirent_cache[key] = dirents_locks

    # ...then return the goodies from the cache.
    return dirents_locks[0], dirents_locks[1]

  def rawdiff(self, path_parts1, rev1, path_parts2, rev2, type, options={}):
    if path_parts1:
      p1 = self._getpath(path_parts1)
      r1 = self._getrev(rev1)
      if not vclib.check_path_access(self, path_parts1, vclib.FILE, rev1):
        raise vclib.ItemNotFound(path_parts1)
    else:
      p1 = None

    if path_parts2:
      p2 = self._getpath(path_parts2)
      r2 = self._getrev(rev2)
      if not vclib.check_path_access(self, path_parts2, vclib.FILE, rev2):
        raise vclib.ItemNotFound(path_parts2)
    else:
      if not p1:
        raise vclib.ItemNotFound(path_parts2)
      p2 = None

    args = vclib._diff_args(type, options)

    def _date_from_rev(rev):
      date, author, msg, revprops, changes = self._revinfo(rev)
      return date

    try:
      if p1:
        temp1 = temp_checkout(self, p1, r1)
        info1 = p1, _date_from_rev(r1), r1
      else:
        temp1 = '/dev/null'
        info1 = '/dev/null', _date_from_rev(rev1), rev1
      if p2:
        temp2 = temp_checkout(self, p2, r2)
        info2 = p2, _date_from_rev(r2), r2
      else:
        temp2 = '/dev/null'
        info2 = '/dev/null', _date_from_rev(rev2), rev2
      return vclib._diff_fp(temp1, temp2, info1, info2, self.diff_cmd, args)
    except core.SubversionException, e:
      _fix_subversion_exception(e)
      if e.apr_err == core.SVN_ERR_FS_NOT_FOUND:
        raise vclib.InvalidRevision
      if e.apr_err != _SVN_ERR_CEASE_INVOCATION:
        raise

 def itemtype(self, path_parts, rev):
   rev = self._getrev(rev)
   basepath = self._getpath(path_parts)
   pathtype = self._gettype(basepath, rev)
   if pathtype is None:
     raise vclib.ItemNotFound(path_parts)
   if not vclib.check_path_access(self, path_parts, pathtype, rev):
     raise vclib.ItemNotFound(path_parts)
   return pathtype

  def listdir(self, path_parts, rev, options):
    if self.itemtype(path_parts, rev) != vclib.DIR:  # does auth-check
      raise vclib.Error("Path '%s' is not a directory."
                        % (_path_join(path_parts)))
    
    # Only RCS files (*,v) and subdirs are returned.
    data = [ ]
    full_name = self._getpath(path_parts)
    for file in os.listdir(full_name):
      name = None
      kind, errors = _check_path(os.path.join(full_name, file))
      if kind == vclib.FILE:
        if file[-2:] == ',v':
          name = file[:-2]
      elif kind == vclib.DIR:
        if file != 'Attic' and file != 'CVS': # CVS directory is for fileattr
          name = file
      else:
        name = file
      if not name:
        continue
      if vclib.check_path_access(self, path_parts + [name], kind, rev):
        data.append(CVSDirEntry(name, kind, errors, 0))

    full_name = os.path.join(full_name, 'Attic')
    if os.path.isdir(full_name):
      for file in os.listdir(full_name):
        name = None
        kind, errors = _check_path(os.path.join(full_name, file))
        if kind == vclib.FILE:
          if file[-2:] == ',v':
            name = file[:-2]
        elif kind != vclib.DIR:
          name = file
        if not name:
          continue
        if vclib.check_path_access(self, path_parts + [name], kind, rev):
          data.append(CVSDirEntry(name, kind, errors, 1))

    return data

  def dirlogs(self, path_parts, rev, entries, options):
    """see vclib.Repository.dirlogs docstring

    rev can be a tag name or None. if set only information from revisions
    matching the tag will be retrieved

    Option values recognized by this implementation:

      cvs_subdirs
        boolean. true to fetch logs of the most recently modified file in each
        subdirectory

    Option values returned by this implementation:

      cvs_tags, cvs_branches
        lists of tag and branch names encountered in the directory
    """
    if self.itemtype(path_parts, rev) != vclib.DIR:  # does auth-check
      raise vclib.Error("Path '%s' is not a directory."
                        % (part2path(path_parts)))
    entries_to_fetch = []
    for entry in entries:
      if vclib.check_path_access(self, path_parts + [entry.name], None, rev):
        entries_to_fetch.append(entry)

    subdirs = options.get('cvs_subdirs', 0)

    dirpath = self._getpath(path_parts)
    alltags = {           # all the tags seen in the files of this dir
      'MAIN' : '',
      'HEAD' : '1.1'
    }

    for entry in entries_to_fetch:
      entry.rev = entry.date = entry.author = None
      entry.dead = entry.absent = entry.log = entry.lockinfo = None
      path = _log_path(entry, dirpath, subdirs)
      if path:
        entry.path = path
        try:
          rcsparse.parse(open(path, 'rb'), InfoSink(entry, rev, alltags))
          if self.guesser:
            entry.log = self.guesser.utf8(entry.log)
        except IOError, e:
          entry.errors.append("rcsparse error: %s" % e)
        except RuntimeError, e:
          entry.errors.append("rcsparse error: %s" % e)
        except rcsparse.RCSStopParser:
          pass

 def itemtype(self, path_parts, rev):
   basepath = self._getpath(path_parts)
   kind = None
   if os.path.isdir(basepath):
     kind = vclib.DIR
   elif os.path.isfile(basepath + ',v'):
     kind = vclib.FILE
   else:
     atticpath = self._getpath(self._atticpath(path_parts))
     if os.path.isfile(atticpath + ',v'):
       kind = vclib.FILE
   if not kind:
     raise vclib.ItemNotFound(path_parts)
   if not vclib.check_path_access(self, path_parts, kind, rev):
     raise vclib.ItemNotFound(path_parts)
   return kind

 def listdir(self, path_parts, rev, options):
   path = self._getpath(path_parts)
   if self.itemtype(path_parts, rev) != vclib.DIR:  # does auth-check
     raise vclib.Error("Path '%s' is not a directory." % path)
   rev = self._getrev(rev)
   fsroot = self._getroot(rev)
   dirents = fs.dir_entries(fsroot, path)
   entries = [ ]
   for entry in dirents.values():
     if entry.kind == core.svn_node_dir:
       kind = vclib.DIR
     elif entry.kind == core.svn_node_file:
       kind = vclib.FILE
     if vclib.check_path_access(self, path_parts + [entry.name], kind, rev):
       entries.append(vclib.DirEntry(entry.name, kind))
   return entries

 def listdir(self, path_parts, rev, options):
   path = self._getpath(path_parts)
   if self.itemtype(path_parts, rev) != vclib.DIR:  # does auth-check
     raise vclib.Error("Path '%s' is not a directory." % path)
   rev = self._getrev(rev)
   entries = [ ]
   dirents, locks = self._get_dirents(path, rev)
   for name in dirents.keys():
     entry = dirents[name]
     if entry.kind == core.svn_node_dir:
       kind = vclib.DIR
     elif entry.kind == core.svn_node_file:
       kind = vclib.FILE
     if vclib.check_path_access(self, path_parts + [name], kind, rev):
       entries.append(vclib.DirEntry(name, kind))
   return entries

 def dirlogs(self, path_parts, rev, entries, options):
   path = self._getpath(path_parts)
   if self.itemtype(path_parts, rev) != vclib.DIR:  # does auth-check
     raise vclib.Error("Path '%s' is not a directory." % path)
   rev = self._getrev(rev)
   dirents, locks = self._get_dirents(path, rev)
   for entry in entries:
     entry_path_parts = path_parts + [entry.name]
     if not vclib.check_path_access(self, entry_path_parts, entry.kind, rev):
       continue
     dirent = dirents[entry.name]
     entry.date, entry.author, entry.log, changes = \
                 self.revinfo(dirent.created_rev)
     entry.rev = str(dirent.created_rev)
     entry.size = dirent.size
     entry.lockinfo = None
     if locks.has_key(entry.name):
       entry.lockinfo = locks[entry.name].owner

 def itemtype(self, path_parts, rev):
   pathtype = None
   if not len(path_parts):
     pathtype = vclib.DIR
   else:
     path = self._getpath(path_parts)
     rev = self._getrev(rev)
     try:
       kind = ra.svn_ra_check_path(self.ra_session, path, rev)
       if kind == core.svn_node_file:
         pathtype = vclib.FILE
       elif kind == core.svn_node_dir:
         pathtype = vclib.DIR
     except:
       pass
   if pathtype is None:
     raise vclib.ItemNotFound(path_parts)
   if not vclib.check_path_access(self, path_parts, pathtype, rev):
     raise vclib.ItemNotFound(path_parts)
   return pathtype

 def dirlogs(self, path_parts, rev, entries, options):
   path = self._getpath(path_parts)
   if self.itemtype(path_parts, rev) != vclib.DIR:  # does auth-check
     raise vclib.Error("Path '%s' is not a directory." % path)
   fsroot = self._getroot(self._getrev(rev))
   rev = self._getrev(rev)
   for entry in entries:
     entry_path_parts = path_parts + [entry.name]
     if not vclib.check_path_access(self, entry_path_parts, entry.kind, rev):
       continue
     path = self._getpath(entry_path_parts)
     entry_rev = _get_last_history_rev(fsroot, path)
     date, author, msg, revprops, changes = self._revinfo(entry_rev)
     entry.rev = str(entry_rev)
     entry.date = date
     entry.author = author
     entry.log = msg
     if entry.kind == vclib.FILE:
       entry.size = fs.file_length(fsroot, path)
     lock = fs.get_lock(self.fs_ptr, path)
     entry.lockinfo = lock and lock.owner or None