Oefening: samenwerken met behulp van een gedeelde opslagplaats

10 minuten

Het rechtstreeks ophalen vanuit de opslagplaats van iemand anders werkt, mits u beide zich in hetzelfde netwerk bevindt. Maar het is een onhandig proces en de meeste medewerkers bevinden zich niet in hetzelfde netwerk. Het is beter om een centrale opslagplaats in te stellen waaruit alle medewerkers kunnen pushen en ophalen.

Wanneer u uw ontwikkelaarvriend Bob vertelt over uw project en Bob vraagt om deel te nemen, is dat precies wat u besluit te doen: stel een centrale opslagplaats in, die ook wel een lege opslagplaats wordt genoemd.

Een lege opslagplaats maken

Wat u nodig hebt, is een opslagplaats die geen werkstructuur heeft. Een lege opslagplaats heeft verschillende voordelen ten opzichte van een werkende boomstructuur:

Zonder een werkende boom kan iedereen wijzigingen pushen zonder dat u zich zorgen hoeft te maken over welke vertakking is uitgecheckt.
Git kan eenvoudig detecteren wanneer een andere gebruiker wijzigingen heeft gepusht die mogelijk conflicteren met die van u.
Een gedeelde opslagplaats kan worden geschaald naar een willekeurig aantal ontwikkelaars. Met een lege opslagplaats moet u alleen weten over de gedeelde opslagplaats en niet over alle andere medewerkers van wie u mogelijk moet ophalen.
Door de gedeelde opslagplaats op een server te plaatsen waartoe u allemaal toegang hebt, hoeft u zich geen zorgen te maken over firewalls en machtigingen.
U hebt geen afzonderlijke accounts op de server nodig omdat Git bijhoudt wie elke doorvoering heeft gemaakt. (GitHub heeft miljoenen gebruikers die allemaal het git account delen. Iedereen gebruikt het cryptografische SSH-netwerkprotocol (Secure Shell) en gebruikers worden onderscheiden door hun openbare sleutels.)

Het maken van een lege opslagplaats voor delen is eenvoudig:

Maak een nieuwe map met de naam Shared.git op hetzelfde niveau als de directory's Alice en Cats voor het opslaan van de lege opslagplaats:
```
cd ..
mkdir Shared.git
cd Shared.git
```
De mapnaam is niet belangrijk, maar in deze oefeningen verwijzen we ernaar als de map Shared.git of alleen de gedeelde map.

De naamgeving van de map Shared.git volgt de lange traditie van het toewijzen van lege opslagplaatsen een naam die eindigt .git om ze te onderscheiden van werkstructuren. Het is een conventie, maar geen vereiste.
Gebruik nu de volgende opdracht om een lege opslagplaats te maken in de gedeelde map:
```
git init --bare
```
Wanneer een opslagplaats nog steeds niet beschikbaar is, kan de git checkout opdracht niet worden gebruikt om de naam van de standaardvertakking in te stellen. Als u deze taak wilt uitvoeren, kunt u de HEAD vertakking wijzigen zodat deze naar een andere vertakking verwijst. In dit geval is dit de main vertakking:
```
git symbolic-ref HEAD refs/heads/main
```
De volgende stap is het ophalen van de inhoud van uw opslagplaats in de gedeelde opslagplaats. Gebruik deze opdrachten om terug te keren naar de projectmap waar uw opslagplaats is opgeslagen, een origin externe locatie in te stellen en een eerste push uit te voeren:
```
cd ../Cats
git remote add origin ../Shared.git
git push origin main
```

Controleer de uitvoer. De uitvoer moet aangeven dat de uitvoer is geslaagd:

Counting objects: 12, done.
Delta compression using up to 2 threads.
Compressing objects: 100% (8/8), done.
Writing objects: 100% (12/12), 1.07 KiB | 0 bytes/s, done.
Total 12 (delta 1), reused 0 (delta 0)
To ../Shared.git
 * [new branch]      main -> main

U wilt push en pull wilt de main vertakking van origin standaard gebruiken, alsof u uw opslagplaats hebt gemaakt door deze in de eerste plaats te klonen. Maar eerst moet u Git vertellen welke vertakking moet worden bijgehouden.
```
git branch --set-upstream-to origin/main
```
Controleer op deze uitvoer:
```
Branch main set up to track remote branch main from origin.
```
Git zou klagen als u deze opdracht vóór de eerste push probeert uit te voeren, omdat de nieuwe opslagplaats geen vertakkingen had. Git kan geen vertakking volgen die niet bestaat. Alles wat Git onder de motorkap doet, zoekt naar .git/refs/remotes/origin een bestand met de naam trunk.

Instellen voor deelnemers

De volgende stap is dat Bob de lege opslagplaats kloont en dat Alice vervolgens de oorsprong in de opslagplaats instelt om de gedeelde opslagplaats te richten op pushes en pulls.

