Fusionar rama de desarrollo con master

Tengo dos ramas, a saber, mastery developmenten un repositorio de GitHub. Estoy haciendo todo mi desarrollo en la rama de desarrollo como se muestra.

git branch development
git add *
git commit -m "My initial commit message"
git push -u origin development

Ahora quiero fusionar todos los cambios en la developmentrama en el master. Mi enfoque actual es:

git checkout master 
git merge development
git push -u origin master 

Avíseme si el procedimiento que estoy siguiendo es correcto.

En general, me gusta fusionarme masteren el developmentprimero para que, si hay algún conflicto, pueda resolver en la developmentpropia sucursal y mis masterrestos estén limpios.

(on branch development)$ git merge master
(resolve any merge conflicts if there are any)
git checkout master
git merge development (there won't be any conflicts now)

No hay mucha diferencia en los dos enfoques, pero a veces me he dado cuenta de que no quiero fusionar la rama mastertodavía, después de fusionarlos, o que todavía hay más trabajo por hacer antes de que estos puedan fusionarse , así que tiendo a dejarlo masterintacto hasta el final.

EDITAR: De los comentarios

Si desea realizar un seguimiento de quién hizo la fusión y cuándo, puede usar la --no-ffbandera mientras se fusiona para hacerlo. Esto generalmente es útil solo cuando se fusiona developmentcon el master(último paso), porque es posible que deba fusionarse masteren development(primer paso) varias veces en su flujo de trabajo, y crear un nodo de confirmación para estos puede no ser muy útil.

git merge --no-ff development

Personalmente, mi enfoque es similar al tuyo, con algunas ramas más y algunos aplastamientos de confirmaciones cuando vuelven a dominar.

A uno de mis compañeros de trabajo no le gusta tener que cambiar tanto de rama y se queda en la rama de desarrollo con algo similar a lo siguiente, todo ejecutado desde la rama de desarrollo.

git fetch origin master

git merge master

git push origin development:master

La primera línea se asegura de que tenga todos los commits ascendentes que se hayan realizado para dominar desde la última vez que actualizó su repositorio local.

El segundo extrae esos cambios (si los hay) del maestro al desarrollo

El tercero empuja la rama de desarrollo (ahora completamente fusionada con master) hasta origin / master.

Puede que su flujo de trabajo básico esté un poco mal, pero esa es la esencia principal.

Explicación desde abajo para los que vinieron aquí sin ningún conocimiento de ramas.

La lógica básica de desarrollo de la rama maestra es: Usted trabaja solo en otras ramas y usa la maestra solo para fusionar otras ramas.

Comienza a crear una nueva sucursal de esta manera:

1) Clone el repositorio en su directorio local (o cree un nuevo repositorio):

$ cd /var/www
$ git clone [email protected]:user_name/repository_name.git

2) Crear una nueva sucursal. Contendrá los últimos archivos de su repositorio de sucursal maestra

$ git branch new_branch

3) Cambia tu rama git actual a new_branch

$ git checkout new_branch

4) Hacer codificación, confirmaciones, como de costumbre ...

$ git add .
$ git commit -m “Initial commit”
$ git push (pushes commits only to “new_branch”)

5) Cuando finalice el trabajo en esta rama, combine con la rama "maestra":

$ git merge master
$ git checkout master (goes to master branch)
$ git merge development (merges files in localhost. Master shouldn’t have any  commits ahead, otherwise there will be a need for pull and merging code by hands!)
$ git push (pushes all “new_branch” commits to both branches - “master” and “new_branch”)

Actualización: recomiendo usar GitKraken para esto para ver el árbol visual de cambios y ver mejor toda la lógica y confirmaciones.

Sería genial si puedes usar el flujo de trabajo de Git Flow . Se puede fusionar desarrollar rama en maestro fácilmente.

Lo que quieres hacer es seguir las instrucciones de git-flow mencionadas aquí:

PASOS:

• configurar el proyecto git-flow
• crear ramas y fusionar todo para desarrollar
• ejecuta el comando git flow release start <version_number>
• luego proporcione un mensaje significativo para el lanzamiento
• ejecuta el comando git flow release finish <version_number>
• fusionará todo en maestro y cambiará la rama a maestro .
• ejecute el comando git pushpara publicar los cambios en el maestro remoto .

Para obtener más información, visite la página: http://danielkummer.github.io/git-flow-cheatsheet/

1. //pull the latest changes of current development branch if any        
git pull (current development branch)

2. //switch to master branch
git checkout master 

3. //pull all the changes if any
git pull

4. //Now merge development into master    
git merge development

5. //push the master branch
git push origin master

Sí, esto es correcto, pero parece un flujo de trabajo muy básico, donde solo está almacenando los cambios antes de que estén listos para la integración. Debería buscar flujos de trabajo más avanzados que git admita. Puede que te guste el enfoque de rama temática , que le permite trabajar en múltiples funciones en paralelo, o el enfoque de graduación que extiende un poco su flujo de trabajo actual.

Si está en Mac o Ubuntu, vaya a la carpeta de trabajo de la sucursal. En la terminal

supongamos que harisdev es el nombre de la sucursal.

git checkout master

si hay archivos no rastreados o no confirmados, recibirá un error y deberá confirmar o eliminar todos los archivos no rastreados o no confirmados.

git merge harisdev 

git push origin master

Un último comando para eliminar la rama.

$ git branch -d harisdev

Paso 1

Cree y cambie a una nueva rama "dev", donde sus archivos git locales estén sincronizados con el remoto pero la rama "dev" aún no existe.

