Mesclar ramo de desenvolvimento com mestre

Eu tenho dois ramos, a saber, mastere developmentem um repositório do GitHub. Estou fazendo todo o meu desenvolvimento no ramo de desenvolvimento, como mostrado.

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

Agora eu quero mesclar todas as alterações no developmentramo no master. Minha abordagem atual é:

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

Informe-me se o procedimento que estou seguindo está correto.

Geralmente, gosto de mesclar mastero developmentprimeiro para que, se houver algum conflito, eu possa resolver no developmentpróprio ramo e meus masterrestos mortais estejam limpos.

(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)

Não há muita diferença nas duas abordagens, mas às vezes notei que ainda não quero mesclar a ramificação masterdepois de mesclá-las ou que ainda há mais trabalho a ser feito antes que elas possam ser mescladas , então eu tendem a deixar masterintocadas até o material final.

EDIT: Dos comentários

Se você quiser acompanhar quem fez a mesclagem e quando, poderá usar o --no-ffsinalizador durante a mesclagem para fazer isso. Geralmente, isso é útil apenas ao mesclar developmentna master(última etapa), pois pode ser necessário mesclar masterna development(primeira etapa) várias vezes no seu fluxo de trabalho, e criar um nó de confirmação para elas pode não ser muito útil.

git merge --no-ff development

Pessoalmente, minha abordagem é semelhante à sua, com mais alguns ramos e algumas abalos de commits quando eles voltam ao domínio.

Um dos meus colegas de trabalho não gosta muito de mudar de ramificação e permanece no ramo de desenvolvimento com algo semelhante ao seguinte, todos executados no ramo de desenvolvimento.

git fetch origin master

git merge master

git push origin development:master

A primeira linha garante que ele tenha quaisquer confirmações upstream que foram feitas para dominar desde a última vez em que atualizou seu repositório local.

O segundo puxa essas mudanças (se houver) do mestre para o desenvolvimento

O terceiro empurra o ramo de desenvolvimento (agora totalmente mesclado com o mestre) até a origem / mestre.

Eu posso estar com o seu fluxo de trabalho básico um pouco errado, mas essa é a essência principal.

Explicação de baixo para aqueles que vieram aqui sem nenhum conhecimento de ramos.

A lógica básica de desenvolvimento de ramificação principal é: Você trabalha apenas em outras ramificações e usa apenas mestre para mesclar outras ramificações.

Você começa a criar uma nova ramificação desta maneira:

1) Clone o repositório no seu diretório local (ou crie um novo repositório):

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

2) Crie uma nova ramificação. Ele conterá os arquivos mais recentes do seu repositório de ramificação principal

$ git branch new_branch

3) Altere sua ramificação atual do git para new_branch

$ git checkout new_branch

4) Faça codificação, confirma, como sempre ...

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

5) Quando o trabalho for concluído neste ramo, mesclar com o ramo "mestre":

$ 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”)

Atualização: eu recomendo usar o GitKraken para isso para ver a árvore visual das alterações e ver melhor toda a lógica e confirmações.

Seria ótimo se você pudesse usar o fluxo de trabalho do Git Flow . Pode mesclar desenvolver ramificações em master facilmente.

O que você quer fazer é seguir as instruções do git-flow mencionadas aqui:

PASSOS:

• configurar o projeto git-flow
• criar filiais e mesclar tudo para desenvolver
• execute o comando git flow release start <version_number>
• depois forneça uma mensagem significativa para a liberação
• execute o comando git flow release finish <version_number>
• ele mesclará tudo no mestre e mudará o ramo para mestre .
• execute o comando git pushpara publicar as alterações no mestre remoto .

Para mais informações, visite a 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

Sim, isso está correto, mas parece um fluxo de trabalho muito básico, no qual você apenas armazena as alterações antes que elas estejam prontas para a integração. Você deve olhar para fluxos de trabalho mais avançados que o git suporta. Você pode gostar da abordagem de ramificação de tópicos , que permite trabalhar em vários recursos em paralelo, ou a abordagem de graduação que amplia um pouco o fluxo de trabalho atual.

