Mantenha o diretório remoto atualizado

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

  •  08-06-2019
  •  | 
  •  

Pergunta

Eu absolutamente amo o Mantenha o diretório remoto atualizado destaque em Winscp.Infelizmente, não consigo encontrar nada tão simples de usar no OS X ou Linux.Eu sei que a mesma coisa pode teoricamente ser realizado usando arquivos alterados ou sincronizar novamente, mas sempre achei os tutoriais de ambas as ferramentas ausentes e/ou contraditórios.

Basicamente, só preciso de uma ferramenta que funcione em OSX ou Linux e mantenha um diretório remoto sincronizado (espelhado) com um diretório local enquanto faço alterações no diretório local.

Atualizar

Examinando as soluções, vejo algumas que resolvem o problema geral de manter um diretório remoto sincronizado com um diretório local manualmente.Eu sei que posso definir uma tarefa cron para executar o rsync a cada minuto, e isso deve ser bem próximo do tempo real.

Esta não é a solução exata que eu procurava, pois o Winscp faz isso e muito mais:ele detecta alterações de arquivos em um diretório (enquanto eu trabalho neles) e, em seguida, envia automaticamente as alterações para o servidor remoto.Eu sei que esta não é a melhor solução (sem repositório de código), mas me permite testar rapidamente o código em um servidor enquanto o desenvolvo.Alguém sabe como combinar o rsync com algum outro comando para obter essa funcionalidade?

Foi útil?

Solução

Quão "em tempo real" você deseja a sincronização?Eu ainda preferiria o rsync, pois você sabe que ele será totalmente compatível com ambas as plataformas (Windows também com o cygwin) e poderá executá-lo por meio de um cron job.Eu tenho um arquivo bash super simples que executo no meu sistema (isso faz não remover arquivos antigos):

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

Sua melhor aposta é configurá-lo e experimentá-lo.O -n (--dry-run) a opção é sua amiga!

Tenha em mente que o rsync (pelo menos no cygwin) não suporta nomes de arquivos unicode (a partir de 16 de agosto de 2008).

Outras dicas

lsyncd parece ser a solução perfeita.isto combina notificar (função interna do kernel que monitora alterações de arquivos em árvores de diretório) e sincronizar novamente (ferramenta de sincronização de arquivos entre plataformas). 

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

Citação do github:

Lsyncd monitora uma interface de monitor de eventos de árvores de diretório local (inotify ou fsevents).Ele agrega e combina eventos por alguns segundos e então gera um (ou mais) processo(s) para sincronizar as alterações.Por padrão, é rsync.Lsyncd é, portanto, uma solução leve de espelho ao vivo que é comparativamente fácil de instalar, não requer novos sistemas de arquivos ou dispositivos de bloco e não prejudica o desempenho do sistema de arquivos local.

O que você deseja fazer para acesso remoto Linux é usar 'sshfs' - o sistema de arquivos SSH.

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

Então trate-o como uma montagem de rede, o que é...

Um pouco mais de detalhes, como configurá-lo para que você possa fazer isso como um usuário normal, em meu blog

Se você deseja o comportamento assíncrono do winSCP, você desejará usar o rsync combinado com algo que o execute periodicamente.A solução cron acima funciona, mas pode ser um exagero para o caso de uso do Winscp.

O comando a seguir executará rsync a cada 5 segundos para enviar conteúdo ao host remoto.Você pode ajustar o tempo de suspensão conforme necessário para reduzir a carga do servidor.

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

Se você tiver uma estrutura de diretórios muito grande e precisar reduzir a sobrecarga da pesquisa, poderá 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

E eu disse que o cron pode ser um exagero?Mas pelo menos tudo isso é feito na linha de comando e pode ser interrompido por meio de Ctrl-C.

KB

Para detectar arquivos alterados, você pode tentar fam (monitor de alteração de arquivos) ou inotify.Este último é específico do Linux, fam possui uma porta bsd que pode funcionar no OS X.Ambos possuem ferramentas de espaço de usuário que podem ser usadas em um script junto com o rsync.

Eu tenho o mesmo problema.Adorei o comando "manter o diretório remoto atualizado" do Winscp.No entanto, em minha busca para me livrar do Windows, perdi o Winscp.Eu escrevi um script que usa fileschanged e rsync para fazer algo semelhante, muito mais próximo do tempo real.

