vagrant-lxd 0.1.0

data/README.md

@@ -0,0 +1,121 @@
+# vagrant-lxd
+
+This is a [Vagrant][] plugin that adds the ability to manage containers
+with [LXD][].
+
+[Vagrant]: https://www.vagrantup.com/
+[LXD]: https://linuxcontainers.org/lxd/
+
+## Features
+
+The following features are currently supported:
+
+ - VM management (create, suspend, destroy, etc.)
+ - IPv4 networking
+ - Synced folders
+ - Snapshots
+
+The following features are not expected to work yet:
+
+ - Forwarded ports
+ - Static IP addresses
+ - IPv6 networking
+
+The plugin requires LXD 2.0 and Vagrant 1.8.7 or newer.
+
+## Installation
+
+Installing the plugin from this repository is a three-step process.
+
+ 1. Use Bundler to install development dependencies:
+    
+        $ bundle install
+    
+ 2. Build the gem:
+    
+        $ bundle exec rake build
+    
+ 3. Install it as a Vagrant plugin:
+    
+        $ vagrant plugin install pkg/vagrant-lxd-<version>.gem
+
+## Usage
+
+### Quick Start
+
+This plugin reuses the `lxc` box format, so VM images from [Vagrant
+Cloud][cloud] should work without modification:
+
+    $ vagrant init --minimal debian/stretch64
+    $ vagrant up --provider lxd
+
+[cloud]: https://app.vagrantup.com/boxes/search?provider=lxc
+
+#### Configuration
+
+Below is an example Vagrantfile showing all of the provider's
+configurable values, along with their defaults. The `debian/stretch64`
+box is available on the Vagrant Cloud, so you should be able to copy
+this file and adjust it as you see fit.
+
+``` ruby
+Vagrant.configure('2') do |config|
+  config.vm.box = 'debian/stretch64'
+
+  config.vm.provider 'lxd' do |lxd|
+    lxd.api_endpoint = 'https://127.0.0.1:8443'
+    lxd.timeout = 10
+    lxd.name = nil
+    lxd.ephemeral = false
+  end
+end
+```
+
+### Shared Folders
+
+In order to use shared folders, you must first add your user ID to the
+host machine's subuid(5) and subgid(5) files:
+
+    $ echo root:$(id -u):1 | sudo tee -a /etc/subuid
+    $ echo root:$(id -g):1 | sudo tee -a /etc/subgid
+
+For more information about these commands, and user/group ID mapping in
+general, we recommend [this article][1].
+
+[1]: https://insights.ubuntu.com/2017/06/15/custom-user-mappings-in-lxd-containers/
+
+### Shared LXD Containers
+
+It's possible to share a single LXD container between multiple Vagrant
+VMs by "attaching" them to the container by name.
+
+For example, to associate the "default" VM with a preexisting LXD
+container called "my-container", use the `vagrant lxd attach` command:
+
+    $ lxc list -cn # list available containers
+    +--------------+
+    |     NAME     |
+    +--------------+
+    | my-container |
+    +--------------+
+    
+    $ vagrant lxd detach default # detach from current container, if necessary
+    ==> default: Machine is not attached to a container, skipping...
+    
+    $ vagrant lxd attach default my-container
+    ==> default: Attaching to container 'my-container'...
+
+## Hacking
+
+To run Vagrant with the plugin automatically loaded, you can use the
+`bundle exec` command:
+
+    $ bundle exec vagrant <command>
+
+## Contributing
+
+ 1. Fork it from <https://gitlab.com/catalyst-it/vagrant-lxd>
+ 2. Create a feature branch (`git checkout -b my-new-feature`)
+ 3. Commit your changes (`git commit -am 'Add some feature'`)
+ 4. Push to the branch (`git push origin my-new-feature`)
+ 5. Create a Merge Request at <https://gitlab.com/catalyst-it/vagrant-lxd/merge_requests>

data/Rakefile

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'rspec/core/rake_task'
+
+Bundler::GemHelper.install_tasks
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = '-I. -rspec/common'
+  t.verbose = false
+end
+
+task :default => :spec

data/lib/vagrant-lxd.rb