git branch dev # create
git checkout dev # switch
# No need to git add or git commit, the current
# branch's files will be cloned to the new branch by-default.
git push --set-upstream origin dev # push the "dev" branch to the remote.

Paso 2

Realice los cambios en la rama "dev" (su actual si sigue el paso 1), confirme y empújelos a la rama remota "dev".

git add .
git commit -S -m "my first commit to the dev branch" # remove the -S if you're not "secure", secure = when you already setup crypto private and public keys (i.e "verified" green sign in github)
git push -u origin dev # push the changes to the remote, -u origin dev is optional but good to use.

Paso 3

Combina tu rama "dev" en el "maestro".

git checkout dev # switch to "dev" branch if you're not already.
git merge master # optionally, this command is being used to resolve any conflicts if you pushed any changes to your "master" but "dev" doesn't have that commit.
git checkout master # switch to "master", which is the branch you want to be merged.
git merge --no-ff dev # merge the "dev" branch into the "master" one.

Así es como lo hago habitualmente. Primero, asegúrese de estar listo para fusionar sus cambios en master.

1. Compruebe si el desarrollo está actualizado con los últimos cambios desde su servidor remoto con un git fetch
2. Una vez que se completa la búsqueda git checkout master.
3. Asegúrese de que la rama maestra tenga las últimas actualizaciones ejecutando git pull
4. Una vez que se hayan completado los preparativos, puede comenzar la fusión con git merge development
5. Empuje los cambios con git push -u origin mastery ya está.

Puede encontrar más información sobre la fusión de git en el artículo.

1) En el desarrollo de la sucursal, verifique el estado de git usando el siguiente comando:

git status

No debe haber código no confirmado. Si es así, inserte su código en la rama Desarrollo:

git add *

git commit -m "My initial commit message"

git push origin Development

2) En la rama Desarrollo, ejecute los siguientes dos comandos:

git branch -f master HEAD

git push -f origin master

Empujará su código de sucursal de Desarrollo a la sucursal maestra.

Basado en @Sailesh y @DavidCulp:

(on branch development)
$ git fetch origin master
$ git merge FETCH_HEAD
(resolve any merge conflicts if there are any)
$ git checkout master
$ git merge --no-ff development (there won't be any conflicts now)

El primer comando se asegurará de que todas las confirmaciones ascendentes se realicen en el maestro remoto, con una respuesta de Sailesh que no sucedería.

El segundo realizará una fusión y creará conflictos que luego podrá resolver.

Después de hacerlo, finalmente puede finalizar la compra de master para cambiar a master.

Luego, fusiona la rama de desarrollo con el maestro local. El indicador no-ff creará un nodo de confirmación en maestro para que se pueda rastrear toda la fusión.

Después de eso, puede comprometerse y empujar su fusión.

Este procedimiento asegurará que haya un compromiso de fusión de desarrollo a maestro que las personas puedan ver, luego, si miran la rama de desarrollo, pueden ver los compromisos individuales que ha realizado a esa rama durante su desarrollo.

Opcionalmente, puede modificar su confirmación de fusión antes de presionarla, si desea agregar un resumen de lo que se hizo en la rama de desarrollo.

EDITAR: mi respuesta original sugirió una git merge masterque no hizo nada, es mejor hacerlo git merge FETCH_HEADdespués de buscar el origen / maestro

Una vez que 'pagas' la rama de desarrollo, ...

 git add .
 git commit -m "first commit"
 git push origin dev
 git merge master

 git checkout master 
 git merge dev
 git push origin master 

Si está utilizando gerrit, los siguientes comandos funcionan perfectamente.

git checkout master
git merge --no-ff development

Puede guardar con el mensaje de confirmación predeterminado. Asegúrese de que se haya generado el ID de cambio. Puede usar el siguiente comando para asegurarse.

git commit --amend

Luego presione con el siguiente comando.

git push origin HEAD:refs/for/refs/heads/master

Puede encontrar un mensaje de error como el siguiente.

! [remote rejected] HEAD -> refs/for/refs/heads/master (you are not allowed to upload merges)

Para resolver esto, el administrador del proyecto gerrit tiene que crear otra referencia en gerrit llamada 'refs / for / refs / heads / master' o 'refs / for / refs / heads / *' (que cubrirá todas las ramas en el futuro). A continuación, otorgue el permiso 'Push Merge Commit' a esta referencia y el permiso 'Enviar' si es necesario para enviar el GCR.

Ahora, intente nuevamente el comando push anterior, y debería funcionar.

Créditos

https://github.com/ReviewAssistant/reviewassistant/wiki/Merging-branches-in-Gerrit

https://stackoverflow.com/a/21199818/3877642

Creo que la solución más fácil sería

git checkout master
git remote update
git merge origin/Develop -X theirs
git commit -m commit -m "New release"
git push --recurse-submodules=check --progress "origin" refs/heads/Master

Esto también conserva el historial de todas las ramas en uso.

1. //push the latest changes of current development branch if any        
git push (current development branch)

2. //switch to master branch
git checkout master 

3. //pull all the changes if any from (current development branch)
git pull origin (current development branch)

4. //Now merge development into master    
git merge development

5. //push the master branch
git push origin master

Error
To https://github.com/rajputankit22/todos-posts.git
 ! [rejected]        master -> master (fetch first)
error: failed to push some refs to 'https://github.com/rajputankit22/todos-posts.git'
hint: Updates were rejected because the remote contains work that you do
hint: not have locally. This is usually caused by another repository pushing
hint: to the same ref. You may want to first integrate the remote changes
hint: (e.g., 'git pull ...') before pushing again.
hint: See the 'Note about fast-forwards' in 'git push --help' for details.

Then Use 
5. //push the master branch forcefully
git push -f origin master