Como usar:

  • Certifique-se de ter o arquivo alterado instalado
  • Salve este script em /usr/local/bin/livesync ou em algum lugar acessível em seu $PATH e torne-o executável
  • Use o Nautilus para conectar-se ao host remoto (sftp ou ftp)
  • Execute este script fazendo livesync FONTE DESTINO
  • O diretório DEST estará em /home/[username]/.gvfs/[path to ftp scp ou qualquer outro]

Algumas desvantagens:

  • É mais lento que o Winscp (acho que é porque ele passa pelo Nautilus e também precisa detectar alterações por meio do rsync)
  • Você deve criar manualmente o diretório de destino se ele ainda não existir.Portanto, se você estiver adicionando um diretório, ele não detectará e criará o diretório no lado DEST.
  • Provavelmente mais que eu ainda não percebi
  • Além disso, não tente sincronizar um diretório SRC denominado "rsyncThis".Provavelmente não será bom :)
#!/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

Você sempre pode usar o controle de versão, como o SVN, então tudo o que você precisa fazer é fazer com que o servidor execute o svn em uma pasta todas as noites.Isso gera problemas de segurança se você compartilhar seus arquivos publicamente, mas funciona.

Se você estiver usando Linux, aprenda a usar o rsync.Na verdade, não é tão difícil, pois você pode testar todos os comandos com -n.Passar pela página de manual, o formato básico que você deseja é

rsync [OPÇÃO...] SRC...[USUÁRIO@]HOST:DEST

o comando que executo do servidor da minha escola para a minha máquina de backup doméstica é este

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

Isso pega todos os arquivos do meu diretório inicial (~) e usa o modo de arquivamento do rsync (-a), detalhadamente (-v), lista todas as alterações feitas (-i), enquanto exclui todos os arquivos que não existem mais (--delete) e coloca na pasta /home/me/School/ no meu servidor remoto.Todas as informações impressas (o que foi copiado, o que foi excluído, etc.) também são anexadas ao arquivo BackupLog.txt

Eu sei que é um passeio rápido pelo rsync, mas espero que ajude.

O rsync soluções são realmente boas, especialmente se você estiver empurrando as mudanças apenas para um lado.Outra ótima ferramenta é unison - tenta sincronizar as alterações em ambas as direções.Leia mais em a página inicial do Unison.

Parece que talvez você esteja resolvendo o problema errado.Se você estiver tentando editar arquivos em um computador remoto, tente usar algo como o plugin FTP para jedit. http://plugins.jedit.org/plugins/?FTP Isso garante que você tenha apenas uma versão do arquivo para que ele nunca fique fora de sincronia.

Com base na sugestão de SVN da icco, eu realmente sugiro que se você estiver usando o subversion ou similar para controle de origem (e se não estiver, provavelmente deveria começar), você pode manter o ambiente de produção atualizado colocando o comando para atualizar o repositório no gancho pós-commit.

Existem muitas variáveis ​​​​em como você gostaria de fazer isso, mas o que vi funcionar é fazer com que o site de desenvolvimento ou ativo seja uma cópia de trabalho e, em seguida, faça com que o pós-commit use uma chave ssh com um comando forçado para faça login no site remoto e acione um svn up na cópia de trabalho.Alternativamente, no gancho pós-commit, você pode acionar um svn export na máquina remota, ou um svn export local (para o repositório svn) e então um rsync para a máquina remota.

Eu ficaria preocupado com coisas que detectam mudanças e as empurram, e até mesmo com coisas que acontecem a cada minuto, apenas por causa das condições da corrida.Como você sabe que o arquivo não será transferido no mesmo instante em que está sendo gravado?Tropeçar nisso uma ou duas vezes e você perderá toda a vantagem de economia de tempo que tinha ao sincronizar constantemente ou algo semelhante.

