Mantenga actualizado el directorio remoto

https://stackoverflow.com/questions/9279

08-06-2019
|

Pregunta

Me encanta el Mantenga actualizado el directorio remoto característica en winscp.Desafortunadamente, no puedo encontrar nada tan sencillo de usar en OS X o Linux.Sé que lo mismo puede teóricamente lograrse usando archivos cambiados o sincronización, pero siempre he encontrado que los tutoriales para ambas herramientas faltan o son contradictorios.

Básicamente, solo necesito una herramienta que funcione en OSX o Linux y mantenga un directorio remoto sincronizado (reflejado) con un directorio local mientras hago cambios en el directorio local.

Actualizar

Al revisar las soluciones, veo un par que resuelve el problema general de mantener un directorio remoto sincronizado con un directorio local. a mano.Sé que puedo configurar una tarea cron para ejecutar rsync cada minuto, y esto debería ser bastante cercano al tiempo real.

Esta no es la solución exacta que estaba buscando ya que winscp hace esto y más:detecta cambios de archivos en un directorio (mientras trabajo en ellos) y luego envía automáticamente los cambios al servidor remoto.Sé que esta no es la mejor solución (sin repositorio de código), pero me permite probar el código muy rápidamente en un servidor mientras lo desarrollo.¿Alguien sabe cómo combinar rsync con otros comandos para obtener esta funcionalidad?

Solución

¿Qué tan "en tiempo real" quieres la sincronización?Todavía me inclinaría por rsync ya que sabes que será totalmente compatible con ambas plataformas (Windows también, con cygwin) y puedes ejecutarlo mediante una tarea cron.Tengo un archivo bash súper simple que ejecuto en mi sistema (esto no no eliminar archivos antiguos):

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

Lo mejor que puedes hacer es configurarlo y probarlo.El -n (--dry-run) ¡La opción es tu amiga!

Tenga en cuenta que rsync (al menos en cygwin) no admite nombres de archivos Unicode (a partir del 16 de agosto de 2008).

Otros consejos

lsyncd Parece ser la solución perfecta.combina inotificar (función incorporada del kernel que vigila los cambios de archivos en un árbol de directorios) y sincronización (herramienta de sincronización de archivos multiplataforma).

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

Cita de github:

Lsyncd observa una interfaz de monitoreo de eventos de árboles de directorio local (inotify o fsevents).Agrega y combina eventos durante unos segundos y luego genera uno (o más) procesos para sincronizar los cambios.Por defecto esto es rsync.Lsyncd es, por lo tanto, una solución de espejo en vivo liviana que es comparativamente fácil de instalar, no requiere nuevos sistemas de archivos o dispositivos de bloqueo y no obstaculiza el rendimiento del sistema de archivos local.

Lo que desea hacer para el acceso remoto de Linux es usar 'sshfs', el sistema de archivos SSH.

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

Luego trátelo como un soporte de red, que es...

Un poco más de detalle, como cómo configurarlo para que puedas hacer esto como un usuario normal, en mi blog

Si desea el comportamiento asincrónico de winSCP, querrá usar rsync combinado con algo que lo ejecute periódicamente.La solución cron anterior funciona, pero puede resultar excesiva para el caso de uso de winscp.

El siguiente comando ejecutará rsync cada 5 segundos para enviar contenido al host remoto.Puede ajustar el tiempo de suspensión 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 utilizar 'buscar':

# 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 que cron puede ser excesivo?Pero al menos todo esto se hace desde la línea de comando y se puede detener mediante Ctrl-C.

Para detectar archivos modificados, puede probar fam (monitor de alteración de archivos) 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 actualizado el directorio remoto".Sin embargo, en mi intento por deshacerme 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 utilizar:

Asegúrate de tener instalado el archivo cambiado.
Guarde este script en /usr/local/bin/livesync o en algún lugar accesible en su $PATH y hágalo ejecutable
Utilice Nautilus para conectarse al host remoto (sftp o ftp)
Ejecute este script haciendo livesync DESTINO FUENTE
El directorio DEST estará en /home/[nombre de usuario]/.gvfs/[ruta a ftp scp o lo que sea]

Un par de desventajas:

Es más lento que winscp (supongo que porque pasa por Nautilus y también tiene que detectar cambios a través de rsync)
Debe crear manualmente el directorio de destino si aún no existe.Entonces, si está agregando un directorio, no detectará ni creará el directorio en el lado DEST.
Probablemente más de los que no he notado todavía.
Además, no intente sincronizar un directorio SRC llamado "rsyncThis".Probablemente eso no sea 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

Siempre puedes usar el control de versiones, como SVN, así que todo lo que tienes que hacer es hacer que el servidor ejecute svn en una carpeta todas las noches.Esto genera problemas de seguridad si comparte sus archivos públicamente, pero funciona.

