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)