Synchroniser les paquets entre différentes machines

J'utilise emacs à différents endroits et je souhaite disposer d'une configuration et de packages similaires installés partout. Je suppose que je peux utiliser un référentiel de contrôle de version pour les fichiers d'installation. Depuis que j'utilise Prelude , ce serait ~/.emacs.d/personal/.

Je ne sais pas comment faire avec les paquets. Existe-t-il un fichier quelque part dans .emacs.d/la liste des packages installés que je peux utiliser pour créer emacs sur d’autres machines et pour installer également ceux répertoriés ici?

Il n'y a pas de fichier manifeste généré automatiquement que vous pouvez synchroniser pour obtenir l'effet souhaité.

Cela dit, vous pouvez ajouter des appels à package-installvotre configuration emacs elle-même.

(package-install 'auctex)

L'idée est que package-installc'est idempotent, donc si le paquet est déjà présent, rien ne se passera réellement. En supposant que vous ayez un tel appel pour chaque paquet que vous utilisez (ou au moins les feuilles du graphique de dépendance), cela synchroniserait efficacement vos paquets sur toutes les machines.

Pour plusieurs packages, vous pouvez utiliser les éléments suivants:

(setq my-package-list '(package1 package2 packageN))
(mapc #'package-install my-package-list)

Je garde mon répertoire .emacs.d dans le contrôle de version. Ensuite, dans mon init.el et les fichiers suivants, j'utilise use-package pour définir la configuration du paquet. Use-package ne charge pas uniquement vos paquets, il les téléchargera à la demande s'ils n'existent pas dans les dépôts de paquets que vous avez configurés.

Par exemple, j'utilise le mode go, mais pas sur toutes les machines. Dans mon init.el j'ai les éléments suivants:

(use-package go-mode
  :ensure t
  :config
  (progn
    (defun my-go-mode-hook ()
      (linum-mode t)
      (setq tab-width 4)
      (add-hook 'before-save-hook 'gofmt-before-save))
    (add-hook 'go-mode-hook 'my-go-mode-hook)))

Cela ajoute un crochet de mode, mais plus important encore, en spécifiant :ensure t, le package sera téléchargé à la demande.

Pour garder une machine synchronisée, vous pouvez simplement effectuer une extraction ou une extraction dans le dépôt et démarrer Emacs. Tous les nouveaux packages seront téléchargés et installés.

Dans Emacs-25, il y a la variable package-selected-packages, vous pouvez donc personnaliser cette variable et l'utiliser package-install-selected-packagespour vous assurer qu'elle est installée.

Ce que vous voulez utiliser est Cask , qui vous permet de créer un fichier Cask spécifiant sur quels paquets installer cask install. Il peut être utilisé pour gérer facilement les dépendances d’un paquet et les "dépendances" de votre configuration Emacs. Placez votre fichier Cask sous contrôle de version et installez / mettez à jour des paquetages machine par machine.

Une autre approche serait la suivante: puisque je ne veux pas seulement synchroniser mes paquets Emacs, mais aussi d' autres fichiers (par exemple .emacs, .bashrcmais aussi d' autres répertoires) entre mon serveur et mon ordinateur portable, j'ai commencé à utiliser unison, pour synchroniser les fichiers et des répertoires. Ainsi, lorsque je travaille sur mon ordinateur portable, je cours simplement unison laptopavant toute autre chose. Mon ~/.unison/laptop.prffichier contient la section suivante pour les fichiers liés à Emacs:

path = .emacs
path = .emacs.d
ignore = Path {.emacs.d/semanticdb}

Étant donné que mes paquets Emacs (ainsi que mes sauvegardes et signets Emacs) sont stockés dans ~/.emacs.dcette mémoire, cela signifie que je dispose de tout le matériel sur toutes mes machines.

Une autre approche serait de placer le .emacs.drépertoire dans un répertoire synchronisé avec OwnCloud, DropBox ou tout autre service de synchronisation de fichiers, puis de créer des liens symboliques à partir ~/.emacs.dde ce répertoire partagé.

Bien que ce package.elsoit la méthode standard pour installer des paquetages, vous pouvez aussi essayer el-getce qui est très utile pour installer des paquets qui ne sont pas (ou ne peuvent pas être) sur elpa. Cette réponse traite de la synchronisation de tels paquets.

La façon dont vous vous assurez que les paquetages sont installés lors de l’utilisation de el-get est d’ajouter quelque chose comme ceci à votre fichier init

(el-get 'sync '(packages))

où packages correspond à la liste des packages à installer. Cette fonction est similaire au fait package-installqu’elle installe les packages uniquement s’ils ne sont pas déjà installés, sinon elle initialise simplement les packages.

J'utilise un petit truc "volé" dans emacs-starter-kit (je pense):

(defun maybe-install-and-require (p)
  (when (not (package-installed-p p))
   (package-install p))
  (require p))

Alors, quand j'ai besoin d'un paquet, j'utilise simplement:

(maybe-install-and-require 'magit)

Sur les startups emacs, en évaluant ma configuration, il package.elsera possible d’installer magit s’il n’est pas installé.

Vous pouvez trouver ma configuration ici:

https://github.com/mdallastella/emacs-config/

J'ai le répertoire ~ / emacs qui est contrôlé par la version mercurial et contient tout ce que ma configuration emacs contient (~ / emacs / site-lisp pour les bibliothèques téléchargées manuellement, ~ / emacs / elpa pour les bibliothèques installées par elpa, ~ / emacs / etc / pour les .emacs fractionnés, ~ / emacs / dot-emacs.el que je symlink comme ~ / .emacs). Certains paquets ont dû être peaufinés pour avoir tous les fichiers importants dans cet arbre, mais cela fonctionne bien. J'ai implémenté ces quelques bits spécifiques à la machine par des conditions sur le nom du système.

Donc, après avoir installé / reconfiguré / modifié quelque chose, je commets simplement à tirer / pousser tous les changements entre toutes les machines que j'utilise.

L’avantage supplémentaire est que j’ai un historique complet de ma configuration et que je peux revenir en arrière / bisecter / revenir en cas de problème.

PS mercurial semble particulièrement adapté car il possède une traction / poussée naturelle des deux côtés, mais une configuration similaire ne devrait pas être difficile à obtenir avec git ou tout autre lecteur de DVD.

J'ai ceci setup-packages.eldans ma configuration emacs, qui est un hybride de code provenant de Prelude et du blog de Tomorokoshi sur la gestion des paquets .

setup-packages.el fait ce qui suit:

• Créez un répertoire pour les elpapackages s’il n’en existe pas et ajoutez-le ainsi que ses sous-répertoires au répertoire load-path.
• Mettre à jour la package-archivesliste avec Melpa.
• Vérifiez si tous les packages répertoriés dans la my-packagesliste sont installés. Si un paquet n'est pas installé, installez-le.

Comment mettre en œuvre

• Enregistrez le setup-packages.elci - dessous dans votre ~/.emacs.d/répertoire.
• Définir user-emacs-directory, setup-packages-fileet les my-packagesvariables dans votre init.elet faire (load setup-packages-file).

Lorsque vous démarrez emacs pour la première fois sur un ordinateur sur lequel ces packages ne sont pas installés, tous les packages énumérés dans my-packagess’installent automatiquement.

setup-packages.el

;; setup-packages.el - Package management

(require 'cl)
(require 'package)

;; Set the directory where you want to install the packages
(setq package-user-dir (concat user-emacs-directory "elpa/"))

;; Add melpa package source when using package list
(add-to-list 'package-archives '("melpa" . "http://melpa.org/packages/") t)

;; Load emacs packages and activate them
;; This must come before configurations of installed packages.
;; Don't delete this line.
(package-initialize)
;; `package-initialize' call is required before any of the below
;; can happen

;; Auto install the required packages
;; Method to check if all packages are installed
(defun packages-installed-p ()
  (loop for p in my-packages
        when (not (package-installed-p p)) do (return nil)
        finally (return t)))

;; if not all packages are installed, check one by one and install the missing ones.
(unless (packages-installed-p)
  ;; check for new packages (package versions)
  (message "%s" "Emacs is now refreshing its package database...")
  (package-refresh-contents)
  (message "%s" " done.")
  ;; install the missing packages
  (dolist (p my-packages)
    (when (not (package-installed-p p))
      (package-install p))))

(provide 'setup-packages)

init.el

Vous auriez besoin des éléments suivants dans votre init.el:

(setq user-home-directory  (getenv "HOME"))
(setq user-emacs-directory (concat user-home-directory ".emacs.d/"))
(setq setup-packages-file  (expand-file-name "setup-packages.el" user-emacs-directory))

;; A list of packages to ensure are installed at launch
(setq my-packages
      '(
        ;; package1
        ;; package2
       ))

(load setup-packages-file nil :nomessage) ; Load the packages

Afin de refléter ma configuration, j'ai décidé d'adopter une approche différente en utilisant Syncthing ; chaque modification de l'un de mes fichiers de configuration se propage à un autre de mes ordinateurs sans avoir à s'en soucier. Ainsi, lorsque je mets à jour des paquets, je ne dois le faire que dans l'un des ordinateurs.

RSYNC : Synchronisez certains dossiers / fichiers à l’aide d’ rsyncun réseau domestique ou sshd’un serveur distant.

rsyncest un utilitaire de synchronisation unidirectionnel capable de supprimer des fichiers sur la cible. Veillez donc à sauvegarder vos données sur les emplacements source et cible et à effectuer des tests approfondis à l'aide de l' --dry-runoption, avant de procéder.

Pour savoir comment configurer correctement le .authinfofichier, voir https://www.gnu.org/software/emacs/manual/auth.html. Un exemple de .authinfocontenu de fichier (pouvant contenir plusieurs entrées différentes) est le suivant:

machine mymachine login myloginname password mypassword port myport

Configurez et utilisez la fonction rsync-remotepour effectuer une synchronisation sur sshun serveur distant. Ou utilisez la fonction rsync-localpour synchroniser sur le même ordinateur ou sur un réseau domestique sécurisé.

(require 'auth-source)

;;; EXAMPLE:
;;;   (get-auth-info "12.34.567.89" "username")
;;;   (get-auth-info "localhost" "root")
(defun get-auth-info (host user &optional port)
  (let ((info (nth 0 (auth-source-search
                      :host host
                      :user user
                      :port port
                      :require '(:user :secret)
                      :create t))))
    (if info
      (let* ((port (plist-get info :port))
             (secret-maybe (plist-get info :secret))
             (secret
               (if (functionp secret-maybe)
                 (funcall secret-maybe)
                 secret-maybe)))
          (list port secret))
    nil)))

(defun rsync-filter (proc string)
  (cond
    ((string-match
       "^\\([a-zA-Z0-9_\\-\\.]+\\)@\\([a-zA-Z0-9_\\-\\.]+\\)'s password: "
       string)
      (let* ((user (substring string (match-beginning 1) (match-end 1)))
             (host (substring string (match-beginning 2) (match-end 2)))
             (password (car (cdr (get-auth-info host user)))))
        (process-send-string proc (concat password "\n"))))
    ((not (or (string-match "files\\.\\.\\.\r" string)
              (string-match "files to consider\n" string)))
      (with-current-buffer (messages-buffer)
        (let ((inhibit-read-only t))
          (goto-char (point-max))
          (when (not (bolp))
            (insert "\n"))
          (insert string)
          (when (not (bolp))
            (insert "\n")))))))

(defun rsync-remote ()
"Use rsync to a remote server via ssh.  Back-up your data first!!!"
(interactive)
  (let* (
      (host "localhost")
      (username "root")
      (port (or (car (get-auth-info host username))
                (number-to-string (read-number "Port:  "))))
      (source
        (let ((dir (expand-file-name (locate-user-emacs-file "elpa/"))))
          (if (file-directory-p dir)
            dir
            (let ((debug-on-quit nil)
                  (msg (format "`%s` is not a valid directory." dir)))
              (signal 'quit `(,msg))))))
      (target "/private/var/mobile/elpa/")
      (ssh "/usr/bin/ssh")
      (rsync "/usr/bin/rsync")
      (rsync-include-file "/path/to/include-file.txt")
      (rsync-exclude-file "/path/to/exclude-file.txt")
      (rsh (concat "--rsh=ssh -p " port " -l " username))
      (host+target (concat host ":" target)))
    (start-process
        "rsync-process"
        nil
        rsync
        "-avr" ;; must specify the `-r` argument when using `--files-from`
        "--delete"
        ;; The paths inside the exclusion file must be relative, NOT absolute.
        ;;; (concat "--files-from=" rsync-include-file)
        ;;; (concat "--exclude-from=" rsync-exclude-file)
        rsh
        source
        host+target)
    (set-process-filter (get-process "rsync-process") 'rsync-filter)
    (set-process-sentinel
      (get-process "rsync-process")
      (lambda (p e) (when (= 0 (process-exit-status p))
        (message "rsync-remote:  synchronizing ... done."))))))

