private void markAdvertised(final AnyObjectId id) {
try {
walk.parseAny(id).add(ADVERTISED);
} catch (IOException readError) {
// We probably just do not have this object locally.
}
}
private boolean sendWants(final Collection<Ref> want) throws IOException {
boolean first = true;
for (final Ref r : want) {
try {
if (walk.parseAny(r.getObjectId()).has(REACHABLE)) {
// We already have this object. Asking for it is
// not a very good idea.
//
continue;
}
} catch (IOException err) {
// Its OK, we don't have it, but we want to fix that
// by fetching the object from the other side.
}
final StringBuilder line = new StringBuilder(46);
line.append("want ");
line.append(r.getObjectId().name());
if (first) {
line.append(enableCapabilities());
first = false;
}
line.append('\n');
pckOut.writeString(line.toString());
}
pckOut.end();
outNeedsEnd = false;
return !first;
}
private Map<String, Ref> computeNewRefs() throws IOException {
final RevWalk rw = new RevWalk(db);
final Map<String, Ref> refs = new HashMap<String, Ref>();
final BufferedReader br =
new BufferedReader(new InputStreamReader(new FileInputStream(refList), Constants.CHARSET));
try {
String line;
while ((line = br.readLine()) != null) {
final String[] parts = line.split("[ \t]{1,}");
final ObjectId origId = ObjectId.fromString(parts[0]);
final String type = parts[1];
final String name = parts[2];
ObjectId id = rewrites.get(origId);
if (id == null) id = origId;
try {
rw.parseAny(id);
} catch (MissingObjectException mue) {
if (!Constants.TYPE_COMMIT.equals(type)) {
System.err.println("skipping " + type + " " + name);
continue;
}
throw new MissingObjectException(id, type);
}
refs.put(name, new Ref(Ref.Storage.PACKED, name, id));
}
} finally {
br.close();
}
return refs;
}
private int maxTimeWanted(final Collection<Ref> wants) {
int maxTime = 0;
for (final Ref r : wants) {
try {
final RevObject obj = walk.parseAny(r.getObjectId());
if (obj instanceof RevCommit) {
final int cTime = ((RevCommit) obj).getCommitTime();
if (maxTime < cTime) maxTime = cTime;
}
} catch (IOException error) {
// We don't have it, but we want to fetch (thus fixing error).
}
}
return maxTime;
}
private void negotiate(final ProgressMonitor monitor) throws IOException, CancelledException {
final MutableObjectId ackId = new MutableObjectId();
int resultsPending = 0;
int havesSent = 0;
int havesSinceLastContinue = 0;
boolean receivedContinue = false;
boolean receivedAck = false;
boolean sendHaves = true;
negotiateBegin();
while (sendHaves) {
final RevCommit c = walk.next();
if (c == null) break;
pckOut.writeString("have " + c.getId().name() + "\n");
havesSent++;
havesSinceLastContinue++;
if ((31 & havesSent) != 0) {
// We group the have lines into blocks of 32, each marked
// with a flush (aka end). This one is within a block so
// continue with another have line.
//
continue;
}
if (monitor.isCancelled()) throw new CancelledException();
pckOut.end();
resultsPending++; // Each end will cause a result to come back.
if (havesSent == 32) {
// On the first block we race ahead and try to send
// more of the second block while waiting for the
// remote to respond to our first block request.
// This keeps us one block ahead of the peer.
//
continue;
}
while (resultsPending > 0) {
final PacketLineIn.AckNackResult anr;
anr = pckIn.readACK(ackId);
resultsPending--;
if (anr == PacketLineIn.AckNackResult.NAK) {
// More have lines are necessary to compute the
// pack on the remote side. Keep doing that.
//
break;
}
if (anr == PacketLineIn.AckNackResult.ACK) {
// The remote side is happy and knows exactly what
// to send us. There is no further negotiation and
// we can break out immediately.
//
multiAck = false;
resultsPending = 0;
receivedAck = true;
sendHaves = false;
break;
}
if (anr == PacketLineIn.AckNackResult.ACK_CONTINUE) {
// The server knows this commit (ackId). We don't
// need to send any further along its ancestry, but
// we need to continue to talk about other parts of
// our local history.
//
markCommon(walk.parseAny(ackId));
receivedAck = true;
receivedContinue = true;
havesSinceLastContinue = 0;
}
if (monitor.isCancelled()) throw new CancelledException();
}
if (receivedContinue && havesSinceLastContinue > MAX_HAVES) {
// Our history must be really different from the remote's.
// We just sent a whole slew of have lines, and it did not
// recognize any of them. Avoid sending our entire history
// to them by giving up early.
//
break;
}
}
// Tell the remote side we have run out of things to talk about.
//
if (monitor.isCancelled()) throw new CancelledException();
pckOut.writeString("done\n");
pckOut.flush();
if (!receivedAck) {
// Apparently if we have never received an ACK earlier
// there is one more result expected from the done we
// just sent to the remote.
//
multiAck = false;
resultsPending++;
}
while (resultsPending > 0 || multiAck) {
final PacketLineIn.AckNackResult anr;
anr = pckIn.readACK(ackId);
resultsPending--;
if (anr == PacketLineIn.AckNackResult.ACK) break; // commit negotiation is finished.
if (anr == PacketLineIn.AckNackResult.ACK_CONTINUE) {
// There must be a normal ACK following this.
//
multiAck = true;
}
if (monitor.isCancelled()) throw new CancelledException();
}
}
