Mantieni aggiornata la directory remota

StackOverflow https://stackoverflow.com/questions/9279

  •  08-06-2019
  •  | 
  •  

Domanda

Adoro assolutamente il Mantieni aggiornata la directory remota caratteristica in Winscp.Sfortunatamente, non riesco a trovare nulla di così semplice da usare in OS X o Linux.So che la stessa cosa può succedere teoricamente essere realizzato utilizzando file modificati O rsync, ma ho sempre trovato i tutorial per entrambi gli strumenti carenti e/o contraddittori.

Fondamentalmente ho solo bisogno di uno strumento che funzioni in OSX o Linux e mantenga una directory remota sincronizzata (in mirroring) con una directory locale mentre apporto modifiche alla directory locale.

Aggiornamento

Osservando le soluzioni, ne vedo un paio che risolvono il problema generale di mantenere una directory remota sincronizzata con una directory locale manualmente.So che posso impostare un'attività cron per eseguire rsync ogni minuto, e questo dovrebbe essere abbastanza vicino al tempo reale.

Questa non è la soluzione esatta che stavo cercando poiché winscp fa questo e altro:rileva le modifiche ai file in una directory (mentre ci lavoro) e quindi invia automaticamente le modifiche al server remoto.So che questa non è la soluzione migliore (nessun repository di codice), ma mi consente di testare molto rapidamente il codice su un server mentre lo sviluppo.Qualcuno sa come combinare rsync con altri comandi per ottenere questa funzionalità?

È stato utile?

Soluzione

Quanto "in tempo reale" vuoi la sincronizzazione?Io continuerei a preferire rsync poiché sai che sarà completamente supportato su entrambe le piattaforme (anche Windows con Cygwin) e puoi eseguirlo tramite un processo cron.Ho un file bash semplicissimo che eseguo sul mio sistema (questo funziona non rimuovere i vecchi file):

#!/bin/sh
rsync -avrz --progress --exclude-from .rsync_exclude_remote . remote_login@remote_computer:remote_dir    

# options
#   -a  archive
#   -v  verbose
#   -r  recursive
#   -z  compress

La soluzione migliore è configurarlo e provarlo.IL -n (--dry-run) l'opzione è tua amica!

Tieni presente che rsync (almeno in Cygwin) non supporta i nomi di file Unicode (dal 16 agosto 2008).

Altri suggerimenti

lsyncd sembra essere la soluzione perfetta.combina notificare (funzione incorporata del kernel che controlla le modifiche ai file negli alberi di directory) e rsync (strumento di sincronizzazione file multipiattaforma). 

lsyncd -rsyncssh /home remotehost.org backup-home/

Citazione da github:

Lsyncd controlla l'interfaccia di monitoraggio degli eventi degli alberi delle directory locali (inotify o fsevents).Aggrega e combina eventi per alcuni secondi e quindi genera uno (o più) processi per sincronizzare le modifiche.Per impostazione predefinita questo è rsync.Lsyncd è quindi una soluzione live mirror leggera che è relativamente facile da installare, non richiede nuovi filesystem o dispositivi a blocchi e non ostacola le prestazioni del filesystem locale.

Quello che vuoi fare per l'accesso remoto a Linux è usare 'sshfs', il file system SSH.

# sshfs username@host:path/to/directory local_dir

Quindi trattalo come un montaggio di rete, che è...

Un po' più di dettagli, ad esempio come configurarlo in modo da poterlo fare come utente normale, su il mio blog

Se desideri il comportamento asincrono di winSCP, ti consigliamo di utilizzare rsync combinato con qualcosa che lo esegua periodicamente.La soluzione cron di cui sopra funziona, ma potrebbe essere eccessiva per il caso d'uso di Winscp.

Il seguente comando eseguirà rsync ogni 5 secondi per inviare il contenuto all'host remoto.È possibile regolare il tempo di sospensione secondo necessità per ridurre il carico del server.

# while true; do rsync -avrz localdir user@host:path; sleep 5; done

Se hai una struttura di directory molto grande e hai bisogno di ridurre il sovraccarico del polling, puoi usare 'find':

# touch -d 01/01/1970 last; while true; do if [ "`find localdir -newer last -print -quit`" ]; then touch last; rsync -avrz localdir user@host:path; else echo -ne .; fi; sleep 5; done

