Hou afstandgids op datum

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

  •  08-06-2019
  •  | 
  •  

Vra

Ek is absoluut mal oor die Hou afstandgids op datum verskyn in Winscp.Ongelukkig kan ek niks so eenvoudig vind om in OS X of Linux te gebruik nie.Ek weet dieselfde ding kan teoreties bewerkstellig word deur gebruik te maak lêers verander of rsinc, maar ek het nog altyd gevind dat die tutoriale vir beide gereedskap ontbreek en/of teenstrydig is.

Ek het basies net 'n instrument nodig wat in OSX of Linux werk en 'n afgeleë gids gesinchroniseer (gespieël) met 'n plaaslike gids hou terwyl ek veranderinge aan die plaaslike gids maak.

Opdateer

As ek deur die oplossings kyk, sien ek 'n paar wat die algemene probleem oplos om 'n afgeleë gids gesinchroniseer met 'n plaaslike gids te hou handmatig.Ek weet dat ek 'n cron-taak kan stel om rsync elke minuut te laat loop, en dit behoort redelik naby aan reële tyd te wees.

Dit is nie die presiese oplossing waarna ek gesoek het nie, want winscp doen dit en meer:dit bespeur lêerveranderinge in 'n gids (terwyl ek daaraan werk) en stoot dan outomaties die veranderinge na die afgeleë bediener.Ek weet dit is nie die beste oplossing nie (geen kodebewaarplek nie), maar dit stel my in staat om kode baie vinnig op 'n bediener te toets terwyl ek dit ontwikkel.Weet iemand hoe om rsync met enige ander opdragte te kombineer om hierdie funksionaliteit te kry?

Was dit nuttig?

Oplossing

Hoe "intyds" wil jy die sinkronisering hê?Ek sal steeds na rsync leun, aangesien jy weet dat dit ten volle op beide platforms ondersteun gaan word (ook Windows, met cygwin) en jy kan dit via 'n cron-werk bestuur.Ek het 'n super-eenvoudige bash-lêer wat ek op my stelsel laat loop (dit doen nie verwyder ou lêers):

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

Jou beste opsie is om dit op te stel en dit uit te probeer.Die -n (--dry-run) opsie is jou vriend!

Hou in gedagte dat rsync (ten minste in cygwin) nie unicode-lêername ondersteun nie (vanaf 16 Aug 2008).

Ander wenke