Se você estiver no Mac ou Ubuntu, vá para a pasta de trabalho da filial. No terminal

suponha que harisdev é o nome da filial.

git checkout master

se houver arquivos não rastreados ou não confirmados, você receberá um erro e precisará confirmar ou excluir todos os arquivos não rastreados ou não confirmados.

git merge harisdev 

git push origin master

Um último comando para excluir a ramificação.

$ git branch -d harisdev

Passo 1

Crie e alterne para uma nova ramificação "dev", na qual seus arquivos git locais estão sincronizados com o controle remoto, mas a ramificação "dev" ainda não 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.

Passo 2

Faça as alterações no ramo "dev" (atual, se você seguir a etapa 1), confirme e envie-as para o ramo "dev" remoto.

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.

etapa 3

Mesclar seu ramo "dev" no "mestre".

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.

É assim que eu costumo fazer. Primeiro, verifique se você está pronto para mesclar suas alterações no mestre.

1. Verifique se o desenvolvimento está atualizado com as alterações mais recentes do servidor remoto com um git fetch
2. Depois que a busca estiver concluída git checkout master.
3. Certifique-se de que a ramificação principal tenha as atualizações mais recentes executando git pull
4. Após a conclusão dos preparativos, você pode iniciar a mesclagem com git merge development
5. Empurre as alterações com git push -u origin mastere pronto.

Você pode descobrir mais sobre a fusão do git no artigo.

1) No desenvolvimento da filial, verifique o status do git usando o seguinte comando:

git status

Não deve haver código não confirmado. Se estiver, envie seu código no ramo Desenvolvimento:

git add *

git commit -m "My initial commit message"

git push origin Development

2) Na ramificação Desenvolvimento, execute os seguintes dois comandos:

git branch -f master HEAD

git push -f origin master

Ele enviará o código da ramificação de Desenvolvimento para a ramificação principal.

Baseado em @Sailesh e @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)

O primeiro comando garantirá que você tenha todas as confirmações upstream feitas no mestre remoto, com a resposta Sailesh que não aconteceria.

O segundo fará uma mesclagem e criará conflitos que você poderá resolver.

Depois de fazer isso, você pode finalmente fazer o checkout do master para mudar para o master.

Em seguida, você mescla a ramificação de desenvolvimento no mestre local. O sinalizador no-ff criará um nó de confirmação no mestre para que toda a mesclagem seja rastreável.

Depois disso, você pode confirmar e empurrar sua mesclagem.

Este procedimento garantirá que haja uma consolidação de mesclagem do desenvolvimento para dominar o que as pessoas podem ver; se elas forem olhar para o ramo de desenvolvimento, poderão ver o comprometimento individual que você fez nesse ramo durante o desenvolvimento.

Opcionalmente, você pode alterar seu commit de mesclagem antes de enviá-lo, se desejar adicionar um resumo do que foi feito no ramo de desenvolvimento.

EDIT: minha resposta original sugeriu um git merge masterque não fez nada, é melhor fazer git merge FETCH_HEADdepois de buscar a origem / mestre

Depois de fazer o checkout do ramo de desenvolvimento, você ...

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

 git checkout master 
 git merge dev
 git push origin master 

Se você estiver usando o gerrit, os seguintes comandos funcionarão perfeitamente.

git checkout master
git merge --no-ff development

Você pode salvar com a mensagem de confirmação padrão. Verifique se o ID de alteração foi gerado. Você pode usar o seguinte comando para garantir.

git commit --amend

Em seguida, pressione com o seguinte comando.

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

Você pode encontrar uma mensagem de erro como a abaixo.

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

Para resolver isso, o administrador do projeto gerrit deve criar outra referência no gerrit chamada 'refs / for / refs / heads / master' ou 'refs / for / refs / heads / *' (que abrangerá todas as ramificações no futuro). Em seguida, conceda a permissão 'Push Merge Commit' a essa referência e a permissão 'Submit', se necessário, para enviar o GCR.

Agora, tente o comando push acima novamente e ele deve funcionar.

Créditos:

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

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

Eu acho que a solução mais fácil seria

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

Isso também preserva o histórico de todos os ramos em 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