Jak używać Gita i Dropbox razem? [zamknięte]

Dobrym sposobem na to jest użycie git-remote-dropbox: https://github.com/anishathalye/git-remote-dropbox

Tworzenie własnego repo w Dropbox powoduje wiele problemów. Anish (twórca biblioteki) wyjaśnia to najlepiej :

Główną przyczyną tych problemów jest to, że pulpit Dropbox klient jest przeznaczony do synchronizacji plików, a nie repozytoriów Git. Bez Specjalna obsługa repozytoriów Git, nie zachowuje tego samego Gwarancje jako Git. Operacje na zdalnym repozytorium nie są już wykonywane atomic, i jednoczesnych operacji lub pechowy czas z synchronizacja może spowodować uszkodzenie repozytorium.

Tradycyjne Git remotes uruchamiają kod po stronie serwera, aby to zadziałało właściwie, ale nie możemy tego zrobić.

Rozwiązanie: możliwe jest poprawne rozwiązanie tego problemu. Możliwe jest użycie Git z Dropbox i mają takie same gwarancje bezpieczeństwa i spójności jako tradycyjny Git remote, nawet gdy są wielu użytkowników i współbieżne operacje!

Dla użytkownika jest to tak proste, jak użycie git-remote-dropbox, Git remote helper, który działa jako przezroczysty dwukierunkowy mostek pomiędzy Gitem i Dropbox i zachowuje wszystkie gwarancje tradycyjnego pilota Git. Jest nawet bezpieczny w użyciu z folderami współdzielonymi, dzięki czemu można go używać do współpraca (yay unlimited private repos with unlimited kolaboranci!).

Za pomocą Remote helpera Można używać Dropbox jako Gita zdalne i nadal używać wszystkich zwykłych komend Git, takich jak git clone, git pociągnij, i git push, i wszystko będzie działać zgodnie z oczekiwaniami.

Ta odpowiedź opiera się na doświadczeniu Mercurial , a nie na Git, ale to doświadczenie mówi, że używanie Dropbox w ten sposób wymaga uszkodzonych repozytoriów, jeśli jest szansa, że aktualizujesz to samo repozytorium oparte na Dropbox z różnych maszyn w różnym czasie (Mac, Unix, Windows w moim przypadku).

Nie mam pełnej listy rzeczy, które mogą pójść źle, ale oto konkretny przykład, który mnie ugryzł. Każda maszyna ma swoje własne pojęcie znaków zakończenia linii i jak wielkie / małe litery są obsługiwane w nazwach plików. Dropbox i Git / Mercurial radzą sobie z tym nieco inaczej (nie przypominam sobie dokładnych różnic). Jeśli Dropbox zaktualizuje repozytorium za plecami Git / Mercurial, presto, zepsute repozytorium. Dzieje się to natychmiast i niewidocznie, więc nawet nie wiesz, że Twoje repozytorium jest uszkodzone, dopóki nie spróbujesz czegoś z niego odzyskać.

Po wykopaniu z jednego bałaganu robiąc rzeczy w ten sposób, używam następujący przepis z wielkim sukcesem i żadnych problemów. Po prostu przenieś swoje repozytorium z Dropbox. Używaj Dropbox do wszystkiego innego; dokumentacji, plików JAR, cokolwiek zechcesz. I użyj GitHub (Git) lub Bitbucket (Mercurial) do zarządzania samym repozytorium. Oba są bezpłatne, więc nie dodaje to nic do kosztów, a każde narzędzie odgrywa teraz swoje mocne strony.

Uruchamianie Git / Mercurial na Dropbox nie dodaje nic poza ryzykiem. Nie rób tego.

Nie chciałem umieszczać wszystkich moich projektów w jednym repozytorium Git, ani nie chciałem wchodzić i uruchamiać tego kodu dla każdego projektu, więc zrobiłem skrypt Bash , który zautomatyzuje proces. Możesz go używać w jednym lub wielu katalogach - więc może zrobić kod w tym poście za Ciebie lub może to zrobić w wielu projektach naraz.

#!/bin/sh
# Script by Eli Delventhal
# Creates Git projects for file folders by making the origin Dropbox. You will need to install Dropbox for this to work.

