def __init__(self,
user_config=None,
configs=[],
options=None,
capabilities=None):
super(TFSClient, self).__init__(user_config, configs, options,
capabilities)
self.tf = None
if sys.platform.startswith('win'):
# First check in the system path. If that doesn't work, look in the
# two standard install locations.
tf_locations = [
'tf.cmd',
r'%programfiles(x86)%\Microsoft Visual Studio 12.0\Common7\IDE\tf.cmd',
r'%programfiles%\Microsoft Team Foundation Server 12.0\Tools\tf.cmd',
]
for location in tf_locations:
if check_install([location, 'help']):
self.tf = location
break
elif check_install(['tf', 'help']):
self.tf = 'tf'
def get_repository_info(self):
if not check_install(['cvs']):
logging.debug('Unable to execute "cvs": skipping CVS')
return None
cvsroot_path = os.path.join('CVS', 'Root')
if not os.path.exists(cvsroot_path):
return None
with open(cvsroot_path, 'r') as fp:
repository_path = fp.read().strip()
i = repository_path.find('@')
if i != -1:
repository_path = repository_path[i + 1:]
i = repository_path.rfind(':')
if i != -1:
host = repository_path[:i]
try:
canon = socket.getfqdn(host)
repository_path = repository_path.replace('%s:' % host,
'%s:' % canon)
except socket.error as msg:
logging.error('failed to get fqdn for %s, msg=%s',
host, msg)
return RepositoryInfo(path=repository_path)
def get_repository_info(self):
if not check_install('p4 help'):
return None
data = execute(["p4", "info"], ignore_errors=True)
m = re.search(r'^Server address: (.+)$', data, re.M)
if not m:
return None
repository_path = m.group(1).strip()
try:
hostname, port = repository_path.split(":")
info = socket.gethostbyaddr(hostname)
# If aliases exist for hostname, create a list of alias:port
# strings for repository_path.
if info[1]:
servers = [info[0]] + info[1]
repository_path = ["%s:%s" % (server, port)
for server in servers]
else:
repository_path = "%s:%s" % (info[0], port)
except (socket.gaierror, socket.herror):
pass
m = re.search(r'^Server version: [^ ]*/([0-9]+)\.([0-9]+)/[0-9]+ .*$',
data, re.M)
self.p4d_version = int(m.group(1)), int(m.group(2))
return RepositoryInfo(path=repository_path, supports_changesets=True)
def get_repository_info(self):
"""
Find out information about the current Bazaar branch (if any) and
return it.
"""
if not check_install(['bzr', 'help']):
logging.debug('Unable to execute "bzr help": skipping Bazaar')
return None
bzr_info = execute(['bzr', 'info'], ignore_errors=True)
if 'ERROR: Not a branch:' in bzr_info:
# This is not a branch:
repository_info = None
else:
# This is a branch, let's get its attributes:
branch_match = re.search(self.BRANCH_REGEX, bzr_info, re.MULTILINE)
path = branch_match.group('branch_path')
if path == '.':
path = os.getcwd()
repository_info = RepositoryInfo(
path=path,
base_path='/', # Diffs are always relative to the root.
supports_parent_diffs=True)
return repository_info
def get_repository_info(self):
"""
Find out information about the current Bazaar branch (if any) and return
it.
"""
if not check_install("bzr help"):
return None
if self.options.repository_url:
return RepositoryInfo(
path=self.options.repository_url,
base_path="/", # Diffs are always relative to the root.
supports_parent_diffs=True,
)
branch = None
for location in ["submit_branch", "parent_location"]:
branch = self._get_config(location)
if branch is not None:
break
if branch is None:
return None
return RepositoryInfo(
path=branch, base_path="/", supports_parent_diffs=True # Diffs are always relative to the root.
)
def __init__(self, config=None, options=None):
super(TFSClient, self).__init__(config, options)
self.tf = None
tf_locations = []
if getattr(self.options, 'tf_cmd', None):
tf_locations.append(self.options.tf_cmd)
if sys.platform.startswith('win'):
# First check in the system path. If that doesn't work, look in the
# two standard install locations.
tf_locations.extend([
'tf.cmd',
r'%programfiles(x86)%\Microsoft Visual Studio 12.0\Common7\IDE\tf.cmd',
r'%programfiles%\Microsoft Team Foundation Server 12.0\Tools\tf.cmd',
])
else:
tf_locations.append('tf')
for location in tf_locations:
location = os.path.expandvars(location)
if check_install([location, 'help']):
self.tf = location
break
def get_repository_info(self):
if not check_install("cvs"):
return None
cvsroot_path = os.path.join("CVS", "Root")
if not os.path.exists(cvsroot_path):
return None
fp = open(cvsroot_path, "r")
repository_path = fp.read().strip()
fp.close()
i = repository_path.find("@")
if i != -1:
repository_path = repository_path[i + 1:]
i = repository_path.rfind(":")
if i != -1:
host = repository_path[:i]
try:
canon = socket.getfqdn(host)
repository_path = repository_path.replace(
'%s:' % host, '%s:' % canon)
except socket.error, msg:
logging.error("failed to get fqdn for %s, msg=%s" %
(host, msg))
def get_local_path(self):
"""Return the local path to the working tree.
Returns:
unicode:
The filesystem path of the repository on the client system.
"""
if not check_install(['cm', 'version']):
logging.debug('Unable to execute "cm version": skipping Plastic')
return None
# Get the workspace directory, so we can strip it from the diff output
self.workspacedir = execute(['cm', 'gwp', '.', '--format={1}'],
split_lines=False,
ignore_errors=True).strip()
logging.debug('Workspace is %s', self.workspacedir)
# Get the repository that the current directory is from
split = execute(['cm', 'ls', self.workspacedir, '--format={8}'],
split_lines=True,
ignore_errors=True)
# remove blank lines
split = [x for x in split if x]
m = re.search(r'^rep:(.+)$', split[0], re.M)
if not m:
return None
return m.group(1)
def get_local_path(self):
"""Return the local path to the working tree.
Returns:
unicode:
The filesystem path of the repository on the client system.
"""
if not check_install(['cvs']):
logging.debug('Unable to execute "cvs": skipping CVS')
return None
cvsroot_path = os.path.join('CVS', 'Root')
if not os.path.exists(cvsroot_path):
return None
with open(cvsroot_path, 'r') as fp:
repository_path = fp.read().strip()
i = repository_path.find('@')
if i != -1:
repository_path = repository_path[i + 1:]
i = repository_path.rfind(':')
if i != -1:
host = repository_path[:i]
try:
canon = socket.getfqdn(host)
repository_path = repository_path.replace('%s:' % host,
'%s:' % canon)
except socket.error as msg:
logging.error('failed to get fqdn for %s, msg=%s',
host, msg)
return repository_path
def get_repository_info(self):
if not check_install('cm version'):
return None
# Get the workspace directory, so we can strip it from the diff output
self.workspacedir = execute(["cm", "gwp", ".", "--format={1}"],
split_lines=False,
ignore_errors=True).strip()
logging.debug("Workspace is %s" % self.workspacedir)
# Get the repository that the current directory is from
split = execute(["cm", "ls", self.workspacedir, "--format={8}"], split_lines=True,
ignore_errors=True)
# remove blank lines
split = filter(None, split)
m = re.search(r'^rep:(.+)$', split[0], re.M)
if not m:
return None
path = m.group(1)
return RepositoryInfo(path,
supports_changesets=True,
supports_parent_diffs=False)
def get_repository_info(self):
"""Return repository information for the current working tree.
Returns:
rbtools.clients.RepositoryInfo:
The repository info structure.
"""
if not check_install([self._exe, '--help']):
logging.debug('Unable to execute "hg --help": skipping Mercurial')
return None
self._init()
if not self.hg_root:
# hg aborted => no mercurial repository here.
return None
if self._type == 'svn':
return self._calculate_hgsubversion_repository_info(self._svn_info)
else:
path = self.hg_root
base_path = '/'
if self._remote_path:
path = self._remote_path[1]
base_path = ''
return RepositoryInfo(path=path,
base_path=base_path,
local_path=self.hg_root)
def get_repository_info(self):
if not check_install('p4 help'):
return None
data = execute(["p4", "info"], ignore_errors=True)
m = re.search(r'^Server address: (.+)$', data, re.M)
if not m:
return None
repository_path = m.group(1).strip()
try:
hostname, port = repository_path.split(":")
info = socket.gethostbyaddr(hostname)
# If aliases exist for hostname, create a list of alias:port
# strings for repository_path.
if info[1]:
servers = [info[0]] + info[1]
repository_path = ["%s:%s" % (server, port)
for server in servers]
else:
repository_path = "%s:%s" % (info[0], port)
except (socket.gaierror, socket.herror):
pass
m = re.search(r'^Server version: [^ ]*/([0-9]+)\.([0-9]+)/[0-9]+ .*$',
data, re.M)
self.p4d_version = int(m.group(1)), int(m.group(2))
return RepositoryInfo(path=repository_path, supports_changesets=True)
def get_repository_info(self):
if not check_install('hg --help'):
return None
self._load_hgrc()
if not self.hg_root:
# hg aborted => no mercurial repository here.
return None
svn_info = execute(["hg", "svn", "info"], ignore_errors=True)
if (not svn_info.startswith('abort:')
and not svn_info.startswith("hg: unknown command")
and not svn_info.lower().startswith('not a child of')):
return self._calculate_hgsubversion_repository_info(svn_info)
self._type = 'hg'
path = self.hg_root
base_path = '/'
if self.hgrc:
self._calculate_remote_path()
if self._remote_path:
path = self._remote_path[1]
base_path = ''
return RepositoryInfo(path=path,
base_path=base_path,
supports_parent_diffs=True)
def __init__(self, config=None, options=None):
super(TFSClient, self).__init__(config, options)
self.tf = None
tf_locations = []
if getattr(self.options, 'tf_cmd', None):
tf_locations.append(self.options.tf_cmd)
if sys.platform.startswith('win'):
# First check in the system path. If that doesn't work, look in the
# two standard install locations.
tf_locations.extend([
'tf.cmd',
r'%programfiles(x86)%\Microsoft Visual Studio 12.0\Common7\IDE\tf.cmd',
r'%programfiles%\Microsoft Team Foundation Server 12.0\Tools\tf.cmd',
])
else:
tf_locations.append('tf')
for location in tf_locations:
location = os.path.expandvars(location)
if check_install([location, 'help']):
self.tf = location
break
def get_repository_info(self):
if not check_install(['cvs']):
logging.debug('Unable to execute "cvs": skipping CVS')
return None
cvsroot_path = os.path.join('CVS', 'Root')
if not os.path.exists(cvsroot_path):
return None
with open(cvsroot_path, 'r') as fp:
repository_path = fp.read().strip()
i = repository_path.find('@')
if i != -1:
repository_path = repository_path[i + 1:]
i = repository_path.rfind(':')
if i != -1:
host = repository_path[:i]
try:
canon = socket.getfqdn(host)
repository_path = repository_path.replace('%s:' % host,
'%s:' % canon)
except socket.error as msg:
logging.error('failed to get fqdn for %s, msg=%s',
host, msg)
return RepositoryInfo(path=repository_path)
def get_repository_info(self):
"""Return the repository info object."""
if not check_install(['hg', '--help']):
logging.debug('Unable to execute "hg --help": skipping Mercurial')
return None
self._init()
if not self.hg_root:
# hg aborted => no mercurial repository here.
return None
if self._type == 'svn':
return self._calculate_hgsubversion_repository_info(self._svn_info)
else:
path = self.hg_root
base_path = '/'
if self._remote_path:
path = self._remote_path[1]
base_path = ''
return RepositoryInfo(path=path,
base_path=base_path,
supports_parent_diffs=True)
def get_repository_info(self):
"""Return repository information for the current working tree.
Returns:
rbtools.clients.RepositoryInfo:
The repository info structure.
"""
if not check_install(['bzr', 'help']):
logging.debug('Unable to execute "bzr help": skipping Bazaar')
return None
bzr_info = execute(['bzr', 'info'], ignore_errors=True)
if 'ERROR: Not a branch:' in bzr_info:
# This is not a branch:
repository_info = None
else:
# This is a branch, let's get its attributes:
branch_match = re.search(self.BRANCH_REGEX, bzr_info, re.MULTILINE)
path = branch_match.group('branch_path')
if path == '.':
path = os.getcwd()
repository_info = RepositoryInfo(
path=path,
base_path='/', # Diffs are always relative to the root.
local_path=path,
supports_parent_diffs=True)
return repository_info
def get_repository_info(self):
if not check_install(['cvs']):
return None
cvsroot_path = os.path.join("CVS", "Root")
if not os.path.exists(cvsroot_path):
return None
fp = open(cvsroot_path, "r")
repository_path = fp.read().strip()
fp.close()
i = repository_path.find("@")
if i != -1:
repository_path = repository_path[i + 1:]
i = repository_path.rfind(":")
if i != -1:
host = repository_path[:i]
try:
canon = socket.getfqdn(host)
repository_path = repository_path.replace('%s:' % host,
'%s:' % canon)
except socket.error, msg:
logging.error("failed to get fqdn for %s, msg=%s"
% (host, msg))
def get_repository_info(self):
if not check_install(['cm', 'version']):
logging.debug('Unable to execute "cm version": skipping Plastic')
return None
# Get the workspace directory, so we can strip it from the diff output
self.workspacedir = execute(["cm", "gwp", ".", "--format={1}"],
split_lines=False,
ignore_errors=True).strip()
logging.debug("Workspace is %s" % self.workspacedir)
# Get the repository that the current directory is from
split = execute(["cm", "ls", self.workspacedir, "--format={8}"],
split_lines=True,
ignore_errors=True)
# remove blank lines
split = [x for x in split if x]
m = re.search(r'^rep:(.+)$', split[0], re.M)
if not m:
return None
path = m.group(1)
return RepositoryInfo(path,
supports_changesets=True,
supports_parent_diffs=False)
def get_repository_info(self):
"""Return the repository info object.
Returns:
rbtools.clients.RepositoryInfo:
The repository info structure.
"""
if not check_install(['hg', '--help']):
logging.debug('Unable to execute "hg --help": skipping Mercurial')
return None
self._init()
if not self.hg_root:
# hg aborted => no mercurial repository here.
return None
if self._type == 'svn':
return self._calculate_hgsubversion_repository_info(self._svn_info)
else:
path = self.hg_root
base_path = '/'
if self._remote_path:
path = self._remote_path[1]
base_path = ''
return RepositoryInfo(path=path,
base_path=base_path,
local_path=self.hg_root,
supports_parent_diffs=True)
def get_repository_info(self):
if not check_install('hg --help'):
return None
self._load_hgrc()
if not self.hg_root:
# hg aborted => no mercurial repository here.
return None
svn_info = execute(["hg", "svn", "info"], ignore_errors=True)
if (not svn_info.startswith('abort:') and
not svn_info.startswith("hg: unknown command") and
not svn_info.lower().startswith('not a child of')):
return self._calculate_hgsubversion_repository_info(svn_info)
self._type = 'hg'
path = self.hg_root
base_path = '/'
if self.hgrc:
self._calculate_remote_path()
if self._remote_path:
path = self._remote_path[1]
base_path = ''
return RepositoryInfo(path=path, base_path=base_path,
supports_parent_diffs=True)
def get_repository_info(self):
if not check_install('cm version'):
return None
# Get the repository that the current directory is from. If there
# is more than one repository mounted in the current directory,
# bail out for now (in future, should probably enter a review
# request per each repository.)
split = execute(["cm", "ls", "--format={8}"],
split_lines=True,
ignore_errors=True)
m = re.search(r'^rep:(.+)$', split[0], re.M)
if not m:
return None
# Make sure the repository list contains only one unique entry
if len(split) != split.count(split[0]):
# Not unique!
die('Directory contains more than one mounted repository')
path = m.group(1)
# Get the workspace directory, so we can strip it from the diff output
self.workspacedir = execute(["cm", "gwp", ".", "--format={1}"],
split_lines=False,
ignore_errors=True).strip()
logging.debug("Workspace is %s" % self.workspacedir)
return RepositoryInfo(path,
supports_changesets=True,
supports_parent_diffs=False)
def get_repository_info(self):
"""
Find out information about the current Bazaar branch (if any) and
return it.
"""
if not check_install("bzr help"):
return None
bzr_info = execute(["bzr", "info"], ignore_errors=True)
if "ERROR: Not a branch:" in bzr_info:
# This is not a branch:
repository_info = None
else:
# This is a branch, let's get its attributes:
branch_match = re.search(self.BRANCH_REGEX, bzr_info, re.MULTILINE)
path = branch_match.group("branch_path")
if path == ".":
path = os.getcwd()
repository_info = RepositoryInfo(
path=path,
base_path="/", # Diffs are always relative to the root.
supports_parent_diffs=True)
return repository_info
def get_repository_info(self):
"""
Find out information about the current Bazaar branch (if any) and
return it.
"""
if not check_install(['bzr', 'help']):
logging.debug('Unable to execute "bzr help": skipping Bazaar')
return None
bzr_info = execute(["bzr", "info"], ignore_errors=True)
if "ERROR: Not a branch:" in bzr_info:
# This is not a branch:
repository_info = None
else:
# This is a branch, let's get its attributes:
branch_match = re.search(self.BRANCH_REGEX, bzr_info, re.MULTILINE)
path = branch_match.group("branch_path")
if path == ".":
path = os.getcwd()
repository_info = RepositoryInfo(
path=path,
base_path="/", # Diffs are always relative to the root.
supports_parent_diffs=True)
return repository_info
def get_repository_info(self):
if not check_install('cm version'):
return None
# Get the repository that the current directory is from. If there
# is more than one repository mounted in the current directory,
# bail out for now (in future, should probably enter a review
# request per each repository.)
split = execute(["cm", "ls", "--format={8}"], split_lines=True,
ignore_errors=True)
m = re.search(r'^rep:(.+)$', split[0], re.M)
if not m:
return None
# Make sure the repository list contains only one unique entry
if len(split) != split.count(split[0]):
# Not unique!
die('Directory contains more than one mounted repository')
path = m.group(1)
# Get the workspace directory, so we can strip it from the diff output
self.workspacedir = execute(["cm", "gwp", ".", "--format={1}"],
split_lines=False,
ignore_errors=True).strip()
logging.debug("Workspace is %s" % self.workspacedir)
return RepositoryInfo(path,
supports_changesets=True,
supports_parent_diffs=False)
def get_repository_info(self):
if not check_install('svn help'):
return None
# Get the SVN repository path (either via a working copy or
# a supplied URI)
svn_info_params = ["svn", "info"]
if self.options.repository_url:
svn_info_params.append(self.options.repository_url)
data = execute(svn_info_params,
ignore_errors=True)
m = re.search(r'^Repository Root: (.+)$', data, re.M)
if not m:
return None
path = m.group(1)
m = re.search(r'^URL: (.+)$', data, re.M)
if not m:
return None
base_path = m.group(1)[len(path):] or "/"
m = re.search(r'^Repository UUID: (.+)$', data, re.M)
if not m:
return None
# Now that we know it's SVN, make sure we have GNU diff installed,
# and error out if we don't.
check_gnu_diff()
return SVNRepositoryInfo(path, base_path, m.group(1))
def get_repository_info(self):
if self._svn_repository_info_cache:
return self._svn_repository_info_cache
if not check_install(['svn', 'help']):
logging.debug('Unable to execute "svn help": skipping SVN')
return None
# Get the SVN repository path (either via a working copy or
# a supplied URI)
svn_info_params = ["info"]
if getattr(self.options, 'repository_url', None):
svn_info_params.append(self.options.repository_url)
data = self._run_svn(svn_info_params, ignore_errors=True,
results_unicode=False,
log_output_on_error=False)
m = re.search(b'^Repository Root: (.+)$', data, re.M)
if not m:
return None
path = m.group(1)
m = re.search(b'^URL: (.+)$', data, re.M)
if not m:
return None
base_path = m.group(1)[len(path):] or b'/'
m = re.search(b'^Repository UUID: (.+)$', data, re.M)
if not m:
return None
uuid = m.group(1)
# Now that we know it's SVN, make sure we have GNU diff installed,
# and error out if we don't.
check_gnu_diff()
# Grab version of SVN client and store as a tuple in the form:
# (major_version, minor_version, micro_version)
ver_string = self._run_svn(['--version', '-q'], ignore_errors=True)
m = self.VERSION_NUMBER_RE.match(ver_string)
if not m:
logging.warn('Unable to parse SVN client version triple from '
'"%s". Assuming version 0.0.0.'
% ver_string.strip())
self.subversion_client_version = (0, 0, 0)
else:
self.subversion_client_version = tuple(map(int, m.groups()))
self._svn_repository_info_cache = SVNRepositoryInfo(path,
base_path,
uuid)
return self._svn_repository_info_cache
def get_repository_info(self):
"""Returns information on the Clear Case repository.
This will first check if the cleartool command is
installed and in the path, and post-review was run
from inside of the view.
"""
if not check_install('cleartool help'):
return None
viewname = execute(["cleartool", "pwv", "-short"]).strip()
if viewname.startswith('** NONE'):
return None
# Now that we know it's ClearCase, make sure we have GNU diff installed,
# and error out if we don't.
check_gnu_diff()
property_lines = execute(["cleartool", "lsview", "-full", "-properties",
"-cview"], split_lines=True)
for line in property_lines:
properties = line.split(' ')
if properties[0] == 'Properties:':
# Determine the view type and check if it's supported.
#
# Specifically check if webview was listed in properties
# because webview types also list the 'snapshot'
# entry in properties.
if 'webview' in properties:
die("Webviews are not supported. You can use post-review"
" only in dynamic or snapshot view.")
if 'dynamic' in properties:
self.viewtype = 'dynamic'
else:
self.viewtype = 'snapshot'
break
# Find current VOB's tag
vobstag = execute(["cleartool", "describe", "-short", "vob:."],
ignore_errors=True).strip()
if "Error: " in vobstag:
die("To generate diff run post-review inside vob.")
# From current working directory cut path to VOB.
# VOB's tag contain backslash character before VOB's name.
# I hope that first character of VOB's tag like '\new_proj'
# won't be treat as new line character but two separate:
# backslash and letter 'n'
cwd = os.getcwd()
base_path = cwd[:cwd.find(vobstag) + len(vobstag)]
return ClearCaseRepositoryInfo(path=base_path,
base_path=base_path,
vobstag=vobstag,
supports_parent_diffs=False)
def get_local_path(self):
"""Return the local path to the working tree.
Returns:
unicode:
The filesystem path of the repository on the client system.
"""
if check_install(['brz', 'help']):
# This is Breezy.
self.bzr = 'brz'
self.is_breezy = True
elif check_install(['bzr', 'help']):
# This is either a legacy Bazaar (aliased to bzr) or the
# modern Breezy. Let's find out.
version = execute(['bzr', '--version'], ignore_errors=True)
self.is_breezy = version.startswith('Breezy')
self.bzr = 'bzr'
else:
logging.debug('Unable to execute "brz help" or "bzr help": '
'skipping Bazaar')
return None
bzr_info = execute([self.bzr, 'info'], ignore_errors=True)
if 'ERROR: Not a branch:' in bzr_info:
return None
if '(format: git)' in bzr_info:
# This is a Git repository, which Breezy will happily use, but
# we want to prioritize Git.
return None
# This is a branch, let's get its attributes:
branch_match = re.search(self.BRANCH_REGEX, bzr_info, re.MULTILINE)
path = branch_match.group('branch_path')
if path == '.':
path = os.getcwd()
return path
def __init__(self, config=None, options=None):
super(TFSClient, self).__init__(config, options)
self.tf = None
if sys.platform.startswith('win'):
# First check in the system path. If that doesn't work, look in the
# two standard install locations.
tf_locations = [
'tf.cmd',
r'%programfiles(x86)%\Microsoft Visual Studio 12.0\Common7\IDE\tf.cmd',
r'%programfiles%\Microsoft Team Foundation Server 12.0\Tools\tf.cmd',
]
for location in tf_locations:
if check_install([location, 'help']):
self.tf = location
break
elif check_install(['tf', 'help']):
self.tf = 'tf'
def get_local_path(self):
"""Return the local path to the working tree.
Returns:
unicode:
The filesystem path of the repository on the client system.
"""
if not check_install([self._exe, '--help']):
logging.debug('Unable to execute "hg --help": skipping Mercurial')
return None
return self.hg_root
def get_repository_info(self):
"""Return repository information for the current working tree.
Returns:
rbtools.clients.RepositoryInfo:
The repository info structure.
"""
if not check_install(['cvs']):
logging.debug('Unable to execute "cvs": skipping CVS')
return None
repository_path = self.get_local_path()
return RepositoryInfo(path=repository_path,
local_path=repository_path)
def get_repository_info(self):
if not check_install(['svn', 'help']):
logging.debug('Unable to execute "svn help": skipping SVN')
return None
# Get the SVN repository path (either via a working copy or
# a supplied URI)
svn_info_params = ["info"]
if getattr(self.options, 'repository_url', None):
svn_info_params.append(self.options.repository_url)
# Add --non-interactive so that this command will not hang
# when used on a https repository path
svn_info_params.append("--non-interactive")
data = self._run_svn(svn_info_params,
ignore_errors=True,
results_unicode=False)
m = re.search(b'^Repository Root: (.+)$', data, re.M)
if not m:
return None
path = m.group(1)
m = re.search(b'^URL: (.+)$', data, re.M)
if not m:
return None
base_path = m.group(1)[len(path):] or "/"
m = re.search(b'^Repository UUID: (.+)$', data, re.M)
if not m:
return None
# Now that we know it's SVN, make sure we have GNU diff installed,
# and error out if we don't.
check_gnu_diff()
# Grab version of SVN client and store as a tuple in the form:
# (major_version, minor_version, micro_version)
ver_string = self._run_svn(['--version', '-q'], ignore_errors=True)
self.subversion_client_version = tuple(map(int, ver_string.split('.')))
return SVNRepositoryInfo(path, base_path, m.group(1))
def get_repository_info(self):
if not check_install(['svn', 'help']):
logging.debug('Unable to execute "svn help": skipping SVN')
return None
# Get the SVN repository path (either via a working copy or
# a supplied URI)
svn_info_params = ["info"]
if getattr(self.options, 'repository_url', None):
svn_info_params.append(self.options.repository_url)
# Add --non-interactive so that this command will not hang
# when used on a https repository path
svn_info_params.append("--non-interactive")
data = self._run_svn(svn_info_params, ignore_errors=True,
results_unicode=False)
m = re.search(b'^Repository Root: (.+)$', data, re.M)
if not m:
return None
path = m.group(1)
m = re.search(b'^URL: (.+)$', data, re.M)
if not m:
return None
base_path = m.group(1)[len(path):] or "/"
m = re.search(b'^Repository UUID: (.+)$', data, re.M)
if not m:
return None
# Now that we know it's SVN, make sure we have GNU diff installed,
# and error out if we don't.
check_gnu_diff()
# Grab version of SVN client and store as a tuple in the form:
# (major_version, minor_version, micro_version)
ver_string = self._run_svn(['--version', '-q'], ignore_errors=True)
self.subversion_client_version = tuple(map(int, ver_string.split('.')))
return SVNRepositoryInfo(path, base_path, m.group(1))
def get_repository_info(self):
if not check_install('/usr/local/svn/bin/svn help'):
return None
# Get the SVN repository path (either via a working copy or
# a supplied URI)
svn_info_params = ["/usr/local/svn/bin/svn", "info"]
if getattr(self.options, 'repository_url', None):
svn_info_params.append(self.options.repository_url)
# Add --non-interactive so that this command will not hang
# when used on a https repository path
svn_info_params.append("--non-interactive")
svn_info_params.append("--username")
svn_info_params.append("felix")
svn_info_params.append("--password")
svn_info_params.append("felix")
data = execute(svn_info_params,
ignore_errors=True)
m = re.search(r'^Repository Root: (.+)$', data, re.M)
if not m:
return None
path = m.group(1)
m = re.search(r'^URL: (.+)$', data, re.M)
if not m:
return None
base_path = m.group(1)[len(path):] or "/"
m = re.search(r'^Repository UUID: (.+)$', data, re.M)
if not m:
return None
# Now that we know it's SVN, make sure we have GNU diff installed,
# and error out if we don't.
check_gnu_diff()
return SVNRepositoryInfo(path, base_path, m.group(1))
def get_repository_info(self):
if not check_install('/usr/local/svn/bin/svn help'):
return None
# Get the SVN repository path (either via a working copy or
# a supplied URI)
svn_info_params = ["/usr/local/svn/bin/svn", "info"]
if getattr(self.options, 'repository_url', None):
svn_info_params.append(self.options.repository_url)
# Add --non-interactive so that this command will not hang
# when used on a https repository path
svn_info_params.append("--non-interactive")
svn_info_params.append("--username")
svn_info_params.append("felix")
svn_info_params.append("--password")
svn_info_params.append("felix")
data = execute(svn_info_params, ignore_errors=True)
m = re.search(r'^Repository Root: (.+)$', data, re.M)
if not m:
return None
path = m.group(1)
m = re.search(r'^URL: (.+)$', data, re.M)
if not m:
return None
base_path = m.group(1)[len(path):] or "/"
m = re.search(r'^Repository UUID: (.+)$', data, re.M)
if not m:
return None
# Now that we know it's SVN, make sure we have GNU diff installed,
# and error out if we don't.
check_gnu_diff()
return SVNRepositoryInfo(path, base_path, m.group(1))
def get_repository_info(self):
if not check_install(["svn", "help"]):
logging.debug('Unable to execute "svn help": skipping SVN')
return None
# Get the SVN repository path (either via a working copy or
# a supplied URI)
svn_info_params = ["svn", "info"]
if getattr(self.options, "repository_url", None):
svn_info_params.append(self.options.repository_url)
# Add --non-interactive so that this command will not hang
# when used on a https repository path
svn_info_params.append("--non-interactive")
data = execute(svn_info_params, ignore_errors=True)
m = re.search(r"^Repository Root: (.+)$", data, re.M)
if not m:
return None
path = m.group(1)
m = re.search(r"^URL: (.+)$", data, re.M)
if not m:
return None
base_path = m.group(1)[len(path) :] or "/"
m = re.search(r"^Repository UUID: (.+)$", data, re.M)
if not m:
return None
# Now that we know it's SVN, make sure we have GNU diff installed,
# and error out if we don't.
check_gnu_diff()
return SVNRepositoryInfo(path, base_path, m.group(1))
def get_repository_info(self):
if not check_install(['hg', '--help']):
return None
self._init()
if not self.hg_root:
# hg aborted => no mercurial repository here.
return None
if self._type == 'svn':
return self._calculate_hgsubversion_repository_info(self._svn_info)
else:
path = self.hg_root
base_path = '/'
if self._remote_path:
path = self._remote_path[1]
base_path = ''
return RepositoryInfo(path=path, base_path=base_path,
supports_parent_diffs=True)
def get_repository_info(self):
if not check_install(['svn', 'help']):
logging.debug('Unable to execute "svn help": skipping SVN')
return None
# Get the SVN repository path (either via a working copy or
# a supplied URI)
svn_info_params = ["info"]
if getattr(self.options, 'repository_url', None):
svn_info_params.append(self.options.repository_url)
# Add --non-interactive so that this command will not hang
# when used on a https repository path
svn_info_params.append("--non-interactive")
data = self._run_svn(svn_info_params, ignore_errors=True)
m = re.search(r'^Repository Root: (.+)$', data, re.M)
if not m:
return None
path = m.group(1)
m = re.search(r'^URL: (.+)$', data, re.M)
if not m:
return None
base_path = m.group(1)[len(path):] or "/"
m = re.search(r'^Repository UUID: (.+)$', data, re.M)
if not m:
return None
# Now that we know it's SVN, make sure we have GNU diff installed,
# and error out if we don't.
check_gnu_diff()
return SVNRepositoryInfo(path, base_path, m.group(1))
def get_repository_info(self):
if not check_install(["hg", "--help"]):
logging.debug('Unable to execute "hg --help": skipping Mercurial')
return None
self._init()
if not self.hg_root:
# hg aborted => no mercurial repository here.
return None
if self._type == "svn":
return self._calculate_hgsubversion_repository_info(self._svn_info)
else:
path = self.hg_root
base_path = "/"
if self._remote_path:
path = self._remote_path[1]
base_path = ""
return RepositoryInfo(path=path, base_path=base_path, supports_parent_diffs=True)
def __init__(self, config=None, options=None):
"""Initialize the wrapper.
Args:
config (dict, optional):
The loaded configuration.
options (argparse.Namespace, optional):
The command line options.
"""
self.config = config
self.options = options
self.tf = None
tf_locations = []
if options and getattr(options, 'tf_cmd', None):
tf_locations.append(options.tf_cmd)
if sys.platform.startswith('win'):
# First check in the system path. If that doesn't work, look in the
# two standard install locations.
tf_locations.extend([
'tf.cmd',
(r'%programfiles(x86)%\Microsoft Visual Studio 12.0\Common7'
r'\IDE\tf.cmd'),
(r'%programfiles%\Microsoft Team Foundation Server 12.0\Tools'
r'\tf.cmd'),
])
else:
tf_locations.append('tf')
for location in tf_locations:
location = os.path.expandvars(location)
if check_install([location, 'help']):
self.tf = location
break
def __init__(self, config=None, options=None):
"""Initialize the wrapper.
Args:
config (dict, optional):
The loaded configuration.
options (argparse.Namespace, optional):
The command line options.
"""
self.config = config
self.options = options
self.tf = None
tf_locations = []
if options and getattr(options, 'tf_cmd', None):
tf_locations.append(options.tf_cmd)
if sys.platform.startswith('win'):
# First check in the system path. If that doesn't work, look in the
# two standard install locations.
tf_locations.extend([
'tf.cmd',
(r'%programfiles(x86)%\Microsoft Visual Studio 12.0\Common7'
r'\IDE\tf.cmd'),
(r'%programfiles%\Microsoft Team Foundation Server 12.0\Tools'
r'\tf.cmd'),
])
else:
tf_locations.append('tf')
for location in tf_locations:
location = os.path.expandvars(location)
if check_install([location, 'help']):
self.tf = location
break
def get_repository_info(self):
if not check_install(['hg', '--help']):
return None
self._init()
if not self.hg_root:
# hg aborted => no mercurial repository here.
return None
if self._type == 'svn':
return self._calculate_hgsubversion_repository_info(self._svn_info)
else:
path = self.hg_root
base_path = '/'
if self._remote_path:
path = self._remote_path[1]
base_path = ''
return RepositoryInfo(path=path,
base_path=base_path,
supports_parent_diffs=True)
def get_repository_info(self):
"""Return repository information for the current working tree.
Returns:
rbtools.clients.RepositoryInfo:
The repository info structure.
"""
if not check_install(['cm', 'version']):
logging.debug('Unable to execute "cm version": skipping Plastic')
return None
# Get the workspace directory, so we can strip it from the diff output
self.workspacedir = execute(['cm', 'gwp', '.', '--format={1}'],
split_lines=False,
ignore_errors=True).strip()
logging.debug('Workspace is %s', self.workspacedir)
# Get the repository that the current directory is from
split = execute(['cm', 'ls', self.workspacedir, '--format={8}'],
split_lines=True,
ignore_errors=True)
# remove blank lines
split = [x for x in split if x]
m = re.search(r'^rep:(.+)$', split[0], re.M)
if not m:
return None
path = m.group(1)
return RepositoryInfo(path=path,
local_path=path,
supports_changesets=True,
supports_parent_diffs=False)
def get_repository_info(self):
"""Return repository information for the current working tree.
Returns:
rbtools.clients.RepositoryInfo:
The repository info structure.
"""
if not check_install(['cm', 'version']):
logging.debug('Unable to execute "cm version": skipping Plastic')
return None
# Get the workspace directory, so we can strip it from the diff output
self.workspacedir = execute(['cm', 'gwp', '.', '--format={1}'],
split_lines=False,
ignore_errors=True).strip()
logging.debug('Workspace is %s', self.workspacedir)
# Get the repository that the current directory is from
split = execute(['cm', 'ls', self.workspacedir, '--format={8}'],
split_lines=True, ignore_errors=True)
# remove blank lines
split = [x for x in split if x]
m = re.search(r'^rep:(.+)$', split[0], re.M)
if not m:
return None
path = m.group(1)
return RepositoryInfo(path=path,
local_path=path,
supports_changesets=True,
supports_parent_diffs=False)
def get_repository_info(self):
if not check_install('git --help'):
# CreateProcess (launched via subprocess, used by check_install)
# does not automatically append .cmd for things it finds in PATH.
# If we're on Windows, and this works, save it for further use.
if (sys.platform.startswith('win')
and check_install('git.cmd --help')):
self.git = 'git.cmd'
else:
return None
git_dir = execute([self.git, "rev-parse", "--git-dir"],
ignore_errors=True).rstrip("\n")
if git_dir.startswith("fatal:") or not os.path.isdir(git_dir):
return None
self.bare = execute([self.git, "config",
"core.bare"]).strip() == 'true'
# post-review in directories other than the top level of
# of a work-tree would result in broken diffs on the server
if not self.bare:
git_top = execute([self.git, "rev-parse", "--show-toplevel"],
ignore_errors=True).rstrip("\n")
# Top level might not work on old git version se we use git dir
# to find it.
if git_top.startswith("fatal:") or not os.path.isdir(git_dir):
git_top = git_dir
os.chdir(os.path.abspath(git_top))
self.head_ref = execute([self.git, 'symbolic-ref', '-q', 'HEAD'],
ignore_errors=True).strip()
# We know we have something we can work with. Let's find out
# what it is. We'll try SVN first, but only if there's a .git/svn
# directory. Otherwise, it may attempt to create one and scan
# revisions, which can be slow. Also skip SVN detection if the git
# repository was specified on command line.
git_svn_dir = os.path.join(git_dir, 'svn')
if (not getattr(self.options, 'repository_url', None)
and os.path.isdir(git_svn_dir)
and len(os.listdir(git_svn_dir)) > 0):
data = execute([self.git, "svn", "info"], ignore_errors=True)
m = re.search(r'^Repository Root: (.+)$', data, re.M)
if m:
path = m.group(1)
m = re.search(r'^URL: (.+)$', data, re.M)
if m:
base_path = m.group(1)[len(path):] or "/"
m = re.search(r'^Repository UUID: (.+)$', data, re.M)
if m:
uuid = m.group(1)
self.type = "svn"
# Get SVN tracking branch
if getattr(self.options, 'parent_branch', None):
self.upstream_branch = self.options.parent_branch
else:
data = execute([self.git, "svn", "rebase", "-n"],
ignore_errors=True)
m = re.search(r'^Remote Branch:\s*(.+)$', data,
re.M)
if m:
self.upstream_branch = m.group(1)
else:
sys.stderr.write('Failed to determine SVN '
'tracking branch. Defaulting'
'to "master"\n')
self.upstream_branch = 'master'
return SVNRepositoryInfo(path=path,
base_path=base_path,
uuid=uuid,
supports_parent_diffs=True)
else:
# Versions of git-svn before 1.5.4 don't (appear to) support
# 'git svn info'. If we fail because of an older git install,
# here, figure out what version of git is installed and give
# the user a hint about what to do next.
version = execute([self.git, "svn", "--version"],
ignore_errors=True)
version_parts = re.search('version (\d+)\.(\d+)\.(\d+)',
version)
svn_remote = execute(
[self.git, "config", "--get", "svn-remote.svn.url"],
ignore_errors=True)
if (version_parts and svn_remote and not self.is_valid_version(
(int(version_parts.group(1)), int(version_parts.group(2)),
int(version_parts.group(3))), (1, 5, 4))):
die("Your installation of git-svn must be upgraded to "
"version 1.5.4 or later")
# Okay, maybe Perforce (git-p4).
git_p4_ref = os.path.join(git_dir, 'refs', 'remotes', 'p4', 'master')
data = execute([self.git, 'config', '--get', 'git-p4.port'],
ignore_errors=True)
m = re.search(r'(.+)', data)
if m and os.path.exists(git_p4_ref):
port = m.group(1)
self.type = 'perforce'
self.upstream_branch = 'remotes/p4/master'
return RepositoryInfo(path=port,
base_path='',
supports_parent_diffs=True)
# Nope, it's git then.
# Check for a tracking branch and determine merge-base
self.upstream_branch = ''
if self.head_ref:
short_head = self._strip_heads_prefix(self.head_ref)
merge = execute(
[self.git, 'config', '--get',
'branch.%s.merge' % short_head],
ignore_errors=True).strip()
remote = execute(
[self.git, 'config', '--get',
'branch.%s.remote' % short_head],
ignore_errors=True).strip()
merge = self._strip_heads_prefix(merge)
if remote and remote != '.' and merge:
self.upstream_branch = '%s/%s' % (remote, merge)
url = None
if getattr(self.options, 'repository_url', None):
url = self.options.repository_url
self.upstream_branch = self.get_origin(self.upstream_branch,
True)[0]
else:
self.upstream_branch, origin_url = \
self.get_origin(self.upstream_branch, True)
if not origin_url or origin_url.startswith("fatal:"):
self.upstream_branch, origin_url = self.get_origin()
url = origin_url.rstrip('/')
# Central bare repositories don't have origin URLs.
# We return git_dir instead and hope for the best.
if not url:
url = os.path.abspath(git_dir)
# There is no remote, so skip this part of upstream_branch.
self.upstream_branch = self.upstream_branch.split('/')[-1]
if url:
self.type = "git"
return RepositoryInfo(path=url,
base_path='',
supports_parent_diffs=True)
return None
def is_supported(self):
return check_install(['p4', 'help'])
def is_supported(self):
return check_install('p4 help')
def get_repository_info(self):
"""Get repository information for the current Git working tree.
Returns:
rbtools.clients.RepositoryInfo:
The repository info structure.
"""
# Temporarily reset the toplevel. This is necessary for making things
# work correctly in unit tests where we may be moving the cwd around a
# lot.
self._git_toplevel = None
if not check_install(['git', '--help']):
# CreateProcess (launched via subprocess, used by check_install)
# does not automatically append .cmd for things it finds in PATH.
# If we're on Windows, and this works, save it for further use.
if (sys.platform.startswith('win') and
check_install(['git.cmd', '--help'])):
self.git = 'git.cmd'
else:
logging.debug('Unable to execute "git --help" or "git.cmd '
'--help": skipping Git')
return None
git_dir = self._execute([self.git, 'rev-parse', '--git-dir'],
ignore_errors=True).rstrip('\n')
if git_dir.startswith('fatal:') or not os.path.isdir(git_dir):
return None
# Sometimes core.bare is not set, and generates an error, so ignore
# errors. Valid values are 'true' or '1'.
bare = execute([self.git, 'config', 'core.bare'],
ignore_errors=True).strip()
self.bare = bare in ('true', '1')
# Running in directories other than the top level of
# of a work-tree would result in broken diffs on the server
if not self.bare:
git_top = execute([self.git, 'rev-parse', '--show-toplevel'],
ignore_errors=True).rstrip('\n')
# Top level might not work on old git version se we use git dir
# to find it.
if (git_top.startswith(('fatal:', 'cygdrive')) or
not os.path.isdir(git_dir)):
git_top = git_dir
self._git_toplevel = os.path.abspath(git_top)
self._head_ref = self._execute(
[self.git, 'symbolic-ref', '-q', 'HEAD'],
ignore_errors=True).strip()
# We know we have something we can work with. Let's find out
# what it is. We'll try SVN first, but only if there's a .git/svn
# directory. Otherwise, it may attempt to create one and scan
# revisions, which can be slow. Also skip SVN detection if the git
# repository was specified on command line.
git_svn_dir = os.path.join(git_dir, 'svn')
if (not getattr(self.options, 'repository_url', None) and
os.path.isdir(git_svn_dir) and
len(os.listdir(git_svn_dir)) > 0):
data = self._execute([self.git, 'svn', 'info'], ignore_errors=True)
m = re.search(r'^Repository Root: (.+)$', data, re.M)
if m:
path = m.group(1)
m = re.search(r'^URL: (.+)$', data, re.M)
if m:
base_path = m.group(1)[len(path):] or '/'
m = re.search(r'^Repository UUID: (.+)$', data, re.M)
if m:
uuid = m.group(1)
self._type = self.TYPE_GIT_SVN
m = re.search(r'Working Copy Root Path: (.+)$', data,
re.M)
if m:
local_path = m.group(1)
else:
local_path = self._git_toplevel
return SVNRepositoryInfo(path=path,
base_path=base_path,
local_path=local_path,
uuid=uuid,
supports_parent_diffs=True)
else:
# Versions of git-svn before 1.5.4 don't (appear to) support
# 'git svn info'. If we fail because of an older git install,
# here, figure out what version of git is installed and give
# the user a hint about what to do next.
version = self._execute([self.git, 'svn', '--version'],
ignore_errors=True)
version_parts = re.search('version (\d+)\.(\d+)\.(\d+)',
version)
svn_remote = self._execute(
[self.git, 'config', '--get', 'svn-remote.svn.url'],
ignore_errors=True)
if (version_parts and svn_remote and
not is_valid_version((int(version_parts.group(1)),
int(version_parts.group(2)),
int(version_parts.group(3))),
(1, 5, 4))):
raise SCMError('Your installation of git-svn must be '
'upgraded to version 1.5.4 or later.')
# Okay, maybe Perforce (git-p4).
git_p4_ref = os.path.join(git_dir, 'refs', 'remotes', 'p4', 'master')
if os.path.exists(git_p4_ref):
data = self._execute([self.git, 'config', '--get', 'git-p4.port'],
ignore_errors=True)
m = re.search(r'(.+)', data)
if m:
port = m.group(1)
else:
port = os.getenv('P4PORT')
if port:
self._type = self.TYPE_GIT_P4
return RepositoryInfo(path=port,
base_path='',
local_path=self._git_toplevel,
supports_parent_diffs=True)
# Nope, it's git then.
# Check for a tracking branch and determine merge-base
self._type = self.TYPE_GIT
url = None
if getattr(self.options, 'repository_url', None):
url = self.options.repository_url
else:
upstream_branch = self._get_parent_branch()
url = self._get_origin(upstream_branch).rstrip('/')
if url.startswith('fatal:'):
raise SCMError('Could not determine remote URL for upstream '
'branch %s' % upstream_branch)
# Central bare repositories don't have origin URLs.
# We return git_dir instead and hope for the best.
if not url:
url = os.path.abspath(git_dir)
if url:
return RepositoryInfo(path=url,
base_path='',
local_path=self._git_toplevel,
supports_parent_diffs=True)
return None
def test_check_install(self):
"""Test 'check_install' method."""
self.assertTrue(checks.check_install(sys.executable + ' --version'))
self.assertFalse(checks.check_install(self.gen_uuid()))
def get_repository_info(self):
"""Return information on the ClearCase repository.
This will first check if the cleartool command is installed and in the
path, and that the current working directory is inside of the view.
Returns:
ClearCaseRepositoryInfo:
The repository info structure.
"""
if not check_install(['cleartool', 'help']):
logging.debug('Unable to execute "cleartool help": skipping '
'ClearCase')
return None
viewname = execute(['cleartool', 'pwv', '-short']).strip()
if viewname.startswith('** NONE'):
return None
# Now that we know it's ClearCase, make sure we have GNU diff
# installed, and error out if we don't.
check_gnu_diff()
property_lines = execute(
['cleartool', 'lsview', '-full', '-properties', '-cview'],
split_lines=True)
for line in property_lines:
properties = line.split(' ')
if properties[0] == 'Properties:':
# Determine the view type and check if it's supported.
#
# Specifically check if webview was listed in properties
# because webview types also list the 'snapshot'
# entry in properties.
if 'webview' in properties:
raise SCMError('Webviews are not supported. You can use '
'rbt commands only in dynamic or snapshot '
'views.')
if 'dynamic' in properties:
self.viewtype = 'dynamic'
else:
self.viewtype = 'snapshot'
break
# Find current VOB's tag
vobstag = execute(['cleartool', 'describe', '-short', 'vob:.'],
ignore_errors=True).strip()
if 'Error: ' in vobstag:
raise SCMError('Failed to generate diff run rbt inside vob.')
root_path = execute(['cleartool', 'pwv', '-root'],
ignore_errors=True).strip()
if 'Error: ' in root_path:
raise SCMError('Failed to generate diff run rbt inside view.')
# From current working directory cut path to VOB. On Windows
# and under cygwin, the VOB tag contains the VOB's path including
# name, e.g. `\new_proj` for a VOB `new_proj` mounted at the root
# of a drive. On Unix, the VOB tag is similar, but with a different
# path separator, e.g. `/vobs/new_proj` for our new_proj VOB mounted
# at `/vobs`.
cwd = os.getcwd()
base_path = cwd[:len(root_path) + len(vobstag)]
return ClearCaseRepositoryInfo(path=base_path,
base_path=base_path,
vobstag=vobstag)
def test_check_install(self):
"""Testing 'check_install' method."""
self.assertTrue(checks.check_install([sys.executable, ' --version']))
self.assertFalse(checks.check_install([self.gen_uuid()]))
def check_download(self, url, zip_filename):
"""Check to see if the file was successfully downloaded.
If the user has :command:`gpg` installed on their system, use that to
check that the package was signed. Otherwise, check the sha256sum.
Args:
url (unicode):
The URL that the file came from.
zip_filename (unicode):
The filename of the downloaded copy.
Raises:
rbtools.commands.CommandError:
The authenticity of the file could not be verified.
"""
if check_install('gpg'):
execute(['gpg', '--recv-keys', '4ED1F993'])
sig_filename = self.download_file('%s.asc' % url)
try:
retcode, output, errors = execute(
['gpg', '--verify', sig_filename, zip_filename],
with_errors=False,
ignore_errors=True,
return_error_code=True,
return_errors=True)
if retcode == 0:
logging.debug('Verified file signature')
else:
raise CommandError(
'Unable to verify authenticity of file downloaded '
'from %s:\n%s' % (url, errors))
finally:
os.unlink(sig_filename)
else:
logging.info('"gpg" not installed. Skipping signature validation.')
try:
sha_url = '%s.sha256sum' % url
logging.debug('Downloading %s', sha_url)
response = urlopen(sha_url)
real_sha = response.read().split(' ')[0]
except (HTTPError, URLError) as e:
raise CommandError('Error when downloading file: %s' % e)
with open(zip_filename, 'r') as f:
our_sha = hashlib.sha256(f.read()).hexdigest()
if real_sha == our_sha:
logging.debug('Verified SHA256 hash')
else:
logging.debug('SHA256 hash does not match!')
logging.debug(' Downloaded file hash was: %s', our_sha)
logging.debug(' Expected hash was: %s', real_sha)
raise CommandError(
'Unable to verify the checksum of the downloaded copy of '
'%s.\n'
'This could be due to an invasive proxy or an attempted '
'man-in-the-middle attack.' % url)
def get_repository_info(self):
"""Return information on the Clear Case repository.
This will first check if the cleartool command is installed and in the
path, and that the current working directory is inside of the view.
"""
if not check_install(['cleartool', 'help']):
logging.debug('Unable to execute "cleartool help": skipping '
'ClearCase')
return None
viewname = execute(['cleartool', 'pwv', '-short']).strip()
if viewname.startswith('** NONE'):
return None
# Now that we know it's ClearCase, make sure we have GNU diff
# installed, and error out if we don't.
check_gnu_diff()
property_lines = execute(
['cleartool', 'lsview', '-full', '-properties', '-cview'],
split_lines=True)
for line in property_lines:
properties = line.split(' ')
if properties[0] == 'Properties:':
# Determine the view type and check if it's supported.
#
# Specifically check if webview was listed in properties
# because webview types also list the 'snapshot'
# entry in properties.
if 'webview' in properties:
raise SCMError('Webviews are not supported. You can use '
'rbt commands only in dynamic or snapshot '
'views.')
if 'dynamic' in properties:
self.viewtype = 'dynamic'
else:
self.viewtype = 'snapshot'
break
# Find current VOB's tag
vobstag = execute(['cleartool', 'describe', '-short', 'vob:.'],
ignore_errors=True).strip()
if 'Error: ' in vobstag:
raise SCMError('Failed to generate diff run rbt inside vob.')
root_path = execute(['cleartool', 'pwv', '-root'],
ignore_errors=True).strip()
if 'Error: ' in root_path:
raise SCMError('Failed to generate diff run rbt inside view.')
# From current working directory cut path to VOB. On Windows
# and under cygwin, the VOB tag contains the VOB's path including
# name, e.g. `\new_proj` for a VOB `new_proj` mounted at the root
# of a drive. On Unix, the VOB tag is similar, but with a different
# path separator, e.g. `/vobs/new_proj` for our new_proj VOB mounted
# at `/vobs`.
cwd = os.getcwd()
base_path = cwd[:len(root_path) + len(vobstag)]
return ClearCaseRepositoryInfo(path=base_path,
base_path=base_path,
vobstag=vobstag,
supports_parent_diffs=False)
def check_download(self, url, zip_filename):
"""Check to see if the file was successfully downloaded.
If the user has :command:`gpg` installed on their system, use that to
check that the package was signed. Otherwise, check the sha256sum.
Args:
url (unicode):
The URL that the file came from.
zip_filename (unicode):
The filename of the downloaded copy.
Raises:
rbtools.commands.CommandError:
The authenticity of the file could not be verified.
"""
if check_install('gpg'):
execute(['gpg', '--recv-keys', '4ED1F993'])
sig_filename = self.download_file('%s.asc' % url)
try:
retcode, output, errors = execute(
['gpg', '--verify', sig_filename, zip_filename],
with_errors=False, ignore_errors=True,
return_error_code=True, return_errors=True)
if retcode == 0:
logging.debug('Verified file signature')
else:
raise CommandError(
'Unable to verify authenticity of file downloaded '
'from %s:\n%s' % (url, errors))
finally:
os.unlink(sig_filename)
else:
logging.info('"gpg" not installed. Skipping signature validation.')
try:
sha_url = '%s.sha256sum' % url
logging.debug('Downloading %s', sha_url)
response = urlopen(sha_url)
real_sha = response.read().split(' ')[0]
except (HTTPError, URLError) as e:
raise CommandError('Error when downloading file: %s' % e)
with open(zip_filename, 'rb') as f:
our_sha = hashlib.sha256(f.read()).hexdigest()
if real_sha == our_sha:
logging.debug('Verified SHA256 hash')
else:
logging.debug('SHA256 hash does not match!')
logging.debug(' Downloaded file hash was: %s', our_sha)
logging.debug(' Expected hash was: %s', real_sha)
raise CommandError(
'Unable to verify the checksum of the downloaded copy of '
'%s.\n'
'This could be due to an invasive proxy or an attempted '
'man-in-the-middle attack.' % url)
def get_repository_info(self):
if not check_install(['git', '--help']):
# CreateProcess (launched via subprocess, used by check_install)
# does not automatically append .cmd for things it finds in PATH.
# If we're on Windows, and this works, save it for further use.
if (sys.platform.startswith('win') and
check_install(['git.cmd', '--help'])):
self.git = 'git.cmd'
else:
logging.debug('Unable to execute "git --help" or "git.cmd '
'--help": skipping Git')
return None
git_dir = execute([self.git, "rev-parse", "--git-dir"],
ignore_errors=True).rstrip("\n")
if git_dir.startswith("fatal:") or not os.path.isdir(git_dir):
return None
# Sometimes core.bare is not set, and generates an error, so ignore
# errors. Valid values are 'true' or '1'.
bare = execute([self.git, 'config', 'core.bare'],
ignore_errors=True).strip()
self.bare = bare in ('true', '1')
# Running in directories other than the top level of
# of a work-tree would result in broken diffs on the server
if not self.bare:
git_top = execute([self.git, "rev-parse", "--show-toplevel"],
ignore_errors=True).rstrip("\n")
# Top level might not work on old git version se we use git dir
# to find it.
if git_top.startswith("fatal:") or not os.path.isdir(git_dir):
git_top = git_dir
os.chdir(os.path.abspath(git_top))
self.head_ref = execute([self.git, 'symbolic-ref', '-q',
'HEAD'], ignore_errors=True).strip()
# We know we have something we can work with. Let's find out
# what it is. We'll try SVN first, but only if there's a .git/svn
# directory. Otherwise, it may attempt to create one and scan
# revisions, which can be slow. Also skip SVN detection if the git
# repository was specified on command line.
git_svn_dir = os.path.join(git_dir, 'svn')
if not getattr(self.options, 'repository_url', None):
if (os.path.isdir(git_svn_dir) and len(os.listdir(git_svn_dir)) > 0):
# git-svn?
data = execute([self.git, "svn", "info"], ignore_errors=True)
else:
# do we have git+svn on the same dir?
data = execute([self.svn, "info"], ignore_errors=True)
sys.stdout.write('Suspecting GIT+SVN\n')
sys.stdout.write(data);
if (len(data) > 0):
m = re.search(r'^Repository Root: (.+)$', data, re.M)
if m:
path = m.group(1)
m = re.search(r'^URL: (.+)$', data, re.M)
if m:
base_path = m.group(1)[len(path):] or "/"
m = re.search(r'^Repository UUID: (.+)$', data, re.M)
if m:
uuid = m.group(1)
self.type = "svn"
# Get SVN tracking branch
if getattr(self.options, 'tracking', None):
self.upstream_branch = self.options.tracking
else:
data = execute([self.git, "svn", "rebase", "-n"],
ignore_errors=True)
m = re.search(r'^Remote Branch:\s*(.+)$', data,
re.M)
if m:
self.upstream_branch = m.group(1)
else:
sys.stderr.write('Failed to determine SVN '
'tracking branch. Defaulting'
'to "master"\n')
self.upstream_branch = 'master'
return SVNRepositoryInfo(path=path,
base_path=base_path,
uuid=uuid,
supports_parent_diffs=True)
else:
# Versions of git-svn before 1.5.4 don't (appear to) support
# 'git svn info'. If we fail because of an older git install,
# here, figure out what version of git is installed and give
# the user a hint about what to do next.
version = execute([self.git, "svn", "--version"],
ignore_errors=True)
version_parts = re.search('version (\d+)\.(\d+)\.(\d+)',
version)
svn_remote = execute(
[self.git, "config", "--get", "svn-remote.svn.url"],
ignore_errors=True)
if (version_parts and svn_remote and
not self.is_valid_version((int(version_parts.group(1)),
int(version_parts.group(2)),
int(version_parts.group(3))),
(1, 5, 4))):
die("Your installation of git-svn must be upgraded to "
"version 1.5.4 or later")
# Okay, maybe Perforce (git-p4).
git_p4_ref = os.path.join(git_dir, 'refs', 'remotes', 'p4', 'master')
if os.path.exists(git_p4_ref):
data = execute([self.git, 'config', '--get', 'git-p4.port'],
ignore_errors=True)
m = re.search(r'(.+)', data)
if m:
port = m.group(1)
else:
port = os.getenv('P4PORT')
if port:
self.type = 'perforce'
self.upstream_branch = 'remotes/p4/master'
return RepositoryInfo(path=port,
base_path='',
supports_parent_diffs=True)
# Nope, it's git then.
# Check for a tracking branch and determine merge-base
self.upstream_branch = ''
if self.head_ref:
short_head = self._strip_heads_prefix(self.head_ref)
merge = execute([self.git, 'config', '--get',
'branch.%s.merge' % short_head],
ignore_errors=True).strip()
remote = execute([self.git, 'config', '--get',
'branch.%s.remote' % short_head],
ignore_errors=True).strip()
merge = self._strip_heads_prefix(merge)
if remote and remote != '.' and merge:
self.upstream_branch = '%s/%s' % (remote, merge)
url = None
if getattr(self.options, 'repository_url', None):
url = self.options.repository_url
self.upstream_branch = self.get_origin(self.upstream_branch,
True)[0]
else:
self.upstream_branch, origin_url = \
self.get_origin(self.upstream_branch, True)
if not origin_url or origin_url.startswith("fatal:"):
self.upstream_branch, origin_url = self.get_origin()
url = origin_url.rstrip('/')
# Central bare repositories don't have origin URLs.
# We return git_dir instead and hope for the best.
if not url:
url = os.path.abspath(git_dir)
# There is no remote, so skip this part of upstream_branch.
self.upstream_branch = self.upstream_branch.split('/')[-1]
if url:
self.type = "git"
return RepositoryInfo(path=url, base_path='',
supports_parent_diffs=True)
return None
def get_repository_info(self):
if not check_install('git --help'):
# CreateProcess (launched via subprocess, used by check_install)
# does not automatically append .cmd for things it finds in PATH.
# If we're on Windows, and this works, save it for further use.
if (sys.platform.startswith('win') and
check_install('git.cmd --help')):
self.git = 'git.cmd'
else:
return None
git_dir = execute([self.git, "rev-parse", "--git-dir"],
ignore_errors=True).rstrip("\n")
if git_dir.startswith("fatal:") or not os.path.isdir(git_dir):
return None
self.bare = execute([self.git, "config",
"core.bare"]).strip() == 'true'
# post-review in directories other than the top level of
# of a work-tree would result in broken diffs on the server
if not self.bare:
os.chdir(os.path.dirname(os.path.abspath(git_dir)))
self.head_ref = execute([self.git, 'symbolic-ref', '-q',
'HEAD']).strip()
# We know we have something we can work with. Let's find out
# what it is. We'll try SVN first, but only if there's a .git/svn
# directory. Otherwise, it may attempt to create one and scan
# revisions, which can be slow.
git_svn_dir = os.path.join(git_dir, 'svn')
if os.path.isdir(git_svn_dir) and len(os.listdir(git_svn_dir)) > 0:
data = execute([self.git, "svn", "info"], ignore_errors=True)
m = re.search(r'^Repository Root: (.+)$', data, re.M)
if m:
path = m.group(1)
m = re.search(r'^URL: (.+)$', data, re.M)
if m:
base_path = m.group(1)[len(path):] or "/"
m = re.search(r'^Repository UUID: (.+)$', data, re.M)
if m:
uuid = m.group(1)
self.type = "svn"
# Get SVN tracking branch
if self._options.parent_branch:
self.upstream_branch = self._options.parent_branch
else:
data = execute([self.git, "svn", "rebase", "-n"],
ignore_errors=True)
m = re.search(r'^Remote Branch:\s*(.+)$', data,
re.M)
if m:
self.upstream_branch = m.group(1)
else:
sys.stderr.write('Failed to determine SVN '
'tracking branch. Defaulting'
'to "master"\n')
self.upstream_branch = 'master'
return SVNRepositoryInfo(path=path,
base_path=base_path,
uuid=uuid,
supports_parent_diffs=True)
else:
# Versions of git-svn before 1.5.4 don't (appear to) support
# 'git svn info'. If we fail because of an older git install,
# here, figure out what version of git is installed and give
# the user a hint about what to do next.
version = execute([self.git, "svn", "--version"],
ignore_errors=True)
version_parts = re.search('version (\d+)\.(\d+)\.(\d+)',
version)
svn_remote = execute([self.git, "config", "--get",
"svn-remote.svn.url"],
ignore_errors=True)
if (version_parts and
not self.is_valid_version((int(version_parts.group(1)),
int(version_parts.group(2)),
int(version_parts.group(3))),
(1, 5, 4)) and
svn_remote):
die("Your installation of git-svn must be upgraded to "
"version 1.5.4 or later")
# Okay, maybe Perforce.
# TODO
# Nope, it's git then.
# Check for a tracking branch and determine merge-base
short_head = self._strip_heads_prefix(self.head_ref)
merge = execute([self.git, 'config', '--get',
'branch.%s.merge' % short_head],
ignore_errors=True).strip()
remote = execute([self.git, 'config', '--get',
'branch.%s.remote' % short_head],
ignore_errors=True).strip()
merge = self._strip_heads_prefix(merge)
self.upstream_branch = ''
if remote and remote != '.' and merge:
self.upstream_branch = '%s/%s' % (remote, merge)
url = None
if self._options.repository_url:
url = self._options.repository_url
else:
self.upstream_branch, origin_url = \
self.get_origin(self.upstream_branch, True)
if not origin_url or origin_url.startswith("fatal:"):
self.upstream_branch, origin_url = self.get_origin()
url = origin_url.rstrip('/')
# Central bare repositories don't have origin URLs.
# We return git_dir instead and hope for the best.
if not url:
url = os.path.abspath(git_dir)
# There is no remote, so skip this part of upstream_branch.
self.upstream_branch = self.upstream_branch.split('/')[-1]
if url:
self.type = "git"
return RepositoryInfo(path=url, base_path='',
supports_parent_diffs=True)
return None
