Jak przenieść repozytorium git ze wszystkimi gałęziami z bitbucket na github?

Jaki jest najlepszy sposób na przeniesienie repozytorium git ze wszystkimi gałęziami i pełną historią z bitbucket na github? Czy istnieje skrypt lub lista poleceń, których muszę użyć?

Możesz odnieść się do strony GitHub „ Duplikowanie repozytorium ”

To używa:

• git clone --mirror: aby sklonować wszystkie referencje (zatwierdzenia, tagi, gałęzie)
• git push --mirror: popychać wszystko

To dałoby:

git clone --mirror https://bitbucket.org/exampleuser/repository-to-mirror.git
# Make a bare mirrored clone of the repository

cd repository-to-mirror.git
git remote set-url --push origin https://github.com/exampleuser/mirrored
# Set the push location to your mirror

git push --mirror

Jak zauważono w komentarzu s przez LS :

• łatwiej jest korzystać z Import Codefunkcji GitHub opisanej przez MarMass .
  Zobacz https://github.com/new/import
• Chyba że ... Twoje repozytorium zawiera duży plik: problem polega na tym, że narzędzie do importowania zakończy się niepowodzeniem bez wyraźnego komunikatu o błędzie. Tylko obsługa GitHub byłaby w stanie zdiagnozować, co się stało.

To jest bardzo proste.

1º Utwórz nowe puste repozytorium w GitHub (bez readme i licesne, możesz dodać je wcześniej), a pojawi się następujący ekran

2º Wewnątrz, aby zaimportować kod , wklejasz repozytorium URL bitbucket i voila !!

Jeśli nie możesz znaleźć przycisku „Importuj kod” na github, możesz:

1. bezpośrednio otwórz Github Importer i wprowadźurl . Będzie to wyglądać następująco:
2. nadaj mu nazwę (lub automatycznie zaimportuje nazwę)
3. wybierz Publiclub Privaterepo
4. Kliknij Begin Import

AKTUALIZACJA: Ostatnio Github ogłosił możliwość „ Importowania repozytoriów z dużymi plikami ”

http://www.blackdogfoundry.com/blog/moving-repository-from-bitbucket-to-github/

Pomogło mi to przejść od jednego dostawcy git do drugiego. Na końcu wszystkie zatwierdzenia były w gicie docelowym. Prosty i prosty.

git remote rename origin bitbucket
git remote add origin https://github.com/edwardaux/Pipelines.git
git push origin master

Gdy byłem szczęśliwy, że wypychanie zakończyło się sukcesem w GitHub, mogłem usunąć starego pilota, wydając:

git remote rm bitbucket

Miałem odwrotny przypadek użycia importowania istniejącego repozytorium z github do bitbucket.

Bitbucket oferuje również narzędzie do importowania . Jedynym niezbędnym krokiem jest dodanie adresu URL do repozytorium.

To wygląda jak:

Zdaję sobie sprawę, że to stare pytanie. Znalazłem to kilka miesięcy temu, gdy próbowałem zrobić to samo i byłem pod wrażeniem udzielonych odpowiedzi. Wydawało się, że wszystkie zajmują się importowaniem z Bitbucket do GitHub po jednym repozytorium na raz, albo za pomocą poleceń wydawanych z karty, albo za pomocą importera GitHub.

Pobrałem kod z projektu GitHub o nazwie gitter i zmodyfikowałem go, aby dostosować go do moich potrzeb.

Możesz rozwidlić sedno lub pobrać kod stąd:

#!/usr/bin/env ruby
require 'fileutils'

# Originally  -- Dave Deriso        -- [email protected]
# Contributor -- G. Richard Bellamy -- [email protected]
# If you contribute, put your name here!
# To get your team ID:
# 1. Go to your GitHub profile, select 'Personal Access Tokens', and create an Access token
# 2. curl -H "Authorization: token <very-long-access-token>" https://api.github.com/orgs/<org-name>/teams
# 3. Find the team name, and grabulate the Team ID
# 4. PROFIT!