# Not enough parameters, show help.
if [ $# -lt 1 ] ; then

cat<<HELP
projects_to_git.sh -- Takes a project folder and creates a Git repository for it on Dropbox

USAGE:
    ./projects_to_git.sh file1 file2 ..

EXAMPLES:
    ./projects_to_git.sh path/to/MyProjectDir
        Creates a git project called MyProjectDir on Dropbox

    ./projects_to_git.sh path/to/workspace/*
        Creates a git project on Dropbox for every folder contained within the workspace directory, where the project name matches the folder name

HELP
    exit 0
fi

# We have enough parameters, so let's actually do this thing.

START_DIR=$(pwd)

# Make sure we have a connection to Dropbox
cd ~
if [ -s 'Dropbox' ] ; then
    echo "Found Dropbox directory."
    cd Dropbox
    if [ -s 'git' ] ; then
        echo "    Dropbox Git directory found."
    else
        echo "    Dropbox Git directory created."
        mkdir git
    fi
else
    echo "You do not have a Dropbox folder at ~/Dropbox! Install Dropbox. Aborting..."
    exit 0
fi

# Process all directories matching the passed parameters.
echo "Starting processing for all files..."
for PROJ in $*
do
    if [ -d $PROJ ] ; then
        PROJNAME=$(basename $PROJ)
        echo "  Processing $PROJNAME..."

        # Enable Git with this project.
        cd $PROJ
        if [ -s '.git' ] ; then
            echo "    $PROJNAME is already a Git repository, ignoring..."
        else
            echo "    Initializing Git for $PROJNAME..."
            git init -q
            git add .
            git commit -m "Initial creation of project." -q

            # Make the origin Dropbox.

            cd ~/Dropbox/git
            if [ -s $PROJNAME ] ; then
                echo "    Warning! $PROJNAME already exists in Git! Ignoring..."
            else
                echo "    Putting $PROJNAME project on Dropbox..."
                mkdir $PROJNAME
                cd $PROJNAME
                git init -q --bare
            fi

            # Link the project to the origin
            echo "    Copying local $PROJNAME to Dropbox..."
            cd $PROJ
            git remote add origin "~/Dropbox/git/$PROJNAME"
            git push -q origin master
            git branch --set-upstream master origin/master
        fi
    fi
done

echo "Done processing all files."
cd $START_DIR

W odniesieniu do małych zespołów korzystających z Dropbox:

Jeśli każdy programista ma swoje własne repozytorium do zapisu w Dropbox, które jest tylko dla innych programistów, ułatwia to udostępnianie kodu bez ryzyka korupcji!

Następnie, jeśli chcesz scentralizowanej 'mainline' , możesz mieć jeden programista zarządzać wszystkimi popychaniami do niego z własnego repo.

Jest teraz 2015, a trzy dni temu zostało stworzone nowe narzędzie oparte na Dropbox API v2, aby bezpiecznie używać Gita na Dropbox. Działa przeciwko API, a nie za pomocą programu desktop client i poprawnie obsługuje wiele jednoczesnych wypychań do repozytorium hostowanego w folderze udostępnionym.

Po skonfigurowaniu, pozwala na skonfigurowanie git remote dokładnie tak, jak każdy inny Git remote.

git clone "dropbox::/path/to/repo"
git remote add origin "dropbox::/path/to/repo"

Nie sądzę, aby korzystanie z Git i Dropbox było dobrym rozwiązaniem... Pomyśl tylko o cechach obu:

Git:

• pozwala na posiadanie centralnego repozytorium
• pozwala na posiadanie własnego repozytorium z własnymi zmianami
• umożliwia wysyłanie i odbieranie zmian z centralnego repozytorium
• pozwala wielu osobom na zmianę tych samych plików i łączy je lub prosi o połączenie, jeśli nie może tego zrobić
• ma klientów internetowych i desktopowych, aby umożliwić dostęp do centralnego repozytorium

Dropbox:

Przechowuje wszystko w centralnym repozytorium]}
• pozwala na posiadanie własnych wersji plików na serwerze
• wymusza wysyłanie i odbieranie zmian z centralnego repozytorium
• Jeśli Wiele osób zmieni te same pliki, pierwszy zatwierdzony plik jest zastępowany późniejszymi zatwierdzeniami i nie następuje scalanie, co jest kłopotliwe (i zdecydowanie jego największą wadą)
• ma WWW i pulpit klientów, aby umożliwić dostęp do centralnego repozytorium.

A jeśli martwisz się udostępnianiem niektórych plików, dlaczego ich nie zaszyfrujesz? A potem możesz uzyskać największą zaletę Dropbox dla Git, czyli mieć publiczne i prywatne pliki...

Używam Mercurial ( lub Git) + TrueCrypt + Dropbox dla zaszyfrowanych zdalnych kopii zapasowych.

Najfajniejsze jest to, że Dropbox nie synchronizuje całego kontenera TrueCrypt, jeśli zmodyfikujesz niewielką część kodu. Czas synchronizacji jest mniej więcej proporcjonalny do ilości zmian. Nawet jeśli jest zaszyfrowany, połączenie TrueCrypt + Dropbox doskonale wykorzystuje szyfr blokowy + synchronizację na poziomie bloków.

Po Drugie, monolityczny zaszyfrowany kontener nie tylko dodaje bezpieczeństwo, zmniejsza również szanse na korupcję repozytorium .

Uwaga: musisz jednak bardzo uważać, aby kontener nie był montowany, gdy Dropbox jest uruchomiony. Rozwiązywanie konfliktów może być również uciążliwe, jeśli 2 różnych klientów sprawdza różne wersje kontenera. Jest więc praktyczny tylko dla jednej osoby używającej go do tworzenia kopii zapasowych, a nie dla zespołu.

Konfiguracja:

• Tworzenie kontenera Truecrypt (wiele gigabajtów jest fine)
• w preferencjach Truecrypt odznacz preserve modification timestamp*.
• Utwórz repo, jak wspomniano powyżej przez Dana ( https://stackoverflow.com/a/1961515/781695 )

Użycie:

• Zakończ Dropbox
• Zamontuj kontener, wypchnij zmiany, odmontuj
• Uruchom dropbox

P. S. odznaczenie preserve modification timestamp informuje dropbox, że plik został zmodyfikowany i powinien zostać zsynchronizowany. zauważ, że zamontowanie kontenera zmienia znacznik czasu, nawet jeśli nie zmieniaj w nim żadnego pliku. Jeśli nie chcesz, aby tak się stało, po prostu zamontuj wolumin jako read-only

Używamy tej metody (tworząc gołe repozytorium w Dropbox) w folderze udostępnionym .

Mała grupa programistów może wyciągnąć z tego nagiego zsynchronizowanego repozytorium i utworzyć lokalny klon. Gdy jednostka pracy zostanie wykonana, odepchniemy się do początku.

Brakuje mi jednej rzeczy, to dobry sposób na wysłanie e-maila z informacją o ustawieniu zmian, gdy wystąpi push to origin. Używamy Google Wave do ręcznego śledzenia zmian.

Uwielbiam odpowiedź dana Mcnevina! Teraz też używam Gita i Dropboxa razem i używam kilku aliasów w moim .bash_profile więc mój workflow wygląda tak:

~/project $ git init
~/project $ git add .
~/project $ gcam "first commit"
~/project $ git-dropbox

To są moje aliasy:

alias gcam='git commit -a -m'
alias gpom='git push origin master'
alias gra='git remote add origin'
alias git-dropbox='TMPGP=~/Dropbox/git/$(pwd | awk -F/ '\''{print $NF}'\'').git;mkdir -p $TMPGP && (cd $TMPGP; git init --bare) && gra $TMPGP && gpom'

Używałem Mercurial w zalecany sposób i nalegam, abyś był ostrożny, zwłaszcza jeśli któreś z maszyn różni się. Fora Dropbox są pełne skarg na tajemnicze problemy związane z nazwą pliku pojawiające się spontanicznie. Hg (i zakładam, że Git) nie zauważy ani nie narzeka podczas rutynowych kontroli, a o korupcji usłyszysz tylko wtedy, gdy narzeka na skorumpowany repo, gdy spróbujesz go użyć naprawdę. Złe wieści. Chciałbym być bardziej konkretny na temat problemu i jego obejścia; Sam wciąż próbuję się wydostać z tego bałaganu.

Istnieje również projekt open source (zbiór wieloplatformowych skryptów [Linux, Mac, Win]), który wykonuje wszystkie szczegóły zarządzania repozytorium za pomocą garści (3-4) poleceń.

Https://github.com/karalabe/gitbox/wiki

Przykładowe użycie to:

$ gitbox create myapp
Creating empty repository...
Initializing new repository...
Repository successfully created.

$ gitbox clone myapp
Cloning repository...
Repository successfully cloned.

Po czym normalne użycie git:

$ echo “Some change” > somefile.txt
$ git add somefile.txt
$ git commit –m “Created some file”
$ git push

Sprawdź wiki projektu i podręczniki, aby uzyskać pełne odniesienia do poleceń i samouczki.

Przechowuję moje repo nie-Github na Dropbox. Jedno zastrzeżenie, na które wpadłem, to synchronizacja po ponownej instalacji. Dropbox pobierze najpierw Najmniejsze pliki przed przejściem do większych. Nie ma problemu, jeśli zaczynasz w nocy i wracasz po weekendzie: -)

Mój wątek- http://forums.dropbox.com/topic.php?id=29984&replies=6

Teraz, w 2014 roku, używam Gita i Dropbox przez około półtora roku bez problemu. Niektóre punkty jednak:

• Wszystkie moje maszyny korzystające z Dropbox są na Windows, różne wersje ( 7 do 8) + 1 mac.
• nie udostępniam repozytorium komuś innemu, więc tylko ja mogę je modyfikować.
• git push pcha do zdalnego repozytorium, tak, że jeśli kiedykolwiek zostanie uszkodzony, mogę łatwo go odzyskać.
• musiałem utworzyć aliasy w C:\Users z mklink /D link target ponieważ niektóre biblioteki były wskazywane na absolutne lokalizacje.

Inne podejście:

Wszystkie odpowiedzi, w tym @Dan answer , która jest najpopularniejsza, odnoszą się do idei korzystania z Dropbox do scentralizowania współdzielonego repozytorium zamiast korzystania z usługi skupionej na gitu, takiej jak github, bitbucket itp.

Ale, ponieważ pierwotne pytanie nie określa, co tak naprawdę oznacza używanie "Git i Dropbox razem", popracujmy nad innym podejściem: "Używanie Dropbox do synchronizacji tylko obszaru roboczego."

How-to ma te kroki:

1. Wewnątrz katalogu projektu tworzy się pusty katalog .git (np. mkdir -p myproject/.git)

2. Usuń synchronizację katalogu .git W Dropbox. Jeśli korzystasz z aplikacji Dropbox: przejdź do opcji Preferencje, synchronizacja i "wybierz foldery do synchronizacji", gdzie katalog .git musi zostać nieoznaczony. Spowoduje to usunięcie katalogu .git.

3. Uruchom git init w katalogu projektu

Działa również, jeśli .git już istnieje, to wykonaj tylko krok 2. Dropbox zachowa jednak kopię plików git w witrynie.

Krok 2 spowoduje, że Dropbox nie zsynchronizuje struktury systemu git, co jest pożądanym rezultatem dla tego podejścia.

Dlaczego warto zastosować takie podejście?

• Zmiany, których jeszcze nie wypchnięto, będą miały kopię zapasową Dropbox i będą synchronizowane na różnych urządzeniach.

• Jeśli Dropbox coś zepsuje podczas synchronizacji między urządzeniami, git status i git diff będą przydatne do sortowania rzeczy Wynocha.

• Oszczędza miejsce na koncie Dropbox (nie będzie tam zapisywana cała historia)

• Unika obaw zgłaszanych przez @ dubek i @Ates w komentarzach do odpowiedzi @ Dana, a obaw przez @clu w innej odpowiedzi .

Istnienie zdalnego gdzie indziej (github, itp.) będzie działać dobrze z tym podejściem.

Praca w różnych gałęziach niesie ze sobą pewne problemy, o które należy zadbać of:

• Jednym z potencjalnych problemów jest posiadanie Dropbox (niepotrzebnie?) synchronizacja potencjalnie wielu plików, gdy ktoś sprawdza różne gałęzie.

• Jeśli dwa lub więcej zsynchronizowanych urządzeń Dropbox ma sprawdzone różne oddziały, niezaangażowane zmiany na obu urządzeniach mogą zostać utracone,

Jednym ze sposobów obejścia tych problemów jest użycie git worktree aby trzymać kasy branch w oddzielnych katalogach.

Podoba mi się najbardziej głosowana odpowiedź dana Mcnevina. Skończyłem z wykonywaniem sekwencji komend Gita zbyt wiele razy i postanowiłem zrobić skrypt. Więc oto jest:

#!/bin/bash

# Usage
usage() {
    echo "Usage: ${0} -m [ master-branch-directory ] -r [ remote-branch-directory ] [ project-name ]"
    exit 1
}

# Defaults
defaults() {
    masterdir="${HOME}/Dropbox/git"
    remotedir="${PWD}"
    gitignorefile="# OS generated files #\n\n.DS_Store\n.DS_Store?\n.Spotlight-V100\n.Trashes\nehthumbs.db\nThumbs.db"
}

# Check if no arguments
if [ ${#} -eq 0 ] ; then
    echo "Error: No arguments specified"
    usage
fi

#Set defaults
defaults

# Parse arguments
while [ ${#} -ge 1 ]; do
    case "${1}" in
        '-h' | '--help' ) usage ;;
        '-m' )
            shift
            masterdir="${1}"
            ;;
        '-r' )
            shift
            remotedir="${1}"
            ;;
        * )
            projectname="${1##*/}"
            projectname="${projectname%.git}.git"
            ;;
    esac
    shift
