Unire il ramo di sviluppo con il master

Ho due rami in particolare mastere developmentin un repository GitHub. Sto facendo tutto il mio sviluppo nel ramo dello sviluppo, come mostrato.

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

Ora voglio unire tutte le modifiche sul developmentramo in master. Il mio approccio attuale è:

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

Per favore fatemi sapere se la procedura che sto seguendo è corretta.

In genere mi piace unirmi masteral developmentprimo in modo che se ci sono conflitti, posso risolverlo nel developmentramo stesso e i miei masterresti puliti.

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

Non c'è molta differenza nei due approcci, ma a volte ho notato che non voglio ancora unire il ramo master, dopo averli uniti, o che c'è ancora molto lavoro da fare prima che questi possano essere uniti , quindi tendo a lasciare masterintatto fino all'ultimo materiale.

EDIT: dai commenti

Se vuoi tenere traccia di chi ha fatto l'unione e quando, puoi usare --no-ffflag durante l'unione per farlo. Questo è generalmente utile solo quando si unisce developmental master(ultimo passaggio), perché potrebbe essere necessario fondersi masterin development(prima fase) più volte nel vostro flusso di lavoro, e la creazione di un commit nodo per questi potrebbe non essere molto utile.

git merge --no-ff development

Personalmente, il mio approccio è simile al tuo, con qualche altro ramo e qualche schiacciamento di commit quando tornano al master.

A uno dei miei colleghi non piace dover cambiare molto ramo e rimane sul ramo di sviluppo con qualcosa di simile al seguente tutto eseguito dal ramo di sviluppo.

git fetch origin master

git merge master

git push origin development:master

La prima riga si assicura che abbia tutti gli commit a monte che sono stati fatti da padroneggiare dall'ultima volta che ha aggiornato il suo repository locale.

Il secondo tira quei cambiamenti (se presenti) dal master allo sviluppo

Il terzo spinge il ramo di sviluppo (ora completamente unito al master) fino a origin / master.

Potrei avere un po 'sbagliato il suo flusso di lavoro di base, ma questa è la sostanza principale.

Spiegazione dal basso per coloro che sono venuti qui senza alcuna conoscenza dei rami.

La logica di sviluppo di base dei rami master è: lavori solo su altri rami e usi master solo per unire altri rami.

Inizi a creare un nuovo ramo in questo modo:

1) Clonare il repository nella directory locale (o creare un nuovo repository):

$ cd /var/www
$ git clone git@bitbucket.org:user_name/repository_name.git

2) Crea un nuovo ramo. Conterrà gli ultimi file del repository della diramazione principale

$ git branch new_branch

3) Cambia il tuo ramo git corrente in new_branch

$ git checkout new_branch

4) Codifica, si impegna, come al solito ...

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

5) Al termine del lavoro su questo ramo, unire con il ramo "master":

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

Aggiornamento: consiglio vivamente di usare GitKraken per questo per vedere l'albero visivo delle modifiche e vedere meglio tutta la logica e gli commit.

Sarebbe bello se puoi usare il flusso di lavoro di Git Flow . Può unire facilmente il ramo di sviluppo al master.

Quello che vuoi fare è semplicemente seguire le istruzioni git-flow menzionate qui:

STEPS:

• imposta il progetto git-flow
• creare rami e unire tutto per sviluppare
• eseguire il comando git flow release start <version_number>
• quindi fornire un messaggio significativo per il rilascio
• eseguire il comando git flow release finish <version_number>
• unirà tutto in maestro e cambierà il ramo in master .
• eseguire il comando git pushper pubblicare le modifiche sul telecomando master .

Per ulteriori informazioni, visitare la pagina - 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ì, questo è corretto, ma sembra un flusso di lavoro molto semplice, in cui stai solo memorizzando le modifiche prima che siano pronte per l'integrazione. Dovresti esaminare i flussi di lavoro più avanzati supportati da git. Potresti apprezzare l' approccio branch topic , che ti consente di lavorare su più funzionalità in parallelo, o l' approccio di graduazione che estende un po 'il tuo flusso di lavoro corrente.