Maak een map met de naam Bob die zich op hetzelfde niveau van de projectmap bevindt en ga vervolgens naar de map Bob :
```
cd ..
mkdir Bob
cd Bob
```
Kloon nu de gedeelde opslagplaats (zorg ervoor dat u de punt aan het einde van de opdracht opneemt):
```
git clone ../Shared.git .
```
Momenteel is de opslagplaats van Alice geconfigureerd voor pushen naar en ophalen uit hun eigen opslagplaats. Gebruik de volgende opdrachten om te wijzigen in de map Alice en deze te wijzigen zodat deze origin verwijst naar de gedeelde opslagplaats:
```
cd ../Alice
git remote set-url origin ../Shared.git
```

Beginnen met samenwerken

Nu Bob is ingesteld om op de website te werken, besluit Bob een voettekst onder aan de pagina toe te voegen. Laten we eens doen alsof we Bob en Alice zijn om zo de basisbeginselen van samenwerking te leren.

Ga eerst naar de map Bob en werk als Bob:

cd ../Bob
git config user.name Bob
git config user.email bob@contoso.com

Open index. html en vervang het element <hr> door deze regel (te vinden aan het eind van het element <body>):
```
<footer><hr>Copyright (c) 2021 Contoso Cats</footer>
```
Sla het bestand vervolgens op en sluit de editor.

De wijzigingen doorvoeren en naar de externe 'origin' pushen:

git commit -a -m "Put a footer at the bottom of the page"
git push

Controleer de uitvoer. Als u een waarschuwing ziet zoals in het volgende voorbeeld, hoeft u zich geen zorgen te maken. Met deze waarschuwing kunnen gebruikers alleen op de hoogte zijn van een wijziging in het standaardgedrag van Git. Als u er zeker van wilt zijn dat u deze waarschuwing niet meer ziet, kunt u uitvoeren git config --global push.default simple.

warning: push.default is unset; its implicit value has changed in
Git 2.0 from 'matching' to 'simple'. To squelch this message
and maintain the traditional behavior, use:

  git config --global push.default matching

To squelch this message and adopt the new behavior now, use:

  git config --global push.default simple

When push.default is set to 'matching', git will push local branches
to the remote branches that already exist with the same name.

Since Git 2.0, Git defaults to the more conservative 'simple'
behavior, which only pushes the current branch to the corresponding
remote branch that 'git pull' uses to update the current branch.

See 'git help config' and search for 'push.default' for further information.
(the 'simple' mode was introduced in Git 1.7.11. Use the similar mode
'current' instead of 'simple' if you sometimes use older versions of Git)

Terwijl Bob de site bewerkt, doet Alice dat ook. Alice besluit een navigatiebalk toe te voegen aan de pagina. Voor deze toevoeging moet Alice twee bestanden wijzigen: index.html en site.css. Ga eerst terug naar de map Alice :
```
cd ../Alice
```
Open nu index.html en voeg direct na de <body> tag op regel 8 de volgende regel in:
```
<nav><a href="./index.html">home</a></nav>
```
Sla het bestand vervolgens op en sluit de editor.
Open vervolgens site.css in de CSS-map en voeg de volgende regel onderaan toe:
```
nav { background-color: #C0D8DF; }
```
Sla het bestand op en sluit de editor.
We gaan ervan uit dat Alice een e-mail van Bob ontvangt met de mededeling dat Bob wijzigingen heeft aangebracht aan de site. Alice besluit de wijzigingen van Bob op te halen (pull) voordat ze haar eigen doorvoert. (Als Alice hun wijzigingen al had doorgevoerd, zouden ze een ander probleem hebben, wat in een andere module wordt besproken.) Alice voert deze opdracht uit:
```
git pull
```

Controleer de uitvoer. Uit de uitvoer blijkt dat Git een probleem heeft voorkomen:

remote: Counting objects: 3, done.
remote: Compressing objects: 100% (3/3), done.
remote: Total 3 (delta 2), reused 0 (delta 0)
Unpacking objects: 100% (3/3), done.
From ../Shared
   843d142..2cf6cbf  main     -> origin/main
Updating 843d142..2cf6cbf
error: Your local changes to the following files would be overwritten by merge:
        index.html
Please commit your changes or stash them before you can merge.
Aborting

Git waarschuwt dat de pull de versie van Alice van index.html overschrijft en dat de wijzigingen verloren gaan. Dat komt omdat Bob index.htmlook heeft gewijzigd. Als Alice index.html niet had gewijzigd, zou Git de samenvoeging hebben doorgevoerd.

Gebruik een git diff-opdracht om te zien welke wijzigingen Bob heeft aangebracht in index.html:
```
git diff origin -- index.html
```
Controleer de uitvoer. Uit de uitvoer blijkt dat de wijzigingen van Alice en de wijzigingen van Bob niet overlappen. Nu kan Alice hun wijzigingen stashen .