#----------------------------------------------------------------------
#your particulars
@access_token = ''
@team_id = ''
@org = ''


#----------------------------------------------------------------------
#the verison of this app
@version = "0.2"

#----------------------------------------------------------------------
#some global params
@create = false
@add = false
@migrate = false
@debug = false
@done = false
@error = false

#----------------------------------------------------------------------
#fancy schmancy color scheme

class String; def c(cc); "\e[#{cc}m#{self}\e[0m" end end
#200.to_i.times{ |i| print i.to_s.c(i) + " " }; puts
@sep = "-".c(90)*95
@sep_pref = ".".c(90)*95
@sep_thick = "+".c(90)*95

#----------------------------------------------------------------------
# greetings

def hello
  puts @sep
  puts "BitBucket to GitHub migrator -- v.#{@version}".c(95)
  #puts @sep_thick
end

def goodbye
  puts @sep
  puts "done!".c(95)
  puts @sep
  exit
end

def puts_title(text)
   puts  @sep, "#{text}".c(36), @sep
end

#----------------------------------------------------------------------
# helper methods

def get_options
  require 'optparse'

  n_options = 0
  show_options = false

  OptionParser.new do |opts|
    opts.banner = @sep +"\nUsage: gitter [options]\n".c(36)
    opts.version = @version
    opts.on('-n', '--name [name]', String, 'Set the name of the new repo') { |value| @repo_name = value; n_options+=1 }
    opts.on('-c', '--create', String, 'Create new repo') { @create = true; n_options+=1 }
    opts.on('-m', '--migrate', String, 'Migrate the repo') { @migrate = true; n_options+=1 }
    opts.on('-a', '--add', String, 'Add repo to team') { @add = true; n_options+=1 }
    opts.on('-l', '--language [language]', String, 'Set language of the new repo') { |value| @language = value.strip.downcase; n_options+=1 }
    opts.on('-d', '--debug', 'Print commands for inspection, doesn\'t actually run them') { @debug = true; n_options+=1 }
    opts.on_tail('-h', '--help', 'Prints this little guide') { show_options = true; n_options+=1 }
    @opts = opts
  end.parse!

  if show_options || n_options == 0
    puts @opts
    puts "\nExamples:".c(36)
    puts 'create new repo: ' + "\t\tgitter -c -l javascript -n node_app".c(93)
    puts 'migrate existing to GitHub: ' + "\tgitter -m -n node_app".c(93)
    puts 'create repo and migrate to it: ' + "\tgitter -c -m -l javascript -n node_app".c(93)
    puts 'create repo, migrate to it, and add it to a team: ' + "\tgitter -c -m -a -l javascript -n node_app".c(93)
    puts "\nNotes:".c(36)
    puts "Access Token for repo is #{@access_token} - change this on line 13"
    puts "Team ID for repo is #{@team_id} - change this on line 14"
    puts "Organization for repo is #{@org} - change this on line 15"
    puts 'The assumption is that the person running the script has SSH access to BitBucket,'
    puts 'and GitHub, and that if the current directory contains a directory with the same'
    puts 'name as the repo to migrated, it will deleted and recreated, or created if it'
    puts 'doesn\'t exist - the repo to migrate is mirrored locally, and then created on'
    puts 'GitHub and pushed from that local clone.'
    puts 'New repos are private by default'
    puts "Doesn\'t like symbols for language (ex. use \'c\' instead of \'c++\')"
    puts @sep
    exit
  end
end

#----------------------------------------------------------------------
# git helper methods