(defun rsync-local ()
"Use rsync locally -- e.g., over a trusted home network.
 Back-up your data first!!!"
  (interactive)
  (let (
      (rsync-program "/usr/bin/rsync")
      (source
        (let ((dir (expand-file-name
                     (file-name-as-directory
                       (read-directory-name "Source Directory: " nil nil nil nil)))))
          (if (file-directory-p dir)
            dir
            (let ((debug-on-quit nil)
                  (msg (format "`%s` is not a valid directory." dir)))
              (signal 'quit `(,msg))))))
      (target (expand-file-name
                (file-name-as-directory
                  (read-directory-name "Target Directory: " nil nil nil nil)))))
    (unless (y-or-n-p (format "SOURCE:  %s | TARGET:  %s" source target))
      (let ((debug-on-quit nil))
        (signal 'quit `("You have exited the function."))))
    (start-process "rsync-process"
      nil
      rsync-program
      "--delete"
      "-arzhv"
      source
      target)
    (set-process-filter (get-process "rsync-process") #'rsync-process-filter)
    (set-process-sentinel
      (get-process "rsync-process")
      (lambda (p e)
        (when (= 0 (process-exit-status p))
        (message "Done!"))))))

https://github.com/redguardtoo/elpa-mirror crée un référentiel local de tous les packages installés.

L'utilisation est simple, il suffit de courir M-x elpamr-create-mirror-for-installed.

Sur d’autres machines, insérez-les (setq package-archives '(("myelpa" . "~/myelpa/")))dans .emacset redémarrez Emacs.

Maintenant, sur toutes les machines, vous obtenez exactement la même version des packages.