E ho detto che cron potrebbe essere eccessivo?Ma almeno tutto questo viene fatto dalla riga di comando e può essere interrotto tramite ctrl-C.

kb

Per rilevare i file modificati, puoi provare fam (monitor di alterazione dei file) o inotify.Quest'ultimo è specifico per Linux, fam ha una porta bsd che potrebbe funzionare su OS X.Entrambi hanno strumenti in spazio utente che potrebbero essere utilizzati in uno script insieme a rsync.

Ho lo stesso problema.Mi è piaciuto il comando winscp "mantieni aggiornata la directory remota".Tuttavia, nel tentativo di sbarazzarmi di Windows, ho perso winscp.Ho scritto uno script che utilizza fileschanged e rsync per fare qualcosa di simile molto più vicino al tempo reale.

Come usare:

  • Assicurati di avere installato fileschanged
  • Salva questo script in /usr/local/bin/livesync o in un posto raggiungibile nel tuo $PATH e rendilo eseguibile
  • Utilizza Nautilus per connetterti all'host remoto (sftp o ftp)
  • Esegui questo script eseguendo la sincronizzazione della vita FONTE DEST
  • La directory DEST sarà in /home/[nome utente]/.gvfs/[percorso ftp scp o altro]

Un paio di aspetti negativi:

  • È più lento di WinSCP (suppongo perché passa attraverso Nautilus e deve rilevare i cambiamenti anche tramite rsync)
  • È necessario creare manualmente la directory di destinazione se non esiste già.Pertanto, se stai aggiungendo una directory, non rileverà e creerà la directory sul lato DEST.
  • Probabilmente altro che non ho ancora notato
  • Inoltre, non tentare di sincronizzare una directory SRC denominata "rsyncThis".Probabilmente non andrà bene :)
#!/bin/sh

upload_files()
{
    if [ "$HOMEDIR" = "." ]
    then
        HOMEDIR=`pwd`
    fi

    while read  input
    do
        SYNCFILE=${input#$HOMEDIR}
        echo -n "Sync File: $SYNCFILE..."
        rsync -Cvz --temp-dir="$REMOTEDIR" "$HOMEDIR/$SYNCFILE" "$REMOTEDIR/$SYNCFILE" > /dev/null
        echo "Done."
    done
}


help()
{
    echo "Live rsync copy from one directory to another.  This will overwrite the existing files on DEST."
    echo "Usage: $0 SOURCE DEST"    
}


case "$1" in
  rsyncThis)
    HOMEDIR=$2
    REMOTEDIR=$3
    echo "HOMEDIR=$HOMEDIR"
    echo "REMOTEDIR=$REMOTEDIR"
    upload_files
    ;;

  help)
    help
    ;;

  *)
    if [ -n "$1" ] && [ -n "$2" ]
    then
        fileschanged -r "$1" | "$0" rsyncThis "$1" "$2"
    else
        help
    fi
    ;;
esac

Puoi sempre utilizzare il controllo della versione, come SVN, quindi tutto ciò che devi fare è far funzionare il server su una cartella ogni notte.Ciò comporta problemi di sicurezza se condividi i tuoi file pubblicamente, ma funziona.

Se stai usando Linux, impara a usare rsync.Non è poi così difficile dato che puoi testare ogni comando con -n.Passa attraverso il pagina man, il formato di base che vorrai è

rsync [OPZIONE...] SRC...[UTENTE@]HOST:DEST

il comando che eseguo dal server della scuola al computer di backup di casa è questo

rsync -avi --delete ~ me@homeserv:~/School/ >> BackupLog.txt

Questo prende tutti i file nella mia directory home (~) e utilizza la modalità archivio di rsync (-a), dettagliatamente (-v), elenca tutte le modifiche apportate (-i), eliminando tutti i file che non esistono più (--delete) e lo inserisce nella cartella /home/me/School/ sul mio server remoto.Tutte le informazioni stampate (cosa è stato copiato, cosa è stato eliminato, ecc.) vengono aggiunte anche al file BackupLog.txt

So che è un tour vorticoso di rsync, ma spero che sia d'aiuto.

IL rsync le soluzioni sono davvero buone, soprattutto se spingi i cambiamenti solo in un modo.Un altro ottimo strumento è unison -- tenta di sincronizzare le modifiche in entrambe le direzioni.Leggi di più su la home page di Unison.