def gitter_create(repo)
  if @language
    %q[curl https://api.github.com/orgs/] + @org + %q[/repos -H "Authorization: token ] + @access_token + %q[" -d '{"name":"] + repo + %q[","private":true,"language":"] + @language + %q["}']
  else
    %q[curl https://api.github.com/orgs/] + @org + %q[/repos -H "Authorization: token ] + @access_token + %q[" -d '{"name":"] + repo + %q[","private":true}']
  end
end

def gitter_add(repo)
  if @language
    %q[curl https://api.github.com/teams/] + @team_id + %q[/repos/] + @org + %q[/] + repo + %q[ -H "Accept: application/vnd.github.v3+json" -H "Authorization: token ] + @access_token + %q[" -d '{"permission":"pull","language":"] + @language + %q["}']
  else
    %q[curl https://api.github.com/teams/] + @team_id + %q[/repos/] + @org + %q[/] + repo + %q[ -H "Accept: application/vnd.github.v3+json" -H "Authorization: token ] + @access_token + %q[" -d '{"permission":"pull"}']
  end
end

def git_clone_mirror(bitbucket_origin, path)
  "git clone --mirror #{bitbucket_origin}"
end

def git_push_mirror(github_origin, path)
  "(cd './#{path}' && git push --mirror #{github_origin} && cd ..)"
end

def show_pwd
  if @debug
    Dir.getwd()
  end
end

def git_list_origin(path)
  "(cd './#{path}' && git config remote.origin.url && cd ..)"
end

# error checks

def has_repo
  File.exist?('.git')
end

def has_repo_or_error(show_error)
  @repo_exists = has_repo
  if !@repo_exists
    puts 'Error: no .git folder in current directory'.c(91) if show_error
    @error = true
  end
  "has repo: #{@repo_exists}"
end

def has_repo_name_or_error(show_error)
  @repo_name_exists = !(defined?(@repo_name)).nil?
  if !@repo_name_exists
    puts 'Error: repo name missing (-n your_name_here)'.c(91) if show_error
    @error = true
  end
end

#----------------------------------------------------------------------
# main methods
def run(commands)
  if @debug
    commands.each { |x| puts(x) }
  else
    commands.each { |x| system(x) }
  end
end

def set_globals

  puts_title 'Parameters'

  @git_bitbucket_origin =   "[email protected]:#{@org}/#{@repo_name}.git"
  @git_github_origin = "[email protected]:#{@org}/#{@repo_name}.git"

  puts 'debug: ' + @debug.to_s.c(93)
  puts 'working in: ' + Dir.pwd.c(93)
  puts 'create: ' + @create.to_s.c(93)
  puts 'migrate: ' + @migrate.to_s.c(93)
  puts 'add: ' + @add.to_s.c(93)
  puts 'language: ' + @language.to_s.c(93)
  puts 'repo name: '+ @repo_name.to_s.c(93)
  puts 'bitbucket: ' + @git_bitbucket_origin.to_s.c(93)
  puts 'github: ' + @git_github_origin.to_s.c(93)
  puts 'team_id: ' + @team_id.to_s.c(93)
  puts 'org: ' + @org.to_s.c(93)
end

def create_repo
  puts_title 'Creating'

  #error checks
  has_repo_name_or_error(true)
  goodbye if @error

  puts @sep

  commands = [
      gitter_create(@repo_name)
  ]

  run commands
end


def add_repo
  puts_title 'Adding repo to team'

  #error checks
  has_repo_name_or_error(true)
  goodbye if @error

  puts @sep

  commands = [
      gitter_add(@repo_name)
  ]

  run commands
end

def migrate_repo

  puts_title "Migrating Repo to #{@repo_provider}"

  #error checks
  has_repo_name_or_error(true)
  goodbye if @error

  if Dir.exists?("#{@repo_name}.git")
    puts "#{@repo_name} already exists... recursively deleting."
    FileUtils.rm_r("#{@repo_name}.git")
  end

  path = "#{@repo_name}.git"
  commands = [
    git_clone_mirror(@git_bitbucket_origin, path),
    git_list_origin(path),
    git_push_mirror(@git_github_origin, path)
  ]

  run commands
end

#----------------------------------------------------------------------
#sequence control
hello
get_options

#do stuff
set_globals
create_repo if @create
migrate_repo if @migrate
add_repo if @add

#peace out
goodbye

Następnie, aby użyć skryptu:

# create a list of repos
foo
bar
baz

# execute the script, iterating over your list
while read p; do ./bitbucket-to-github.rb -a -n $p; done<repos

# good nuff

Istnieje importowanie repozytorium za pomocą narzędzia GitHub Importer

Jeśli masz projekt hostowany w innym systemie kontroli wersji, takim jak Mercurial, możesz automatycznie zaimportować go do GitHub za pomocą narzędzia GitHub Importer.

1. W prawym górnym rogu dowolnej strony kliknij, a następnie kliknij Importuj repozytorium.
2. W obszarze „Klonowany adres URL starego repozytorium” wpisz adres URL projektu, który chcesz zaimportować.
3. Wybierz konto użytkownika lub organizację, która będzie właścicielem repozytorium, a następnie wpisz nazwę repozytorium na GitHub.
4. Określ, czy nowe repozytorium powinno być publiczne, czy prywatne.
   • Publiczne repozytoria są widoczne dla każdego użytkownika GitHub, dzięki czemu możesz korzystać ze społeczności współpracującej z GitHub.
   • Przyciski opcji publicznego lub prywatnego repozytorium Prywatne repozytoria są dostępne tylko dla właściciela repozytorium, a także dla wszystkich współpracowników, którym chcesz się dzielić.
5. Przejrzyj wprowadzone informacje, a następnie kliknij Rozpocznij import.

Otrzymasz wiadomość e-mail, gdy repozytorium zostanie całkowicie zaimportowane.

1. https://help.github.com/categories/importing-your-projects-to-github
2. https://help.github.com/articles/importing-a-repository-with-github-importer/

Jeśli chcesz przenieść lokalne repozytorium git do innego, możesz zrobić to:

aby uzyskać bieżący zdalny adres URL:

git zdalne pochodzenie get-url

pokaże coś takiego: https://bitbucket.com/git/myrepo

aby ustawić nowe zdalne repozytorium:

git zdalny set-url origin [email protected]: folder / myrepo.git

teraz wypychaj zawartość bieżącego (rozwijanego) oddziału:

git push - rozwijanie źródła początkowego

Masz teraz pełną kopię oddziału w nowym pilocie.

opcjonalnie wróć do oryginalnego git-remote dla tego folderu lokalnego:

git zdalny początek adresu URL https://bitbucket.com/git/myrepo

Daje korzyść, że możesz teraz pobrać nowe repozytorium git z github w innym folderze, dzięki czemu masz dwa foldery lokalne, oba wskazujące na różne piloty, poprzedni (bitbucket) i nowy oba dostępne.

Zrobiłem następujący skrypt bash, aby sklonować WSZYSTKIE moje repozytoria Bitbucket (użytkownika) do GitHub jako prywatne repozytoria.

Wymagania:

• jq (procesor JSON z wiersza poleceń) | System operacyjny Mac:brew install jq

Kroki:

1. Wejdź na https://github.com/settings/tokens i utwórz token dostępu. Potrzebujemy tylko zakresu „repo”.

2. Zapisz move_me.shskrypt w folderze roboczym i edytuj plik zgodnie z potrzebami.

3. Nie zapomnij CHMOD 755

4. Biegać! ./move_me.sh

5. Ciesz się zaoszczędzonym czasem.

Uwagi:

• Sklonuje repozytoria BitBucket w katalogu, w którym znajduje się skrypt (w katalogu roboczym).

• Ten skrypt nie usuwa twoich repozytoriów BitBucket.

Chcesz przejść do publicznych repozytoriów na GitHub?

Znajdź i zmień "private": truesię "private": falseponiżej.

Przenosisz repozytoria organizacji?

Zapoznaj się z przewodnikiem dla programistów . Kilka zmian dalej.

Miłego przeprowadzki.

#!/bin/bash

BB_USERNAME=your_bitbucket_username 
BB_PASSWORD=your_bitbucket_password

GH_USERNAME=your_github_username
GH_ACCESS_TOKEN=your_github_access_token

###########################

pagelen=$(curl -s -u $BB_USERNAME:$BB_PASSWORD https://api.bitbucket.org/2.0/repositories/$BB_USERNAME | jq -r '.pagelen')

echo "Total number of pages: $pagelen"

hr () {
  printf '%*s\n' "${COLUMNS:-$(tput cols)}" '' | tr ' ' -  
}

i=1

while [ $i -le $pagelen ]
do
  echo
  echo "* Processing Page: $i..."
  hr  
  pageval=$(curl -s -u $BB_USERNAME:$BB_PASSWORD https://api.bitbucket.org/2.0/repositories/$BB_USERNAME?page=$i)

  next=$(echo $pageval | jq -r '.next')
  slugs=($(echo $pageval | jq -r '.values[] | .slug'))
  repos=($(echo $pageval | jq -r '.values[] | .links.clone[1].href'))

  j=0
  for repo in ${repos[@]}
  do
    echo "$(($j + 1)) = ${repos[$j]}"
    slug=${slugs[$j]}
  git clone --bare $repo 
  cd "$slug.git"
  echo
  echo "* $repo cloned, now creating $slug on github..."  
  echo  

  read -r -d '' PAYLOAD <<EOP
  {
    "name": "$slug",
    "description": "$slug - moved from bitbucket",
    "homepage": "https://github.com/$slug",
    "private": true
  }
  EOP

  curl -H "Authorization: token $GH_ACCESS_TOKEN" --data "$PAYLOAD" \
      https://api.github.com/user/repos
  echo
  echo "* mirroring $repo to github..."  
  echo
  git push --mirror "[email protected]:$GH_USERNAME/$slug.git"
  j=$(( $j + 1 ))
  hr    
  cd ..
  done  
  i=$(( $i + 1 ))
done

Oto kroki, aby przenieść prywatne repozytorium Git:

Krok 1: Utwórz repozytorium Github

Najpierw utwórz nowe prywatne repozytorium na Github.com. Ważne jest, aby repozytorium pozostało puste, np. Nie zaznaczaj opcji Zainicjuj to repozytorium za pomocą README podczas tworzenia repozytorium.

Krok 2: przenieś istniejącą treść

Następnie musimy wypełnić repozytorium Github treścią z naszego repozytorium Bitbucket:

1. Sprawdź istniejące repozytorium z Bitbucket:

    $ git clone https://[email protected]/USER/PROJECT.git

2. Dodaj nowe repozytorium Github jako zdalne zdalne repozytorium wypisane z Bitbucket:

    $ cd PROJECT
    $ git remote add upstream https://github.com:USER/PROJECT.git

3. Wciśnij wszystkie gałęzie (poniżej: tylko master) i tagi do repozytorium Github:

    $ git push upstream master
    $ git push --tags upstream

Krok 3: Wyczyść stare repozytorium

Wreszcie musimy zadbać o to, aby programiści nie byli zdezorientowani, mając dwa repozytoria dla tego samego projektu. Oto jak usunąć repozytorium Bitbucket:

1. Sprawdź dwukrotnie, czy repozytorium Github ma całą zawartość

2. Przejdź do interfejsu internetowego starego repozytorium Bitbucket

3. Wybierz opcję menu Ustawienia> Usuń repozytorium

4. Dodaj adres URL nowego repozytorium Github jako adres URL przekierowania

Dzięki temu repozytorium całkowicie osiedliło się w nowym domu w Github. Poinformuj wszystkich programistów!

Najprostszy sposób to zrobić:

git remote rename origin repo_bitbucket

git remote add origin https://github.com/abc/repo.git

git push origin master

Po pomyślnym przekazaniu do GitHub usuń stary pilot, uruchamiając:

git remote rm repo_bitbucket