done

# check if specified directories and project name exists
if [ -z "${projectname}" ]; then
    echo "Error: Project name not specified"
    usage
fi

if [ ! -d "${remotedir}" ]; then
    echo "Error: Remote directory ${remotedir} does not exist"
    usage
fi

if [ ! -d "${masterdir}" ]; then
    echo "Error: Master directory ${masterdir} does not exist"
    usage
fi

#absolute paths
remotedir="`( cd \"${remotedir}\" && pwd )`"
masterdir="`( cd \"${masterdir}\" && pwd )`"

#Make master git repository
cd "${masterdir}"
git init --bare "${projectname}"

#make local repository and push to master
cd "${remotedir}"
echo -e "${gitignorefile}" > .gitignore # default .gitignore file
git init
git add .
git commit -m "first commit"
git remote add origin "${masterdir}/${projectname}"
git push -u origin master

#done
echo "----- Locations -----"
echo "Remote branch location: ${remotedir}"
echo "Master branch location: ${masterdir}"
echo "Project Name: ${projectname}"

Skrypt wymaga tylko nazwy projektu. Wygeneruje repozytorium git w ~/Dropbox/git/ pod podaną nazwą i wypchnie całą zawartość bieżącego katalogu do nowo utworzonej gałęzi origin master. Jeśli podano więcej niż jedną nazwę projektu, zostanie użyty argument o nazwie projektu.

