@Override
protected void run() throws Exception {
CheckoutCommand command = new Git(db).checkout();
command.setCreateBranch(createBranch);
command.setName(name);
command.setForce(force);
command.call();
}
public static Ref checkout(
final Git git,
final String remote,
final boolean createBranch,
final SetupUpstreamMode mode,
final boolean force)
throws GitAPIException {
CheckoutCommand checkout = git.checkout();
checkout.setCreateBranch(createBranch);
checkout.setName(remote);
checkout.setForce(force);
checkout.setUpstreamMode(mode);
return checkout.call();
}
public void branchesCheckout() {
String branchName = "";
Set<Entry<String, Ref>> refs = repository.getAllRefs().entrySet();
for (Entry<String, Ref> ref : refs) {
if (ref.getKey().startsWith(Constants.R_REMOTES) && !ref.getKey().contains(Constants.HEAD)) {
branchName = ref.getValue().getName().split(Constants.R_REMOTES)[1];
// TODO: replace with logging
System.out.println(
"Trying to checkout branch: "
+ branchName
+ " ("
+ branchName.split("origin/")[1]
+ ")");
CheckoutCommand checkoutCommand = this.git.checkout();
checkoutCommand.setForce(true);
checkoutCommand.setCreateBranch(true);
checkoutCommand.setUpstreamMode(SetupUpstreamMode.TRACK);
checkoutCommand.setName(branchName.split("origin/")[1]);
checkoutCommand.setStartPoint(branchName);
try {
checkoutCommand.call();
// TODO: replace with logging
// println "Successfully checked out branch " + branchName;
} catch (RefAlreadyExistsException e) {
// TODO: replace with logging
// println "Skipping branch (already exists): " + branchName;
} catch (RefNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvalidRefNameException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (GitAPIException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
public void cloneBinaryRepository() throws GitException {
// find the name of the "source repository"
String srcRepoUrl = getSourceRemoteUrl();
String org = GitUtils.getOrgName(srcRepoUrl);
String repoName = GitUtils.getRepositoryName(srcRepoUrl);
String binaryRepoName = calculateBinaryRepositoryName(org, repoName);
// find where ".git" folder is found
File f = sourceRepository.getDirectory();
File sourceDir = f.getParentFile();
String sourceRepoFolderName = f.getParentFile().getName();
// construct the binary repository URL
String giturl = "[email protected]:Binary/" + binaryRepoName + ".git";
// calculate binary repository folder
File parent = f.getParentFile().getParentFile();
File binaryRepoFolder = new File(parent, ("." + sourceRepoFolderName));
// clone the binary repository
CloneCommand cloneCmd = Git.cloneRepository();
cloneCmd.setURI(giturl);
cloneCmd.setDirectory(binaryRepoFolder);
cloneCmd.setCloneAllBranches(true);
Git binrepository = null;
try {
System.out.println("cloning repository " + giturl);
binrepository = cloneCmd.call();
binaryRepository = new FileRepository(binrepository.getRepository().getDirectory());
} catch (InvalidRemoteException e) {
throw new GitException("unable to clone " + giturl, e);
} catch (TransportException e) {
throw new GitException("unable to clone " + giturl, e);
} catch (GitAPIException e) {
throw new GitException("unable to clone " + giturl, e);
} catch (IOException e) {
throw new GitException("unable assign " + giturl, e);
}
// read the branch from "source" repository
String branchName = "master";
try {
branchName = sourceRepository.getBranch();
} catch (IOException e) {
e.printStackTrace();
}
// Checkout the "branch" if it is not equal to "master"
if (!branchName.toLowerCase().equals("master")) {
// check whether the branch exists
boolean remoteBranchExists = GitUtils.isRemoteBranchExists(binaryRepository, branchName);
CheckoutResult result = null;
if (!remoteBranchExists) {
try {
// create branch
Git binrepo = Git.wrap(binaryRepository);
CreateBranchCommand branchCmd = binrepo.branchCreate();
branchCmd.setName(branchName);
branchCmd.call();
// checkout the branch
CheckoutCommand checkout = binrepo.checkout();
checkout.setName(branchName);
Ref ref = checkout.call();
if (ref == null) {
// TODO:
} else {
result = checkout.getResult();
}
} catch (RefAlreadyExistsException e) {
throw new GitException("unable to create branch " + branchName, e);
} catch (RefNotFoundException e) {
throw new GitException("unable to create branch " + branchName, e);
} catch (InvalidRefNameException e) {
throw new GitException("unable to create branch " + branchName, e);
} catch (GitAPIException e) {
throw new GitException("unable to create branch " + branchName, e);
}
} else {
CheckoutCommand checkoutCmd = binrepository.checkout();
checkoutCmd.setCreateBranch(true);
checkoutCmd.setName(branchName);
checkoutCmd.setUpstreamMode(CreateBranchCommand.SetupUpstreamMode.TRACK);
checkoutCmd.setStartPoint("origin/" + branchName);
System.out.println("checking out branch " + branchName);
try {
// Ref branch = branchCmd.call();
Ref ref = checkoutCmd.call();
System.out.println("checkout is complete");
if (ref != null) {
// System.out.println("ref " + ref.getName() );
result = checkoutCmd.getResult();
}
} catch (RefAlreadyExistsException e) {
throw new GitException("unable to checkout branch " + branchName, e);
} catch (RefNotFoundException e) {
throw new GitException("unable to checkout branch " + branchName, e);
} catch (InvalidRefNameException e) {
throw new GitException("unable to checkout branch " + branchName, e);
} catch (CheckoutConflictException e) {
throw new GitException("unable to checkout branch " + branchName, e);
} catch (GitAPIException e) {
throw new GitException("unable to checkout branch " + branchName, e);
}
}
if (result.getStatus().equals(CheckoutResult.OK_RESULT)) {
System.out.println("checkout is OK");
} else {
// TODO: handle the error.
}
}
// System.out.println( result.getStatus());
// TODO: find out whether Binary is upto-date with the sources
/*
// call the MapSvc to find it out.
final org.eclipse.jgit.lib.Repository repository = new org.eclipse.jgit.storage.file.FileRepository(f);
final RevWalk revWalk = new RevWalk(repository);
final ObjectId resolve = repository.resolve(Constants.HEAD);
final RevCommit commit = revWalk.parseCommit(resolve);
final String commitHash = commit.getName();
final String url = getUrlForFindByRepoBranchCommit() + "repourl=" + URLEncoder.encode(getSourceRemoteUrl(), UTF_8) +
"&branch=" + URLEncoder.encode(branchName, UTF_8) + "&commitid=" + URLEncoder.encode(commitHash, UTF_8);
final WebResource webResource = client.resource(url);
boolean noContent = false;
BinRepoBranchCommitDO binRepoBranchCommitDO = null;
try {
System.out.println("calling mapsvc ");
binRepoBranchCommitDO = webResource.accept(MediaType.APPLICATION_JSON_TYPE).get(BinRepoBranchCommitDO.class);
} catch (UniformInterfaceException e) {
int statusCode = e.getResponse().getClientResponseStatus().getStatusCode();
noContent = (statusCode == 204);
} catch (Exception e) { // catch-all in case there are network problems
e.printStackTrace();
}
// No matching entry found in mapping service
// TODO: RGIROTI Talk to Nambi and find out what we want to do in this case
if (noContent) {
} else {
// if it matches copy the .class files from binaryrepository to source-repository
if (binRepoBranchCommitDO != null &&
binRepoBranchCommitDO.getRepoUrl().equalsIgnoreCase(getSourceRemoteUrl()) &&
binRepoBranchCommitDO.getBranch().equalsIgnoreCase(branchName) &&
binRepoBranchCommitDO.getCommitId().equalsIgnoreCase(commitHash)) {
}
}
*/
try {
FileUtil.copyBinaryFolders(binaryRepoFolder, sourceDir, ".git");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
