Jak wprowadzić .vimrc, kiedy mam SSH?

Moja praca zwykle polega na korzystaniu z SSH do łączenia się z różnymi komputerami, a następnie z użyciem vima do edycji plików na tych komputerach. Problem polega na tym, że muszę ciągle kopiować mój plik .vimrc. Otwarcie vima i brak jakichkolwiek ustawień jest bardzo denerwujące. Czy można przenosić moje ustawienia vima ze sobą na maszynę bez ręcznego kopiowania go wszędzie?

Czuję twój ból. Mam wszystkie moje pliki ~ /.* rc pod kontrolą wersji (Subversion), działa świetnie, odkąd zacząłem w 1998 roku, używając CVS. Jednym ze sposobów, aby to zrobić, jest sprawdzenie wszystkich takich plików rc, gdy stoisz w katalogu domowym:

svn co svn+ssh://user@host/path/to/repo/trunk/home/user .
A    .signature
A    .vimrc
A    .bashrc
A    .screenrc
A    .psqlrc
[...]
Checked out revision 7645.

W ten sposób pliki konfiguracyjne będą również synchronizowane i aktualizowane na różnych komputerach po uruchomieniu aktualizacji svn.

Zamiast przenosić plik .vimrc na każdy serwer, na którym musisz pracować, dlaczego nie edytować plików zdalnych z lokalnego vima:

W vim / gvim uruchom:

:e scp://[email protected]//path/to/document

lub zacznij vim tak:

vim scp://[email protected]//path/to/document

Spowoduje to otwarcie pliku na miejscu (faktycznie kopiuje plik lokalnie), a kiedy zapiszesz, wyśle ​​on edytowany plik z powrotem na serwer.

Prosi o hasło ssh, ale można je usprawnić za pomocą kluczy ssh.

Jak wspomnieli inni, jedyną wadą tej metody jest to, że nie uzyskuje się rywalizacji o ścieżkę / plik, tak jak w przypadku pracy bezpośrednio na komputerze.

Aby uzyskać więcej informacji, zapoznaj się z poniższym samouczkiem .

Możesz utworzyć skrypt bash, aby kopiować go automatycznie przy każdym logowaniu, w następujący sposób:

#!/usr/bin/env bash

scp ~/.vimrc $1:
ssh $1

Na przykład możesz to nazwać ssh_vim. To nie jest idealne rozwiązanie, ale rozwiąże problem.

Możesz go ulepszyć, aby najpierw sprawdzić, czy już tam jest. Jeśli nie zawsze uruchamiasz ssh z tego samego komputera, możesz zmienić skrypt, aby pobrać plik z scp z innego komputera.

EDYCJA 1

W powiązanej notatce można również zamontować system plików komputera zdalnego za pomocą sshfs. W ten sposób zyskujesz na swoim środowisku i narzędziach (nie tylko .vimrc) i masz ukończoną powłokę (której nie używasz scp: //).

EDYCJA 2

Właśnie dowiedziałem się, że możesz pobrać swój plik .vimrc za pomocą scp: //, w następujący sposób:

:source scp://you@your_computer//yourpath/.vimrc

Działa to z wiersza poleceń vim, ale w tej chwili nie wiem, jak to zautomatyzować. Wydaje się, że nie działa ani z przełącznikiem „-u”, ani w .vimrc, ani z $ VIMINIT.

EDYCJA 3

Znalazłem to! Możesz to zrobić, aby uruchomić vima z .vimrc pobranym z twojego zbioru referencji:

vim -c ':source scp://you@your_computer//yourpath/.vimrc'

Opcja „-c” wykonuje polecenie zaraz po uruchomieniu vima.

Możesz utworzyć alias w wybranej powłoce, aby uniknąć pisania. W bash wyglądałoby to tak:

alias vim="vim -c ':source scp://you@your_computer//yourpath/.vimrc'"

Jeśli korzystasz z uwierzytelniania za pomocą klucza publicznego, możesz użyć tego w ~/.ssh/config:

Host *
   PermitLocalCommand yes
   LocalCommand bash -c 'scp -P %p %d/.vimrc %u@%n: &>/dev/null &'

Podoba mi się to lepiej niż sztuczka skryptu sugerowana powyżej, ponieważ nie zakłóca wywołania sshpolecenia (przy określaniu dodatkowych parametrów itp.)

Kilka rozwiązań:

1) Utwórz udział NFS dla swojego folderu domowego i zamapuj go w wielu lokalizacjach.

