¿Cuál es la mejor manera de mover un repositorio git con todas las ramas e historial completo de bitbucket a github? ¿Hay un script o una lista de comandos que tengo que usar?
¿Cuál es la mejor manera de mover un repositorio git con todas las ramas e historial completo de bitbucket a github? ¿Hay un script o una lista de comandos que tengo que usar?
Respuestas:
Puede consultar la página de GitHub " Duplicar un repositorio "
Usa:
git clone --mirror
: para clonar todas las referencias (commits, etiquetas, ramas)git push --mirror
: empujar todoEso daría:
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
Como se señaló en los comentarios de LS :
Import Code
función de GitHub descrita por MarMass . Es muy simple.
1º Cree un nuevo repositorio vacío en GitHub (sin readme o licesne, puede agregarlos antes) y la siguiente pantalla mostrará
2º Dentro de la opción de importar código , pega el repositorio de URL de tu bitbucket y ¡voilà!
/import
el final de la URL con /settings
para acceder a la configuración y eliminarla.
En caso de que no pueda encontrar el botón "Importar código" en github, puede:
url
. Se verá así:Public
o Private
repoBegin Import
ACTUALIZACIÓN: Recientemente, Github anunció la capacidad de " Importar repositorios con archivos grandes "
http://www.blackdogfoundry.com/blog/moving-repository-from-bitbucket-to-github/
Esto me ayudó a pasar de un proveedor de git a otro. Al final, todos los commits estaban en el git de destino. Simple y directo.
git remote rename origin bitbucket git remote add origin https://github.com/edwardaux/Pipelines.git git push origin master
Una vez que estuve feliz de que el empuje haya tenido éxito en GitHub, pude eliminar el viejo control remoto emitiendo:
git remote rm bitbucket
Tuve el caso de uso inverso de importar un repositorio existente de github a bitbucket.
Bitbucket también ofrece una herramienta de importación . El único paso necesario es agregar URL al repositorio.
Parece que:
Me doy cuenta de que esta es una vieja pregunta. Lo encontré hace varios meses cuando intentaba hacer lo mismo, y me decepcionaron las respuestas dadas. Todos parecían lidiar con la importación de Bitbucket a GitHub un repositorio a la vez, ya sea a través de comandos emitidos a la carta o a través del importador de GitHub.
Tomé el código de un proyecto de GitHub llamado gitter y lo modifiqué para satisfacer mis necesidades.
Puede bifurcar la esencia , o tomar el código desde aquí:
#!/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
Luego, para usar el 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
Existe la importación de un repositorio con GitHub Importer
Si tiene un proyecto alojado en otro sistema de control de versiones como Mercurial, puede importarlo automáticamente a GitHub utilizando la herramienta Importador de GitHub.
Recibirá un correo electrónico cuando el repositorio se haya importado por completo.
En caso de que desee mover su repositorio git local a otro ascendente, también puede hacer esto:
para obtener la URL remota actual:
origen de get-url remoto de git
mostrará algo como: https://bitbucket.com/git/myrepo
configurar un nuevo repositorio remoto:
git remote set-url origin git@github.com: carpeta / myrepo.git
ahora empuje el contenido de la rama actual (desarrollo):
git push: se desarrolla el origen ascendente
Ahora tiene una copia completa de la rama en el nuevo control remoto.
opcionalmente regrese a git-remote original para esta carpeta local:
origen de set-url remoto de git https://bitbucket.com/git/myrepo
Le da el beneficio de que ahora puede obtener su nuevo repositorio git de github en otra carpeta para que tenga dos carpetas locales que apuntan a los diferentes controles remotos, el anterior (bitbucket) y el nuevo disponibles.
brew install jq
Vaya a https://github.com/settings/tokens y cree un token de acceso. Solo necesitamos el alcance "repo".
Guarde el move_me.sh
script en una carpeta de trabajo y edite el archivo según sea necesario.
No te olvides de CHMOD 755
¡Correr! ./move_me.sh
Disfruta el tiempo que has ahorrado.
Clonará los repositorios de BitBucket dentro del directorio donde reside el script (su directorio de trabajo).
Este script no elimina sus repositorios de BitBucket.
Buscar y cambiar el "private": true
a "private": false
continuación.
Consulte la guía del desarrollador , está a un par de ediciones.
Feliz mudanza
#!/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
Estos son los pasos para mover un repositorio privado de Git:
Paso 1: crear el repositorio de Github
Primero, cree un nuevo repositorio privado en Github.com. Es importante mantener el repositorio vacío, por ejemplo, no marque la opción Inicializar este repositorio con un archivo README al crear el repositorio.
Paso 2: mover contenido existente
Luego, necesitamos llenar el repositorio de Github con el contenido de nuestro repositorio de 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
Paso 3: limpiar el repositorio antiguo
Finalmente, debemos asegurarnos de que los desarrolladores no se confundan al tener dos repositorios para el mismo proyecto. Aquí se explica cómo eliminar el repositorio de Bitbucket:
Verifique que el repositorio de Github tenga todo el contenido
Vaya a la interfaz web del antiguo repositorio de Bitbucket
Seleccione la opción de menú Configuración> Eliminar repositorio
Agregue la URL del nuevo repositorio de Github como URL de redireccionamiento
Con eso, el repositorio se instaló por completo en su nuevo hogar en Github. ¡Que todos los desarrolladores lo sepan!
La forma más simple de hacerlo:
git remote rename origin repo_bitbucket
git remote add origin https://github.com/abc/repo.git
git push origin master
Una vez que el envío a GitHub sea exitoso, elimine el control remoto anterior ejecutando:
git remote rm repo_bitbucket