Simple Git client using JGit has trouble with fetch/pull

Question

I use JGit to implement a very simple Git client that is only able to do two things:

• Add a file to a branch in a repository
• Retrieve a file of a branch in a repository.

The client doesn't have to worry about conflicts because it is assumed that files are never modified, only added or deleted.

The code I have for this is below. My problem is, that the fetch in getFile() does not fetch any updates from the repository. If I replace fetch with pull I get a

org.eclipse.jgit.api.errors.InvalidConfigurationException: No value for key branch.development.merge found in configuration

I am not sure how the configuration is supposed to look like, but after execution of main() it looks as given below, and I would assume that an entry is missing for branch "development"?

Can anybody help?

Updated code and configuration, problem persists

public class GitClient {

private String remoteRepositoryUI;
private String localRepositoryPath;
private Git localGit;
private UsernamePasswordCredentialsProvider credentialsProvider;

public GitClient(String remoteRepositoryURI, String localRepositoryPath, 
        String user, String password) {
    this.credentialsProvider = new UsernamePasswordCredentialsProvider(user, password);
    this.remoteRepositoryUI = remoteRepositoryURI;
    this.localRepositoryPath = localRepositoryPath; 
}

public void addFile(String sourceFilePath, String repositoryFilePath, Branch branch, String message) throws Exception {
    switchBranch(branch);
    FileUtils.copyFile(new File(sourceFilePath), 
            new File(this.localRepositoryPath + File.separator + repositoryFilePath));
    localGit.add().addFilepattern(repositoryFilePath).call();
    localGit.commit().setMessage(message).call();
    localGit.push().setCredentialsProvider(this.credentialsProvider).call();        
}

public File getFile(String repositoryFilePath, Branch branch) throws Exception {
    switchBranch(branch);
    return new File(this.localRepositoryPath + File.separator + repositoryFilePath);
}

private void switchBranch(Branch branch) throws InvalidRemoteException, TransportException, IOException, GitAPIException {
    if(!isInitialized())
        initialize(branch);

    boolean branchExists = localGit.getRepository().getRef(branch.toString()) != null;
    if (!branchExists) {
        localGit.branchCreate()
            .setName(branch.toString())
            .setUpstreamMode(SetupUpstreamMode.TRACK)
            .setStartPoint("origin/" + branch.toString())
            .call();
    }
    localGit.checkout().setName(branch.toString()).call();
    localGit.fetch().call();
    localGit.pull();
}

private boolean isInitialized() {
    return this.localGit != null;
}

private void initialize(Branch branch) throws IOException, 
            InvalidRemoteException, TransportException, GitAPIException {
    boolean localRepositoryExists = true;
    try {
        this.localGit = Git.open(new File(this.localRepositoryPath));  
    } catch(IOException e) {
        localRepositoryExists = false;
    }

    if(!localRepositoryExists) {
        List<String> branchesToClone = new LinkedList<String>();
        for(Branch aBranch : Branch.values())
            branchesToClone.add(aBranch.toString());
        Git.cloneRepository()
        // set the branches to clone from remote to local repository
        .setBranchesToClone(branchesToClone)
        // set the initial branch to check out and where to place HEAD
        .setBranch("refs/heads/" + branch.toString())
        // provide the URI of the remote repository from where to clone
        .setURI(this.remoteRepositoryUI)
        // set local store location of the cloned repository
        .setDirectory(new File(this.localRepositoryPath))
        .call();

        this.localGit = Git.open(new File(this.localRepositoryPath));
        for(Branch aBranch : Branch.values()) {
            boolean branchExists = localGit.getRepository().getRef(aBranch.toString()) != null;
            if (!branchExists) {
                localGit.branchCreate()
                    .setName(aBranch.toString())
                    .setUpstreamMode(SetupUpstreamMode.TRACK)
                    .setStartPoint("origin/" + aBranch.toString())
                    .call();
            }
            localGit.checkout().setName(aBranch.toString()).call();
        }
    }
}

public static void main(String[] args) throws Exception {
    GitClient clientA = new GitClient("URLToRepository.git",
            "local", "username", "password");
    GitClient clientB = new GitClient("URLToRepository.git",
            "localB", "username", "password");

    clientA.addFile("fileA1", "fileA1", Branch.master, "clientA1");
    clientB.addFile("fileB1", "fileB1", Branch.master, "clientB1");
    clientB.addFile("fileB2", "fileB2", Branch.development, "clientB2");
    clientA.addFile("fileA2", "fileA2", Branch.development, "clientA2");
    clientA.addFile("fileA3", "fileA3", Branch.master, "clientA3");

    File file = clientA.getFile("fileA1", Branch.master);
    System.out.println(file.getAbsolutePath() + " " + file.exists());

    file = clientA.getFile("fileA2", Branch.development);
    System.out.println(file.getAbsolutePath() + " " + file.exists());

    file = clientA.getFile("fileA3", Branch.master);
    System.out.println(file.getAbsolutePath() + " " + file.exists());

    file = clientA.getFile("fileB1", Branch.master);
    System.out.println(file.getAbsolutePath() + " " + file.exists());

    file = clientA.getFile("fileB2", Branch.development);
    System.out.println(file.getAbsolutePath() + " " + file.exists());
}

}

config:

[core]
   repositoryformatversion = 0
   filemode = false
   logallrefupdates = true
[remote "origin"]
   url = URLToRepository.git
   fetch = +refs/heads/*:refs/remotes/origin/*
[branch "master"]
   remote = origin
   merge = refs/heads/master
[branch "development"]
   remote = origin
   merge = refs/heads/development

Answer 1

In switchBranch, add the following option to the CheckoutCommand:

setCreateBranch(true)

The problem is, this should only be done once (it will fail if the branch already exists). So instead of doing it in one command, separate branch creation and checkout:

String branchName = branch.toString();
boolean branchExists = localGit.getRepository().getRef(branchName) != null;
if (!branchExists) {
    localGit.branchCreate()
        .setName(branchName)
        .setUpstreamMode(SetupUpstreamMode.TRACK)
        .setStartPoint("origin/" + branchName)
        .call();
}
localGit.checkout().setName(branchName).call();