使用SVNkit删除版本库的文件
源网址:http://wiki.svnkit.com/Committing_To_A_Repository
Editing Operation: commiting to a repository
The low-level layer provides for an ability to build and change tree-like hierarchies in a repository giving a developer an abstract editor. With such an editor you make edits to a repository manually (i.e. explicitly in your code): you add new nodes (directories) and items (files) under those nodes, change or delete existing ones identifying them (refering to them) by their paths in a repository. Now we are going to show this model in details.
Using the ISVNEditor Interface
ISVNEditor is the interface for editing operations, for committing changes to a repository in particular. ISVNEditor is also used to receive and apply changes from a repository during an update but this is the scope of the next example.
Imagine that we have got the following tree structure in our repository:
And we want to change it to something like this:
In other words we want to:
delete /nodeB/itemB1
change contents of /nodeB/nodeC/itemC1
add /nodeB/nodeC/itemC2 with some versioned properties attached to it
add /nodeB/nodeD
Now we'll discuss how to do these changes using a commit editor. We'll assume that we are working with a local repository. First of all we should obtain such an editor to carry out our plans. We create an SVNRepository driver bounded to the node /nodeB (since all our planned changes will be performed under this node):
Here we don't use an authentication manager - a session user name will be used as an author of a commit. Getting a commit editor:
Now when we have got an editor we can not call any reposiotory access methods of our SVNRepository driver till we call the editor's closeEdit() method. The following code snippet demonstrates how to prepare our planned changes in a single transaction. Main steps of the editing a repository tree process are numbered to the left of the code:
1 ...
2 //provide your local revision of nodeB
3 1 long r = ...;
4 editor.openRoot( r );
5
6 //provide your local revision of itemB1
7 2 r = ...;
8 editor.deleteEntry( "itemB1" , r );
9
10 //provide your local revision of nodeC
11 3 r = ...;
12 editor.openDir( "nodeC" , r );
13
14 //provide your local revision of itemC1
15 4 r = ...;
16 editor.openFile( "nodeC/itemC1" , r );
Now about applying text delta - text changes (only differences) made locally to itemC1. A base checksum is used to be sure that both client's base item and repository's one (of the same revision) have got the same contents what prevents from committing if a client's item is corrupted since calculated differences won't be applied correctly in this case:
Use a delta generator to calculate differences between base and working versions of the item. The generator produces differences or delta as a sequence of diff windows of fixed size. It means that applying one such a window against item contents gives you not larger than N bytes of the output text. A default size of a window is 100K bytes.
The delta generator passes each produced diff window to the editor calling its textDeltaChunk() method:
When the generator is finished it calls the editor's textDeltaEnd() method:
sendDelta() method returns the checksum for the working version of the item contents. This checksum may be used to verify that the delta is applied correctly on the repository side. If contents of the local working item and the one in the repository do not match, checksums are likely to be different, too:
1 editor.closeFile( "nodeC/itemC1" , checksum );
2
3 5 //the second and the third parameters are the path and revision respectively
4 //of the item's ancestor if the item is being added with history
5 editor.addFile( "nodeC/itemC2" , null , -1 );
6
7 baseChecksum = ...;
8 editor.applyTextDelta( "nodeC/itemC2" , baseChecksum );
9
10 baseData = ...;
11 workingData = ...;
12 checksum = deltaGenerator.sendDelta( "nodeC/itemC2" , baseData , 0 , workingData , editor , true );
13 editor.closeFile( "nodeC/itemC2" , checksum );
14
15 6 editor.changeFileProperty( "nodeC/itemC2" , "propName1" , "propValue1" );
16 editor.changeFileProperty( "nodeC/itemC2" , "propName2" , "propValue2" );
17 ...
18
19 //we are finished with changes under nodeC, so closing nodeC
20 editor.closeDir( );
21
22 7 //now we are under nodeB again
23 editor.addDir( "nodeD" , null , -1 );
24
25 //close nodeD
26 editor.closeDir( );
27
28 //close root - nodeB
29 editor.closeDir( );
In the step 5 we are adding a new item, not copying an existing one. But if we need to make a copy of an existing item we should provide the copy source absolute path and the revision of the copy source path as the second and third arguments of the editor.addFile() method respectively. If you would like only to copy an item (file) without changes, you don't need to apply any delta - Subversion will take care of making a copy on the server side.
In regard to addition of a directory - parameters are like in addFile(). We are not copying a directory, just adding a new one without history.
As you see every opened/added directory (including the root one) as well as every opened/added file must be closed with the editor. The final point - closing our editor what results in committing the transaction tree into the repository:
If transaction succeeds and this call makes our changes immutable in the repository, the editor returns an SVNCommitInfo object containing information about a new revision. However at any call to the editor it can throw an exception which means that something has went wrong. When we've got an exception from the editor we should abort it to purge the transaction like this:
After we have closed the editor we may go on using our SVNRepository driver. The following diagram illustrates our changes step by step. Numbers in the diagram correspond to numbers of our steps in the code:
Notes:
with ISVNEditor you edit your repository in a hierarchical way traversing a necessary subtree; that is if your driver is bound to /a and you are going to change /a/b/c/d, you can not just open dwithout moving down in the tree to the node /a/b/c, you have to open the root (/a), then open /a/b, and then /a/b/c, after what you open /a/b/c/d.
- for all versioned data which is present on your local machine, you have to keep local revision numbers somehow, so that when you try to change an item, a repository server can check whether your local item is out of date or not.
- you don't have to apply text deltas immediately after you have opened a file; you may first open all necessary files in the way described above, then close all directories (including the root one) remaining opened in a way inverse to the one you opened them, then apply deltas to opened files and finally close files; you can not change directory properties after you've closed target directories.
- In repository edition operations you'll never need to use the following methods of a commit editor (they are irrelevant in commits, but relevant in updates):
Example On Using ISVNEditor In A Commit Operation
In the following example we'll continue discussing application of ISVNEditor in low-level commit operations. We will perform some simple commits in the following order:
- add a directory with a file to a repository,
- modify the added file,
- copy the whole added directory within a repository,
- delete both the original and copied directories.
For each of these four commit operations we'll write separate functions:
1. Addition:
1 private static SVNCommitInfo addDir( ISVNEditor editor , String dirPath , String filePath , byte[] data ) throws SVNException {
2 editor.openRoot( -1 );
3
4 editor.addDir( dirPath , null , -1 );
5
6 editor.addFile( filePath , null , -1 );
7
8 editor.applyTextDelta( filePath , null );
9
10 SVNDeltaGenerator deltaGenerator = new SVNDeltaGenerator( );
11 String checksum = deltaGenerator.sendDelta( filePath , new ByteArrayInputStream( data ) , editor , true );
12
13 editor.closeFile(filePath, checksum);
14
15 //Closes dirPath.
16 editor.closeDir();
17
18 //Closes the root directory.
19 editor.closeDir();
20
21 return editor.closeEdit();
22 }
2. File modification:
1 private static SVNCommitInfo modifyFile( ISVNEditor editor , String dirPath , String filePath , byte[] oldData , byte[] newData ) throws SVNException {
2 editor.openRoot( -1 );
3
4 editor.openDir( dirPath , -1 );
5
6 editor.openFile( filePath , -1 );
7
8 editor.applyTextDelta( filePath , null );
9
10 SVNDeltaGenerator deltaGenerator = new SVNDeltaGenerator( );
11 String checksum = deltaGenerator.sendDelta( filePath , new ByteArrayInputStream( oldData ) , 0 , new ByteArrayInputStream( newData ) , editor , true );
12
13 //Closes filePath.
14 editor.closeFile( filePath , checksum );
15
16 // Closes dirPath.
17 editor.closeDir( );
18
19 //Closes the root directory.
20 editor.closeDir( );
21
22 return editor.closeEdit( );
23 }
Here we use invalid revision numbers (-1) for simplifying the example since they will work for us, and that's all we need now. Of course, in real systems they'd better be real (valid) revision numbers. The same is regarding a base checksum.
3. Directory copying:
1 private static SVNCommitInfo copyDir( ISVNEditor editor , String srcDirPath , String dstDirPath , long revision ) throws SVNException {
2 editor.openRoot( -1 );
3
4 editor.addDir( dstDirPath , srcDirPath , revision );
5
6 //Closes dstDirPath.
7 editor.closeDir( );
8
9 //Closes the root directory.
10 editor.closeDir( );
11
12 return editor.closeEdit( );
13 }
4. Directory deletion:
Now when we've got these functions we are ready to start:
1 public class Commit {
2
3 public static void main( String[] args ) {
4
5 FSRepositoryFactory.setup( );
6 SVNURL url = SVNURL.parseURIDecoded( "file:///localhost/testRepos" );
7 String userName = "foo";
8 String userPassword = "bar";
9
10 byte[] contents = "This is a new file".getBytes( );
11 byte[] modifiedContents = "This is the same file but modified a little.".getBytes( );
12
13 SVNRepository repository = SVNRepositoryFactory.create( url );
14
15 ISVNAuthenticationManager authManager = SVNWCUtil.createDefaultAuthenticationManager( userName, userPassword );
16 repository.setAuthenticationManager( authManager );
17
18 SVNNodeKind nodeKind = repository.checkPath( "" , -1 );
19
20 if ( nodeKind == SVNNodeKind.NONE ) {
21 System.out.println( "No entry at URL " + url );
22 System.exit( 1 );
23 } else if ( nodeKind == SVNNodeKind.FILE ) {
24 System.out.println( "Entry at URL " + url + " is a file while directory was expected" );
25 System.exit( 1 );
26 }
27
28 //Get exact value of the latest (HEAD) revision.
29 long latestRevision = repository.getLatestRevision( );
30 System.out.println( "Repository latest revision (before committing): " + latestRevision );
31
32 ISVNEditor editor = repository.getCommitEditor( "directory and file added" , null );
33
34 try {
35 SVNCommitInfo commitInfo = addDir( editor , "test" , "test/file.txt" , contents );
36 System.out.println( "The directory was added: " + commitInfo );
37 } catch ( SVNException svne ) {
38 editor.abortEdit( );
39 throw svne;
40 }
41
42 editor = repository.getCommitEditor( "file contents changed" , null );
43 try {
44 commitInfo = modifyFile( editor , "test" , "test/file.txt" , contents , modifiedContents );
45 System.out.println( "The file was changed: " + commitInfo );
46 } catch ( SVNException svne ) {
47 editor.abortEdit( );
48 throw svne;
49 }
50
51 //converts a relative path to an absolute one
52 String absoluteSrcPath = repository.getRepositoryPath( "test" );
53 long srcRevision = repository.getLatestRevision( );
54
55 editor = repository.getCommitEditor( "directory copied" , null );
56 try {
57 commitInfo = copyDir( editor , absoluteSrcPath , "test2" , srcRevision );
58 System.out.println( "The directory was copied: " + commitInfo );
59 } catch ( SVNException svne ) {
60 editor.abortEdit( );
61 throw svne;
62 }
63
64
65 //Delete directory "test".
66 editor = repository.getCommitEditor( "directory deleted" , null );
67 try {
68 commitInfo = deleteDir( editor , "test" );
69 System.out.println( "The directory was deleted: " + commitInfo );
70 } catch ( SVNException svne ) {
71 editor.abortEdit( );
72 throw svne;
73 }
74
75 //Delete directory "test2".
76 editor = repository.getCommitEditor( "copied directory deleted" , null );
77 try {
78 commitInfo = deleteDir( editor , "test2" );
79 System.out.println( "The copied directory was deleted: " + commitInfo );
80 } catch ( SVNException svne ) {
81 editor.abortEdit( );
82 throw svne;
83 }
84
85 latestRevision = repository.getLatestRevision( );
86 System.out.println( "Repository latest revision (after committing): " + latestRevision );
87 ...
88 }
89 ...
90 }
That's what you'll see if you run the program:
Repository latest revision (before committing): 0
The directory was added: r1 by 'foo' at Tue Jun 27 15:46:59 NOVST 2006
The file was changed: r2 by 'foo' at Tue Jun 27 15:46:59 NOVST 2006
The directory was copied: r3 by 'foo' at Tue Jun 27 15:46:59 NOVST 2006
The directory was deleted: r4 by 'foo' at Tue Jun 27 15:46:59 NOVST 2006
The copied directory was deleted: r5 by 'foo' at Tue Jun 27 15:47:00 NOVST 2006
Repository latest revision (after committing): 5
Download the example program source code.
使用SVNkit删除版本库的文件的更多相关文章
- Linux svn直接删除版本库文件
业务目录:/home/web/oa.youxi.com/htdocs/materialsvn地址:svn://192.168.13.61:/oa.youxi.com/htdocs/material m ...
- svn创建版本库和删除版本库
作者:朱金灿 来源:http://blog.csdn.net/clever101 svn创建版本库的做法:使用cd命令进入版本仓库的根目录,我的是E:\Repository,然后运行命令: svnad ...
- gitblit删除版本库
Git客户端不提供删除远程仓库的方法,gitblit服务器网页也不支持删除版本仓库.若要强制删除,Windows下可以: 先在任务管理器中停止gitblit进程,然后将gitblit版本库文件夹中将版 ...
- git忽略已加入到版本库的文件
项目中,我们会用到 '.gitignore' 来忽略一些文件,不记录这些文件的版本控制. 然而,经常发现,已经添加到了 '.gitignore' 的文件/目录,每次的修改等扔会记录版本. 产生这种原因 ...
- IDEA中,已经被加到版本库的文件如何在提交的时候忽略它们
因为某些资源共享的原因,我在本地调试的时候需要修改Java启动程序类上的一些配置,禁用掉Kafka等等.然后我就想 把这些本地调试需要修改的但是线上服务不需要修改的给忽略掉,于是加入到了.gitign ...
- 利用SVNKit进行版本库的树的导出
public List searchByTree(String userName,String passwd,String SVNServerUrl,String dirUrl){ //这里有点像 s ...
- Git如何删除版本库中的一个提交?
如果不小心增加了一个最新的提交,可以通过以下的操作删除,记住:是删除最新的提交,如果回滚到其他的提交上面,就会导致之后的全部消失. 1.git reset --hard HEAD~1 2.gi ...
- git 忽略已经添加到版本库的文件
第一步: 指令:git rm -r --cached YOUR_PATH YOUR_PATH 即 你的文件,-r 指定了递归所有的子文件夹. 第二步: 修改项目根目录下的 .gitignore 文件, ...
- Git使用(二)版本库创建及文件修改
一.创建版本库 1.安装完成后,在开始菜单里找到“Git”->“Git Bash”,蹦出一个类似命令行窗口的东西,就说明Git安装成功! 安装完成后,还需要最后一步设置,在命令行输入: $ gi ...
随机推荐
- 《Swift编程语言》中文翻译及读书笔记page25
The Swift Programming Language读书笔记学习笔记 第25页 本页主要说在swift语言里能够使用分号,但分号不作为每条swift语言语句的结尾 而是间隔写在一行的多条swi ...
- gbs remotebuild使用说明
本文件从:https://source.tizen.org/documentation/articles/gbs-remotebuild翻译而来. 1 远程构建 使用remotebuild子指令将本地 ...
- 我觉得主要靠积累,难度不是问题,主要靠时间积累,以及兴趣带来的学习能力(我觉得至少5年全职Qt开发经验,才能算精通)
顺便想请教一下,你用QT有几年了? 3年不到 那感觉怎么样?是比较难,还是不难但需要时间才能掌握全部? 很多东西真的要拿来做项目了,才会懂.要靠积累.一开始看看理论貌似都很简单. 但是QT和C++本身 ...
- HDU 4668 Finding string (解析字符串 + KMP)
转载请注明出处,谢谢http://blog.csdn.net/ACM_cxlove?viewmode=contents by---cxlove 题意:给出一个压缩后的串,以及一个模式串,问模式串 ...
- alv 显示 汇总数据
alv中有 字段设置 gs_fieldcat-do_sum = ‘1’.字段 用于控制汇总
- 手把手教你修改pcduino系统默认的音频输出
最近要搞个小玩意儿,要用到pcduino的音频输出,但是系统默认的是输出到hdmi的音频,我的显示器上没有喇叭,只能搞个USB声卡.但是系统默认又不是输出到USB,这里我手把手叫你怎么设置系统默认声卡 ...
- 理解并解决GBK转UTF-8奇数中文乱码(转)
最近在做一个反馈功能,把数据反馈到对方公司网站,我公司是GBK编码,对方公司是UTF-8编码.因此,我需要将GBK编码数据转换成UTF-8编码数据,这样对方网站才不会乱码.最简单的方法是将HttpCl ...
- openssl之BIO系列之5---CallBack函数及其控制
CallBack函数及其控制 ---依据openssl doc/crypto/bio/bio_set_callback.pod翻译和自己的理解写成 (作者:DragonKin ...
- skynet源代码学习 - 从全局队列中弹出/压入一个消息队列过程
学习云风的skynet源代码,简单记录下. void skynet_globalmq_push(struct message_queue * queue) { struct global_queue ...
- ROOT android 原则。 基于(zergRush)
从: http://bbs.gfan.com/android-2996211-1-1.html 须要ROOT的同学请去上面的地址下载. a.控制手机创建个暂时目录,然后把zergRush脚本写入此目录 ...