Java SVNRepositoryFactoryImpl.setup方法代码示例

import org.tmatesoft.svn.core.internal.io.svn.SVNRepositoryFactoryImpl; //导入方法依赖的package包/类
public static void setupLibrary(String url) {
	// For using over http:// and https://
	if (url.startsWith("http://") || url.startsWith("https://")) {
		DAVRepositoryFactory.setup();
	}

	// For using over http:// and https://
	if (url.startsWith("svn")) {
		SVNRepositoryFactoryImpl.setup();
	}

	// For using over file:///
	if (url.startsWith("file://")) {
		FSRepositoryFactory.setup();
	}
}
 

import org.tmatesoft.svn.core.internal.io.svn.SVNRepositoryFactoryImpl; //导入方法依赖的package包/类
/**
 * Initializes the library to work with a repository either via svn:// (and
 * svn+ssh://) or via http:// (and https://)
 */
private static void initialize()
{
    if ( initialized )
    {
        return;
    }

    /*
     * for DAV (over http and https)
     */
    DAVRepositoryFactory.setup();

    /*
    * for svn (over svn and svn+ssh)
    */
    SVNRepositoryFactoryImpl.setup();

    /*
     * for file
     */
    FSRepositoryFactory.setup();
    initialized = true;
}
 

import org.tmatesoft.svn.core.internal.io.svn.SVNRepositoryFactoryImpl; //导入方法依赖的package包/类
@Autowired
public SVNClientImpl(SVNEventDao svnEventDao, EnvService envService, TransactionService transactionService) {
    this.svnEventDao = svnEventDao;
    this.transactionService = transactionService;
    // Spooling directory
    File spoolDirectory = envService.getWorkingDir("svn", "spooling");
    logger.info("[svn] Using Spooling directory at {}", spoolDirectory.getAbsolutePath());
    // Custom logger
    SVNDebugLog.setDefaultLog(new SVNClientLogger());
    // Repository factories
    SVNRepositoryFactoryImpl.setup();
    DAVRepositoryFactory.setup(
            // Using spooling
            new DefaultHTTPConnectionFactory(
                    spoolDirectory,
                    true,
                    null)
    );
}
 

import org.tmatesoft.svn.core.internal.io.svn.SVNRepositoryFactoryImpl; //导入方法依赖的package包/类
/**
 * Initializes the library to work with a repository via
 * different protocols.
 */
private static void setupLibrary() {
    /*
     * For using over http:// and https://
     */
    DAVRepositoryFactory.setup();
    /*
     * For using over svn:// and svn+xxx://
     */
    SVNRepositoryFactoryImpl.setup();

    /*
     * For using over file:///
     */
    FSRepositoryFactory.setup();
}
 

import org.tmatesoft.svn.core.internal.io.svn.SVNRepositoryFactoryImpl; //导入方法依赖的package包/类
public static void iniciaRepositorio(String url) {

        String[] partes = url.split(":");

        if (partes.length > 1) {
            if (partes[0].equals("http") || partes[0].equals("https")) {
                DAVRepositoryFactory.setup();
            } else if (partes[0].equals("file")) {
                FSRepositoryFactory.setup();
            } else {
                SVNRepositoryFactoryImpl.setup();
            }
        } else {
            throw new IndexOutOfBoundsException("URL inválida.");
        }
    }
 

import org.tmatesoft.svn.core.internal.io.svn.SVNRepositoryFactoryImpl; //导入方法依赖的package包/类
public synchronized void initRepositoryFactory(final String repositoryUrl) {
    if (repositoryUrl.matches("^file://.*$") && !FSRepositoryInitialized) {
        System.out.println("----------------> Initializing FSRepositoryFactory");
        FSRepositoryFactory.setup();
        FSRepositoryInitialized = true;

    } else if (repositoryUrl.matches("^https?://.*$") && !DAVRepositoryInitialized) {
        System.out.println("----------------> Initializing DAVRepositoryFactory");
        DAVRepositoryFactory.setup();
        DAVRepositoryInitialized = true;

    } else if (repositoryUrl.matches("^svn(\\+.+)?://.*$") && !SVNRepositoryInitialized) {
        System.out.println("----------------> Initializing SVNRepositoryFactory");
        SVNRepositoryFactoryImpl.setup();
        DAVRepositoryInitialized = true;
    }
}
 

import org.tmatesoft.svn.core.internal.io.svn.SVNRepositoryFactoryImpl; //导入方法依赖的package包/类
@BeforeClass
public static void setUpClass() throws Exception {
    System.out.println("ESTABELECENDO O SVN");
    /*
     * Para uso sobre http:// e https://
     */
    DAVRepositoryFactory.setup();
    /*
     * Para uso sobre svn:// e svn+xxx://
     */
    SVNRepositoryFactoryImpl.setup();
    /*
     * Para uso sobre  file:///
     */
    FSRepositoryFactory.setup();
    System.out.println("SVN ESTABELECIDO");
}
 

import org.tmatesoft.svn.core.internal.io.svn.SVNRepositoryFactoryImpl; //导入方法依赖的package包/类
private static void setupLibrary() {
	/*
	 * For using over http:// and https://
	 */
	DAVRepositoryFactory.setup();
	/*
	 * For using over svn:// and svn+xxx://
	 */
	SVNRepositoryFactoryImpl.setup();

	/*
	 * For using over file:///
	 */
	FSRepositoryFactory.setup();
}
 

