try:
n = top.lresolve(target)
-except vfs.NodeError, e:
+except vfs.NodeError as e:
o.fatal(e)
if isinstance(n, vfs.FakeSymlink):
af, socktype, proto, canonname, sa = res
try:
s = socket.socket(af, socktype, proto)
- except socket.error, e:
+ except socket.error as e:
continue
try:
if af == socket.AF_INET6:
s.bind(sa)
s.listen(1)
fcntl.fcntl(s.fileno(), fcntl.F_SETFD, fcntl.FD_CLOEXEC)
- except socket.error, e:
+ except socket.error as e:
s.close()
continue
socks.append(s)
if opt.quick:
try:
quick_verify(base)
- except Exception, e:
+ except Exception as e:
debug('error: %s\n' % e)
return 1
return 0
else: # child
try:
sys.exit(do_pack(base, last, par2_exists))
- except Exception, e:
+ except Exception as e:
log('exception: %r\n' % e)
sys.exit(99)
def do_ls(cmd_args):
try:
ls.do_ls(cmd_args, pwd, onabort=OptionError)
- except OptionError, e:
+ except OptionError as e:
return
n = pwd.resolve(dir)
subs = list(filter(lambda x: x.name.startswith(name),
n.subs()))
- except vfs.NoSuchFile, e:
+ except vfs.NoSuchFile as e:
subs = []
return (dir, name, qtype, lastword, subs)
ret = shquote.what_to_add(qtype, lastword, fullname,
terminate=True) + ' '
return text + ret
- except Exception, e:
+ except Exception as e:
log('\n')
try:
import traceback
traceback.print_tb(sys.exc_traceback)
- except Exception, e2:
+ except Exception as e2:
log('Error printing traceback: %s\n' % e2)
log('\nError in completion: %s\n' % e)
outf = open(n.name, 'wb')
write_to_file(inf, outf)
outf.close()
- except Exception, e:
+ except Exception as e:
rv = 1
log(' error: %s\n' % e)
elif cmd == 'help' or cmd == '?':
else:
rv = 1
raise Exception('no such command %r' % cmd)
- except Exception, e:
+ except Exception as e:
rv = 1
log('error: %s\n' % e)
#raise
os.execvp('man', ['man', '-l', g[0]])
else:
os.execvp('man', ['man', docname])
- except OSError, e:
+ except OSError as e:
sys.stderr.write('Unable to run man command: %s\n' % e)
sys.exit(1)
else:
os.remove(path)
if opt.verbose:
log('clear: removed %s\n' % path)
- except OSError, e:
+ except OSError as e:
if e.errno != errno.ENOENT:
raise
if rig.cur and rig.cur.name == path: # paths that already existed
try:
meta = metadata.from_path(path, statinfo=pst)
- except (OSError, IOError), e:
+ except (OSError, IOError) as e:
add_error(e)
rig.next()
continue
else: # new paths
try:
meta = metadata.from_path(path, statinfo=pst)
- except (OSError, IOError), e:
+ except (OSError, IOError) as e:
add_error(e)
continue
# See same assignment to 0, above, for rationale.
try:
git.init_repo() # local repo
-except git.GitError, e:
+except git.GitError as e:
log("bup: error: could not init repository: %s" % e)
sys.exit(1)
try:
for blob in cat(id):
outfile.write(blob)
- except KeyError, e:
+ except KeyError as e:
outfile.flush()
log('error: %s\n' % e)
ret = 1
for name in extra:
try:
ix = git.open_idx(name)
- except git.GitError, e:
+ except git.GitError as e:
add_error('%s: %s' % (name, e))
continue
if len(opt.find) == 40:
d = {}
try:
f = open('/proc/self/status')
- except IOError, e:
+ except IOError as e:
if not _linux_warned:
log('Warning: %s\n' % e)
_linux_warned = 1
log('Checking %s.\n' % nicename)
try:
ix = git.open_idx(name)
- except git.GitError, e:
+ except git.GitError as e:
add_error('%s: %s' % (name, e))
return
for count,subname in enumerate(ix.idxnames):
if sp:
sp.wait()
break
- except SigException, e:
+ except SigException as e:
log('\nbup on: %s\n' % e)
os.kill(p.pid, e.signum)
ret = 84
-except SigException, e:
+except SigException as e:
if ret == 0:
ret = 99
log('\nbup on: %s\n' % e)
try:
os.link(target_path, fullname)
return True
- except OSError, e:
+ except OSError as e:
if e.errno != errno.EXDEV:
raise
else:
path,name = os.path.split(d)
try:
n = top.lresolve(d)
- except vfs.NodeError, e:
+ except vfs.NodeError as e:
add_error(e)
continue
isdir = stat.S_ISDIR(n.mode)
if opt.remote or is_reverse:
try:
cli = client.Client(opt.remote)
- except client.ClientError, e:
+ except client.ClientError as e:
log('error: %s' % e)
sys.exit(1)
oldref = refname and cli.read_ref(refname) or None
r = index.Reader(indexfile)
try:
msr = index.MetaStoreReader(indexfile + '.meta')
-except IOError, ex:
+except IOError as ex:
if ex.errno != EACCES:
raise
log('error: cannot access %r; have you run bup index?' % indexfile)
# Not indexed, so just grab the FS metadata or use empty metadata.
try:
meta = metadata.from_path(fs_path) if fs_path else metadata.Metadata()
- except (OSError, IOError), e:
+ except (OSError, IOError) as e:
add_error(e)
lastskip_name = dir_name
meta = metadata.Metadata()
if stat.S_ISREG(ent.mode):
try:
f = hashsplit.open_noatime(ent.name)
- except (IOError, OSError), e:
+ except (IOError, OSError) as e:
add_error(e)
lastskip_name = ent.name
else:
(mode, id) = hashsplit.split_to_blob_or_tree(
w.new_blob, w.new_tree, [f],
keep_boundaries=False)
- except (IOError, OSError), e:
+ except (IOError, OSError) as e:
add_error('%s: %s' % (ent.name, e))
lastskip_name = ent.name
else:
elif stat.S_ISLNK(ent.mode):
try:
rl = os.readlink(ent.name)
- except (OSError, IOError), e:
+ except (OSError, IOError) as e:
add_error(e)
lastskip_name = ent.name
else:
hlink = find_hardlink_target(hlink_db, ent)
try:
meta = metadata.from_path(ent.name, hardlink_target=hlink)
- except (OSError, IOError), e:
+ except (OSError, IOError) as e:
add_error(e)
lastskip_name = ent.name
else:
for blob in cat_pipe.join(id):
conn.write(struct.pack('!I', len(blob)))
conn.write(blob)
- except KeyError, e:
+ except KeyError as e:
log('server: error: %s\n' % e)
conn.write('\0\0\0\0')
conn.error(e)
try:
it = cp.get(line.strip())
next(it, None) # skip the file type
- except KeyError, e:
+ except KeyError as e:
add_error('error: %s' % e)
continue
yield IterToFile(it)
try:
hash = git.rev_parse(commit)
-except git.GitError, e:
+except git.GitError as e:
log("bup: error: %s" % e)
sys.exit(2)
tag_file = git.repo('refs/tags/%s' % tag_name)
try:
tag = file(tag_file, 'w')
-except OSError, e:
+except OSError as e:
log("bup: error: could not create tag '%s': %s" % (tag_name, e))
sys.exit(3)
try:
show_hidden = int(self.request.arguments.get('hidden', [0])[-1])
- except ValueError, e:
+ except ValueError as e:
show_hidden = False
self.render(
try:
sock = http_server._socket # tornado < 2.0
- except AttributeError, e:
+ except AttributeError as e:
sock = http_server._sockets.values()[0]
print "Serving HTTP on %s:%d..." % sock.getsockname()
res = str(value) # Undo autoconversion.
try:
res = parse_timestamp(res)
- except ValueError, ex:
+ except ValueError as ex:
if ex.args:
o.fatal('unable to parse %s resolution "%s" (%s)'
% (field, value, ex))
for path in remainder:
try:
m = metadata.from_path(path, archive_path = path)
- except (OSError,IOError), e:
+ except (OSError,IOError) as e:
if e.errno == errno.ENOENT:
add_error(e)
continue
self.pout = self.p.stdout
self.pin = self.p.stdin
self.conn = Conn(self.pout, self.pin)
- except OSError, e:
+ except OSError as e:
raise ClientError, 'connect: %s' % e, sys.exc_info()[2]
elif self.protocol == 'bup':
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
def __del__(self):
try:
self.close()
- except IOError, e:
+ except IOError as e:
if e.errno == errno.EPIPE:
pass
else:
% rv)
try:
return self.conn.check_ok()
- except Exception, e:
+ except Exception as e:
raise ClientError, e, sys.exc_info()[2]
def check_busy(self):
try:
(self._bwcount, self._bwtime) = _raw_write_bwlimit(
self.file, outbuf, self._bwcount, self._bwtime)
- except IOError, e:
+ except IOError as e:
raise ClientError, e, sys.exc_info()[2]
self.outbytes += len(data)
self.count += 1
for n in os.listdir('.'):
try:
st = xstat.lstat(n)
- except OSError, e:
+ except OSError as e:
add_error(Exception('%s: %s' % (realpath(n), str(e))))
continue
if (st.st_mode & _IFMT) == stat.S_IFDIR:
else:
try:
OsFile(name).fchdir()
- except OSError, e:
+ except OSError as e:
add_error('%s: %s' % (prepend, e))
else:
for i in _recursive_dirlist(prepend=prepend+name, xdev=xdev,
if stat.S_ISLNK(pst.st_mode):
yield (path, pst)
continue
- except OSError, e:
+ except OSError as e:
add_error('recursive_dirlist: %s' % e)
continue
try:
pfile = OsFile(path)
- except OSError, e:
+ except OSError as e:
add_error(e)
continue
pst = pfile.stat()
args = [path.exe(), 'midx', '--auto', '--dir', objdir]
try:
rv = subprocess.call(args, stdout=open('/dev/null', 'w'))
- except OSError, e:
+ except OSError as e:
# make sure 'args' gets printed to help with debugging
add_error('%r: exception: %s' % (args, e))
raise
args = [path.exe(), 'bloom', '--dir', objdir]
try:
rv = subprocess.call(args, stdout=open('/dev/null', 'w'))
- except OSError, e:
+ except OSError as e:
# make sure 'args' gets printed to help with debugging
add_error('%r: exception: %s' % (args, e))
raise
if not d.get(full):
try:
ix = open_idx(full)
- except GitError, e:
+ except GitError as e:
add_error(e)
continue
d[full] = ix
oneblob = ''.join(datalist)
try:
f.write(oneblob)
- except IOError, e:
+ except IOError as e:
raise GitError, e, sys.exc_info()[2]
nw = len(oneblob)
crc = zlib.crc32(oneblob) & 0xffffffff
guess_repo(path)
try:
os.stat(repo('objects/pack/.'))
- except OSError, e:
+ except OSError as e:
if e.errno == errno.ENOENT:
log('error: %r is not a bup repository; run "bup init"\n'
% repo())
def next(self):
try:
return self.it.next()
- except StopIteration, e:
+ except StopIteration as e:
self.done = True
raise
except:
readline_result = self.p.stdout.readline()
assert(readline_result == '\n')
self.inprogress = None
- except Exception, e:
+ except Exception as e:
it.abort()
raise
raise IOError('select(fd) returned without being writable')
try:
sz = os.write(fd, buf)
- except OSError, e:
+ except OSError as e:
if e.errno != errno.EAGAIN:
raise
assert(sz >= 0)
os.makedirs(d, mode)
else:
os.makedirs(d)
- except OSError, e:
+ except OSError as e:
if e.errno == errno.EEXIST:
pass
else:
"""
try:
os.unlink(f)
- except OSError, e:
+ except OSError as e:
if e.errno != errno.ENOENT:
raise
msize = min(_fmincore_chunk_size, st.st_size - pos)
try:
m = mmap.mmap(fd, msize, mmap.MAP_PRIVATE, 0, 0, pos)
- except mmap.error, ex:
+ except mmap.error as ex:
if ex.errno == errno.EINVAL or ex.errno == errno.ENODEV:
# Perhaps the file was a pipe, i.e. "... | bup split ..."
return None
For now we expect a string that contains a float."""
try:
date = float(str)
- except ValueError, e:
+ except ValueError as e:
raise fatal('invalid date format (should be a float): %r' % e)
else:
return date
elif option == '--exclude-from':
try:
f = open(realpath(parameter))
- except IOError, e:
+ except IOError as e:
raise fatal("couldn't read %s" % parameter)
for exclude_path in f.readlines():
# FIXME: perhaps this should be rstrip('\n')
if option == '--exclude-rx':
try:
excluded_patterns.append(re.compile(parameter))
- except re.error, ex:
+ except re.error as ex:
fatal('invalid --exclude-rx pattern (%s): %s' % (parameter, ex))
elif option == '--exclude-rx-from':
try:
f = open(realpath(parameter))
- except IOError, e:
+ except IOError as e:
raise fatal("couldn't read %s" % parameter)
for pattern in f.readlines():
spattern = pattern.rstrip('\n')
continue
try:
excluded_patterns.append(re.compile(spattern))
- except re.error, ex:
+ except re.error as ex:
fatal('invalid --exclude-rx pattern (%s): %s' % (spattern, ex))
return excluded_patterns
f = None
try:
f = open(filename, 'r')
- except IOError, e:
+ except IOError as e:
if e.errno == errno.ENOENT:
pass
else:
else: # No data -- delete _filename if it exists.
try:
os.unlink(self._filename)
- except OSError, e:
+ except OSError as e:
if e.errno == errno.ENOENT:
pass
else:
self.gitmode, self.sha, self.flags,
self.children_ofs, self.children_n,
self.meta_ofs)
- except (DeprecationWarning, struct.error), e:
+ except (DeprecationWarning, struct.error) as e:
log('pack error: %s (%r)\n' % (e, self))
raise
f = None
try:
f = open(filename, 'r+')
- except IOError, e:
+ except IOError as e:
if e.errno == errno.ENOENT:
pass
else:
rp = slashappend(rp)
p = slashappend(p)
xpaths.append((rp, p))
- except OSError, e:
+ except OSError as e:
add_error('reduce_paths: %s' % e)
xpaths.sort()
output_node_info(sub, name)
else:
output_node_info(n, os.path.normpath(path))
- except vfs.NodeError, e:
+ except vfs.NodeError as e:
log('error: %s\n' % e)
ret = 1
st = None
try:
st = xstat.lstat(path)
- except OSError, e:
+ except OSError as e:
if e.errno != errno.ENOENT:
raise
if st:
if stat.S_ISDIR(st.st_mode):
try:
os.rmdir(path)
- except OSError, e:
+ except OSError as e:
if e.errno in (errno.ENOTEMPTY, errno.EEXIST):
msg = 'refusing to overwrite non-empty dir ' + path
raise Exception(msg)
elif stat.S_ISSOCK(self.mode):
try:
os.mknod(path, 0o600 | stat.S_IFSOCK)
- except OSError, e:
+ except OSError as e:
if e.errno in (errno.EINVAL, errno.EPERM):
s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
s.bind(path)
if lutime and stat.S_ISLNK(self.mode):
try:
lutime(path, (self.atime, self.mtime))
- except OSError, e:
+ except OSError as e:
if e.errno == errno.EACCES:
raise ApplyError('lutime: %s' % e)
else:
else:
try:
utime(path, (self.atime, self.mtime))
- except OSError, e:
+ except OSError as e:
if e.errno == errno.EACCES:
raise ApplyError('utime: %s' % e)
else:
if uid != -1 or gid != -1:
try:
os.lchown(path, uid, gid)
- except OSError, e:
+ except OSError as e:
if e.errno == errno.EPERM:
add_error('lchown: %s' % e)
elif sys.platform.startswith('cygwin') \
try:
if stat.S_ISLNK(st.st_mode):
self.symlink_target = os.readlink(path)
- except OSError, e:
+ except OSError as e:
add_error('readlink: %s' % e)
def _encode_symlink_target(self):
if stat.S_ISDIR(st.st_mode):
def_acl = posix1e.ACL(filedef=path)
def_acls = [def_acl, def_acl]
- except EnvironmentError, e:
+ except EnvironmentError as e:
if e.errno not in (errno.EOPNOTSUPP, errno.ENOSYS):
raise
if acls:
def apply_acl(acl_rep, kind):
try:
acl = posix1e.ACL(text = acl_rep)
- except IOError, e:
+ except IOError as e:
if e.errno == 0:
# pylibacl appears to return an IOError with errno
# set to 0 if a group referred to by the ACL rep
raise
try:
acl.applyto(path, kind)
- except IOError, e:
+ except IOError as e:
if e.errno == errno.EPERM or e.errno == errno.EOPNOTSUPP:
raise ApplyError('POSIX1e ACL applyto: %s' % e)
else:
attr = get_linux_file_attr(path)
if attr != 0:
self.linux_attr = attr
- except OSError, e:
+ except OSError as e:
if e.errno == errno.EACCES:
add_error('read Linux attr: %s' % e)
elif e.errno in (errno.ENOTTY, errno.ENOSYS, errno.EOPNOTSUPP):
return
try:
set_linux_file_attr(path, self.linux_attr)
- except OSError, e:
+ except OSError as e:
if e.errno in (errno.ENOTTY, errno.EOPNOTSUPP, errno.ENOSYS,
errno.EACCES):
raise ApplyError('Linux chattr: %s (0x%s)'
if not xattr: return
try:
self.linux_xattr = xattr.get_all(path, nofollow=True)
- except EnvironmentError, e:
+ except EnvironmentError as e:
if e.errno != errno.EOPNOTSUPP:
raise
return
try:
existing_xattrs = set(xattr.list(path, nofollow=True))
- except IOError, e:
+ except IOError as e:
if e.errno == errno.EACCES:
raise ApplyError('xattr.set %r: %s' % (path, e))
else:
or v != xattr.get(path, k, nofollow=True):
try:
xattr.set(path, k, v, nofollow=True)
- except IOError, e:
+ except IOError as e:
if e.errno == errno.EPERM \
or e.errno == errno.EOPNOTSUPP:
raise ApplyError('xattr.set %r: %s' % (path, e))
for k in existing_xattrs:
try:
xattr.remove(path, k, nofollow=True)
- except IOError, e:
+ except IOError as e:
if e.errno == errno.EPERM:
raise ApplyError('xattr.remove %r: %s' % (path, e))
else:
self._apply_linux_xattr_rec):
try:
apply_metadata(path, restore_numeric_ids=num_ids)
- except ApplyError, e:
+ except ApplyError as e:
add_error(e)
def same_file(self, other):
"""
try:
(flags,extra) = self.optfunc(args, self._shortopts, self._longopts)
- except getopt.GetoptError, e:
+ except getopt.GetoptError as e:
self.fatal(e)
opt = OptDict(aliases=self._aliases)
skip_test = False
try:
b = bloom.create('bup.bloom', f=tf, expected=2**28, delaywrite=False)
- except EnvironmentError, ex:
+ except EnvironmentError as ex:
(ptr_width, linkage) = platform.architecture()
if ptr_width == '32bit' and ex.errno == errno.ENOMEM:
WVMSG('skipping large bloom filter test (mmap probably failed) '
open(bupdir + '/objects/pack', 'w').close()
try:
git.check_repo_or_die()
- except SystemExit, e:
+ except SystemExit as e:
WVPASSEQ(e.code, 14)
else:
WVFAIL()
try:
git.check_repo_or_die('nonexistantbup.tmp')
- except SystemExit, e:
+ except SystemExit as e:
WVPASSEQ(e.code, 15)
else:
WVFAIL()
WVPASSEQ(x, '42\n')
try:
readpipe(['bash', '-c', 'exit 42'])
- except Exception, ex:
+ except Exception as ex:
WVPASSEQ(str(ex), "subprocess 'bash -c exit 42' failed with status 42")
WVPASSEQ(out, '42\n')
try:
batchpipe(['bash', '-c'], ['exit 42'])
- except Exception, ex:
+ except Exception as ex:
WVPASSEQ(str(ex), "subprocess 'bash -c exit 42' failed with status 42")
args = [str(x) for x in range(6)]
# Force batchpipe to break the args into batches of 3. This
elif rc > 0:
print >> sys.stderr, 'returned exit status', rc
sys.exit(1)
- except OSError, e:
+ except OSError as e:
print >> sys.stderr, 'subprocess call failed:', e
sys.exit(1)
return False
try:
metadata.get_linux_file_attr(path)
- except OSError, e:
+ except OSError as e:
if e.errno in (errno.ENOTTY, errno.ENOSYS, errno.EOPNOTSUPP):
return False
else:
try:
_bup_utimensat = _helpers.bup_utimensat
-except AttributeError, e:
+except AttributeError as e:
_bup_utimensat = False
try:
_bup_utimes = _helpers.bup_utimes
-except AttributeError, e:
+except AttributeError as e:
_bup_utimes = False
try:
_bup_lutimes = _helpers.bup_lutimes
-except AttributeError, e:
+except AttributeError as e:
_bup_lutimes = False
try:
optspec = ['help', 'version', 'debug', 'profile', 'bup-dir=']
global_args, subcmd = getopt.getopt(argv[1:], '?VDd:', optspec)
-except getopt.GetoptError, ex:
+except getopt.GetoptError as ex:
usage('error: %s' % ex.msg)
help_requested = None
ret = p.wait()
forward_signals = False
break
- except OSError, e:
+ except OSError as e:
log('%s: %s\n' % (subcmd[0], e))
ret = 98
finally:
'''
try:
func(*args, **kwargs)
- except etype, e:
+ except etype as e:
return _check(True, 'EXCEPT(%s)' % _code())
except:
_check(False, 'EXCEPT(%s)' % _code())
sys.stdout.flush()
try:
_run_in_chdir(os.path.split(mod.__file__)[0], f)
- except Exception, e:
+ except Exception as e:
print
print traceback.format_exc()
tb = sys.exc_info()[2]
projects / bup.git / commitdiff