lsyncd blyk die perfekte oplossing te wees.dit kombineer in kennis stel (kern ingeboude funksie wat kyk vir lêerveranderinge in 'n gidsbome) en rsinc (kruisplatform lêer-sinkronisering-instrument). 

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

Aanhaling van github:

Lsyncd kyk na 'n plaaslike gidsbome gebeurtenis monitor koppelvlak (notify of fsevents).Dit versamel en kombineer gebeurtenisse vir 'n paar sekondes en skep dan een (of meer) proses(se) om die veranderinge te sinchroniseer.By verstek is dit rsync.Lsyncd is dus 'n liggewig lewendige spieëloplossing wat relatief maklik is om te installeer wat nie nuwe lêerstelsels of bloktoestelle benodig nie en nie plaaslike lêerstelselwerkverrigting belemmer nie.

Wat jy wil doen vir Linux-afstandtoegang, is om 'sshfs' te gebruik - die SSH-lêerstelsel.

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

Behandel dit dan soos 'n netwerkmontering, wat dit is ...

'n Bietjie meer detail, soos hoe om dit op te stel sodat jy dit as 'n gewone gebruiker kan doen my blog

As jy die asynchrone gedrag van winSCP wil hê, sal jy rsync wil gebruik gekombineer met iets wat dit periodiek uitvoer.Die cron-oplossing hierbo werk, maar kan te veel wees vir die winscp-gebruiksgeval.

Die volgende opdrag sal rsync elke 5 sekondes uitvoer om inhoud na die afgeleë gasheer te stoot.Jy kan die slaaptyd aanpas soos nodig om die bedienerlading te verminder.

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

As jy 'n baie groot gidsstruktuur het en die bokoste van die peiling moet verminder, kan jy 'vind' gebruik:

# 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

En ek het gesê dat cron dalk oordrewe is?Maar dit word ten minste alles net vanaf die opdragreël gedoen en kan gestop word via 'n ctrl-C.

kb

Om veranderde lêers op te spoor, kan jy probeer fam (lêerveranderingsmonitor) of inotify.Laasgenoemde is Linux-spesifiek, fam het 'n bsd-poort wat op OS X kan werk.Albei het gebruikersruimtenutsgoed wat saam met rsync in 'n skrip gebruik kan word.

Ek het dieselfde probleem.Ek was mal oor winscp "hou remote directory up to date" opdrag.In my strewe om myself van Windows te ontslae te raak, het ek egter winscp verloor.Ek het wel 'n skrip geskryf wat filechanged en rsync gebruik om iets soortgelyks baie nader aan real-time te doen.

Hoe om te gebruik:

  • Maak seker dat jy lêers verander het geïnstalleer
  • Stoor hierdie skrip in /usr/local/bin/livesync of iewers bereikbaar in jou $PATH en maak dit uitvoerbaar
  • Gebruik Nautilus om aan die afgeleë gasheer te koppel (sftp of ftp)
  • Begin hierdie skrip deur lewendige sinchronisasie te doen BRON BESTEMMING
  • Die DEST-gids sal in /home/[gebruikersnaam]/.gvfs/[pad na ftp scp of wat ook al] wees

'n Paar nadele:

  • Dit is stadiger as winscp (my raaiskoot is omdat dit deur Nautilus gaan en ook veranderinge deur rsync moet opspoor)
  • Jy moet die bestemmingsgids handmatig skep as dit nie reeds bestaan ​​nie.As jy dus 'n gids byvoeg, sal dit nie die gids aan die DEST-kant opspoor en skep nie.
  • Seker meer wat ek nog nie opgemerk het nie
  • Moet ook nie probeer om 'n SRC-gids met die naam "rsyncThis" te sinchroniseer nie.Dit sal seker nie goed wees nie :)
#!/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

Jy kan altyd weergawebeheer gebruik, soos SVN, so al wat jy hoef te doen is om die bediener elke aand op 'n gids te laat loop.Dit loop in sekuriteitskwessies as jy jou lêers publiek deel, maar dit werk.

As jy egter Linux gebruik, leer om rsync te gebruik.Dit is regtig nie so moeilik nie, want jy kan elke opdrag met -n toets.Gaan deur die man bladsy, is die basiese formaat wat jy wil hê

rsync [OPSIE...] SRC...[USER@]HOST:DEST

die opdrag wat ek vanaf my skoolbediener na my tuisrugsteunmasjien uitvoer, is dit

rsync -avi --delete ~ my@homeserv:~/Skool/ >> BackupLog.txt

Dit neem al die lêers in my tuisgids (~) en gebruik rsync se argiefmodus (-a), verbosly (-v), lys al die veranderinge wat gemaak is (-i), terwyl enige lêers wat nie meer bestaan ​​nie, uitvee (--delete) en plaas die in die gids /home/me/School/ op my afgeleë bediener.Al die inligting wat dit uitdruk (wat gekopieer is, wat uitgevee is, ens.) word ook by die lêer BackupLog.txt gevoeg

Ek weet dit is 'n warrelwind toer van rsync, maar ek hoop dit help.

Die rsync oplossings is regtig goed, veral as jy net veranderinge op een manier druk.Nog 'n wonderlike hulpmiddel is unison -- dit poog om veranderinge in beide rigtings te sinkroniseer.Lees meer by die Unison-tuisblad.

Dit lyk of jy dalk die verkeerde probleem oplos.As jy probeer om lêers op 'n afgeleë rekenaar te wysig, kan jy dalk iets soos die ftp-inprop vir jedit probeer gebruik. http://plugins.jedit.org/plugins/?FTP Dit verseker dat jy net een weergawe van die lêer het, sodat dit nooit gesinchroniseer kan word nie.

Op grond van icco se voorstel van SVN, sou ek eintlik voorstel dat as jy subversion of soortgelyke gebruik vir bronbeheer (en as jy nie is nie, moet jy waarskynlik begin) jy die produksie-omgewing op datum kan hou deur die opdrag te plaas om die bewaarplek in die post-commit-haak op te dateer.

Daar is baie veranderlikes in hoe jy dit wil doen, maar wat ek gesien het werk is dat die ontwikkeling of lewendige werf 'n werkende kopie moet wees en dan moet die post-commit 'n ssh-sleutel gebruik met 'n gedwonge opdrag om meld aan by die afgeleë webwerf en aktiveer 'n svn op die werkkopie.Alternatiewelik kan jy in die post-commit-haak 'n svn-uitvoer op die afgeleë masjien aktiveer, of 'n plaaslike (na die svn-bewaarplek) svn-uitvoer en dan 'n rsync na die afgeleë masjien.

Ek sou bekommerd wees oor dinge wat veranderinge opspoor en dit druk, en ek sou selfs bekommerd wees oor dinge wat elke minuut hardloop, net as gevolg van wedrentoestande.Hoe weet jy dat dit nie die lêer gaan oordra op dieselfde oomblik waarna dit geskryf word nie?Kom dit een of twee keer oor en jy sal al die tydbesparende voordeel wat jy gehad het verloor deur voortdurend te sinkroniseer of soortgelyk.

Sal DropBox (http://www.getdropbox.com/) doen wat jy wil?

Gebruiker watcher.py en rsync om dit te outomatiseer.Lees die volgende stap-vir-stap instruksies hier:

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

Ek het vroeër dieselfde opstelling onder Windows as jy gehad, dit is 'n plaaslike lêerboom (weergawe) en 'n toetsomgewing op 'n afgeleë bediener, wat ek intyds met WinSCP weerspieël gehou het.Toe ek na Mac oorgeskakel het, moes ek nogal grawe voordat ek gelukkig was, maar het uiteindelik die volgende gebruik:

  • SmartSVN as my subversion kliënt
  • Sublieme teks 2 as my redakteur (het dit al op Windows gebruik)
  • SFTP-inprop na ST2 wat die oplaai by stoor hanteer (jammer, kan nie meer as 2 skakels plaas nie)

Ek kan hierdie opstelling regtig aanbeveel, hoop dit help!

U kan ook Fetch as 'n SFTP-kliënt gebruik, en dan lêers direk op die bediener van daaruit redigeer.Daar is ook SSHFS-opsies (monteer 'n ssh-lêergids as 'n volume).Dit is in ooreenstemming met wat stimms gesê het - is jy seker jy wil dinge gesinchroniseer hê, of wil net lêers op die bediener wysig?

OS X het sy eie lêerkennisgewingstelsel - dit is waarop Spotlight gebaseer is.Ek het nog nie gehoor van enige program wat dit gebruik om dinge dan gesinchroniseer te hou nie, maar dit is beslis denkbaar.

Ek gebruik persoonlik RCS vir hierdie tipe ding:- alhoewel dit 'n handmatige aspek het, is dit onwaarskynlik dat ek iets na selfs die toetsbediener van my dev-masjien wil stoot sonder om dit eers te toets.En as ek aan 'n ontwikkelingsbediener werk, gebruik ek een van die opsies hierbo gegee.

Wel, ek het dieselfde soort probleem gehad en dit is moontlik om hierdie saam te gebruik:rsync, SSH Passwordless Login, Watchdog ('n Python-sinkroniseringsprogram) en Terminal Notifier ('n OS X-kennisgewingsnutsmiddel wat met Ruby gemaak is.Nie nodig nie, maar help om te weet wanneer die sinkronisering klaar is).

  1. Ek het die sleutel tot Wagwoordlose aanmelding geskep met behulp van hierdie tutoriaal vanaf Dreamhost wiki: http://cl.ly/MIw5

    1.1.As jy klaar is, toets of alles reg is ... as jy nie Wagwoordloos kan aanmeld nie, moet jy dalk afp mount probeer.Dreamhost (waar my webwerf is) laat nie afp-montering toe nie, maar laat Wagwoordlose aanmelding toe.Tik in terminaal:

    ssh username@host.com Jy moet aanmeld sonder dat wagwoorde gevra word :P

  2. Ek het die Terminal Notifier vanaf die Github-bladsy geïnstalleer: http://cl.ly/MJ5x

    2.1.Ek het die Gem installeerder opdrag gebruik.Tik in Terminal:

    gem install terminal-notifier

    2.3.Toets of die kennisgewing werk.Tik in Terminal:

    terminal-notifier -message "Starting sync"

  3. Skep 'n sh script om die rsync + kennisgewing te toets.Stoor dit waar jy wil, met die naam waarvan jy hou.In hierdie voorbeeld sal ek dit noem ~/Scripts/sync.sh Ek het die ".sh-uitbreiding gebruik, maar ek weet nie of dit nodig is nie.

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

    3.1.Onthou om uitvoeringstoestemming aan hierdie sh script te gee.Tik in Terminal:

    sudo chmod 777 ~/Scripts/sync.sh 3.2.Begin die skrip en verifieer of die boodskappe korrek vertoon word en die rsync sinkroniseer eintlik jou plaaslike vouer met die afgeleë vouer.

  4. Uiteindelik het ek Watchdog vanaf die Github-bladsy afgelaai en geïnstalleer: http://cl.ly/MJfb

    4.1.Eerstens het ek die libyaml-afhanklikheid met Brew geïnstalleer (daar is baie hulp om Brew te installeer - soos 'n "aanleg" vir OS X).Tik in Terminal:

    brew install libyaml

    4.2.Toe het ek die "easy_install command" gebruik.Gaan die gids van Watchdog, en tik in Terminal:

    easy_install watchdog

  5. Nou is alles geïnstalleer! Gaan na die gids wat jy gesinkroniseer wil word, verander hierdie kode volgens jou behoeftes, en tik in Terminal:

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

    Dit moet wees PRESIES op hierdie manier, met die skuinsstreepies en lynbreuke, so jy sal hierdie reëls na 'n teksredigeerder moet kopieer, die skrif verander, in terminaal plak en terugkeer druk.

    Ek het probeer sonder die lynbreuke, en dit werk nie!

    In my Mac kry ek altyd 'n fout, maar dit lyk nie of dit enigiets beïnvloed nie:

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

    Nou, maak 'n paar veranderinge in 'n lêer binne die gids, en kyk na die magie!

Ek gebruik hierdie klein 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

Pas dit aan vir jou behoeftes!

As jy python op 'n afgeleë bediener ontwikkel, kan Pycharm 'n goeie keuse vir jou wees.Jy kan jou afgeleë lêers sinchroniseer met jou plaaslike lêers deur gebruik te maak van die pycharm-afgeleë ontwikkelingsfunksie.Die gids skakel as:https://www.jetbrains.com/help/pycharm/creating-a-remote-server-configuration.html

Gelisensieer onder: CC-BY-SA met toeskrywing
Nie verbonde aan StackOverflow
scroll top