Opcjonalnie, argument polecenia-r określa zdalną gałąź, która zostanie przekazana do Master origin. Lokalizacja wzorca projektu origin może być również określona argumentem-m. Domyślnie .plik gitignore jest również umieszczony w zdalnym katalogu branch. Katalog i .domyślne wartości plików gitignore są określone w skrypcie.

Za moje centy 2 Dropbox sprawia, że sence jest tylko do użytku osobistego, gdzie nie chcesz zawracać sobie głowy uzyskaniem centralnego hosta repo. W przypadku rozwoju zawodowego prawdopodobnie stworzysz więcej problemów niż rozwiążesz, jak już wspomniano kilka razy w tym wątku, Dropbox nie jest przeznaczony do tego przypadku użycia. To powiedziawszy, całkowicie bezpieczną metodą zrzucania repozytoriów na Dropbox bez żadnych wtyczek lub narzędzi innych firm jest używanie pakietów. Mam następujące aliasy w moim .gitconfig, aby zapisać typowanie:

[alias]
        bundle-push = "!cd \"${GIT_PREFIX:-.}\" && if path=\"$(git config remote.\"$1\".url)\" && [ \"${path:0:1}\" = / ]; then git bundle create \"$path\" --all && git fetch \"$1\"; else echo \"Not a bundle remote\"; exit 1; fi #"
        bundle-fetch = "!cd \"${GIT_PREFIX:-.}\" && if path=\"$(git config remote.\"$1\".url)\" && [ \"${path:0:1}\" = / ]; then git bundle verify \"$path\" && git fetch \"$1\"; else echo \"Not a bundle remote\"; exit 1; fi #"
        bundle-new = "!cd \"${GIT_PREFIX:-.}\" && if [ -z \"${1:-}\" -o -z \"${2:-}\" ]; then echo \"Usage: git bundle-new <file> <remote name>\"; exit 1; elif [ -e \"$2\" ]; then echo \"File exist\"; exit 1; else git bundle create \"$2\" --all && git remote add -f \"$1\" \"$(realpath \"$2\")\"; fi #"