@@ -0,0 +1,23 @@
+#
+# Copyright (c) 2017 Catalyst.net Ltd
+#
+# This file is part of vagrant-lxd.
+#
+# vagrant-lxd is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or (at
+# your option) any later version.
+#
+# vagrant-lxd is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with vagrant-lxd. If not, see <http://www.gnu.org/licenses/>.
+#
+
+require 'i18n'
+require 'vagrant-lxd/plugin'
+
+I18n.load_path << File.expand_path('../../templates/locales/en.yml', __FILE__)

data/lib/vagrant-lxd/action.rb

@@ -0,0 +1,314 @@
+#
+# Copyright (c) 2017 Catalyst.net Ltd
+#
+# This file is part of vagrant-lxd.
+#
+# vagrant-lxd is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or (at
+# your option) any later version.
+#
+# vagrant-lxd is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with vagrant-lxd. If not, see <http://www.gnu.org/licenses/>.
+#
+
+require 'vagrant/action/builder'
+require 'vagrant/machine_state'
+require 'vagrant-lxd/driver'
+
+module VagrantLXD
+  module Action
+
+    #
+    # The LXD class is middleware that simply forwards its call to the
+    # corresponding method on the LXD driver and copies the result into
+    # the env hash under the key `:machine_<method>`.
+    #
+    # The method to be called is controlled by the proxy object's class
+    # name. The correct instance to use for a particular method call is
+    # retrieved with `LXD.action`.
+    #
+    class LXD
+      def initialize(app, env, *args)
+        @app = app
+        @args = args
+        @driver = Driver.new(env[:machine])
+      end
+
+      def call(env)
+        env[:"machine_#{method}"] = @driver.send(method, *@args)
+        @app.call(env)
+      end
+
+    private
+
+      def method
+        self.class.to_s.split('::').last.downcase
+      end
+
+      def LXD.action(name)
+        const = name.to_s.sub(/[a-z]/, &:upcase)
+        const_get(const)
+      rescue NameError
+        Class.new(LXD).tap do |proxy|
+          const_set(const, proxy)
+        end
+      end
+    end
+
+    #
+    # Message issues a message to the user through the `env[:ui]` object
+    # provided to this middleware. The level is controlled via `type`,
+    # which should be a method on `env[:ui]`.
+    #
+    class Message
+      def initialize(app, env, type, message)
+        @app = app
+        @type = type
+        @message = message
+      end
+
+      def call(env)
+        env[:ui].send(@type, @message)
+        @app.call(env)
+      end
+    end
+
+    #
+    # Check whether the LXD driver is usable and immediately signal an
+    # error if not (preventing any remaining middlewares from running).
+    #
+    class ConnectionValidate
+      def initialize(app, env)
+        @app = app
+        @driver = Driver.new(env[:machine])
+      end
+
+      def call(env)
+        @driver.validate!
+        @app.call(env)
+      end
+    end
+
+    #
+    # Action definitions.
+    #
+    class << Action
+      include Vagrant::Action::Builtin
+
+      def up
+        builder do |b|
+          b.use Call, state do |env, c|
+            case env[:machine_state]
+            when Vagrant::MachineState::NOT_CREATED_ID
+              c.use Message, :info, 'Machine has not been created yet, starting...'
+              c.use HandleBox
+              c.use LXD.action(:create)
+              c.use LXD.action(:resume)
+              c.use SyncedFolders
+              c.use WaitForCommunicator
+              c.use Provision
+            when :running
+              c.use Message, :info, 'Machine is already running.'
+            when :frozen, :stopped
+              c.use resume
+            else
+              c.use Message, :error, "Machine cannot be started while #{env[:machine_state]}."
+            end
+          end
+        end
+      end
+
+      def destroy
+        builder do |b|
+          b.use Call, IsState, Vagrant::MachineState::NOT_CREATED_ID do |env, c|
+            if env[:result]
+              next
+            else
+              c.use Call, DestroyConfirm do |env, d|
+                if env[:result]
+                  d.use halt
+                  d.use Message, :info, 'Destroying machine and associated data...'
+                  d.use LXD.action(:destroy)
+                else
+                  d.use Message, :info, 'Machine will not be destroyed.'
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def halt
+        builder do |b|
+          b.use Call, state do |env, c|
+            case env[:machine_state]
+            when Vagrant::MachineState::NOT_CREATED_ID
+              next
+            when :stopped
+              c.use Message, :info, 'Machine is already stopped.'
+            when :frozen, :running
+              c.use Message, :info, 'Stopping machine...'
+              c.use LXD.action(:halt)
+            else
+              c.use Message, :error, "Machine cannot be stopped while #{env[:machine_state]}."
+            end
+          end
+        end
+      end
+
+      def suspend
+        builder do |b|
+          b.use Call, state do |env, c|
+            case env[:machine_state]
+            when Vagrant::MachineState::NOT_CREATED_ID
+              next
+            when :frozen
+              c.use Message, :info, 'Machine is already suspended.'
+            when :running
+              c.use Message, :info, 'Suspending machine...'
+              c.use LXD.action(:suspend)
+            else
+              c.use Message, :error, "Machine cannot be suspended while #{env[:machine_state]}."
+            end
+          end
+        end
+      end
+
+      def resume
+        builder do |b|
+          b.use Call, state do |env, c|
+            case env[:machine_state]
+            when Vagrant::MachineState::NOT_CREATED_ID
+              next
+            when :running
+              c.use Message, :info, 'Machine is already running.'
+            when :frozen, :stopped
+              c.use Message, :info, 'Resuming machine...'
+              c.use LXD.action(:resume)
+              c.use SyncedFolders
+              c.use WaitForCommunicator
+              c.use Provision
+            else
+              c.use Message, :error, "Machine cannot be resumed while #{env[:machine_state]}."
+            end
+          end
+        end
+      end
+
+      def reload
+        builder do |b|
+          b.use Call, state do |env, c|
+            case env[:machine_state]
+            when Vagrant::MachineState::NOT_CREATED_ID
+              next
+            when :frozen, :running
+              c.use halt
+            end
+            c.use resume
+          end
+        end
+      end
+
+      def provision
+        builder do |b|
+          b.use Call, IsState, Vagrant::MachineState::NOT_CREATED_ID do |env, c|
+            if env[:result]
+              next
+            else
+              c.use Provision
+            end
+          end
+        end
+      end
+
+      def snapshot_list
+        builder do |b|
+          b.use Call, IsState, Vagrant::MachineState::NOT_CREATED_ID do |env, c|
+            if env[:result]
+              next
+            else
+              c.use LXD.action(:snapshot_list)
+            end
+          end
+        end
+      end
+
+      def snapshot_save
+        builder do |b|
+          b.use Call, IsState, Vagrant::MachineState::NOT_CREATED_ID do |env, c|
+            if env[:result]
+              next
+            else
+              c.use Message, :info, I18n.t('vagrant.actions.vm.snapshot.saving', name: env[:snapshot_name])
+              c.use LXD.action(:snapshot_save), env[:snapshot_name]
+              c.use Message, :success, I18n.t('vagrant.actions.vm.snapshot.saved', name: env[:snapshot_name])
+            end
+          end
+        end
+      end
+
+      def snapshot_restore
+        builder do |b|
+          b.use Call, IsState, Vagrant::MachineState::NOT_CREATED_ID do |env, c|
+            if env[:result]
+              next
+            else
+              c.use Message, :info, I18n.t('vagrant.actions.vm.snapshot.restoring', name: env[:snapshot_name])
+              c.use LXD.action(:snapshot_restore), env[:snapshot_name]
+              c.use Message, :success, I18n.t('vagrant.actions.vm.snapshot.restored', name: env[:snapshot_name])
+              c.use Call, IsEnvSet, :snapshot_delete do |env, d|
+                d.use snapshot_delete if env[:result]
+              end
+            end
+          end
+        end
+      end
+
+      def snapshot_delete
+        builder do |b|
+          b.use Call, IsState, Vagrant::MachineState::NOT_CREATED_ID do |env, c|
+            if env[:result]
+              next
+            else
+              c.use Message, :info, I18n.t('vagrant.actions.vm.snapshot.deleting', name: env[:snapshot_name])
+              c.use LXD.action(:snapshot_delete), env[:snapshot_name]
+              c.use Message, :info, I18n.t('vagrant.actions.vm.snapshot.deleted', name: env[:snapshot_name])
+            end
+          end
+        end
+      end
+
+      def state
+        builder { |b| b.use LXD.action(:state) }
+      end
+
+      def info
+        builder { |b| b.use LXD.action(:info) }
+      end
+
+      def ssh
+        builder { |b| b.use SSHExec }
+      end
+
+      def ssh_run
+        builder { |b| b.use SSHRun }
+      end
+
+    private
+
+      def builder
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectionValidate
+          yield b
+        end
+      end
+    end
+  end
+end