Add a heursitic for initial pushes which are really imports

Summary:
Fixes T7298. There are two ways to import a repository that you want to host, today:

  - Create it as "hosted", then push everything to it.
  - Create it as "imported", let it import, then switch it to "hosted".
  - (Neither of these work with SVN.)

We don't specifically recommend one or the other, although I believe both should work, and most users seem to go with the first one.

In the first workflow, the new empty repository imports completely and gets marked "imported", so our default behavior is then to publish commits. This can generate a lot of email/notification/feed spam.

If you're a fancy expert you might turn off "publish" before pushing, but normal users will frequently miss this.

Instead, when we receive an "import-like" push to an empty repository, put the repository back into "importing" after we accept the changes.

This has to be heuristic since we can't know for sure if a push is an import or new commits, but here's a simple rule that should do pretty well. We can refine it if necessary.

Test Plan:
  - Created a new empty repository.
  - Added some debugging code; verified the "commit count" and "empty" rules were calculated properly.
  - Pushed 8+ commits and saw the repo go into "importing", import, and leave "importing".
  - Pushed 8+ commits again and saw them publish.

Reviewers: btrahan

Reviewed By: btrahan

Subscribers: epriestley

Maniphest Tasks: T7298

Differential Revision: https://secure.phabricator.com/D11827

src/applications/diffusion/engine/DiffusionCommitHookEngine.php

@@ -173,6 +173,23 @@ final class DiffusionCommitHookEngine extends Phobject {
       throw $caught;
     }
 
+    // If this went through cleanly, detect pushes which are actually imports
+    // of an existing repository rather than an addition of new commits. If
+    // this push is importing a bunch of stuff, set the importing flag on
+    // the repository. It will be cleared once we fully process everything.
+
+    if ($this->isInitialImport($all_updates)) {
+      $repository = $this->getRepository();
+
+      $repository->openTransaction();
+        $repository->beginReadLocking();
+          $repository = $repository->reload();
+          $repository->setDetail('importing', true);
+          $repository->save();
+        $repository->endReadLocking();
+      $repository->saveTransaction();
+    }
+
     if ($this->emailPHIDs) {
       // If Herald rules triggered email to users, queue a worker to send the
       // mail. We do this out-of-process so that we block pushes as briefly
@@ -1190,4 +1207,58 @@ final class DiffusionCommitHookEngine extends Phobject {
     return $map;
   }
 
+  private function isInitialImport(array $all_updates) {
+    $repository = $this->getRepository();
+
+    $vcs = $repository->getVersionControlSystem();
+    switch ($vcs) {
+      case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
+        // There is no meaningful way to import history into Subversion by
+        // pushing.
+        return false;
+      default:
+        break;
+    }
+
+    // Now, apply a heuristic to guess whether this is a normal commit or
+    // an initial import. We guess something is an initial import if:
+    //
+    //   - the repository is currently empty; and
+    //   - it pushes more than 7 commits at once.
+    //
+    // The number "7" is chosen arbitrarily as seeming reasonable. We could
+    // also look at author data (do the commits come from multiple different
+    // authors?) and commit date data (is the oldest commit more than 48 hours
+    // old), but we don't have immediate access to those and this simple
+    // heruistic might be good enough.
+
+    $commit_count = 0;
+    $type_commit = PhabricatorRepositoryPushLog::REFTYPE_COMMIT;
+    foreach ($all_updates as $update) {
+      if ($update->getRefType() != $type_commit) {
+        continue;
+      }
+      $commit_count++;
+    }
+
+    if ($commit_count <= 7) {
+      // If this pushes a very small number of commits, assume it's an
+      // initial commit or stack of a few initial commits.
+      return false;
+    }
+
+    $any_commits = id(new DiffusionCommitQuery())
+      ->setViewer($this->getViewer())
+      ->withRepository($repository)
+      ->setLimit(1)
+      ->execute();
+
+    if ($any_commits) {
+      // If the repository already has commits, this isn't an import.
+      return false;
+    }
+
+    return true;
+  }
+
 }