Przykład:

# Create bundle remote (in local repo)
$ git bundle-new dropbox ~/Dropbox/my-repo.bundle
# Fetch updates from dropbox
$ git bundle-fetch dropbox
# NOTE: writes over previous bundle. Thus, roughly equivalent to push --force --prune --all
$ git bundle-push

Spotkałem się z podobnym problemem i stworzyłem mały skrypt dla tego samego. Chodzi o to, aby używać Dropbox z Gitem tak prosto, jak to tylko możliwe. Obecnie szybko zaimplementowałem kod Ruby i wkrótce dodam więcej.

Skrypt jest dostępny pod adresem https://github.com/nuttylabs/box-git.

Bez korzystania z narzędzi do integracji innych firm, mógłbym nieco poprawić ten stan i korzystać z DropBox i innych podobnych usług dyskowych w chmurze, takich jak SpiderOak z Gitem.

Celem jest uniknięcie synchronizacji w środku tych modyfikacji plików, ponieważ może ona przesłać częściowy stan, a następnie pobrać go z powrotem, całkowicie niszcząc twój stan git.

Aby uniknąć tego problemu, zrobiłem:

1. Połącz mój indeks git w jeden plik używając git bundle create my_repo.git --all.
2. Ustaw opóźnienie dla monitorowanie plików, np. 5 minut, zamiast natychmiastowego. Zmniejsza to szanse, że DropBox zsynchronizuje stan częściowy w trakcie zmiany. Bardzo pomaga również podczas modyfikowania plików na dysku w chmurze w locie (np. w przypadku aplikacji do natychmiastowego zapisywania notatek).