import org.tmatesoft.svn.core.internal.io.svn.SVNRepositoryFactoryImpl; //导入方法依赖的package包/类
private void setupType(final String url) throws SVNException {
    svnurl = SVNURL.parseURIDecoded(url);

    if (url.startsWith("http")) {
        DAVRepositoryFactory.setup();
        repository = SVNRepositoryFactory.create(svnurl);
    } else if (url.startsWith("svn")) {
        SVNRepositoryFactoryImpl.setup();
        repository = SVNRepositoryFactory.create(svnurl);
    } else {
        FSRepositoryFactory.setup();
        repository = SVNRepositoryFactory.create(svnurl);
    }
}
 

import org.tmatesoft.svn.core.internal.io.svn.SVNRepositoryFactoryImpl; //导入方法依赖的package包/类
private static void setupLibrary() {
    /*
     * For using over http:// and https://
     */
    DAVRepositoryFactory.setup();
    /*
     * For using over svn:// and svn+xxx://
     */
    SVNRepositoryFactoryImpl.setup();
    
    /*
     * For using over file:///
     */
    FSRepositoryFactory.setup();
}
 

import org.tmatesoft.svn.core.internal.io.svn.SVNRepositoryFactoryImpl; //导入方法依赖的package包/类
/**
 * Initialises repository to accept requests for svn protocol.
 */
public SvnRepository() {
  super();
  FSRepositoryFactory.setup();
  DAVRepositoryFactory.setup();
  SVNRepositoryFactoryImpl.setup();
  try {
    Manifest manifest = getManifest(this.getClass());
    Attributes attributes = manifest.getMainAttributes();
    Message.info("IvySvn Build-Version: " + attributes.getValue("Build-Version"));
    Message.info("IvySvn Build-DateTime: " + attributes.getValue("Build-DateTime"));
  } catch (IOException e) {
    Message.warn("Could not load manifest: " + e.getMessage());
  }
}
 

import org.tmatesoft.svn.core.internal.io.svn.SVNRepositoryFactoryImpl; //导入方法依赖的package包/类
@Before
public void setUp() throws SVNException {
  FSRepositoryFactory.setup();
  DAVRepositoryFactory.setup();
  SVNRepositoryFactoryImpl.setup();
  testTempFolder.mkdirs();
  creatIvyRepositoryRoot();
  ivyRepositoryRootURL = SVNURL.parseURIEncoded(ivyRepositoryRoot);
  readRepository = SvnUtils.createRepository(ivyRepositoryRootURL, svnUserName, svnPassword, null, null, -1, null,
      null, false);
  svnDAO = new SvnDao(readRepository);
}
 

import org.tmatesoft.svn.core.internal.io.svn.SVNRepositoryFactoryImpl; //导入方法依赖的package包/类
/**
 * 
 * @param option
 */
public AbstractSvnOperation(SvnOptions option) {

	// 安装仓库工厂
	SVNRepositoryFactoryImpl.setup();
	logger.info("SVNRepository Factory setup");

	try {
		repositoryURL = SVNURL.parseURIEncoded(option.getRepositoryURL());
		logger.info("repository URL success");
	} catch (SVNException e) {
		logger.error("repository URL error");
	}

	// 驱动选项
	ISVNOptions options = SVNWCUtil.createDefaultOptions(true);

	this.clientManager = SVNClientManager.newInstance(
			(DefaultSVNOptions) options, option.getName(),
			option.getPassword());
	logger.info("create SVNClientManager success");

	this.workpath = option.getWorkPath();

	doCheckout();

}
 

import org.tmatesoft.svn.core.internal.io.svn.SVNRepositoryFactoryImpl; //导入方法依赖的package包/类
/**
 * Called internally to initialize the connection to the Subversion
 * repository.
 * @throws IOException Unable to connect to Subversion.
 */
private void initializeRepository() throws IOException {
   if (repositoryReference == null) {
      try {
         final SVNURL path = SVNURL.parseURIEncoded(getPath());
         final String protocol = path.getProtocol();
         
         if (protocol.startsWith("http")) {
            DAVRepositoryFactory.setup();
         } else {
            SVNRepositoryFactoryImpl.setup();
         }
         
         repositoryReference =
               SVNRepositoryFactory.create(
                     SVNURL.parseURIEncoded(getPath())
               );
         
      } catch (SVNException e) {
         throw new IOException("Could not connect to Subversion", e);
      }
      
      final String username = getUsername();
      final String password = getPassword();
      if (username != null && password != null) {
         repositoryReference.setAuthenticationManager(
               SVNWCUtil.createDefaultAuthenticationManager(
                     username,
                     password)
               );
      }
   }
}
 

import org.tmatesoft.svn.core.internal.io.svn.SVNRepositoryFactoryImpl; //导入方法依赖的package包/类
public static void setupLibrary() {
	DAVRepositoryFactory.setup();
	SVNRepositoryFactoryImpl.setup();
	FSRepositoryFactory.setup();
}