2) Utwórz mały skrypt, aby wypchnąć plik .vimrc na serwer, z którym się łączysz, za pomocą pliku tożsamości / klucza. Może wyglądać mniej więcej tak (pseudokod):

connectString = arg0  #username@ipaddress

scp -i ~/.ssh/indentity connectString:~/ ~/.vimrc
ssh -i ~/.ssh/indentity connectString

Dokładnie taka sama odpowiedź, jak sunny256, ale użyj git zamiast SubVersion.

Zachowaj jeden główny oddział z plikami wspólnymi dla wszystkich komputerów i jeden oddział dla każdego nowego komputera.

W ten sposób możesz mieć prawie takie same pliki na większości komputerów i nadal nie być zdezorientowanym.

Wiem, że to stary wątek, ale jednym ze sposobów, w jaki to robię, jest użycie sshfs, który montuje system plików na bezpieczniku. Lokalny vim wykonuje całą edycję, więc nie ma powodu, aby kopiować .vimrc.

Ma to tę wadę, że inny terminal będzie musiał być otwarty dla wszelkich poleceń, które muszą być uruchomione na zdalnym serwerze, ale do edycji uważam, że ten sposób jest najlepszy.

Ma również dodatkową zaletę korzystania ze schowka systemowego.

Używam https://github.com/andsens/homeshick do zarządzania moimi plikami dot i przechowywania ich na github.

Homeshick napisany jest w 100% bash i pomaga zarządzać „zamkami”, które są po prostu repozytoriami git zawierającymi katalog / home /. Ma polecenia, aby przenieść istniejące pliki kropek do repozytorium i zastąpić je dowiązaniami symbolicznymi. I aby dowiązać symbolicznie wszystkie pliki z repozytorium do twojego katalogu domowego na nowym komputerze.

Zatem ogólną ideą jest trzymanie plików dot w systemie kontroli wersji i dowiązanie do nich z prawdziwej ścieżki. W ten sposób Twoje repozytorium nie musi zaczynać się od katalogu domowego i zawierać mnóstwo plików, których nigdy nie chcesz dodawać.

Jeśli jesteś podobny do mnie i masz wiele maszyn programistycznych (również maszyn wirtualnych) z różnych powodów, możesz łączyć klucze ssh, inteligentny profil bash_profil i wybrany RCS.

Po drugie użyłbym nfs / samaba / sshfs. Jedną z wad jest to, że jeśli nie masz dostępu do sieci przez cały czas, nie możesz uzyskać dostępu do tego, czego potrzebujesz (latanie, brak Wi-Fi, zapory ogniowe, problemy z routingiem itp.). Komputery, które synchronizuję, nie są dostępne jednocześnie, ale chcę udostępnić między nimi informacje.

Oto jak zacząłem pożyczać wiele pomysłów z Internetu.

.bash_profile może mieć coś takiego

$HOME/bin/shell_ssh_agent

Mam to z kilku miejsc, ale nie mogę teraz znaleźć linku do tego. Plik shell_ssh_agent:

#!/bin/bash

SSH_ENV=$HOME/.ssh/environment

#echo "starting"

