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?
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?
Risposte:
È possibile fare riferimento alla pagina GitHub " Duplicazione di un repository "
Utilizza:
git clone --mirror
: per clonare ogni riferimento (commit, tag, rami)git push --mirror
: spingere tuttoCiò 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 :
Import Code
funzionalità di GitHub descritta da MarMass . È molto semplice.
1º Creare un nuovo repository vuoto in GitHub (senza readme o licesne, è possibile aggiungerli prima) e la seguente schermata mostrerà
2º All'interno dell'opzione di importazione del codice , incolla il repository e il voilà dell'URL bitbucket !!
/import
la fine dell'URL con /settings
per accedere alle impostazioni e rimuoverlo.
Se non riesci a trovare il pulsante "Importa codice" su github, puoi:
url
. Sembrerà che:Public
o Private
repoBegin Import
AGGIORNAMENTO: Di recente, Github ha annunciato la possibilità di " Importare repository con file di grandi dimensioni "
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
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:
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
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.
Riceverai un'email quando il repository è stato completamente importato.
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.
brew install jq
Vai su https://github.com/settings/tokens e crea un token di accesso. Abbiamo solo bisogno dell'ambito "repo".
Salvare lo move_me.sh
script in una cartella di lavoro e modificare il file secondo necessità.
Non dimenticare di CHMOD 755
Correre! ./move_me.sh
Goditi il tempo che hai risparmiato.
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.
Trovare e cambiare l' "private": true
ad "private": false
di sotto.
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
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:
$ git clone https://USER@bitbucket.org/USER/PROJECT.git
$ cd PROJECT
$ git remote add upstream https://github.com:USER/PROJECT.git
$ 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:
Ricontrolla che il repository Github abbia tutto il contenuto
Vai all'interfaccia web del vecchio repository Bitbucket
Selezionare l'opzione di menu Impostazioni> Elimina repository
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!
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