vagrant-alpine 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c2fc2915174a868f52ce574bb9af430ac32bdfc3
+  data.tar.gz: 0716848819f01d49981e4da58430d3d6a015bb94
+SHA512:
+  metadata.gz: 4c5693032537c8775b1a0396e01cb26683f25aa992561f3d85c8a154f5f81cf56b25f7ef5d0e90d2817c75500800def2bc8a62f62c3043e213cd4ba697d1ac15
+  data.tar.gz: bfdd58c7edc571e0de7dd59bbad1fff77b7e0de3dad43e367f920cd71ebb593babda86cd4489a982242a89f5f091703bb9ff6aac53d967eb69ac5f1533ead7a3

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/vendor/
+Vagrantfile
+.vagrant
+TODO.md
+

data/.rspec

@@ -0,0 +1,5 @@
+--format doc
+--order random
+--color
+--fail-fast
+

data/.rubocop.yml

@@ -0,0 +1,4 @@
+Metrics/LineLength:
+  Enabled: false
+Documentation:
+  Enabled: false

data/.ruby-gemset

@@ -0,0 +1 @@
+vagrant-alpine

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.2.0

data/.travis.yml

@@ -0,0 +1,13 @@
+language: ruby
+before_install:
+  - sudo apt-get update -qq
+  - sudo apt-get install -qq -y bsdtar
+  - rvm @global do gem uninstall bundler --all --executables
+  - gem uninstall bundler --all --executables
+  - gem install bundler --version '< 1.7.0'
+rvm:
+  - 2.2.0
+env:
+  global:
+    - NOKOGIRI_USE_SYSTEM_LIBRARIES=true
+script: rake

data/Gemfile

