linux - mac - Mantener el directorio remoto actualizado

ssh linux comandos

Question

Me encanta la función Keep Remote Directory Up- Winscp en Winscp . Desafortunadamente, no puedo encontrar nada tan simple de usar en OS X o Linux. Sé que lo mismo se puede lograr teóricamente usando changedfiles o rsync , pero siempre he encontrado que los tutoriales para ambas herramientas son inexistentes o contradictorios.

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

Actualizar

Al examinar las soluciones, veo un par que resuelve el problema general de mantener un directorio remoto sincronizado con un directorio local de forma manual . 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 yo trabajo en ellos) y luego empuja los cambios automáticamente al servidor remoto. Sé que esta no es la mejor solución (sin repositorio de código), pero me permite probar código rápidamente en un servidor mientras lo desarrollo. ¿Alguien sabe cómo combinar rsync con otros comandos para obtener esta funcionalidad?

Answer 1

¿Cómo "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 a través de un trabajo cron. Tengo un archivo bash super simple que ejecuto en mi sistema (esto no elimina los 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 

Su mejor apuesta es configurarlo y probarlo. ¡La opción -n (--dry-run) es tu amiga!

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

Answer 2

¿DropBox ( http://www.getdropbox.com/ ) hará lo que quieras?

Answer 3

Bueno, tuve el mismo tipo de problema y es posible usarlos 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 cuando la sincronización ha terminado).

1. Creé la clave para el inicio de sesión sin contraseña utilizando 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 de afp. 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] Debes iniciar sesión sin que se te pregunten las contraseñas: P

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

   2.1. Usé el comando instalador Gem. En Terminal, escribe:

   gem install terminal-notifier

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

   terminal-notifier -message "Starting sync"

3. Cree un script sh para probar la notificación rsync +. Guárdelo en cualquier lugar que desee, con el nombre que desee. En este ejemplo, lo llamaré ~ / Scripts / sync.sh Usé la extensión ".sh, pero no sé 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 otorgar permiso de ejecución a este script sh. En Terminal, escribe:

   sudo chmod 777 ~/Scripts/sync.sh 3.2. Ejecute el script y verifique si los mensajes se muestran correctamente y el rsync realmente sincroniza 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 "aptitud" para OS X). En Terminal, escribe:

   brew install libyaml

   4.2. Luego, utilicé el "comando easy_install". Ve a la carpeta de Watchdog y escribe 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 deberá copiar estas líneas en un editor de texto, cambiar la secuencia de comandos, pegar en la terminal y presionar regresar.

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

   En mi Mac, siempre aparece 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, realizó algunos cambios en un archivo dentro de la carpeta y ¡mira la magia!

Answer 4

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áptelo para sus necesidades!

Answer 5

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

Answer 6

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

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

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

Si desea el comportamiento asincrónico de winSCP, querrá usar rsync combinado con algo que se ejecute periódicamente. La solución anterior de cron funciona, pero puede ser 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 de la encuesta, puede usar ''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 demasiado? Pero al menos esto se acaba de hacer desde la línea de comandos, y se puede detener a través de un ctrl-C.

kb

Answer 7

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.

Answer 8

Parece que quizás estás resolviendo el problema equivocado. Si intentas editar archivos en una computadora remota, entonces podrías 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, por lo que nunca puede estar fuera de sincronización.

Answer 9

Partiendo de la sugerencia de icco de SVN, 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 te gustaría hacer eso, pero lo que he visto funciona es que el sitio de desarrollo o en vivo sea una copia de trabajo y luego haz que el post-commit use una clave ssh con un comando forzado para inicie sesión en el sitio remoto y active un svn en la copia de trabajo. De forma alternativa, en el enganche post-commit puede desencadenar una exportación svn en la máquina remota, o un svn local (al repositorio svn) exportar y luego una rsync a la máquina remota.

Me preocuparían las cosas que detectan cambios y los presionan, y hasta me preocupan las cosas que funcionan a cada minuto, solo por las condiciones de la carrera. ¿Cómo sabes que no va a transferir el archivo en el mismo instante en que se está escribiendo? Tropieza con eso una o dos veces y perderás toda la ventaja de ahorro de tiempo que tenías al sincronizar constantemente o algo similar.

Answer 10

Siempre puedes usar el control de versiones, como SVN, por lo que todo lo que tienes que hacer es que el servidor ejecute svn en una carpeta todas las noches. Esto entra en problemas de seguridad si está compartiendo 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. Pase por la página man , el formato básico que querrá es

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

el comando que ejecuto desde el servidor de mi escuela a mi máquina de copia de seguridad casera 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), verbosly (-v), enumera todos los cambios realizados (-i), mientras elimina cualquier archivo que ya no exista. (--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 agrega al archivo BackupLog.txt

Sé que es una gira torbellino de rsync, pero espero que ayude.

Answer 11

Solía ​​tener la misma configuración en Windows que usted, que es un archivo de archivos local (versionado) y un entorno de prueba en un servidor remoto, que guardé reflejado en tiempo real con WinSCP. Cuando cambié a Mac tuve que hacer algunas excavaciones antes de ser feliz, pero finalmente terminé usando:

• SmartSVN como mi cliente de subversión
• Sublime Text 2 como mi editor (ya lo usé en Windows)
• SFTP-plugin to 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!

Answer 12

También puede usar Recuperar como un cliente SFTP, y luego editar archivos directamente desde dentro del servidor. También hay opciones de SSHFS (montar una carpeta ssh como volumen). Esto está en línea con lo que dicen los estímulos: ¿estás seguro de que quieres que las cosas estén sincronizadas, o solo quieres 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.

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

Answer 13

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

Cómo utilizar:

• Asegúrate de tener los archivos cambiados instalados
• Guarde este script en / usr / local / bin / livesync o en algún lugar accesible en $ PATH y hágalo ejecutable
• Use Nautilus para conectarse al host remoto (sftp o ftp)
• Ejecute este script haciendo livesync SOURCE DEST
• El directorio DEST estará en /home/[nombredeusuario]/.gvfs/[path para ftp scp o lo que sea]

Un par de desventajas:

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

Answer 14

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

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

Answer 15

lsyncd parece ser la solución perfecta. combina inotify (función integrada kernel que vigila los cambios de archivos en un árbol 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 árbol 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. Por lo tanto, Lsyncd es una solución ligera de espejo real que es comparativamente fácil de instalar y no requiere nuevos sistemas de archivos o dispositivos de bloqueo y no obstaculiza el rendimiento del sistema de archivos local.