Come spostare il repository git con tutti i rami da bitbucket a github?


334

Qual è il modo migliore per spostare un repository git con tutti i rami e la cronologia completa da bitbucket a github? C'è uno script o un elenco di comandi che devo usare?


9
Github fornisce strumenti e documentazione per questo: help.github.com/articles/… help.github.com/articles/…
mems

Poco in ritardo alla festa, ma ecco uno script per la migrazione: gist.github.com/chinmaya-n/cff02f1277c811deab2e550f2aad9967
inblueswithu

Risposte:


394

È possibile fare riferimento alla pagina GitHub " Duplicazione di un repository "

Utilizza:

Ciò darebbe:

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

Come notato nel commento di LS :


2
Questo metodo ha creato un problema per me (non sono sicuro che sia un problema). Quando ho rispecchiato il repository da bitbucket a github, per 5 rami è mostrato come "Confronta e tira richiesta" in github. Non viene mostrato come rami in github. Cosa posso fare al riguardo?
Siddharth,

2
E poi che dire di problemi e wiki?
Vladislav Rastrusny,

Il wiki @FractalizeR è solo un altro repository che puoi replicare anche ( github.com/blog/699-making-github-more-open-git-backed-wikis ). Non esiste un modo semplice per replicare i problemi. Devi usare l'API (vari programmi di backup repository GitHub fanno proprio questo: addyosmani.com/blog/backing-up-a-github-account )
VonC,

3
Funziona se vuoi spostare anche un repository da Github a Bitbucket.
simeg

1
Avevo bisogno di usare questo metodo per copiare un repository perché conteneva un file di grandi dimensioni (> 100 MB). GH non consentirebbe file di grandi dimensioni nei loro repository. Ho rimosso il file di grandi dimensioni prima di inviare il repository a GH. Tuttavia, salvo altri problemi, l'utilizzo della funzione " Importa repository " di GH è la scelta giusta il 95% delle volte, come descritto in un'altra risposta . Tuttavia, se fallisce, non fornisce utili messaggi di errore ed è necessario contattare il supporto GH. È stato il supporto GH che mi ha informato della restrizione sulla dimensione del file.
LS

412

È molto semplice.

Creare un nuovo repository vuoto in GitHub (senza readme o licesne, è possibile aggiungerli prima) e la seguente schermata mostrerà

All'interno dell'opzione di importazione del codice , incolla il repository e il voilà dell'URL bitbucket !!

Fai clic sul codice di importazione


12
Stai davvero rispondendo alla domanda qui, poiché la risposta accettata mostra solo un metodo generico Git. La tua risposta è molto più semplice!
Emile Bergeron,

6
Questa risposta è valida fintanto che sei tu a creare il repository ed è vuota. Se qualcun altro ha creato il repository per te (come l'incarico dell'amministratore per la creazione di filiali), questo non funziona. La risposta accettata è la strada da percorrere in questo caso.
Master.Aurora,

4
Rivolgiti a chiunque stia pensando di utilizzare questo metodo, rimuovi l'autenticazione a due fattori sul precedente host di repository prima di utilizzare questo servizio, altrimenti rimarrai bloccato in un ciclo infinito di tentativi di rimozione del repository appena creato in GitHub e l'unico modo per uscirne è quello di sostituire /importla fine dell'URL con /settingsper accedere alle impostazioni e rimuoverlo.
Dave,

1
Piccolo avvertimento: se si verifica un problema, non verrà visualizzato un messaggio di errore descrittivo.
RobertH,

L'uso della funzione " Importa repository " di GH è la scelta giusta il 95% delle volte. Tuttavia, se fallisce, non fornisce utili messaggi di errore ed è necessario contattare il supporto GH. Non ho potuto usarlo per un repository perché conteneva un file di grandi dimensioni (> 100 MB). Avevo bisogno di usare il metodo CLI accettato , rimuovendo il file di grandi dimensioni appena prima di inviare il repository a GH.
LS

125

Se non riesci a trovare il pulsante "Importa codice" su github, puoi:

  1. apri direttamente Github Importer e inserisci il url. Sembrerà che:Schermata dell'importatore github
  2. dagli un nome (o importerà il nome automaticamente)
  3. selezionare Publico Privaterepo
  4. Clic Begin Import