git stash slaat de status van de werkstructuur en index op door een aantal tijdelijke doorvoeringen te maken. Denk aan de opslag als een manier om uw huidige werk op te slaan terwijl u iets anders doet, zonder dat u een 'echte' doorvoering uitvoert of de geschiedenis van uw opslagplaats beïnvloedt.

In werkelijkheid moet Alice hun wijzigingen hebben opgeslagen of doorgevoerd voordat ze probeerden op te halen. Een pull van een 'dirty' werkstructuur is riskant, omdat het dingen kan doen die u niet eenvoudig kunt herstellen.

Gebruik de volgende opdracht om de wijzigingen van Alice op te slaan:
```
git stash
```

Controleer de uitvoer. Dit moet er als volgt uitzien:

Saved working directory and index state WIP on main: 95bbc3b Change background color to light blue
HEAD is now at 95bbc3b Change background color to light blue

Nu is het veilig voor Alice om te trekken, waarna ze de stash kunnen "pop", die is georganiseerd als een stapel. (In feite git stash is afkorting voor git stash push. Het is veel vergelijkbaar met de stapel waar u facturen hebt geplaatst die u nog niet hebt betaald.) Voer deze opdrachten uit:
```
git pull
git stash pop
```
Door een pop-bewerking uit te voeren op de opslag, worden de wijzigingen samengevoegd. Als wijzigingen elkaar overlappen, kan er een conflict zijn. U kunt leren hoe u deze situaties kunt oplossen in een geavanceerdere Git-module van Microsoft Learn.

Controleer de uitvoer. Alice zou deze uitvoer moeten zien, zodat ze kunnen zien dat de samenvoeging is geslaagd en dat hun wijzigingen terug zijn, maar nog niet zijn klaargezet voor doorvoer:

Auto-merging index.html
On branch main
Your branch is up-to-date with 'origin/main'.
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working directory)

        modified:   CSS/site.css
        modified:   index.html

no changes added to commit (use "git add" and/or "git commit -a")
Dropped refs/stash@{0} (0cfb7b75d56611d9fc6a6ab660a51f5582b8d9c5)

Op dit moment kan Alice blijven werken of alleen wijzigingen doorvoeren en pushen. We gaan als Anne een andere wijziging aanbrengen door voetteksten toe te wijzen die dezelfde stijl hebben als navigatiebalken.

Open site.css in de CSS-map en vervang de derde regel(de regel die elementen aan het stijlen <nav> is) door deze gedeelde CSS-regel. Sla uw wijzigingen vervolgens op zoals gebruikelijk en sluit de editor.
```
nav, footer { background-color: #C0D8DF; }
```
Voer nu de wijzigingen door en push ze naar de gedeelde opslagplaats:
```
git commit -a -m "Stylize the nav bar"
git push
```
De bijgewerkte site bevindt zich nu in de gedeelde opslagplaats.
Ga nu terug naar de projectmap en voer een pull-bewerking uit:
```
cd ../Cats
git pull
```

Open index.html (de map in de projectmap) om te bevestigen dat de wijzigingen die door Bob en Alice zijn aangebracht, aanwezig zijn in uw lokale opslagplaats. Controleer of index.html de meest recente code heeft:

<!DOCTYPE html>
<html>
  <head>
    <meta charset='UTF-8'>
    <title>Our Feline Friends</title>
    <link rel="stylesheet" href="CSS/site.css">
  </head>
  <body>
    <nav><a href="./index.html">home</a></nav>
    <h1>Our Feline Friends</h1>
    <p>Eventually we will put cat pictures here.</p>
    <footer><hr>Copyright (c) 2021 Contoso Cats</footer>
  </body>
</html>

Op dit moment worden uw opslagplaats en de opslagplaats van Alice gesynchroniseerd, maar de opslagplaats van Bob is dat niet. Rond het af door Bob ook te laten bijwerken:
```
cd ../Bob
git pull
```

Alle drie de opslagplaatsen zijn nu op elkaar afgestemd. De gedeelde opslagplaats is de enige bron van waarheid voor alle gebruikers en alle pushes en pulls worden omgeleid naar de gedeelde opslagplaats.

Als u nieuwsgierig bent naar hoe de website eruitziet, vindt u hier een preview-versie:

Screenshot of the rendered Cats website.

Als u wilt, kunt u uw bestanden downloaden om ze lokaal te bekijken:

Zip de map Katten :
```
cd ..
zip -r Cats.zip Cats
```
Download het zip-bestand:
```
download Cats.zip
```
Pak het bestand nu uit op uw lokale computer en open index.hml om zelf te zien.

Doorgaan

Een lege opslagplaats maken

Instellen voor deelnemers

Beginnen met samenwerken

Feedback