wake-up-neo.com

Wie git Repository mit allen Zweigen von Bitbucket zu Github verschieben

Was ist der beste Weg, um ein Git-Repository mit allen Zweigen und der gesamten Historie von Bitbucket zu Github zu verschieben? Gibt es ein Skript oder eine Liste von Befehlen, die ich verwenden muss?

298
swalkner

Sie können auf die GitHub-Seite " Duplizieren eines Repositorys " verweisen.

Es verwendet:

Das würde geben:

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

Wie notiert im Kommentar s von L S :

349
VonC

Es ist sehr einfach. 

Erstellen Sie ein neues leeres Repository in GitHub (ohne Readme oder Licesne können Sie diese zuvor hinzufügen), und der folgende Bildschirm wird angezeigt

Innerhalb vonImportcodeOption fügen Sie das Repo und die Voilà Ihrer Bitbucket-URL ein !! 

Click in import code

394
MarMass

Falls Sie die Schaltfläche "Code importieren" auf github nicht finden können, können Sie: 

  1. Öffnen Sie direkt Github Importer und geben Sie url ein. Es wird so aussehen: Screenshot of github importer
  2. einen Namen vergeben (oder der Name wird automatisch importiert)
  3. wählen Sie Public oder Private Repo
  4. Klicken Sie auf Begin Import

UPDATE: Vor kurzem gab Github die Möglichkeit bekannt, " Repositorys mit großen Dateien zu importieren

121
biniam

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

Dies half mir, von einem Git-Anbieter zu einem anderen zu wechseln. Am Ende waren alle Commits im Zielgit. Einfach und unkompliziert.

git remote rename Origin bitbucket
git remote add Origin https://github.com/edwardaux/Pipelines.git
git Push Origin master

Sobald ich glücklich war, dass der Push für GitHub erfolgreich war, konnte ich Löschen Sie die alte Fernbedienung, indem Sie Folgendes ausgeben:

git remote rm bitbucket
35
Rettel

Ich hatte den umgekehrten Anwendungsfall, ein vorhandenes Repository von github nach bitbucket zu importieren.

Bitbucket bietet auch ein Import-Tool an. Der einzig notwendige Schritt ist das Hinzufügen einer URL zum Repository.

Es sieht aus wie:

Screenshot of the bitbucket import tool

13
k0pernikus

Es gibt das Importieren eines Repositorys mit GitHub Importer

Wenn Sie ein Projekt in einem anderen Versionskontrollsystem als Mercurial gehostet haben, können Sie es mit dem GitHub Importer-Tool automatisch in GitHub importieren.

  1. Klicken Sie in der oberen rechten Ecke einer beliebigen Seite auf und dann auf Repository importieren.
  2. Geben Sie unter "Klon-URL Ihres alten Repositorys" die URL des Projekts ein, das Sie importieren möchten.
  3. Wählen Sie Ihr Benutzerkonto oder eine Organisation aus, der das Repository gehören soll, und geben Sie einen Namen für das Repository in GitHub ein.
  4. Geben Sie an, ob das neue Repository öffentlich oder privat sein soll .
    • Öffentliche Repositorys sind für jeden Benutzer in GitHub sichtbar, sodass Sie von der kollaborativen Gemeinschaft von GitHub profitieren können.
    • Optionsfelder für öffentliche oder private RepositorysPrivate Repositorys stehen nur dem Repository-Besitzer sowie allen Mitarbeitern zur Verfügung, mit denen Sie die Freigabe vornehmen.
  5. Überprüfen Sie die eingegebenen Informationen und klicken Sie dann auf Import beginnen.

Sie erhalten eine E-Mail, wenn das Repository vollständig importiert wurde.

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

Mir ist klar, dass dies eine alte Frage ist. Ich habe es vor einigen Monaten gefunden, als ich dasselbe versuchte, und war von den Antworten nicht begeistert. Sie alle schienen sich mit dem Import von Bitbucket in GitHub eines Repositorys zu befassen, entweder über à la carte Befehle oder über den GitHub-Importer.

Ich habe den Code aus einem GitHub-Projekt namens gitter übernommen und an meine Bedürfnisse angepasst.

Sie können die Gist abspalten oder den Code von hier übernehmen:

#!/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 [email protected]_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 [email protected]_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

Dann verwenden Sie das Skript:

# 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
4
rbellamy

Einfachste Möglichkeit:

git remote rename Origin repo_bitbucket

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

git Push Origin master

Wenn der Push to GitHub erfolgreich ist, löschen Sie die alte Fernbedienung, indem Sie Folgendes ausführen:

git remote rm repo_bitbucket

So verschieben Sie ein privates Git-Repository:

Schritt 1: Github-Repository erstellen

Erstellen Sie zunächst ein neues privates Repository auf Github.com. Es ist wichtig, das Repository leer zu halten, z. Aktivieren Sie diese Option nicht. Initialisieren Sie dieses Repository mit einem README, wenn Sie das Repository erstellen.

Schritt 2: Vorhandenen Inhalt verschieben

Als nächstes müssen wir das Github-Repository mit dem Inhalt aus unserem Bitbucket-Repository füllen:

  1. Checkt das vorhandene Repository aus von Bitbucket:
    $ git clone https://[email protected]/USER/PROJECT.git
  1. Fügen Sie das neue Github-Repository als pstream-Remote des aus Bitbucket ausgecheckten Repositorys hinzu:
    $ cd PROJECT
    $ git remote add upstream https://github.com:USER/PROJECT.git
  1. Alle Zweige pushen (unten: nur Master) und Tags zum Github-Repository:
    $ git Push upstream master
    $ git Push --tags upstream

Schritt 3: Altes Repository bereinigen

Schließlich müssen wir sicherstellen, dass Entwickler nicht durch zwei Repositorys für dasselbe Projekt verwirrt werden. So löschen Sie das Bitbucket-Repository:

  1. Stellen Sie sicher, dass das Github-Repository den gesamten Inhalt enthält

  2. Gehen Sie zur Weboberfläche des alten Bitbucket-Repository

  3. Wählen Sie die Menüoption Einstellungen> Repository löschen

  4. Fügen Sie die URL des neuen Github-Repositorys als Weiterleitungs-URL hinzu

Damit hat sich das Endlager vollständig in seinem neuen Zuhause in Github niedergelassen. Lass es alle Entwickler wissen!

0
Ryan

Falls Sie Ihr lokales Git-Repository in ein anderes Upstream verschieben möchten, können Sie auch Folgendes tun:

so rufen Sie die aktuelle Remote-URL ab:

git remote get-url Origin

zeigt etwas wie: https://bitbucket.com/git/myrepo

so legen Sie ein neues Remote-Repository fest:

git Remote-Set-Url Origin [email protected]: Ordner/myrepo.git

jetzt Push-Inhalte des aktuellen (Entwicklungs-) Zweigs:

git Push --set-upstream Origin entwickeln

Sie haben jetzt eine vollständige Kopie der Niederlassung in der neuen Fernbedienung.

optional zum ursprünglichen git-remote für diesen lokalen Ordner zurückkehren:

git remote set-url Origin https://bitbucket.com/git/myrepo

Bietet den Vorteil, dass Sie Ihr neues Git-Repository jetzt von github in einem anderen Ordner abrufen können, so dass Sie über zwei lokale Ordner verfügen, die auf die verschiedenen Fernbedienungen verweisen, den vorherigen (bitbucket) und den neuen, die beide verfügbar sind.

0
Hace