Sin embargo, si usa Linux, aprenda a usar rsync.Realmente no es tan difícil ya que puedes probar cada comando con -n.Ir a través de página de manual, el formato básico que querrás es

rsync [OPCIÓN...] SRC...[USUARIO@]HOST:DEST

El comando que ejecuto desde el servidor de mi escuela a la máquina de respaldo de mi casa es este

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

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

Sé que es un recorrido vertiginoso por rsync, pero espero que ayude.

El rsync Las soluciones son realmente buenas, especialmente si solo estás impulsando cambios en una dirección.Otra gran herramienta es unison -- intenta sincronizar los cambios en ambas direcciones.Lea mas en la página de inicio de Unison.

Parece que quizás estés resolviendo el problema equivocado.Si está intentando editar archivos en una computadora remota, puede intentar usar algo como el complemento ftp para jedit. http://plugins.jedit.org/plugins/?FTP Esto garantiza que solo tenga una versión del archivo para que nunca pueda perder la sincronización.

Partiendo de la sugerencia de SVN de icco, en realidad sugeriría que si está utilizando subversion o similar para el control de 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 enlace posterior a la confirmación.

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

Me preocuparían las cosas que detectan cambios y los impulsan, e incluso me preocuparían las cosas que se ejecutan cada minuto, sólo por las condiciones de carrera.¿Cómo sabes que no transferirá el archivo en el mismo instante en que se escribe?Si te encuentras con eso una o dos veces, perderás toda la ventaja de ahorrar tiempo que tenías al sincronizar constantemente o algo similar.

Será 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 árbol de archivos local (versionado) y un entorno de prueba en un servidor remoto, que mantenía reflejado en tiempo real con WinSCP.Cuando me cambié a Mac, tuve que investigar un poco antes de estar satisfecho, pero finalmente terminé usando:

SmartSVN como mi cliente de subversión
Texto sublime 2 como mi editor (ya lo usé en Windows)
Complemento SFTP para ST2 que maneja la carga al guardar (lo siento, no puedo publicar más de 2 enlaces)

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

También puede usar Fetch como cliente SFTP y luego editar archivos directamente en el servidor desde allí.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: en esto se basa Spotlight.No he oído hablar de ningún programa que utilice 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 enviar algo al servidor de prueba desde mi máquina de desarrollo sin probarlo primero.Y si estoy trabajando en un servidor de desarrollo, uso una de las opciones dadas anteriormente.

Bueno, tuve el mismo tipo de problema y es posible usarlos juntos:rsync, inicio de sesión sin contraseña SSH, Watchdog (una utilidad de sincronización de Python) y Terminal Notifier (una utilidad de notificación de OS X creada con Ruby.No es necesario, pero ayuda a saber cuándo finalizó la sincronización).

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

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

ssh username@host.comDeberías iniciar sesión sin que te pidan contraseñas :P
Instalé Terminal Notifier desde la página de Github: http://cl.ly/MJ5x

2.1.Utilicé el comando del instalador de Gem.En Terminal, escriba:

gem install terminal-notifier

2.3.Pruebe si la notificación funciona. En Terminal, escriba:

terminal-notifier -message "Starting sync"
Cree un script sh para probar la notificación rsync +.Guárdalo donde quieras, con el nombre que quieras.En este ejemplo, lo llamaré ~/Scripts/sync.sh Utilicé la extensión ".sh, pero no sé si es necesaria.

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

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

sudo chmod 777 ~/Scripts/sync.sh3.2.Ejecute el script y verifique si los mensajes se muestran correctamente y si rsync realmente sincroniza su carpeta local con la carpeta remota.
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 "aptitud" para OS X).En Terminal, escriba:

brew install libyaml

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

easy_install watchdog
¡Ahora todo está instalado! Vaya a la carpeta que desea sincronizar, cambia este código según tus 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 barras y saltos de línea, tendrás que copiar estas líneas a un editor de texto, cambiar el script, pegarlas en la terminal y presionar Enter.

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

En mi Mac siempre me sale 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, haga algunos cambios en un archivo dentro de la carpeta y ¡observe la magia!

Estoy usando este pequeño 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

¡Adáptalo a tus necesidades!

Si está desarrollando Python en un servidor remoto, Pycharm puede ser una buena opción para usted.Puede sincronizar sus archivos remotos con sus archivos locales utilizando la función de desarrollo remoto de pycharm.El enlace de la guía como:https://www.jetbrains.com/help/pycharm/creating-a-remote-server-configuration.html

Licenciado bajo: CC-BY-SA con atribución

No afiliado a StackOverflow