Se sei su Mac o Ubuntu, vai alla cartella di lavoro del ramo. Nel terminale

supponiamo che harisdev sia il nome del ramo.

git checkout master

se sono presenti file non tracciati o non impegnati, verrà visualizzato un errore e sarà necessario eseguire il commit o l'eliminazione di tutti i file non tracciati o non impegnati.

git merge harisdev 

git push origin master

Un ultimo comando per eliminare il ramo.

$ git branch -d harisdev

Passo 1

Crea e passa a un nuovo ramo "dev", dove i tuoi file git locali sono sincronizzati con il telecomando ma il ramo "dev" non esiste ancora.

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

Apporta le modifiche al ramo "dev" (il tuo attuale se segui il passaggio 1), esegui il commit e spingile al 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.

Passaggio 3

Unisci il tuo ramo "dev" nel "master".

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.

È così che di solito lo faccio. Innanzitutto, assicurati di essere pronto a unire le tue modifiche in master.

1. Controlla se lo sviluppo è aggiornato con le ultime modifiche dal tuo server remoto con a git fetch
2. Una volta completato il recupero git checkout master .
3. Assicurarsi che il ramo principale abbia gli ultimi aggiornamenti eseguendo git pull
4. Una volta completati i preparativi, puoi iniziare l'unione con git merge development
5. Spingi le modifiche con git push -u origin mastere il gioco è fatto.

Puoi trovare ulteriori informazioni sulla fusione di git nell'articolo.

1) Su Branch Branch, controlla lo stato git usando il seguente comando:

git status

Non ci dovrebbero essere codici non impegnati. In tal caso, inserisci il tuo codice nel ramo Sviluppo:

git add *

git commit -m "My initial commit message"

git push origin Development

2) Nel ramo Sviluppo, esegui due comandi seguenti:

git branch -f master HEAD

git push -f origin master

Spingerà il codice del ramo di sviluppo al ramo principale.

Basato su @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)

Il primo comando assicurerà che tutti i commit a monte siano stati fatti su master remoto, con la risposta di Sailesh che non sarebbe avvenuta.

Il secondo eseguirà un'unione e creerà conflitti che è possibile risolvere.

Dopo averlo fatto, puoi finalmente effettuare il checkout del master per passare al master.

Quindi unisci il ramo di sviluppo al master locale. Il flag no-ff creerà un nodo di commit nel master affinché l'intera unione sia tracciabile.

Dopodiché puoi impegnarti e spingere la tua unione.

Questa procedura assicurerà che ci sia un commit di unione dallo sviluppo al master che le persone possono vedere, quindi se guardano al ramo di sviluppo possono vedere i singoli commit che hai fatto a quel ramo durante il suo sviluppo.

Facoltativamente, è possibile modificare il commit di unione prima di inviarlo, se si desidera aggiungere un riepilogo di ciò che è stato fatto nel ramo di sviluppo.

EDIT: la mia risposta originale mi ha suggerito di git merge masternon fare nulla, è meglio farlo git merge FETCH_HEADdopo aver recuperato l'origine / master

Dopo aver verificato il ramo di sviluppo ...

 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 stai usando gerrit, i seguenti comandi funzionano perfettamente.

git checkout master
git merge --no-ff development

È possibile salvare con il messaggio di commit predefinito. Assicurarsi che l'id di modifica sia stato generato. È possibile utilizzare il seguente comando per assicurarsi.

git commit --amend

Quindi premere con il seguente comando.

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

È possibile che venga visualizzato un messaggio di errore simile al seguente.

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

Per risolvere questo problema, l'amministratore del progetto gerrit deve creare un altro riferimento in gerrit chiamato 'refs / for / refs / heads / master' o 'refs / for / refs / heads / *' (che coprirà tutti i rami in futuro). Quindi concedere l'autorizzazione "Push Merge Commit" a questo riferimento e l'autorizzazione "Invia" se necessario per inviare il GCR.

Ora prova di nuovo il comando push sopra e dovrebbe funzionare.

Crediti:

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

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

Penso che la soluzione più semplice sarebbe

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

Ciò preserva anche la storia di tutti i rami in 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