Devops for your dotfiles (and desktop).

Initially created to answer two questions:

• Can I create a tool like stow.
• Is there a reason Ansible/Salt really needs to use awful Jinja/YAML? (No.)

Not really fit for actual use yet. It's untested, a bit of a mess, and doesn't implement many modules.

• No support for remote hosts. Just local.
• No YAML. Instead, use a language, not markup, to define recipes.
• No 'facts'. It's local-only, and a scripted recipes, you should be able to fetch the facts as you need them.
• No package management. CLI and modules should be easily implementable by the end user in whichever language they desire. i.e. Search on $PATH.
• sudo, but only when you need it. Users shouldn't need to use sudo when they don't need it.
• self-documenting. Users should be able to determine recipe parameters from just using the application.

pip install git+https://github.com/xlevus/dotops

Currently there are two commands:

• dotops apply [recipe]: Runs a recipe
• dotops exec [module] [data]: Runs an individual module.

Additional commands can be implemented by placing a dotops-<command> executable on your $PATH.

Currently, the following modules are implemented:

• pip: Install packages via pip.

Additional modules currently need to be implemented as a python class with a main method that takes kwargs. These can be called by using the full importable python path. e.g.::

Via command line

dotops exec my_module.RubyGem '{"packages":["sass"]}'

Via Recipe:

(task "my_module.RubyGem"
      :packages ["sass"])

In future, modules will be able to be implemented in a fasion similar to commands.

See example directory.

Recipes are written in hy, a lisp-like python.

• Can pure-python modules be executed in the same thread, or should they be executed in a subprocess like currently?
• How should external modules be named?
  • dotops.<module>.module
  • <module>.dotops
• How should modules self-document?
  • Have a --spec command flag?
  • Have modules take arguments in a defined format (--package a --package b --user)
• Should modules provide a --check and --apply interface?
  • Can this be used to detect if sudo is needed?
• What is needed to implement recipe-generation? e.g. Running:

  dotops autorecipe my-recipe pip '{"packages": ["my-package"]}''
  dotops autorecipe my-recipe systemd '{"unit": "my.service", "user": True}'
  dotops autorecipe my-recipe pip '{"packages": ["something-else"]}''
  

  installs packages, starts the service, and creates:

  (recipe
    (task "pip" :packages ['my-package' 'something-else'])
    (task "systemd" :unit "my.service" :user True))