function start_agent {
    #echo "reaping agents"
    killall ssh-agent
    #echo "Initialising new SSH agent..."
    /usr/bin/ssh-agent | sed 's/^echo/#echo/' > ${SSH_ENV}
    #echo succeeded
    chmod 600 ${SSH_ENV}
    . ${SSH_ENV}
    /usr/bin/ssh-add;
}

# Source SSH settings, if applicable

if [ -f "${SSH_ENV}" ]; then
    . ${SSH_ENV}
    #echo "sourced ssh env"
    ps -ef | grep ${SSH_AGENT_PID} | grep ssh-agent > /dev/null || { start_agent; }
else
    start_agent;
fi

Teraz przy pierwszym logowaniu konfigurujesz klucze. Wyloguj się i zaloguj, a to po prostu ułatwiło życie.

Umieść wszystkie skrypty w RCS, co ułatwia synchronizację maszyn programistycznych. Używam git. Uwierzytelnianie za pomocą git odbywa się za pośrednictwem ssh, więc klucze ssh również tutaj pomagają. Zauważ, że w tym momencie mogłeś użyć czegoś takiego jak nfs. Nadal byłbym fanem RCS z powodów, które wymienię poniżej.

Przypadek użycia to

1. zaloguj się po raz pierwszy, klucze zostaną skonfigurowane
2. jeśli RCS nie jest skonfigurowany, sprawdź swoje skrypty osobiste (i zaktualizuj / scal w razie potrzeby, może nawet być częścią twojego .bash_profile, jeśli chcesz)
3. edytuj vimrc, specjalne skrypty itp. i zatwierdzaj je
4. po zalogowaniu się na innych komputerach wykonaj aktualizację / scalenie / pobranie. Dzięki temu wszystko jest zsynchronizowane; tzn. koniec z kopiowaniem plików, które czasem tupiesz i nie chcesz.
5. dodatkową korzyścią jest moc RCS. Czasami wprowadzam niekorzystne zmiany w skryptach lub konfiguracjach i muszę je wycofać i tym podobne.

Coś, co chcę wypróbować, to zapakować początkowe dane logowania / ustawienia do pliku makefile, który kopiuję na nowy komputer. Plik makefile może następnie wykonać konfigurację kluczy, RCS itp. Oczywiście jest tu trochę narzutu, ale jeśli zakończysz konfigurowanie wielu maszyn, jest to:

1. oszczędność czasu
2. łatwiej utrzymać synchronizację konfiguracji i osobistych skryptów maszyn programistycznych
3. zarządzanie zmianami w skryptach i konfiguracjach.

Używam makefile, który ma listę wszystkich serwerów, na które się loguję, a kiedy dokonam zmiany na moim komputerze lokalnym, „make” jest uruchamiany przy użyciu makefile, który aktualizuje wszystkie serwery za pomocą jakichkolwiek zmian lub wtyczek