@@ -0,0 +1,17 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development do
+  gem 'vagrant', git: 'https://github.com/mitchellh/vagrant.git'
+end
+
+group :plugins do
+  gem 'vagrant-alpine', path: '.'
+end
+
+group :test do
+  gem 'rake'
+  gem 'rubocop'
+end
+

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 matt maier
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,70 @@
+# [Vagrant Alpine Linux Guest](https://github.com/maier/vagrant-alpine)
+
+This is a [Vagrant](http://vagrantup.com/) plugin adding support for [Alpine Linux](http://alpinelinx.org) guests.
+
+> **NOTE:** The vagrant-alpine requires Vagrant 1.7+
+
+## Features
+
+* Detection
+* Set hostname
+* Configure networking DHCP or static
+* Halt/Shutdown the guest
+* RSync detection and installation
+* NFS client installation
+
+## Installation
+
+```
+$ vagrant plugin install vagrant-alpine
+```
+
+## Usage
+
+```
+$ vagrant init maier/alpine-3.1.3
+$ vagrant up
+```
+
+## Configuration
+
+The vagrant-alpine plugin does not offer any configuration options.
+
+
+## Development
+
+To work on the `vagrant-alpine` plugin, clone this repository, and use
+[Bundler](http://gembundler.com) to get the dependencies:
+
+```
+$ gem install bundler -v '~> 1.7.0'
+$ bundle install --path vendor/bundle
+```
+
+Once you have the dependencies, verify the unit tests pass with `rake`:
+
+```
+$ bundle exec rake
+```
+
+If those pass, you're ready to start developing. You can test
+the plugin without installing it into your Vagrant environment
+by creating a `Vagrantfile` in teh top level directory (it is gitignored).
+There is an example supplied in this repository.
+(`cp Vagrantfile.example Vagrantfile` and edit.)
+
+Use bundler to execute Vagrant:
+```
+$ bundle exec vagrant up
+```
+
+
+## Notes
+
+Alpine Linux boxes for testing are available on
+[Atlas](https://atlas.hashicorp.com/maier/). Packer templates
+for building the boxes are in this
+[GitHub repository](https://github.com/maier/packer-templates/).
+
+Using `VAGRANT_LOG=info`, Vagrant's `--debug` switch, and `vb.gui = true`
+were all very useful when originally developing this guest plugin.

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+Bundler::GemHelper.install_tasks
+
+RSpec::Core::RakeTask.new
+task :default => 'spec'

data/Vagrantfile.example

@@ -0,0 +1,49 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+#
+# Vagrantfile for testing vagrant-alpine
+#
+
+Vagrant.configure(2) do |config|
+
+  config.vm.box = 'maier/alpine-3.1.3-x86_64'
+
+  # config.ssh.username = 'vagrant'
+  # config.ssh.password = 'vagrant'
+  # config.ssh.shell = '/bin/sh'
+
+  #
+  # Networking
+  #
+  # DHCP
+  # config.vm.network 'private_network', type: 'dhcp'
+  #
+  # Static (replace <IP> with an appropriate private address)
+  # config.vm.network 'private_network', ip: '<IP>', auto_config: true
+
+  #
+  # Shared folders
+  #
+  # Note, for shared folders via NFS a static IP *must* be provided
+  # until guest additions can be built and installed out of main.
+  # The reason being that although a DHCP interface does successfully
+  # get an IP, virtualbox is unaware of it and therefore cannot
+  # provide it to Vagrant.
+  #
+  # If not assigning a static IP, ensure the default
+  # share is disabled.
+  config.vm.synced_folder '.', '/vagrant', disabled: true
+  #
+  # Define NFS shares (comment out above when enabling
+  # this 'default' folder, or mount a different folder.)
+  # config.vm.synced_folder '.', '/vagrant', type: 'nfs'
+
+  config.vm.provider 'virtualbox' do |vb|
+    vb.name = 'vagrant-alpine-test'
+    vb.cpus = 1
+    vb.memory = 1024
+    # vb.gui = true
+  end
+
+end

data/lib/vagrant-alpine.rb

@@ -0,0 +1,23 @@
+# rubocop:disable Style/FileName
+#
+# squelch:
+# lib/vagrant-alpine.rb:1:1: C: Use snake_case for source file names.
+# require 'pathname'
+#
+require 'pathname'
+require 'vagrant-alpine/plugin'
+
+module VagrantPlugins
+  module GuestAlpine
+    # lib_path = Pathname.new(File.expand_path('../vagrant-alpine', __FILE__))
+    # autoload :Action, lib_path.join('action')
+    # autoload :Errors, lib_path.join('errors')
+
+    # This returns the path to the source of this plugin.
+    #
+    # @return [Pathname]
+    def self.source_root
+      @source_root ||= Pathname.new(File.expand_path('../../', __FILE__))
+    end
+  end
+end

data/lib/vagrant-alpine/cap/change_host_name.rb

@@ -0,0 +1,95 @@
+module VagrantPlugins
+  module GuestAlpine
+    module Cap
+      class ChangeHostName
+        def self.change_host_name(machine, name)
+          new(machine, name).change!
+        end
+
+        attr_reader :machine, :new_hostname
+
+        def initialize(machine, new_hostname)
+          @machine = machine
+          @new_hostname = new_hostname
+        end
+
+        def change!
+          return unless should_change?
+
+          update_etc_hostname
+          update_etc_hosts
+          refresh_hostname_service
+          update_mailname
+          renew_dhcp
+        end
+
+        def should_change?
+          new_hostname != current_hostname
+        end
+
+        def current_hostname
+          @current_hostname ||= fetch_current_hostname
+        end
+
+        def fetch_current_hostname
+          hostname = ''
+          sudo 'hostname -f' do |type, data|
+            hostname = data.chomp if type == :stdout && hostname.empty?
+          end
+
+          hostname
+        end
+
+        def update_etc_hostname
+          sudo("echo '#{short_hostname}' > /etc/hostname")
+        end
+
+        # /etc/hosts should resemble:
+        # 127.0.0.1   localhost
+        # 127.0.1.1   host.fqdn.com host.fqdn host
+        def update_etc_hosts
+          if test("grep '#{current_hostname}' /etc/hosts")
+            # Current hostname entry is in /etc/hosts
+            ip_address = '([0-9]{1,3}\.){3}[0-9]{1,3}'
+            search     = "^(#{ip_address})\\s+#{Regexp.escape(current_hostname)}(\\s.*)?$"
+            replace    = "\\1 #{fqdn} #{short_hostname}"
+            expression = ['s', search, replace, 'g'].join('@')
+
+            sudo("sed -ri '#{expression}' /etc/hosts")
+          else
+            # Current hostname entry isn't in /etc/hosts, just append it
+            sudo("echo '127.0.1.1 #{fqdn} #{short_hostname}' >>/etc/hosts")
+          end
+        end
+
+        def refresh_hostname_service
+          sudo('hostname -F /etc/hostname')
+        end
+
+        def update_mailname
+          sudo('hostname --fqdn > /etc/mailname')
+        end
+
+        def renew_dhcp
+          sudo('ifdown -a; ifup -a; ifup eth0')
+        end
+
+        def fqdn
+          new_hostname
+        end
+
+        def short_hostname
+          new_hostname.split('.').first
+        end
+
+        def sudo(cmd, &block)
+          machine.communicate.sudo(cmd, &block)
+        end
+
+        def test(cmd)
+          machine.communicate.test(cmd)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-alpine/cap/configure_networks.rb

@@ -0,0 +1,64 @@
+# rubocop:disable Metrics/MethodLength
+# rubocop:disable Metrics/AbcSize
+# rubocop:disable Style/BracesAroundHashParameters
+#
+# FIXME: address disabled warnings
+#
+require 'set'
+require 'tempfile'
+
+require 'vagrant/util/template_renderer'
+
+module VagrantPlugins
+  module GuestAlpine
+    module Cap
+      class ConfigureNetworks
+        include Vagrant::Util
+        def self.configure_networks(machine, networks)
+          machine.communicate.tap do |comm|
+            # First, remove any previous network modifications
+            # from the interface file.
+            comm.sudo("sed -e '/^#VAGRANT-BEGIN/,$ d' /etc/network/interfaces > /tmp/vagrant-network-interfaces.pre")
+            comm.sudo("sed -ne '/^#VAGRANT-END/,$ p' /etc/network/interfaces | tail -n +2 > /tmp/vagrant-network-interfaces.post")
+
+            # Accumulate the configurations to add to the interfaces file as
+            # well as what interfaces we're actually configuring since we use that
+            # later.
+            interfaces = Set.new
+            entries = []
+            networks.each do |network|
+              interfaces.add(network[:interface])
+              entry = TemplateRenderer.render("guests/alpine/network_#{network[:type]}", { options: network, template_root: GuestAlpine.source_root.join('templates') })
+              entries << entry
+            end
+
+            # Perform the careful dance necessary to reconfigure
+            # the network interfaces
+            temp = Tempfile.new('vagrant')
+            temp.binmode
+            temp.write(entries.join("\n"))
+            temp.close
+
+            comm.upload(temp.path, '/tmp/vagrant-network-entry')
+
+            # Bring down all the interfaces we're reconfiguring. By bringing down
+            # each specifically, we avoid reconfiguring eth0 (the NAT interface) so
+            # SSH never dies.
+            interfaces.each do |interface|
+              comm.sudo("/sbin/ifdown eth#{interface} 2> /dev/null")
+              comm.sudo("/sbin/ip addr flush dev eth#{interface} 2> /dev/null")
+            end
+
+            comm.sudo('cat /tmp/vagrant-network-interfaces.pre /tmp/vagrant-network-entry /tmp/vagrant-network-interfaces.post > /etc/network/interfaces')
+            comm.sudo('rm -f /tmp/vagrant-network-interfaces.pre /tmp/vagrant-network-entry /tmp/vagrant-network-interfaces.post')
+
+            # Bring back up each network interface, reconfigured
+            interfaces.each do |interface|
+              comm.sudo("/sbin/ifup eth#{interface}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-alpine/cap/halt.rb

@@ -0,0 +1,21 @@
+# rubocop:disable Style/RedundantBegin
+# rubocop:disable Lint/HandleExceptions
+#
+# FIXME: address disabled warnings
+#
+module VagrantPlugins
+  module GuestAlpine
+    module Cap
+      class Halt
+        def self.halt(machine)
+          begin
+            machine.communicate.sudo('poweroff')
+          rescue Net::SSH::Disconnect, IOError
+            # Ignore, this probably means connection closed because it
+            # shut down and SSHd was stopped.
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-alpine/cap/nfs_client.rb

@@ -0,0 +1,15 @@
+module VagrantPlugins
+  module GuestAlpine
+    module Cap
+      class NFSClient
+        def self.nfs_client_install(machine)
+          machine.communicate.tap do |comm|
+            comm.sudo('apk add nfs-utils')
+            comm.sudo('rc-update add rpc.statd')
+            comm.sudo('rc-service rpc.statd start')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-alpine/cap/rsync.rb

@@ -0,0 +1,17 @@
+module VagrantPlugins
+  module GuestAlpine
+    module Cap
+      class RSync
+        def self.rsync_installed(machine)
+          machine.communicate.test('test -f /usr/bin/rsync')
+        end
+
+        def self.rsync_install(machine)
+          machine.communicate.tap do |comm|
+            comm.sudo('apk add rsync')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-alpine/guest.rb

@@ -0,0 +1,19 @@
+begin
+  require 'vagrant'
+rescue LoadError
+  raise 'The Vagrant Alpine Linux Guest plugin must be run within Vagrant.'
+end
+
+if Vagrant::VERSION < '1.7.0'
+  fail 'The vagrant-alpine plugin is only compatible with Vagrant 1.7+'
+end
+
+module VagrantPlugins
+  module GuestAlpine
+    class Guest < Vagrant.plugin('2', :guest)
+      def detect?(machine)
+        machine.communicate.test('cat /etc/alpine-release')
+      end
+    end
+  end
+end

data/lib/vagrant-alpine/plugin.rb

@@ -0,0 +1,53 @@
+begin
+  require 'vagrant'
+rescue LoadError
+  raise 'The Vagrant Alpine Linux Guest plugin must be run within Vagrant.'
+end
+
+if Vagrant::VERSION < '1.7.0'
+  fail 'The vagrant-alpine plugin is only compatible with Vagrant 1.7+'
+end
+
+module VagrantPlugins
+  module GuestAlpine
+    class Plugin < Vagrant.plugin('2')
+      name 'Alpine guest'
+      description 'Alpine Linux guest support.'
+
+      guest('alpine', 'linux') do
+        require File.expand_path('../guest', __FILE__)
+        Guest
+      end
+
+      guest_capability('alpine', 'configure_networks') do
+        require_relative 'cap/configure_networks'
+        Cap::ConfigureNetworks
+      end
+
+      guest_capability('alpine', 'halt') do
+        require_relative 'cap/halt'
+        Cap::Halt
+      end
+
+      guest_capability('alpine', 'change_host_name') do
+        require_relative 'cap/change_host_name'
+        Cap::ChangeHostName
+      end
+
+      guest_capability('alpine', 'nfs_client_install') do
+        require_relative 'cap/nfs_client'
+        Cap::NFSClient
+      end
+
+      guest_capability('alpine', 'rsync_installed') do
+        require_relative 'cap/rsync'
+        Cap::RSync
+      end
+
+      guest_capability('alpine', 'rsync_install') do
+        require_relative 'cap/rsync'
+        Cap::RSync
+      end
+    end
+  end
+end

data/lib/vagrant-alpine/version.rb

@@ -0,0 +1,6 @@
+module VagrantPlugins
+  # Alpine Linux guest gem + plugin version
+  module GuestAlpine
+    VERSION = '0.1.1'
+  end
+end

data/spec/cap/change_host_name_spec.rb

@@ -0,0 +1,128 @@
+
+require 'spec_helper'
+
+describe 'VagrantPlugins::GuestAlpine::Cap::ChangeHostname' do
+  let(:described_class) do
+    VagrantPlugins::GuestAlpine::Plugin.components.guest_capabilities[:alpine].get(:change_host_name)
+  end
+  let(:machine) { double('machine') }
+  let(:communicator) { VagrantTests::DummyCommunicator::Communicator.new(machine) }
+  let(:old_hostname) { 'oldhostname.olddomain.tld' }
+
+  before do
+    allow(machine).to receive(:communicate).and_return(communicator)
+    communicator.stub_command('hostname -f', stdout: old_hostname)
+  end
+
+  after do
+    communicator.verify_expectations!
+  end
+
+  describe '.change_host_name' do
+    it 'updates /etc/hostname on the machine' do
+      communicator.expect_command("echo 'newhostname' > /etc/hostname")
+      described_class.change_host_name(machine, 'newhostname.newdomain.tld')
+    end
+
+    it 'does nothing when the provided hostname is not different' do
+      described_class.change_host_name(machine, 'oldhostname.olddomain.tld')
+      expect(communicator.received_commands).to eq(['hostname -f'])
+    end
+
+    it 'refreshes the hostname service with the hostname command' do
+      communicator.expect_command('hostname -F /etc/hostname')
+      described_class.change_host_name(machine, 'newhostname.newdomain.tld')
+    end
+
+    it 'renews dhcp on the system with the new hostname' do
+      communicator.expect_command('ifdown -a; ifup -a; ifup eth0')
+      described_class.change_host_name(machine, 'newhostname.newdomain.tld')
+    end
+
+    describe 'flipping out the old hostname in /etc/hosts' do
+      let(:sed_command) do
+        # Here we run the change_host_name through and extract the recorded sed
+        # command from the dummy communicator
+        described_class.change_host_name(machine, 'newhostname.newdomain.tld')
+        communicator.received_commands.find { |cmd| cmd =~ /^sed/ }
+      end
+
+      # Now we extract the regexp from that sed command so we can do some
+      # verification on it
+      let(:expression) { sed_command.sub(%r{^sed -ri '\(.*\)' /etc/hosts$}, "\1") }
+      let(:search)     { Regexp.new(expression.split('@')[1], Regexp::EXTENDED) }
+      let(:replace)    { expression.split('@')[2] }
+
+      let(:grep_command) { "grep '#{old_hostname}' /etc/hosts" }
+
+      before do
+        communicator.stub_command(grep_command, exit_code: 0)
+      end
+
+      it 'works on an simple /etc/hosts file' do
+        original_etc_hosts = <<-ETC_HOSTS.gsub(/^ */, '')
+          127.0.0.1 localhost
+          127.0.1.1 oldhostname.olddomain.tld oldhostname
+        ETC_HOSTS
+
+        modified_etc_hosts = original_etc_hosts.gsub(search, replace)
+
+        expect(modified_etc_hosts).to eq <<-RESULT.gsub(/^ */, '')
+          127.0.0.1 localhost
+          127.0.1.1 newhostname.newdomain.tld newhostname
+        RESULT
+      end
+
+      it 'does not modify lines which contain similar hostnames' do
+        original_etc_hosts = <<-ETC_HOSTS.gsub(/^ */, '')
+          127.0.0.1 localhost
+          127.0.1.1 oldhostname.olddomain.tld oldhostname
+          # common prefix, but different fqdn
+          192.168.12.34 oldhostname.olddomain.tld.different
+          # different characters at the dot
+          192.168.34.56 oldhostname-olddomain.tld
+        ETC_HOSTS
+
+        modified_etc_hosts = original_etc_hosts.gsub(search, replace)
+
+        expect(modified_etc_hosts).to eq <<-RESULT.gsub(/^ */, '')
+          127.0.0.1 localhost
+          127.0.1.1 newhostname.newdomain.tld newhostname
+          # common prefix, but different fqdn
+          192.168.12.34 oldhostname.olddomain.tld.different
+          # different characters at the dot
+          192.168.34.56 oldhostname-olddomain.tld
+        RESULT
+      end
+
+      it "appends 127.0.1.1 if it isn't there" do
+        communicator.stub_command(grep_command, exit_code: 1)
+        described_class.change_host_name(machine, 'newhostname.newdomain.tld')
+
+        sed = communicator.received_commands.find { |cmd| cmd =~ /^sed/ }
+        expect(sed).to be_nil
+
+        echo = communicator.received_commands.find { |cmd| cmd =~ /^echo/ }
+        expect(echo).to_not be_nil
+      end
+
+      context 'when the old fqdn has a trailing dot' do
+        let(:old_hostname) { 'oldhostname.withtrailing.dot.' }
+
+        it 'modifies /etc/hosts properly' do
+          original_etc_hosts = <<-ETC_HOSTS.gsub(/^ */, '')
+            127.0.0.1 localhost
+            127.0.1.1 oldhostname.withtrailing.dot. oldhostname
+          ETC_HOSTS
+
+          modified_etc_hosts = original_etc_hosts.gsub(search, replace)
+
+          expect(modified_etc_hosts).to eq <<-RESULT.gsub(/^ */, '')
+            127.0.0.1 localhost
+            127.0.1.1 newhostname.newdomain.tld newhostname
+          RESULT
+        end
+      end
+    end
+  end
+end

data/spec/cap/configure_networks_spec.rb

@@ -0,0 +1,40 @@
+
+require 'spec_helper'
+
+describe 'VagrantPlugins::GuestAlpine::Cap::ConfigureNetworks' do
+  let(:described_class) do
+    VagrantPlugins::GuestAlpine::Plugin.components.guest_capabilities[:alpine].get(:configure_networks)
+  end
+  let(:machine) { double('machine') }
+  let(:communicator) { VagrantTests::DummyCommunicator::Communicator.new(machine) }
+
+  before do
+    allow(machine).to receive(:communicate).and_return(communicator)
+  end
+
+  after do
+    communicator.verify_expectations!
+  end
+
+  it 'should configure networks' do
+    networks = [
+      { type: :static, ip: '192.168.10.10', netmask: '255.255.255.0', interface: 0, name: 'eth0' },
+      { type: :dhcp, interface: 1, name: 'eth1' }
+    ]
+
+    communicator.should_receive(:sudo).with("sed -e '/^#VAGRANT-BEGIN/,$ d' /etc/network/interfaces > /tmp/vagrant-network-interfaces.pre")
+    communicator.should_receive(:sudo).with("sed -ne '/^#VAGRANT-END/,$ p' /etc/network/interfaces | tail -n +2 > /tmp/vagrant-network-interfaces.post")
+    communicator.should_receive(:sudo).with('/sbin/ifdown eth0 2> /dev/null')
+    communicator.should_receive(:sudo).with('/sbin/ip addr flush dev eth0 2> /dev/null')
+    communicator.should_receive(:sudo).with('/sbin/ifdown eth1 2> /dev/null')
+    communicator.should_receive(:sudo).with('/sbin/ip addr flush dev eth1 2> /dev/null')
+    communicator.should_receive(:sudo).with('cat /tmp/vagrant-network-interfaces.pre /tmp/vagrant-network-entry /tmp/vagrant-network-interfaces.post > /etc/network/interfaces')
+    communicator.should_receive(:sudo).with('rm -f /tmp/vagrant-network-interfaces.pre /tmp/vagrant-network-entry /tmp/vagrant-network-interfaces.post')
+    communicator.should_receive(:sudo).with('/sbin/ifup eth0')
+    communicator.should_receive(:sudo).with('/sbin/ifup eth1')
+
+    allow_message_expectations_on_nil
+
+    described_class.configure_networks(machine, networks)
+  end
+end

data/spec/cap/halt_spec.rb

@@ -0,0 +1,24 @@
+
+require 'spec_helper'
+
+describe 'VagrantPlugins::GuestAlpine::Cap::Halt' do
+  let(:described_class) do
+    VagrantPlugins::GuestAlpine::Plugin.components.guest_capabilities[:alpine].get(:halt)
+  end
+  let(:machine) { double('machine') }
+  let(:communicator) { VagrantTests::DummyCommunicator::Communicator.new(machine) }
+
+  before do
+    allow(machine).to receive(:communicate).and_return(communicator)
+  end
+
+  after do
+    communicator.verify_expectations!
+  end
+
+  it 'should halt guest' do
+    communicator.should_receive(:sudo).with('poweroff')
+    allow_message_expectations_on_nil
+    described_class.halt(machine)
+  end
+end

data/spec/cap/nfs_client_spec.rb

@@ -0,0 +1,27 @@
+
+require 'spec_helper'
+
+describe 'VagrantPlugins::GuestAlpine::Cap::NFSClient' do
+  let(:described_class) do
+    VagrantPlugins::GuestAlpine::Plugin.components.guest_capabilities[:alpine].get(:nfs_client_install)
+  end
+  let(:machine) { double('machine') }
+  let(:communicator) { VagrantTests::DummyCommunicator::Communicator.new(machine) }
+
+  before do
+    allow(machine).to receive(:communicate).and_return(communicator)
+  end
+
+  after do
+    communicator.verify_expectations!
+  end
+
+  it 'should install nfs client' do
+    communicator.should_receive(:sudo).with('apk add nfs-utils')
+    communicator.should_receive(:sudo).with('rc-update add rpc.statd')
+    communicator.should_receive(:sudo).with('rc-service rpc.statd start')
+
+    allow_message_expectations_on_nil
+    described_class.nfs_client_install(machine)
+  end
+end

data/spec/cap/rsync_spec.rb

@@ -0,0 +1,35 @@
+
+require 'spec_helper'
+
+describe 'VagrantPlugins::GuestAlpine::Cap::RSync' do
+  let(:machine) { double('machine') }
+  let(:communicator) { VagrantTests::DummyCommunicator::Communicator.new(machine) }
+
+  before do
+    allow(machine).to receive(:communicate).and_return(communicator)
+  end
+
+  after do
+    communicator.verify_expectations!
+  end
+
+  let(:described_class) do
+    VagrantPlugins::GuestAlpine::Plugin.components.guest_capabilities[:alpine].get(:rsync_install)
+  end
+
+  it 'should install rsync' do
+    communicator.should_receive(:sudo).with('apk add rsync')
+    allow_message_expectations_on_nil
+    described_class.rsync_install(machine)
+  end
+
+  let(:described_class) do
+    VagrantPlugins::GuestAlpine::Plugin.components.guest_capabilities[:alpine].get(:rsync_installed)
+  end
+
+  it 'should verify rsync installed' do
+    communicator.should_receive(:test).with('test -f /usr/bin/rsync')
+    allow_message_expectations_on_nil
+    described_class.rsync_installed(machine)
+  end
+end

data/spec/guest_spec.rb

@@ -0,0 +1,29 @@
+require 'vagrant-alpine/guest'
+
+require 'vagrant-alpine/plugin'
+
+require 'vagrant-alpine/cap/change_host_name'
+require 'vagrant-alpine/cap/configure_networks'
+require 'vagrant-alpine/cap/halt'
+require 'vagrant-alpine/cap/rsync'
+require 'vagrant-alpine/cap/nfs_client'
+
+describe VagrantPlugins::GuestAlpine::Plugin do
+  it 'should be loaded with alpine' do
+    expect(described_class.components.guests[:alpine].first).to eq(VagrantPlugins::GuestAlpine::Guest)
+  end
+
+  {
+    change_host_name: VagrantPlugins::GuestAlpine::Cap::ChangeHostName,
+    configure_networks: VagrantPlugins::GuestAlpine::Cap::ConfigureNetworks,
+    halt: VagrantPlugins::GuestAlpine::Cap::Halt,
+    rsync_installed: VagrantPlugins::GuestAlpine::Cap::RSync,
+    rsync_install: VagrantPlugins::GuestAlpine::Cap::RSync,
+    nfs_client_install: VagrantPlugins::GuestAlpine::Cap::NFSClient
+  }.each do |cap, cls|
+    it "should be capable of #{cap} with alpine" do
+      expect(described_class.components.guest_capabilities[:alpine][cap])
+        .to eq(cls)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'vagrant'
+require 'support/dummy_communicator'
+

data/spec/support/dummy_communicator.rb

@@ -0,0 +1,84 @@
+module VagrantTests
+  module DummyCommunicator
+    class Communicator < Vagrant.plugin("2", :communicator)
+      def ready?
+        true
+      end
+
+      attr_reader :known_commands
+
+      def initialize(machine)
+        @known_commands = Hash.new do |hash, key|
+          hash[key] = { expected: 0, received: 0, response: nil }
+        end
+      end
+
+      def expected_commands
+        known_commands.select do |command, info|
+          info[:expected] > 0
+        end
+      end
+
+      def received_commands
+        known_commands.select do |command, info|
+          info[:received] > 0
+        end.keys
+      end
+
+      def stub_command(command, response)
+        known_commands[command][:response] = response
+      end
+
+      def expect_command(command)
+        known_commands[command][:expected] += 1
+      end
+
+      def received_summary
+        received_commands.map { |cmd| " - #{cmd}" }.unshift('received:').join("\n")
+      end
+
+      def verify_expectations!
+        expected_commands.each do |command, info|
+          if info[:expected] != info[:received]
+            fail([
+              "expected to receive '#{command}' #{info[:expected]} times",
+              "got #{info[:received]} times instead",
+              received_summary
+            ].join("\n"))
+          end
+        end
+      end
+
+      def execute(command, opts=nil)
+        known = known_commands[command]
+        known[:received] += 1
+        response = known[:response]
+        return unless response
+
+        if block_given?
+          [:stdout, :stderr].each do |type|
+            Array(response[type]).each do |line|
+              yield type, line
+            end
+          end
+        end
+
+        if response[:raise]
+          raise response[:raise]
+        end
+
+        response[:exit_code]
+      end
+
+      def sudo(command, opts=nil, &block)
+        execute(command, opts, &block)
+      end
+
+      def test(command, opts=nil)
+        execute(command, opts) == 0
+      end
+    end
+  end
+end
+
+

data/templates/guests/alpine/network_dhcp.erb

@@ -0,0 +1,13 @@
+#VAGRANT-BEGIN
+# The contents below are automatically generated by Vagrant. Do not modify.
+auto eth<%= options[:interface] %>
+iface eth<%= options[:interface] %> inet dhcp
+<% if !options[:use_dhcp_assigned_default_route] %>
+    post-up route del default dev $IFACE || true
+<% else %>
+    # We need to disable eth0, see GH-2648
+    post-up route del default dev eth0
+    post-up dhclient $IFACE
+    pre-down route add default dev eth0
+<% end %>
+#VAGRANT-END

data/templates/guests/alpine/network_static.erb

@@ -0,0 +1,7 @@
+#VAGRANT-BEGIN
+# The contents below are automatically generated by Vagrant. Do not modify.
+auto eth<%= options[:interface] %>
+iface eth<%= options[:interface] %> inet static
+      address <%= options[:ip] %>
+      netmask <%= options[:netmask] %>
+#VAGRANT-END

data/vagrant-alpine.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'vagrant-alpine/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'vagrant-alpine'
+  spec.version       = VagrantPlugins::GuestAlpine::VERSION
+  spec.license       = 'MIT'
+
+  spec.authors       = ['matt maier']
+  spec.email         = ['maier@users.noreply.github.com']
+
+  spec.summary       = 'Enables Vagrant to manage Alpine Linux Guests.'
+  spec.description   = 'Enables Vagrant to manage Alpine Linux Guests.'
+  spec.homepage      = 'https://github.com/maier/vagrant-alpine'
+
+  spec.add_development_dependency 'rake', '~> 10.4.2'
+  spec.add_development_dependency 'rspec-core', '~> 2.14'
+  spec.add_development_dependency 'rspec-expectations', '~> 2.14'
+  spec.add_development_dependency 'rspec-mocks', '~> 2.14'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_path  = 'lib'
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: vagrant-alpine
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- matt maier
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+- !ruby/object:Gem::Dependency
+  name: rspec-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: rspec-expectations
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: rspec-mocks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+description: Enables Vagrant to manage Alpine Linux Guests.
+email:
+- maier@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-gemset"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- Vagrantfile.example
+- lib/vagrant-alpine.rb
+- lib/vagrant-alpine/cap/change_host_name.rb
+- lib/vagrant-alpine/cap/configure_networks.rb
+- lib/vagrant-alpine/cap/halt.rb
+- lib/vagrant-alpine/cap/nfs_client.rb
+- lib/vagrant-alpine/cap/rsync.rb
+- lib/vagrant-alpine/guest.rb
+- lib/vagrant-alpine/plugin.rb
+- lib/vagrant-alpine/version.rb
+- spec/cap/change_host_name_spec.rb
+- spec/cap/configure_networks_spec.rb
+- spec/cap/halt_spec.rb
+- spec/cap/nfs_client_spec.rb
+- spec/cap/rsync_spec.rb
+- spec/guest_spec.rb
+- spec/spec_helper.rb
+- spec/support/dummy_communicator.rb
+- templates/guests/alpine/network_dhcp.erb
+- templates/guests/alpine/network_static.erb
+- vagrant-alpine.gemspec
+homepage: https://github.com/maier/vagrant-alpine
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Enables Vagrant to manage Alpine Linux Guests.
+test_files: []