Sembra che tu stia risolvendo il problema sbagliato.Se stai provando a modificare file su un computer remoto, potresti provare a utilizzare qualcosa come il plugin ftp per jedit. http://plugins.jedit.org/plugins/?FTP Ciò garantisce di avere solo una versione del file in modo che non possa mai essere fuori sincronia.

Basandosi sul suggerimento di SVN da parte di icco, suggerirei in realtà che se stai utilizzando subversion o simili per il controllo del codice sorgente (e se non lo sei, probabilmente dovresti iniziare) puoi mantenere aggiornato l'ambiente di produzione inserendo il comando per aggiornare il repository nell'hook post-commit.

Ci sono molte variabili nel modo in cui vorresti farlo, ma quello che ho visto funzionare è che lo sviluppo o il sito live siano una copia funzionante e quindi fare in modo che il post-commit utilizzi una chiave ssh con un comando forzato per accedere al sito remoto e attivare un svn sulla copia di lavoro.In alternativa nell'hook post-commit è possibile attivare un'esportazione svn sulla macchina remota o un'esportazione svn locale (nel repository svn) e quindi un rsync sulla macchina remota.

Sarei preoccupato per le cose che rilevano i cambiamenti e li spingono, e sarei anche preoccupato per le cose che si verificano ogni minuto, solo a causa delle condizioni di gara.Come fai a sapere che il file non verrà trasferito nello stesso istante in cui viene scritto?Se ti imbatti in questo una o due volte, perderai tutto il vantaggio di risparmiare tempo che avevi grazie alla sincronizzazione costante o simili.