AGGIORNAMENTO: Di recente, Github ha annunciato la possibilità di " Importare repository con file di grandi dimensioni "


Purtroppo questo non ha funzionato per il mio tentativo di passare da codebasehq a git-hub, ha dato un "Questo URL non è supportato". :(
sjmcdowall,

@sjmcdowall Mi dispiace, ma credo che avrebbe dovuto funzionare poiché l'URL codebasehq punta a un repository git.
biniam,

L'URL non esiste più.
Contenitore codificato

@CodedContainer Ho appena controllato e funziona. Ho anche aggiornato la schermata proprio ora.
biniam,

1
L'URL restituirà un 404 solo se non si è effettuato l'accesso a GitHub. Se hai effettuato l'accesso, verrà caricato lo strumento di importazione.
Jason Hurt,

41

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

Questo mi ha aiutato a passare da un provider GIT a un altro. Alla fine, tutti gli commit erano nel git di destinazione. Semplice e diretto.

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

Una volta che sono stato contento che il push fosse riuscito a GitHub, ho potuto eliminare il vecchio telecomando emettendo:

git remote rm bitbucket

2
Includi le parti pertinenti di un link nella tua risposta in quanto dovrebbe essere in grado di resistere da solo.
k0pernikus,

Viene visualizzato un errore che dice "Errore: impossibile inviare alcuni riferimenti a ' url.gi ' suggerimento: gli aggiornamenti sono stati rifiutati perché il telecomando contiene lavoro che non si ha a livello locale. Questo di solito è causato da un altro repository che passa allo stesso riferimento. Potresti voler prima integrare le modifiche remote (ad es. Pull ...) prima di spingere di nuovo. Vedi la nota sull'avanzamento rapido in git push - aiuto per i dettagli
Coded Container

1
questa è l'unica risposta che funziona ancora nel 03/03/2019 :)
Wang-Zhao-Liu QM

13

Ho avuto il caso di utilizzo inverso dell'importazione di un repository esistente da github a bitbucket.

Bitbucket offre anche uno strumento di importazione . L'unico passaggio necessario è aggiungere l'URL al repository.

Sembra:

Schermata dello strumento di importazione bitbucket


5

Mi rendo conto che questa è una vecchia domanda. L'ho trovato diversi mesi fa quando stavo cercando di fare la stessa cosa, e sono stato deluso dalle risposte fornite. Sembrava che tutti avessero a che fare con l'importazione da Bitbucket a GitHub un repository alla volta, tramite comandi emessi à la carte o tramite l'importatore GitHub.

Ho preso il codice da un progetto GitHub chiamato gitter e l' ho modificato per soddisfare le mie esigenze.

È possibile sborsare la sostanza , o prendere il codice da qui:

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

# Originally  -- Dave Deriso        -- deriso@gmail.com
# Contributor -- G. Richard Bellamy -- rbellamy@terradatum.com
# 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 =   "git@bitbucket.org:#{@org}/#{@repo_name}.git"
  @git_github_origin = "git@github.com:#{@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

Quindi, per utilizzare lo script:

# 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

5

Esiste l' importazione di un repository con GitHub Importer

Se hai un progetto ospitato su un altro sistema di controllo della versione come Mercurial, puoi importarlo automaticamente in GitHub usando lo strumento GitHub Importer.

  1. Nell'angolo in alto a destra di qualsiasi pagina, fare clic su, quindi fare clic su Importa repository.
  2. In "URL clone del tuo vecchio repository", digita l'URL del progetto che desideri importare.
  3. Scegli il tuo account utente o un'organizzazione per possedere il repository, quindi digita un nome per il repository su GitHub.
  4. Specificare se il nuovo repository deve essere pubblico o privato.
    • I repository pubblici sono visibili a qualsiasi utente su GitHub, quindi puoi beneficiare della comunità collaborativa di GitHub.
    • Pulsanti di opzione del repository pubblico o privato I repository privati ​​sono disponibili solo per il proprietario del repository, nonché per tutti i collaboratori con cui si sceglie di condividere.
  5. Rivedi le informazioni inserite, quindi fai clic su Inizia importazione.

Riceverai un'email quando il repository è stato completamente importato.

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

2

Nel caso in cui desideri spostare il tuo repository git locale su un altro upstream, puoi anche fare questo:

per ottenere l'URL remoto corrente:

git origine get-url remota

mostrerà qualcosa come: https://bitbucket.com/git/myrepo

per impostare un nuovo repository remoto:

git origine set-url remota git@github.com: cartella / myrepo.git

ora spinge i contenuti dell'attuale ramo (sviluppo):

git push - sviluppo dell'origine a monte

Ora hai una copia completa del ramo nel nuovo telecomando.

facoltativamente tornare al git-remote originale per questa cartella locale:

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

Offre il vantaggio che ora puoi ottenere il tuo nuovo repository git da github in un'altra cartella in modo da avere due cartelle locali che puntano entrambe ai telecomandi diversi, il precedente (bitbucket) e il nuovo entrambi disponibili.


2

Ho creato il seguente script bash per clonare TUTTI i miei repository Bitbucket (utente) su GitHub come repository privati .


Requisiti:

  • jq (processore JSON da riga di comando) | Mac OS:brew install jq

passi:

  1. Vai su https://github.com/settings/tokens e crea un token di accesso. Abbiamo solo bisogno dell'ambito "repo".

  2. Salvare lo move_me.shscript in una cartella di lavoro e modificare il file secondo necessità.

  3. Non dimenticare di CHMOD 755

  4. Correre! ./move_me.sh

  5. Goditi il ​​tempo che hai risparmiato.


Appunti:

  • Clonerà i repository BitBucket all'interno della directory in cui risiede lo script (la directory di lavoro.)

  • Questo script non elimina i tuoi repository BitBucket.


Devi passare ai repository pubblici su GitHub?

Trovare e cambiare l' "private": truead "private": falsedi sotto.

Spostare i repository di un'organizzazione?

Dai un'occhiata alla guida per gli sviluppatori , ci sono un paio di modifiche.


Muoversi felice.

#!/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 "git@github.com:$GH_USERNAME/$slug.git"
  j=$(( $j + 1 ))
  hr    
  cd ..
  done  
  i=$(( $i + 1 ))
done

1
Script interessante, combinato con un token. Neat. Upvoted.
VonC,

@VonC Grazie!
cenk,

1

Ecco i passaggi per spostare un repository Git privato:

Passaggio 1: creare il repository Github

Innanzitutto, crea un nuovo repository privato su Github.com. È importante mantenere vuoto il repository, ad esempio non selezionare l'opzione Inizializza questo repository con un README durante la creazione del repository.

Passaggio 2: spostare i contenuti esistenti

Successivamente, dobbiamo riempire il repository Github con il contenuto del nostro repository Bitbucket:

  1. Dai un'occhiata al repository esistente da Bitbucket:
    $ git clone https://USER@bitbucket.org/USER/PROJECT.git
  1. Aggiungi il nuovo repository Github come remoto a monte del repository estratto da Bitbucket:
    $ cd PROJECT
    $ git remote add upstream https://github.com:USER/PROJECT.git
  1. Invia tutti i rami (sotto: solo master) e tag al repository Github:
    $ git push upstream master
    $ git push --tags upstream

Passaggio 3: ripulire il vecchio repository

Infine, dobbiamo garantire che gli sviluppatori non vengano confusi avendo due repository per lo stesso progetto. Ecco come eliminare il repository Bitbucket:

  1. Ricontrolla che il repository Github abbia tutto il contenuto

  2. Vai all'interfaccia web del vecchio repository Bitbucket

  3. Selezionare l'opzione di menu Impostazioni> Elimina repository

  4. Aggiungi l'URL del nuovo repository Github come URL di reindirizzamento

Con ciò, il repository si sistemò completamente nella sua nuova casa a Github. Fai sapere a tutti gli sviluppatori!


-1

Il modo più semplice per farlo:

git remote rename origin repo_bitbucket

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

git push origin master

Una volta che l'invio a GitHub ha esito positivo, eliminare il vecchio telecomando eseguendo:

git remote rm repo_bitbucket
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.