Mantener el Directorio Remoto actualizado

Lsyncd parece ser la solución perfecta. combina inotify (función incorporada del núcleo que vigila los cambios de archivos en los árboles de directorios) y rsync (herramienta de sincronización de archivos multiplataforma).

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

Cita de github:

Lsyncd observa una interfaz de monitor de eventos de árboles de directorios locales (inotify o fsevents). Agrega y combina eventos durante unos segundos y luego genera uno (o más) procesos para sincronizar los cambios. Predeterminada esto es rsync. Lsyncd es, por lo tanto, una solución liviana de live mirror que es comparativamente fácil de instalar y no requiere nuevos sistemas de archivos o dispositivos de bloque y no obstaculiza el rendimiento del sistema de archivos local.

Lo que quiere hacer para el acceso remoto de linux es usar 'sshfs' - el Sistema de Archivos SSH.

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

Entonces trátalo como un montaje en red, que es...

Un poco más de detalle, como cómo configurarlo para que pueda hacerlo como usuario habitual, en mi blog

Si desea el comportamiento asíncrono de WinSCP, querrá usar rsync combinado con algo que lo ejecute periódicamente. La solución de cron anterior funciona, pero puede ser excesiva para el uso de winscp caso.

El siguiente comando ejecutará rsync cada 5 segundos para enviar contenido al host remoto. Puede ajustar el tiempo de reposo según sea necesario para reducir la carga del servidor.

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

Si tiene una estructura de directorios muy grande y necesita reducir la sobrecarga del sondeo, puede usar '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

Y dije cron puede ser exagerado? Pero al menos todo esto se hace desde la línea de comandos, y se puede detener a través de ctrl-C.

Kb

Para detectar archivos modificados, puede probar fam (file alteration monitor) o inotify. Este último es específico de linux, fam tiene un puerto bsd que podría funcionar en OS X. Ambos tienen herramientas de espacio de usuario que podrían usarse en un script junto con rsync.

Tengo el mismo problema. Me encantó el comando winscp "mantener el directorio remoto actualizado". Sin embargo, en mi búsqueda para librarme de Windows, perdí winscp. Escribí un script que usa fileschanged y rsync para hacer algo similar mucho más cercano al tiempo real.

Cómo usar:

• Asegúrese de tener instalado fileschanged
• Guarde este script en/usr/local/bin / livesync o en algún lugar accesible en su PATH PATH y hágalo ejecutable
• Utilice Nautilus para conectarse a la host remoto (sftp o ftp)
• Ejecute este script haciendo livesync SOURCE DEST
• El directorio DEST estará en /home/[username]/.gvfs / [ruta a ftp scp o lo que sea]

Un par de desventajas:

• Es más lento que winscp (mi conjetura es porque pasa a través de Nautilus y tiene que detectar cambios a través de rsync también)
• Tiene que crear manualmente el directorio de destino si no existe ya. Así que si está agregando un directorio, no lo hará detectar y crear el directorio en el lado DEST.
• Probablemente más de lo que aún no he notado
• Además, no intente sincronizar un directorio SRC llamado "rsyncThis". Eso probablemente no será bueno:)

#!/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

Las soluciones rsync son realmente buenas, especialmente si solo estás empujando cambios de una manera. Otra gran herramienta es unison attempts intenta sincronizar los cambios en ambas direcciones. Lea más en la página principal de Unison.

Siempre puede usar control de versiones, como SVN, por lo que todo lo que tiene que hacer es que el servidor ejecute svn en una carpeta todas las noches. Esto se encuentra con problemas de seguridad si está compartiendo sus archivos públicamente, pero funciona.

Si está usando Linux, aprenda a usar rsync. Realmente no es tan difícil ya que puede probar cada comando con-n. Vaya a través de la página de manual , el formato básico que querrá es

Rsync [OPCIÓN...] SRC... [USER@]HOST: DEST

El comando que corro desde el servidor de mi escuela a la máquina de copia de seguridad de mi hogar es este

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

Esto toma todos los archivos en mi directorio personal (~) y usa el modo de archivo de rsync (-a), verbosly (-v), lista todos los cambios realizados (-i), mientras borra los archivos que ya no existen (delete delete) y los coloca en la carpeta /home/me/School/ en mi servidor remoto. Toda la información imprime (lo que se copió, lo que se eliminó, etc.) también se añade al archivo BackupLog.txt

Sé que es un viaje relámpago de rsync, pero espero que ayude.

Parece que tal vez estás resolviendo el problema equivocado. Si está tratando de editar archivos en un equipo remoto, puede intentar usar algo como el plugin ftp para jedit. http://plugins.jedit.org/plugins/?FTP Esto asegura que solo tiene una versión del archivo para que nunca pueda estar fuera de sincronización.

Basándose en la sugerencia de icco de SVN, en realidad sugeriría que si está utilizando subversion o similar para el control de código fuente (y si no lo está, probablemente debería comenzar) puede mantener el entorno de producción actualizado poniendo el comando para actualizar el repositorio en el gancho post-commit.

Hay muchas variables en cómo querrías hacer eso, pero lo que he visto funcionar es que el sitio de desarrollo o en vivo sea una copia de trabajo y luego que el post-commit use un ssh clave con un comando forzado para iniciar sesión en el sitio remoto y activar un svn en la copia de trabajo. Alternativamente, en el hook post-commit puede activar una exportación svn en la máquina remota, o una exportación svn local (al repositorio svn) y luego una rsync a la máquina remota.

