def __init__(self, url, path, branch=None):
"""
INPUT:
* url - repository address
* path - directory where the check-outs are done
* branch - branch. SVN doesn't really have branches.
"""
VCSHandlerBase.__init__(self, url, path, branch)
self.client = pysvn.Client()
self.client.callback_ssl_server_trust_prompt = self._ssl_server_trust_prompt_
def fetch(self, key, rev):
"""
fetch revision ``rev`` of entity identified by ``key``.
"""
c = pysvn.Client()
svnrev = pysvn.Revision(pysvn.opt_revision_kind.number, int(rev))
olddata = c.cat(os.path.join(settings.SVN_WC_PATH, key),
revision=svnrev)
return olddata
def __init__(self, path=None):
WorkingCopy.__init__(self, path)
self.path = os.path.realpath(path)
client = pysvn.Client()
try:
url = client.info(self.path).url
except pysvn.ClientError:
pass
else:
self.repository = SubversionRepository(url)
def isKnownSVNFile(filepath):
client = pysvn.Client()
try:
info = client.info(filepath)
if info == None:
return False
return True
except pysvn.ClientError as e:
return False
def getListAdded(path) :
logging.debug('list file added')
print "files added :"
client = pysvn.Client()
changes = client.status(path)
for f in changes :
if f.text_status == pysvn.wc_status_kind.added :
logging.debug(f.path)
print f.path
logging.debug('list file added done')
def getListDeleted(path) :
print "files deleted :"
logging.debug('list file deleted')
client = pysvn.Client()
changes = client.status(path)
for f in changes :
if f.text_status == pysvn.wc_status_kind.deleted :
print f.path
logging.debug(f.path)
logging.debug('list file deleted done')
def Installsvn(self, entry):
"""Checkout contents from a svn repository"""
# pylint: disable=E1101
client = pysvn.Client()
try:
client.update(entry.get('name'), recurse=True)
except pysvn.ClientError:
self.logger.error("Failed to update repository", exc_info=1)
return False
return True
def svn_add(path, message, commit=False):
client = pysvn.Client('/home/vocabadmin/.svn')
client.callback_get_login = lambda realm, username, may_save:(True, ag.svnusername, ag.svnpassword, True)
try:
client.add(path)
added = True
except Exception, e:
added = False
msg = e
return(added, msg)
def __init__(self, username=None, password=None, accept_cert=False):
self._client = pysvn.Client()
self.__username = username
self.__password = password
self.__accept_cert = accept_cert
if not username is None:
self._client.set_default_username(username)
def get_login(realm, username, may_save):
# logger.debug('get login')
# logger.debug(realm)
# logger.debug(username)
if self.__username is None or self.__password is None:
raise ExcSyncRequestAuth
return True, self.__username, self.__password, True
self._client.callback_get_login = get_login
self._messages = []
def callback_log_message(arg):
self._messages.append(arg)
self._client.callback_get_log_message = callback_log_message
self._notifications = []
def callback_notification(arg):
self._notifications.append(arg)
self._client.callback_notify = callback_notification
def callback_accept_cert(arg):
# logger.debug("callback certificate %s"%arg)
return True, 1, True
if self.__accept_cert:
return True, 1, True
if arg['hostname'] == 'kolekti' and arg[
'realm'] == 'https://07.kolekti.net:443':
return True, 12, True
raise ExcSyncRequestSSL
self._client.callback_ssl_server_trust_prompt = callback_accept_cert
def callback_conflict_resolver(arg):
try:
logger.debug(arg)
conflict_choice = "mine_full"
save_merged = None
merge_file = None
return conflict_choice, merge_file, save_merged
except:
logger.exception('callback confilct resolver')
self._client.callback_conflict_resolver = callback_conflict_resolver
def make_tag(from_url, tag_base_url, version):
client = pysvn.Client()
client.callback_get_log_message = lambda: (True, 'Tag version ' + version)
client.callback_get_login = callback_getLogin
try:
from_files = client.ls(from_url, recurse=False)
print 'Info: Found', from_url
except pysvn.ClientError, e:
print 'Error: From does not exist', from_url
return
def is_versioned(path):
try:
import pysvn
except:
return False
client = pysvn.Client()
r = client.status(path, False)
if len(r) > 0:
return r[0]['is_versioned']
else:
return False
def get_revision_pysvn():
# The following only works if pysvn is installed. We'd prefer not to use this since it's very slow.
# It was taken from this stackoverflow post:
# http://stackoverflow.com/questions/242295/how-does-one-add-a-svn-repository-build-number-to-python-code
import pysvn
repo = "."
rev = pysvn.Revision(pysvn.opt_revision_kind.working)
client = pysvn.Client()
info = client.info2(repo, revision=rev, recurse=False)
output = format(str(info[0][1].rev.number))
return output
def handle(self, *args, **options):
logger.debug('handle')
self.republish_list = {}
self.client = pysvn.Client()
try:
self.stdout.write(str(datetime.datetime.now()))
revision = options['revision']
repo = options['repo']
project = repo.split('/')[-1]
user = self.get_author(revision, repo)
self.stdout.write("author : [%s]"%user)
try:
acllist = TranslatorRelease.objects.exclude(user__username = user).filter(project__directory = project)
except TranslatorRelease.DoesNotExist:
raise CommandError('No update for "%d" ' % revision)
seen = set()
republish = {}
for mf in self.get_changed(revision, repo):
logger.debug(mf)
mf = mf[4:]
chunks = mf.split('/')
if len(chunks) > 1 and chunks[0] == "releases":
release = chunks[1]
updates = acllist.filter(release_name = release)
for update in updates:
path = os.path.join(settings.KOLEKTI_BASE, update.user.username, update.project.directory, 'releases', release)
# register things to be republished
if os.path.exists(path):
self.register_publish(update.user.username, chunks)
else:
self.register_publish(update.user.username, ['releases', release, 'share'])
if not release in seen:
# update local copy of release
seen.add(release)
if os.path.exists(path):
self.client.update(path)
logger.debug(path+" updated")
self.stdout.write(path+" updated")
else:
url = "file://%s/%s/releases/%s"%(settings.KOLEKTI_SVN_ROOT, update.project.directory,release)
self.client.checkout(url, path)
self.republish(project)
logger.debug('update succesfully completed')
self.stdout.write(self.style.SUCCESS('update succesfully completed'))
except:
logger.exception('update command failed')
def __init__(self, username, password, local_dir, rep_url):
self.update_connection_data(username, password, local_dir, rep_url)
self.svn_client = pysvn.Client()
self.svn_client.exception_style = 1
self.svn_client.callback_ssl_server_trust_prompt = self.ssl_server_trust_prompt
self.svn_client.callback_get_login = self.get_login
self.svn_client.callback_notify = self.callback_notify
if hasattr(self.svn_client, 'callback_conflict_resolver'):
self.svn_client.callback_conflict_resolver = self.callback_conflict_resolver
self.prepare_action_map()
self.updated_files = []
def connect(self):
client = pysvn.Client()
client.callback_ssl_server_trust_prompt = lambda dummy: (True, 0, False)
cancel_at = time.time() + self.timeout
client.callback_cancel = lambda: time.time() > cancel_at
client.set_auth_cache(False)
client.set_store_passwords(False)
client.set_interactive(False)
client.set_default_username(self.login)
client.set_default_password(self.password)
return client
def svn_freeze(paths, params):
"""..."""
client = pysvn.Client()
result = []
for i in paths:
info = client.info(i)
result.append([i, info.url, info.revision])
for i in sorted(result):
print(i)
def svn_path_exists(path, rev=None):
svn = SVNLibWrapper(pysvn.Client())
if rev:
rev = pysvn.Revision(pysvn.opt_revision_kind.number, rev)
else:
rev = pysvn.Revision(pysvn.opt_revision_kind.head)
try:
svn.info2(path, revision=rev, recurse=False)
return True
except pysvn.ClientError:
return False
def getlogs(newrev, startrev):
import pysvn
logs = []
log_messages = []
loglimit = 200
def get_login(realm, username, may_save):
return True, newrev.branch.project.repo_user, newrev.branch.project.repo_pass, False
client = pysvn.Client()
if newrev.branch.project.repo_user != "":
client.callback_get_login = get_login
try:
log_messages = \
client.log(
newrev.branch.project.repo_path,
revision_start=pysvn.Revision(
pysvn.opt_revision_kind.number, startrev.commitid
),
revision_end=pysvn.Revision(
pysvn.opt_revision_kind.number, newrev.commitid
)
)
except pysvn.ClientError as e:
raise CommitLogError(e.args)
except ValueError:
raise CommitLogError("'%s' is an invalid subversion revision number" %
newrev.commitid)
log_messages.reverse()
s = len(log_messages)
while s > loglimit:
log_messages = log_messages[:s]
s = len(log_messages) - 1
for log in log_messages:
try:
author = log.author
except AttributeError:
author = ""
date = datetime.fromtimestamp(log.date).strftime("%Y-%m-%d %H:%M:%S")
message = log.message
tag = get_tag(log.revision.number, newrev.branch.project.repo_path,
client)
# Add log unless it is the last commit log, which has already been tested
logs.append({
'date': date,
'author': author,
'message': message,
'commitid': log.revision.number,
'tag': tag
})
return logs
def getHeadRevision(dir):
if not usingPysvn:
return getHeadRevisionNoPysvn(dir)
client = pysvn.Client()
client.callback_ssl_server_trust_prompt = _ssl_server_trust_prompt
info = client.info(dir)
url = info.url
info = client.info2(url, pysvn.Revision(pysvn.opt_revision_kind.head), recurse=False)
rev = int(info[0][1].last_changed_rev.number)
return rev
def create_pysvn_client(self):
self.client = pysvn.Client()
#self.client.callback_get_log_message = self.callback_get_Log_Message
self.client.callback_notify = self.callback_notify
self.client.callback_cancel = self.callback_cancel
self.client.callback_ssl_client_cert_password_prompt = self.callback_ssl_client_cert_password_prompt
self.client.callback_ssl_client_cert_prompt = self.callback_ssl_client_cert_prompt
self.client.callback_ssl_server_prompt = self.callback_ssl_server_prompt
self.client.callback_ssl_server_trust_prompt = self.callback_ssl_server_trust_prompt
self.client.callback_get_login = self.callback_get_login
def load_archive(self):
try:
client = pysvn.Client()
client.callback_get_login = get_login
folder = get_svn_directory(self)
inifile = os.path.join(folder, self._modelname+'.ini')
client.update(inifile)
for log in client.log(inifile):
self._archive.append(ArchivedIni(self._modelname, inifile, log))
except pysvn.ClientError as e:
self.set_no_archive(e)
def main():
if not dataPath or (not msgPath):
return
svn = pysvn.Client()
versionStr = ""
lenList = len(allPath)
for index, tPath in enumerate(allPath):
LogList = svn.log(tPath, limit=1)
info = LogList[0]
versionNum = info.revision.number
if index == (lenList - 1):
versionStr += str(versionNum)
else:
versionStr += str(versionNum)
versionStr += "."
exportPath1 = op.join(op.dirname(dataPath), "version")
exportPath = op.join(exportPath1, 'version.txt')
f = open(exportPath, 'w')
f.write(versionStr)
f.close()
SvnCmd(path=exportPath,
cmd='commit',
logmsg='Commit version text.{}||{}'.format(exportPath1,
SERV_VERSION_DIR)).Run()
# copy version 到 trunk
SvnCmd(path=SERV_VERSION_DIR, cmd='update',
logmsg='update version files.').Run()
update_files_version, add_files_version = FileUtil.copy(
exportPath1, SERV_VERSION_DIR, suffixes=('.txt', ), force=True)
# print("{} .txt files {}".format("#" * 16, "#" * 16))
# print("updated:")
# # prettyOutput(update_files_version)
# print('')
if add_files_version:
print("added:")
prettyOutput(add_files_version)
for new_file in add_files_version:
dst_file = op.join(SERV_VERSION_DIR, op.basename(new_file))
SvnCmd(path=dst_file,
cmd='add',
logmsg='add new config data files').Run()
SvnCmd(path=SERV_VERSION_DIR, cmd='commit',
logmsg='commit version files').Run()
def UpdateSvn(workingCopy):
import pysvn
def SslServerTrustPromptCallback(dummy):
"""
See pysvn documentation for
pysvn.Client.callback_ssl_server_trust_prompt
"""
return True, 0, True
svn = pysvn.Client()
svn.callback_ssl_server_trust_prompt = SslServerTrustPromptCallback
svn.update(workingCopy)
def getSVNRevisonNumber(svnPath):
try:
client = pysvn.Client()
LogList = client.log(svnPath, limit=1)
ReposInfo = LogList[0]
ReposRevNumber = ReposInfo.revision.number
return ReposRevNumber
except:
return ""
def __init__(self, url=None):
self.url = url
# Set up our client object
try:
self.client = pysvn.Client()
self.client.callback_ssl_server_trust_prompt = (
self.ssl_server_trust_prompt)
self.client.set_default_username(svn_user)
self.client.set_default_password(svn_pass)
except NameError:
logging.error('pysn module is absent, no svn support')
def get_svn_version():
"""
Returns SVN version of the GSM.
"""
if SVN_LOCATION:
try:
client = pysvn.Client(SVN_LOCATION)
return client.info(SVN_LOCATION).data['revision'].number
except:
return -1
else:
return -1
def setUp(self):
settings.PROJECTS_REPOSITORY_DIRECTORY = settings.PROJECTS_REPOSITORY_DIRECTORY_UNIT
master_name = "unit_1_master"
co_name = "1"
self.client = pysvn.Client()
self.repository = SvnTestRepository()
self.repository.set_repository_base_path(
settings.PROJECTS_REPOSITORY_DIRECTORY)
self.repository_master_path = self.repository.create_master(
master_name)
self.repository_path = self.repository.create_checkout(
master_name, co_name)
def _setup_cli(self):
self.svn_cli = pysvn.Client()
self.svn_cli.exception_style = 1
if self._svn_username:
def get_login(r, u, s):
return (True, self._svn_username, self._svn_password, False)
self.svn_cli.callback_get_login = get_login
self.svn_cli.callback_notify = self._cb_notify
if self._ssl_server_trust_prompt:
self.svn_cli.callback_ssl_server_trust_prompt = self._ssl_server_trust_prompt
def getPySvnClient():
"""Returns the module-global pysvn Client object (creating one if needed).
Lazily initializes a global pysvn Client object, returning the same one
once it exists.
"""
global _client
if not _client:
_client = pysvn.Client()
return _client
def _update_repository(repository):
source_identifier = "%s:%s" % (__name__, repository.url)
last_update_date = Item.objects.get_last_update_of_model(
CodeCommit, source=source_identifier)
log.info("Updating changes from %s since %s", repository.url,
last_update_date)
rev = pysvn.Revision(pysvn.opt_revision_kind.date,
time.mktime(last_update_date.timetuple()))
c = pysvn.Client()
for revision in reversed(c.log(repository.url, revision_end=rev)):
if revision.author == repository.username:
_handle_revision(repository, revision)
