void schedule(Project.NameKey project, String ref, URIish uri, ReplicationState state) {
repLog.info("scheduling replication {}:{} => {}", project, ref, uri);
if (!shouldReplicate(project, ref, state)) {
return;
}
if (!config.replicatePermissions()) {
PushOne e;
synchronized (stateLock) {
e = pending.get(uri);
}
if (e == null) {
try (Repository git = gitManager.openRepository(project)) {
try {
Ref head = git.exactRef(Constants.HEAD);
if (head != null
&& head.isSymbolic()
&& RefNames.REFS_CONFIG.equals(head.getLeaf().getName())) {
return;
}
} catch (IOException err) {
stateLog.error(String.format("cannot check type of project %s", project), err, state);
return;
}
} catch (IOException err) {
stateLog.error(String.format("source project %s not available", project), err, state);
return;
}
}
}
synchronized (stateLock) {
PushOne e = pending.get(uri);
if (e == null) {
e = opFactory.create(project, uri);
pool.schedule(e, config.getDelay(), TimeUnit.SECONDS);
pending.put(uri, e);
}
e.addRef(ref);
state.increasePushTaskCount(project.get(), ref);
e.addState(ref, state);
repLog.info("scheduled {}:{} => {} to run after {}s", project, ref, e, config.getDelay());
}
}
/**
* It schedules again a PushOp instance.
*
* <p>If the reason for rescheduling is to avoid a collision with an in-flight push to the same
* URI, we don't mark the operation as "retrying," and we schedule using the replication delay,
* rather than the retry delay. Otherwise, the operation is marked as "retrying" and scheduled to
* run following the minutes count determined by class attribute retryDelay.
*
* <p>In case the PushOp instance to be scheduled has same URI than one marked as "retrying," it
* adds to the one pending the refs list of the parameter instance.
*
* <p>In case the PushOp instance to be scheduled has the same URI as one pending, but not marked
* "retrying," it indicates the one pending should be canceled when it starts executing, removes
* it from pending list, and adds its refs to the parameter instance. The parameter instance is
* scheduled for retry.
*
* <p>Notice all operations to indicate a PushOp should be canceled, or it is retrying, or
* remove/add it from/to pending Map should be protected by synchronizing on the stateLock object.
*
* @param pushOp The PushOp instance to be scheduled.
*/
void reschedule(PushOne pushOp, RetryReason reason) {
synchronized (stateLock) {
URIish uri = pushOp.getURI();
PushOne pendingPushOp = pending.get(uri);
if (pendingPushOp != null) {
// There is one PushOp instance already pending to same URI.
if (pendingPushOp.isRetrying()) {
// The one pending is one already retrying, so it should
// maintain it and add to it the refs of the one passed
// as parameter to the method.
// This scenario would happen if a PushOp has started running
// and then before it failed due transport exception, another
// one to same URI started. The first one would fail and would
// be rescheduled, being present in pending list. When the
// second one fails, it will also be rescheduled and then,
// here, find out replication to its URI is already pending
// for retry (blocking).
pendingPushOp.addRefs(pushOp.getRefs());
pendingPushOp.addStates(pushOp.getStates());
pushOp.removeStates();
} else {
// The one pending is one that is NOT retrying, it was just
// scheduled believing no problem would happen. The one pending
// should be canceled, and this is done by setting its canceled
// flag, removing it from pending list, and adding its refs to
// the pushOp instance that should then, later, in this method,
// be scheduled for retry.
// Notice that the PushOp found pending will start running and,
// when notifying it is starting (with pending lock protection),
// it will see it was canceled and then it will do nothing with
// pending list and it will not execute its run implementation.
pendingPushOp.canceledByReplication();
pending.remove(uri);
pushOp.addRefs(pendingPushOp.getRefs());
pushOp.addStates(pendingPushOp.getStates());
pendingPushOp.removeStates();
}
}
if (pendingPushOp == null || !pendingPushOp.isRetrying()) {
pending.put(uri, pushOp);
switch (reason) {
case COLLISION:
pool.schedule(pushOp, config.getDelay(), TimeUnit.SECONDS);
break;
case TRANSPORT_ERROR:
case REPOSITORY_MISSING:
default:
pushOp.setToRetry();
pool.schedule(pushOp, config.getRetryDelay(), TimeUnit.MINUTES);
break;
}
}
}
}