O DropBox (http://www.getdropbox.com/) faça o que você quiser?

Use watcher.py e rsync para automatizar isso.Leia as seguintes instruções passo a passo aqui:

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

Eu costumava ter a mesma configuração que você no Windows, que é uma árvore de arquivos local (versionada) e um ambiente de teste em um servidor remoto, que mantive espelhado em tempo real com WinSCP.Quando mudei para o Mac, tive que pesquisar bastante antes de ficar feliz, mas finalmente acabei usando:

  • SmartSVN como meu cliente subversão
  • Texto Sublime 2 como meu editor (já usei no Windows)
  • Plugin SFTP para ST2 que lida com o upload ao salvar (desculpe, não é possível postar mais de 2 links)

Eu realmente recomendo esta configuração, espero que ajude!

Você também pode usar o Fetch como um cliente SFTP e editar arquivos diretamente no servidor a partir dele.Existem também opções de SSHFS (montar uma pasta ssh como volume).Isso está de acordo com o que stimms disse - você tem certeza de que deseja que as coisas sejam mantidas sincronizadas ou apenas deseja editar arquivos no servidor?

O OS X tem seu próprio sistema de notificações de arquivos - é nisso que o Spotlight se baseia.Não ouvi falar de nenhum programa que use isso para manter as coisas sincronizadas, mas certamente é concebível.

Eu pessoalmente uso o RCS para esse tipo de coisa: - embora tenha um aspecto manual, é improvável que eu queira enviar algo para o servidor de teste da minha máquina de desenvolvimento sem testá-lo primeiro.E se estou trabalhando em um servidor de desenvolvimento, uso uma das opções fornecidas acima.

Bem, eu tive o mesmo tipo de problema e é possível usá-los juntos:rsync, SSH Passwordless Login, Watchdog (um utilitário de sincronização Python) e Terminal Notifier (um utilitário de notificação do OS X feito com Ruby.Não é necessário, mas ajuda a saber quando a sincronização terminou).

  1. Criei a chave para login sem senha usando este tutorial do wiki Dreamhost: http://cl.ly/MIw5

    1.1.Quando terminar, teste se está tudo bem… se não conseguir o Login sem senha, talvez seja necessário tentar o afp mount.Dreamhost (onde está meu site) não permite montagem afp, mas permite login sem senha.No terminal, digite:

    ssh username@host.com Você deve fazer o login sem que as senhas sejam solicitadas: P

  2. Instalei o Terminal Notifier da página do Github: http://cl.ly/MJ5x

    2.1.Usei o comando do instalador Gem.No Terminal, digite:

    gem install terminal-notifier

    2.3.Teste se a notificação funciona. No Terminal, digite:

    terminal-notifier -message "Starting sync"

  3. Crie um script sh para testar a notificação rsync +.Salve-o onde quiser, com o nome que desejar.Neste exemplo, vou chamá-lo ~/Scripts/sync.sh Usei a extensão ".sh, mas não sei se é necessária.

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

    3.1.Lembre-se de dar permissão de execução a este script sh.No Terminal, digite:

    sudo chmod 777 ~/Scripts/sync.sh 3.2.Execute o script e verifique se as mensagens são exibidas corretamente e se o rsync realmente sincroniza sua pasta local com a pasta remota.

  4. Finalmente, baixei e instalei o Watchdog da página do Github: http://cl.ly/MJfb

    4.1.Primeiro, instalei a dependência libyaml usando o Brew (há muita ajuda sobre como instalar o Brew - como uma "aptidão" para o OS X).No Terminal, digite:

    brew install libyaml

    4.2.Então usei o "comando easy_install".Vá até a pasta do Watchdog e digite Terminal:

    easy_install watchdog

  5. Agora está tudo instalado! Vá para a pasta que deseja sincronizar, altere este código de acordo com suas necessidades, e digite Terminal:

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

    Tem que ser EXATAMENTE desta forma, com as barras e quebras de linha, então você terá que copiar essas linhas para um editor de texto, alterar o script, colar no terminal e pressionar Enter.

    Tentei sem quebras de linha e não funcionou!

    No meu Mac, sempre recebo um erro, mas isso não parece afetar 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.

    Agora, faça algumas alterações em um arquivo dentro da pasta e veja a mágica!

Estou usando este pequeno 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

Adapte-o às suas necessidades!

Se você estiver desenvolvendo python em um servidor remoto, o Pycharm pode ser uma boa escolha para você.Você pode sincronizar seus arquivos remotos com seus arquivos locais utilizando o recurso de desenvolvimento remoto pycharm.O link do guia como:https://www.jetbrains.com/help/pycharm/creating-a-remote-server-configuration.html

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top