Sarà DropBox (http://www.getdropbox.com/) Fai quello che vuoi?

Utilizza watcher.py e rsync per automatizzarlo.Leggi le seguenti istruzioni passo passo qui:

http://kushellig.de/linux-file-auto-sync-directories/

Avevo la tua stessa configurazione sotto Windows, ovvero un filetree locale (con versione) e un ambiente di test su un server remoto, che mantenevo in mirroring in tempo reale con WinSCP.Quando sono passato al Mac ho dovuto scavare parecchio prima di essere soddisfatto, ma alla fine ho utilizzato:

  • SmartSVN come mio cliente di sovversione
  • Testo sublime 2 come mio editor (già usato su Windows)
  • Plug-in SFTP su ST2 che gestisce il caricamento al salvataggio (scusate, non è possibile pubblicare più di 2 collegamenti)

Posso davvero consigliare questa configurazione, spero che sia d'aiuto!

Puoi anche utilizzare Fetch come client SFTP e quindi modificare i file direttamente sul server da esso.Ci sono anche opzioni SSHFS (montare una cartella ssh come volume).Questo è in linea con quanto detto da Stimms: sei sicuro di voler mantenere le cose sincronizzate o di voler semplicemente modificare i file sul server?

OS X ha il proprio sistema di notifica dei file: questo è ciò su cui si basa Spotlight.Non ho sentito parlare di nessun programma che lo utilizzi per mantenere le cose sincronizzate, ma è certamente concepibile.

Personalmente utilizzo RCS per questo tipo di cose: - sebbene abbia un aspetto manuale, è improbabile che io voglia inviare qualcosa anche al server di test dalla mia macchina di sviluppo senza prima testarlo.E se lavoro su un server di sviluppo, utilizzo una delle opzioni sopra indicate.

Bene, ho avuto lo stesso tipo di problema ed è possibile utilizzarli insieme:rsync, SSH Passwordless Login, Watchdog (un'utilità di sincronizzazione Python) e Terminal Notifier (un'utilità di notifica OS X realizzata con Ruby.Non necessario, ma aiuta a sapere quando la sincronizzazione è terminata).

  1. Ho creato la chiave per l'accesso senza password utilizzando questo tutorial dal wiki di Dreamhost: http://cl.ly/MIw5

    1.1.Al termine, verifica se è tutto ok... se non riesci ad accedere senza password, forse devi provare afp mount.Dreamhost (dove si trova il mio sito) non consente il montaggio afp, ma consente l'accesso senza password.Nel terminale digitare:

    ssh username@host.com Dovresti accedere senza che venga richiesta la password: P

  2. Ho installato Terminal Notifier dalla pagina Github: http://cl.ly/MJ5x

    2.1.Ho usato il comando di installazione di Gem.Nel Terminale digitare:

    gem install terminal-notifier

    2.3.Verifica se la notifica funziona. Nel Terminale, digita:

    terminal-notifier -message "Starting sync"

  3. Crea uno script sh per testare la notifica rsync +.Salvalo dove preferisci, con il nome che preferisci.In questo esempio, lo chiamerò ~/Scripts/sync.sh Ho usato l'estensione ".sh, ma non so se fosse necessaria.

    #!/bin/bash terminal-notifier -message "Starting sync" rsync -azP ~/Sites/folder/ user@host.com:site_folder/ terminal-notifier -message "Sync has finished"

    3.1.Ricordati di dare il permesso di esecuzione a questo script sh.Nel Terminale digitare:

    sudo chmod 777 ~/Scripts/sync.sh 3.2.Esegui lo script e verifica se i messaggi vengono visualizzati correttamente e rsync sincronizza effettivamente la tua cartella locale con la cartella remota.

  4. Infine, ho scaricato e installato Watchdog dalla pagina Github: http://cl.ly/MJfb

    4.1.Innanzitutto, ho installato la dipendenza libiaml utilizzando Brew (ci sono molti aiuti su come installare Brew, come un "aptitude" per OS X).Nel Terminale digitare:

    brew install libyaml

    4.2.Quindi, ho utilizzato il "comando easy_install".Vai alla cartella di Watchdog e digita Terminale:

    easy_install watchdog

  5. Ora è tutto installato! Vai alla cartella che desideri sincronizzare, cambia questo codice in base alle tue esigenze, e digita nel Terminale:

      watchmedo shell-command
      --patterns="*.php;*.txt;*.js;*.css" \
      --recursive \
      --command='~/Scripts/Sync.sh' \
      .

    Deve essere ESATTAMENTE in questo modo, con le barre e le interruzioni di riga, quindi dovrai copiare queste righe in un editor di testo, modificare lo script, incollarle nel terminale e premere Invio.

    Ho provato senza interruzioni di riga e non funziona!

    Nel mio Mac, ricevo sempre un errore, ma non sembra influire su nulla:

    /Library/Python/2.7/site-packages/argh-0.22.0-py2.7.egg/argh/completion.py:84: UserWarning: Bash completion not available. Install argcomplete.

    Ora, apporta alcune modifiche a un file all'interno della cartella e osserva la magia!

Sto usando questo piccolo Ruby-Script:

#!/usr/bin/env ruby
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Rsyncs 2Folders
#
# watchAndSync by Mike Mitterer, 2014 <http://www.MikeMitterer.at>
# with credit to Brett Terpstra <http://brettterpstra.com>
# and Carlo Zottmann <https://github.com/carlo/haml-sass-file-watcher>
# Found link on: http://brettterpstra.com/2011/03/07/watch-for-file-changes-and-refresh-your-browser-automatically/
#

trap("SIGINT") { exit }

if ARGV.length < 2
  puts "Usage: #{$0} watch_folder sync_folder"
  puts "Example: #{$0} web keepInSync"
  exit
end

dev_extension = 'dev'
filetypes = ['css','html','htm','less','js', 'dart']

watch_folder = ARGV[0]
sync_folder = ARGV[1]

puts "Watching #{watch_folder} and subfolders for changes in project files..."
puts "Syncing with #{sync_folder}..."

while true do
  files = []
  filetypes.each {|type|
    files += Dir.glob( File.join( watch_folder, "**", "*.#{type}" ) )
  }
  new_hash = files.collect {|f| [ f, File.stat(f).mtime.to_i ] }
  hash ||= new_hash
  diff_hash = new_hash - hash

  unless diff_hash.empty?
    hash = new_hash

    diff_hash.each do |df|
      puts "Detected change in #{df[0]}, syncing..."
      system("rsync -avzh #{watch_folder} #{sync_folder}")
    end
  end

  sleep 1
end

Adattatelo alle vostre esigenze!

Se stai sviluppando Python su un server remoto, Pycharm potrebbe essere una buona scelta per te.Puoi sincronizzare i tuoi file remoti con i tuoi file locali utilizzando la funzionalità di sviluppo remoto pycharm.Il collegamento alla guida come:https://www.jetbrains.com/help/pycharm/creating-a-remote-server-configuration.html

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top