sshrc rozwiązuje ten problem. Umieszczasz .vimrc w ~ / .sshrc.d /, a następnie dodajesz export VIMINIT="let \$MYVIMRC='$SSHHOME/.sshrc.d/.vimrc' | source \$MYVIMRC"do `/.sshrc.

Napisałem do tego proste narzędzie, które pozwoli ci natywnie transportować plik .vimrc za każdym razem, gdy ssh , przy użyciu wbudowanych opcji konfiguracyjnych SSHd w niestandardowy sposób.

Brak dodatkowych svn, scp, copy/pasteitp wymagane.

Jest prosty, lekki i domyślnie działa na wszystkich konfiguracjach serwerów, które testowałem do tej pory.

https://github.com/gWOLF3/viSSHous

Za pomocą zmiennej VIMINIT:

export VIMINIT='set number'

i przekazanie go do zdalnego serwera:

ssh remoteuser@remoteserver -o SendEnv=LC_VIMINIT -t 'export VIMINIT=$LC_VIMINIT && bash'

jest łatwe przy użyciu .bash_profiles lub .bashrc

export VIMINIT='
set number
'

export LC_VIMINIT=$VIMINIT

sshh (){
ssh -o SendEnv=LC_VIMINIT $1 -t 'export VIMINIT=$LC_VIMINIT && bash'

Teraz spróbuj uruchomić vima na zdalnym serwerze używając sshh do połączenia:

sshh remoteuser@remoteserver

Jeśli chcesz, możesz również zabrać wtyczki na zdalny serwer:

export LC_VIMINIT="
set number
set nocompatible
filetype off
set rtp+=~/.[USER]_vim/bundle/Vundle.vim
call vundle#begin()
Plugin 'VundleVim/Vundle.vim'


set shell=/bin/bash
call vundle#end()
filetype plugin indent on
"

export VIMINIT=$LC_VIMINIT

sshh (){
        if [[ $1 ]]; then
                ssh-copy-id $1 &>/dev/null &&
                rsync -lzr --partial --del ~/.[USER]_vim ${1}: &&
                ssh -o SendEnv=LC_VIMINIT $1 -t 'export VIMINIT=$LC_VIMINIT && bash';
        else
                echo "Provide remote user@host";
        fi
}

Mam tę samą sytuację, ale to nie tylko „ .vimrc”. Też mam takie rzeczy

• konfiguracja bash, pytania i funkcje,
• pliki konfiguracji i autoryzacji ssh,
• Skrypty powłoki lubię mieć pod ręką.
• oczywiście mój vimrc, ale także niektóre funkcje vim i pliki podświetlające składnię.

Moje rozwiązanie (rozpoczęte 30 lat temu od „dist” pierwotnie!) Polega na skonfigurowaniu nocnego crona do rsync minimalnej konfiguracji domowej na wszystkich komputerach, na których pracuję, aby aktualizował się co noc.

W ten sposób wszystkie inne maszyny, z którymi pracuję, są na bieżąco! Mogę po prostu dodać nowy komputer do listy „kont” i przeprowadzić dystrybucję jednego komputera, aby go uruchomić.

Nie musi to być wiele, a możesz zacząć od małego i uczynić go bardziej złożonym. Jak możecie sobie wyobrazić po 30 latach, moja dystrybucja jest teraz dość złożona, więc nie umieszczę jej tutaj. Nie trzeba dodawać, że zmienia także konfigurację dla innych sieci, porządki domowe (np. Kosz, pliki pamięci podręcznej), upewnia się, że uprawnienia domowe są prawidłowe i tak dalej.

UWAGA Zezwalam na logowanie ssh bez hasła z jednego komputera domowego do wszystkich pozostałych, nigdy więcej! Każdy cross ssh jest chroniony hasłem.

Możesz rozważyć skrypt EXPECT, który pozwala ustawić ścieżkę i środowisko (np. Zmienne EXRC) po naciśnięciu określonego klawisza. Nie powinno to potrwać długo, zanim ktoś opublikuje podobny skrypt.

Gdy farmy serwerów zajmują więcej niż kilkadziesiąt (pomyśl tysiące), posiadanie czegoś, co łatwo skonfigurować środowisko na „dziewiczym” polu, jest prawdziwym ratownikiem

Często, gdy loguję się do skrzynki, tworzy mój homedir po raz pierwszy!

Zostało to zrealizowane za pomocą następującego narzędzia bash oneliner. Ponieważ odbywa się to za pomocą procesu podstawiania, pliki tymczasowe nie są tworzone.

ssh -t user@host '
bash --rcfile <(
    echo -e ' $(cat <(echo "function lvim() { vim -u <(echo "$(cat ~/.vimrc|base64)"|base64 -d) \$@ ; }") \
                    ~/dotfiles/{.bashrc,sh_function,sh_alias,bash_prompt} \
                    <(echo -e alias vim=lvim) | \
                    base64 
               ) ' \
    |base64 -d)'

https://gist.github.com/blacknon/a47083f3bbbd0374998bdf7e3b3396cc