Me preocuparían las cosas que detectan los cambios y los empujan, e incluso me preocuparían las cosas que corrían cada minuto, solo por las condiciones de la carrera. ¿Cómo sabes que no se va a transferir el archivo en el mismo instante en que está escrito? Tropiece con eso una o dos veces y perderá toda la ventaja de ahorro de tiempo que tenía al sincronizar constantemente o similar.

Se DropBox ( http://www.getdropbox.com / ) haz lo que quieras?

Usuario watcher.py y rsync para automatizar esto. Lea las siguientes instrucciones paso a paso aquí:

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

Solía tener la misma configuración en Windows que usted, es decir, un filetree local (versionado) y un entorno de prueba en un servidor remoto, que mantuve reflejado en tiempo real con WinSCP. Cuando cambié a Mac tuve que hacer bastante investigación antes de estar feliz, pero finalmente terminé usando:

• SmartSVN como mi cliente de subversion
• Sublime Text 2 como mi editor (ya lo usaba en Windows)
• SFTP-plugin para ST2 que maneja la carga al guardar (lo sentimos, no se pueden publicar más de 2 enlaces)

Realmente puedo recomendar esta configuración, espero que ayude!

También puede usar Fetch como un cliente SFTP, y luego editar archivos directamente en el servidor desde dentro. También hay opciones SSHFS (montar una carpeta ssh como volumen). Esto está en línea con lo que dijo stimms: ¿está seguro de que desea que las cosas se mantengan sincronizadas o simplemente desea editar archivos en el servidor?

OS X tiene su propio sistema de notificaciones de archivos - esto es en lo que se basa Spotlight. No he oído hablar de ningún programa que use esto para mantener las cosas sincronizadas, pero ciertamente es concebible.

Yo personalmente uso RCS para este tipo de cosas:- aunque tiene un aspecto manual, es poco probable que quiera empujar algo incluso al servidor de prueba de mi máquina de desarrollo sin probarlo primero. Y si estoy trabajando en un servidor de desarrollo, entonces utilizo una de las opciones dadas anteriormente.

Bueno, tuve el mismo tipo de problema y es posible usar estos juntos: rsync, SSH Passwordless Login, Watchdog (una utilidad de sincronización de Python) y Terminal Notifier (una utilidad de notificación de OS X hecha con Ruby. No es necesario, pero ayuda a saber cuándo ha terminado la sincronización).

1. Creé la clave para iniciar sesión sin contraseña usando este tutorial de Dreamhost wiki: http://cl.ly/MIw5

   1.1. Cuando termines, prueba si todo está bien if si no puedes Passwordless Login, tal vez usted tiene que probar afp mount. Dreamhost (donde está mi sitio) no permite el montaje de afp, pero permite el inicio de sesión sin contraseña. En terminal, escriba:

   ssh [email protected] Debe iniciar sesión sin que se le pregunten contraseñas: P

2. Instalé el Notificador de Terminal desde la página de Github: http://cl.ly/MJ5x

   2.1. Usé el comando Gem installer. En Terminal, escriba:

   gem install terminal-notifier

   2.3. Prueba si la notificación works.In Terminal, tipo:

   terminal-notifier -message "Starting sync"

3. Cree un script sh para probar la notificación rsync+. Guárdalo donde quieras, con el nombre que te guste. En este ejemplo, lo llamaré ~/Scripts/sync.sh Usé la extensión ".sh, pero no se si es necesario.

   #!/bin/bash terminal-notifier -message "Starting sync" rsync -azP ~/Sites/folder/ [email protected]:site_folder/ terminal-notifier -message "Sync has finished"

   3.1. Recuerde dar permiso de ejecución a este script sh. En Terminal, escriba:

   sudo chmod 777 ~/Scripts/sync.sh 3.2. Ejecute el script y verifique si los mensajes se muestran correctamente y el rsync en realidad sincronice su carpeta local con la carpeta remota.

4. Finalmente, descargué e instalé Watchdog desde la página de Github: http://cl.ly/MJfb

   4.1. Primero, instalé la dependencia libyaml usando Brew (hay mucha ayuda sobre cómo instalar Brew - como una "aptitude" para OS X). En Terminal, escriba:

   brew install libyaml

   4.2. Luego, usé el "comando easy_install". Vaya a la carpeta de Watchdog y escriba Terminal:

   easy_install watchdog

5. Ahora, todo está instalado! Vaya a la carpeta que desea sincronizar, cambie este código a sus necesidades, y escriba Terminal:

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

   Tiene que ser EXACTAMENTE de esta manera, con las barras y los saltos de línea, por lo que tendrá que copiar estas líneas a un editor de texto, cambiar el script, pegar en terminal y presionar return.

   Lo intenté sin los saltos de línea, ¡y no funciona!

   En mi Mac, yo siempre obtiene un error, pero no parece afectar nada:

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

   Ahora, hizo algunos cambios en un archivo dentro de la carpeta, y ver la magia!

Estoy usando este pequeño Script Ruby:

#!/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

¡Adáptalo a tus necesidades!