1. 25 Mar, 2019 1 commit
  2. 20 Mar, 2019 1 commit
  3. 12 Feb, 2019 1 commit
    • Stan Hu's avatar
      Create the source branch for a GitHub import · e34a3213
      Stan Hu authored
      When the GitHub importer creates a merge request, it retrieves the SHA
      but does not actually create the source branch. This makes it impossible
      to merge an open merge request, particularly if the source branch were
      from a forked project. In that case, the branch will never exist because
      the original `project-name:source-branch` name is never created, nor
      is it a valid branch name.
      
      To prevent possible branch name conflicts, forked source branches
      are now renamed `github/fork/project-name/source-branch` and created
      when necessary.
      
      Note that we only create the source branch if the merge request
      is open. For projects that have many merge requests, the project
      would end up with a lot of possibly dead branches.
      
      Closes https://gitlab.com/gitlab-org/gitlab-ce/issues/57370
      e34a3213
  4. 24 Aug, 2018 1 commit
  5. 20 Aug, 2018 1 commit
    • Yorick Peterse's avatar
      Refactor AutocompleteController · 6f3c4901
      Yorick Peterse authored
      This refactors the AutocompleteController according to the guidelines
      and boundaries discussed in
      https://gitlab.com/gitlab-org/gitlab-ce/issues/49653. Specifically,
      ActiveRecord logic is moved to different finders, which are then used in
      the controller. View logic in turn is moved to presenters, instead of
      directly using ActiveRecord's "to_json" method.
      
      The finder MoveToProjectFinder is also adjusted according to the
      abstraction guidelines and boundaries, resulting in a much more simple
      finder.
      
      By using finders (and other abstractions) more actively, we can push a
      lot of logic out of the controller. We also remove the need for various
      "before_action" hooks, though this could be achieved without using
      finders as well.
      
      The various finders related to AutcompleteController have also been
      moved into a namespace. This removes the need for calling everything
      "AutocompleteSmurfFinder", instead you can use
      "Autocomplete::SmurfFinder".
      6f3c4901
  6. 16 Aug, 2018 1 commit
  7. 12 Jun, 2018 1 commit
    • Yorick Peterse's avatar
      Ensure MR diffs always exist in the PR importer · e4612df0
      Yorick Peterse authored
      In rare cases it could happen that an MR was created, but creating the
      MR diffs somehow failed (e.g. due to an error). This commit adds an
      additional check to make sure MR diffs are always present when importing
      GitHub pull requests.
      e4612df0
  8. 04 Jun, 2018 1 commit
    • Yorick Peterse's avatar
      Perform pull request IO work outside a transaction · 71ed7987
      Yorick Peterse authored
      When importing a GitHub pull request we would perform all work in a
      single database transaction. This is less than ideal, because we perform
      various slow Git operations when creating a merge request. This in turn
      can lead to many DB connections being used, while just waiting for an IO
      operation to complete.
      
      To work around this, we now move most of the heavy lifting out of the
      database transaction. Some extra error handling is added to ensure we
      can resume importing a partially imported pull request, instead of just
      throwing an error.
      
      This commit also changes the specs for IssueImporter so they don't rely
      on deprecated RSpec methods.
      71ed7987
  9. 07 Nov, 2017 1 commit
    • Yorick Peterse's avatar
      Rewrite the GitHub importer from scratch · 4dfe26cd
      Yorick Peterse authored
      Prior to this MR there were two GitHub related importers:
      
      * Github::Import: the main importer used for GitHub projects
      * Gitlab::GithubImport: importer that's somewhat confusingly used for
        importing Gitea projects (apparently they have a compatible API)
      
      This MR renames the Gitea importer to Gitlab::LegacyGithubImport and
      introduces a new GitHub importer in the Gitlab::GithubImport namespace.
      This new GitHub importer uses Sidekiq for importing multiple resources
      in parallel, though it also has the ability to import data sequentially
      should this be necessary.
      
      The new code is spread across the following directories:
      
      * lib/gitlab/github_import: this directory contains most of the importer
        code such as the classes used for importing resources.
      * app/workers/gitlab/github_import: this directory contains the Sidekiq
        workers, most of which simply use the code from the directory above.
      * app/workers/concerns/gitlab/github_import: this directory provides a
        few modules that are included in every GitHub importer worker.
      
      == Stages
      
      The import work is divided into separate stages, with each stage
      importing a specific set of data. Stages will schedule the work that
      needs to be performed, followed by scheduling a job for the
      "AdvanceStageWorker" worker. This worker will periodically check if all
      work is completed and schedule the next stage if this is the case. If
      work is not yet completed this worker will reschedule itself.
      
      Using this approach we don't have to block threads by calling `sleep()`,
      as doing so for large projects could block the thread from doing any
      work for many hours.
      
      == Retrying Work
      
      Workers will reschedule themselves whenever necessary. For example,
      hitting the GitHub API's rate limit will result in jobs rescheduling
      themselves. These jobs are not processed until the rate limit has been
      reset.
      
      == User Lookups
      
      Part of the importing process involves looking up user details in the
      GitHub API so we can map them to GitLab users. The old importer used
      an in-memory cache, but this obviously doesn't work when the work is
      spread across different threads.
      
      The new importer uses a Redis cache and makes sure we only perform
      API/database calls if absolutely necessary.  Frequently used keys are
      refreshed, and lookup misses are also cached; removing the need for
      performing API/database calls if we know we don't have the data we're
      looking for.
      
      == Performance & Models
      
      The new importer in various places uses raw INSERT statements (as
      generated by `Gitlab::Database.bulk_insert`) instead of using Rails
      models. This allows us to bypass any validations and callbacks,
      drastically reducing the number of SQL queries and Gitaly RPC calls
      necessary to import projects.
      
      To ensure the code produces valid data the corresponding tests check if
      the produced rows are valid according to the model validation rules.
      4dfe26cd