Nie jest idealny, ponieważ nie ma gwarancji, że nie zepsuje ponownie stanu Gita, ale pomaga i na razie nie dostałem żadnego problemu.

W systemie MacOS możesz również po prostu zatrzymać Dropbox, wprowadzić zmiany, a następnie ponownie uruchomić Dropbox. Używam następującej kombinacji i jestem z niej całkiem zadowolony:

W obu (lokalnym katalogu projektu zarządzanego przez git i zdalnym repozytorium git znajdującym się na Dropbox) uruchom następujące polecenie, aby wyłączyć automatyczne pakowanie (co jest głównym problemem z synchronizacją dropbox)

git config --global gc.auto 0

Następnie od czasu do czasu Kompresuj repozytoria z wyłączonym dropbox. Na przykład wykonuję następujące czynności w moim bash-build-script za każdym razem, gdy robię nowe wersje moich aplikacji.

osascript -e "tell application \"Dropbox\" to quit"

# Compress local
git gc --prune=now; git repack -a -d

# Compress remote
REPOS_DIR_REMOTE=`git remote get-url --push origin`
cd "${REPOS_DIR_REMOTE}"
git gc --prune=now; git repack -a -d

osascript -e "tell application \"Dropbox\" to launch"
osascript -e "display notification with title \"Compress Done\""