vagrant-notify 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format documentation
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+before_script:
+  - sudo apt-get install virtualbox
+rvm:
+  - 1.9.3
+  - 1.8.7

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in vagrant-notify.gemspec
+gemspec
+
+gem 'rb-inotify'
+gem 'guard'
+gem 'guard-rspec'

data/Gemfile.lock

@@ -0,0 +1,60 @@
+PATH
+  remote: .
+  specs:
+    vagrant-notify (0.0.1)
+      vagrant
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    archive-tar-minitar (0.5.2)
+    childprocess (0.3.6)
+      ffi (~> 1.0, >= 1.0.6)
+    diff-lcs (1.1.3)
+    erubis (2.7.0)
+    ffi (1.1.5)
+    guard (1.4.0)
+      listen (>= 0.4.2)
+      thor (>= 0.14.6)
+    guard-rspec (2.1.0)
+      guard (>= 1.1)
+      rspec (~> 2.11)
+    i18n (0.6.1)
+    json (1.5.4)
+    listen (0.5.3)
+    log4r (1.1.10)
+    net-scp (1.0.4)
+      net-ssh (>= 1.99.1)
+    net-ssh (2.2.2)
+    rake (0.9.2.2)
+    rb-inotify (0.8.8)
+      ffi (>= 0.5.0)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.3)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.3)
+    thor (0.16.0)
+    vagrant (1.0.5)
+      archive-tar-minitar (= 0.5.2)
+      childprocess (~> 0.3.1)
+      erubis (~> 2.7.0)
+      i18n (~> 0.6.0)
+      json (~> 1.5.1)
+      log4r (~> 1.1.9)
+      net-scp (~> 1.0.4)
+      net-ssh (~> 2.2.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  guard
+  guard-rspec
+  rake
+  rb-inotify
+  rspec
+  vagrant-notify!

data/Guardfile

@@ -0,0 +1,5 @@
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/vagrant-notify/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Fabio Rehm
+
+MIT License
+
+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,53 @@
+# Vagrant::Notify
+
+[![Build Status](https://travis-ci.org/fgrehm/vagrant-notify.png)](https://travis-ci.org/fgrehm/vagrant-notify)
+
+A Vagrant plugin that forwards `notify-send` from guest to host machine, tested
+using Ubuntu as guest and host machine.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'vagrant-notify'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install vagrant-notify
+
+## Usage
+
+After installing the gem, whenever you run `vagrant up`, a Ruby
+[TCPServer](http://www.ruby-doc.org/stdlib-1.9.3/libdoc/socket/rdoc/TCPServer.html)
+will fire up on `8081` port and a [script](https://github.com/fgrehm/vagrant-notify/blob/master/files/notify-send.erb)
+will be installed on the guest machine to replace the original `notify-send`
+command.
+
+If by any change your IP changes, you can run `vagrant provision` in order to
+update the guest script with the new IP.
+
+In case you need to run the notification server on a different port, you can set
+it from your `Vagrantfile`:
+
+```ruby
+Vagrant::Notify::server_port = 8888
+```
+
+## TODO
+
+* Display guest machine icons
+* Support for Multi-VM environments
+* Notify provisioning status
+* Support for Mac OS
+
+## Contributing
+
+1. Fork it
+2. Create your 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 new Pull Request

data/Rakefile

@@ -0,0 +1,22 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "spec/**/*_spec.rb"
+end
+
+desc 'Outpus some information about Vagrant middleware stack useful for development (use ACTION=action_name to filter out actions)'
+task 'vagrant-stack' do
+  require 'vagrant'
+  Vagrant.actions.to_hash.each do |action, stack|
+    next unless !ENV['ACTION'] || ENV['ACTION'] == action.to_s
+
+    puts action
+    stack.send(:stack).each do |middleware|
+      puts "  #{middleware[0]}"
+      puts "    -> #{middleware[1].inspect}" unless middleware[1].empty?
+    end
+  end
+end
+
+task :default => :spec

data/files/notify-send.erb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+# This is the wrapper around Ubuntu's notify-send that connects to the host machine
+# when sending notifications
+
+require 'rubygems'
+require 'socket'
+require 'optparse'
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: example.rb [options]"
+
+  opts.on('-u', '--urgency LEVEL')           { |v| options[:u] = v }
+  opts.on('-t', '--expire-time TIME')        { |v| options[:t] = v }
+  opts.on('-a', '--app-name APP_NAME')       { |v| options[:a] = v }
+  opts.on('-i', '--icon ICON[,ICON...]')     { |v| options[:i] = v }
+  opts.on('-c', '--category TYPE[,TYPE...]') { |v| options[:c] = v }
+  opts.on('-h', '--hint TYPE:NAME:VALUE')    { |v| options[:h] = v }
+  opts.on('-v', '--version')                 { |v| options[:v] = v }
+
+end.parse!
+
+cmd = options.map do |key, value|
+  "-#{key} '#{value}'"
+end.join(' ')
+
+# TODO: Need to escape values
+unless ARGV.empty?
+  cmd << ' -- '
+  cmd << ARGV.map{|a| "'#{a}'"}.join(' ')
+end
+
+TCPSocket.open "<%= host_ip %>", <%= host_port %> do |s|
+  s.send cmd, 0
+end

data/lib/vagrant-notify.rb

@@ -0,0 +1,32 @@
+require 'vagrant'
+require 'socket'
+require 'erb'
+require 'ostruct'
+
+require 'vagrant-notify/middleware'
+require 'vagrant-notify/server'
+require "vagrant-notify/version"
+
+module Vagrant
+  module Notify
+    class << self
+      def server_port
+        @@server_port ||= 8081
+      end
+      def server_port=(server_port)
+        @@server_port = server_port
+      end
+
+      def files_path
+        @file_path ||= File.expand_path(File.dirname(__FILE__) + '/../files')
+      end
+    end
+  end
+end
+
+Vagrant.actions[:start].tap do |start|
+  start.use          Vagrant::Notify::Middleware::StartServer
+  start.insert_after Vagrant::Action::VM::Boot, Vagrant::Notify::Middleware::InstallCommand
+end
+Vagrant.actions[:halt].use Vagrant::Notify::Middleware::StopServer
+Vagrant.actions[:provision].use Vagrant::Notify::Middleware::InstallCommand

data/lib/vagrant-notify/middleware.rb

@@ -0,0 +1,3 @@
+Dir[File.dirname(__FILE__) + '/middleware/**/*.rb'].each do |file|
+  require file
+end

data/lib/vagrant-notify/middleware/install_command.rb

@@ -0,0 +1,43 @@
+module Vagrant
+  module Notify
+    module Middleware
+      class InstallCommand
+        def initialize(app, env)
+          @app = app
+          @command_template_file = Vagrant::Notify.files_path + '/notify-send.erb'
+        end
+
+        def call(env)
+          env[:ui].info('Compiling and installing notify-send script on guest machine')
+          path = compile_command(env)
+          install_command_on_guest(env, path)
+          @app.call(env)
+        end
+
+        def host_ip(env)
+          ip = nil
+          env[:vm].channel.execute('echo -n $SSH_CLIENT | cut -d" " -f1') do |buffer, data|
+            ip = data.chomp if buffer == :stdout
+          end
+          ip
+        end
+
+        private
+
+        def compile_command(env)
+          host_port = Vagrant::Notify::server_port
+          template_binding = OpenStruct.new(:host_ip => host_ip(env), :host_port => host_port)
+          command = ERB.new(File.read(@command_template_file)).result(template_binding.instance_eval { binding })
+          File.open(env[:vm].env.tmp_path + 'vagrant-notify-send', 'w') { |f| f.write(command) }
+        end
+
+        def install_command_on_guest(env, command_path)
+          # DISCUSS: Should we back up the original command if present?
+          source = env[:vm].env.tmp_path + 'vagrant-notify-send'
+          env[:vm].channel.upload(source.to_s, '/tmp/notify-send')
+          env[:vm].channel.sudo('mv /tmp/notify-send /usr/bin/notify-send && chmod +x /usr/bin/notify-send')
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-notify/middleware/start_server.rb

@@ -0,0 +1,48 @@
+module Vagrant
+  module Notify
+    module Middleware
+      class StartServer
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if pid = server_is_running?(env)
+            env[:ui].info "Notification server is already running (#{pid})"
+          else
+            pid = run_server(env)
+            env[:ui].info "Notification server fired up (#{pid})"
+          end
+
+          @app.call(env)
+        end
+
+        private
+
+        def run_server(env)
+          pid = Server.run
+
+          local_data = env[:vm].env.local_data
+          local_data['vagrant-notify'] ||= Vagrant::Util::HashWithIndifferentAccess.new
+          local_data['vagrant-notify']['pid'] = pid
+          local_data.commit
+
+          pid
+        end
+
+        # REFACTOR: This is duplicated on Middleware::StopServer
+        def server_is_running?(env)
+          begin
+            pid = env[:vm].env.local_data.fetch('vagrant-notify', {}).fetch('pid', nil)
+            return false unless pid
+
+            Process.getpgid(pid)
+            pid
+          rescue Errno::ESRCH
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-notify/middleware/stop_server.rb

@@ -0,0 +1,49 @@
+module Vagrant
+  module Notify
+    module Middleware
+      class StopServer
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # TODO: Need to handle multi VMs setup
+
+          if pid = server_is_running?(env)
+            env[:ui].info('Stopping notification server...')
+            stop_server(pid)
+            cleanup_local_data(env)
+          end
+
+          @app.call(env)
+        end
+
+        private
+
+        def stop_server(pid)
+          Process.kill('KILL', pid.to_i) rescue nil
+        end
+
+        def cleanup_local_data(env)
+          local_data = env[:vm].env.local_data
+          local_data['vagrant-notify'] ||= Vagrant::Util::HashWithIndifferentAccess.new
+          local_data['vagrant-notify'].delete('pid')
+          local_data.commit
+        end
+
+        # REFACTOR: This is duplicated on Middleware::StartServer
+        def server_is_running?(env)
+          begin
+            pid = env[:vm].env.local_data.fetch('vagrant-notify', {}).fetch('pid', nil)
+            return false unless pid
+
+            Process.getpgid(pid.to_i)
+            pid
+          rescue Errno::ESRCH
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-notify/server.rb

@@ -0,0 +1,28 @@
+module Vagrant
+  module Notify
+    class Server
+      def receive_data(client)
+        args = ''
+        while tmp = client.gets
+          args << tmp
+        end
+        client.close
+
+        system("notify-send #{args}")
+      end
+
+      def self.run
+        fork do
+          $0 = 'vagrant-notify-server'
+          tcp_server = TCPServer.open(Vagrant::Notify::server_port)
+          server = self.new
+          loop {
+            Thread.start(tcp_server.accept) do |client|
+              server.receive_data(client)
+            end
+          }
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-notify/version.rb

@@ -0,0 +1,5 @@
+module Vagrant
+  module Notify
+    VERSION = "0.0.1"
+  end
+end

data/lib/vagrant_init.rb

@@ -0,0 +1,4 @@
+# This file is automatically loaded by Vagrant to load any
+# plugins. This file kicks off this plugin.
+
+require 'vagrant-notify'

data/spec/middleware/install_command_spec.rb

@@ -0,0 +1,59 @@
+describe Vagrant::Notify::Middleware::InstallCommand do
+  let(:start_stack)           { Vagrant.actions[:start].send(:stack) }
+  let(:provision_stack)       { Vagrant.actions[:provision].send(:stack) }
+  let(:host_ip)               { 'host-ip' }
+  let(:host_port)             { Vagrant::Notify::server_port }
+  let(:template)              { ERB.new('<%= host_ip %> <%= host_port %>') }
+  let(:compiled_command_path) { @env[:vm].env.tmp_path + 'vagrant-notify-send' }
+  let(:target_tmp_path)       { '/tmp/notify-send' }
+  let(:target_path)           { '/usr/bin/notify-send' }
+  let(:channel)               { mock(:channel, :sudo => true, :upload => true, :execute => true) }
+  let(:get_ip_command)        { 'echo -n $SSH_CLIENT | cut -d" " -f1' }
+
+  subject { described_class.new(@app, @env) }
+
+  before do
+    @app, @env = action_env(vagrant_env.vms.values.first.env)
+    @env[:vm].stub(:channel => channel)
+    ERB.stub(:new => template)
+  end
+
+  it 'gets called after boot middleware when starting machine' do
+    boot_index       = start_stack.index([Vagrant::Action::VM::Boot, [], nil])
+    middleware_index = start_stack.index([described_class, [], nil])
+
+    boot_index.should < middleware_index
+  end
+
+  it 'gets called when provisioning machine' do
+    provision_stack.should include([described_class, [], nil])
+  end
+
+  it "is able to identify host's ip" do
+    channel.should_receive(:execute).with(get_ip_command).and_yield(:stdout, host_ip + "\n")
+    subject.host_ip(@env).should == host_ip
+  end
+
+  it 'compiles command script passing host ip and server port' do
+    subject.stub(:host_ip => host_ip)
+    subject.call(@env)
+    File.read(compiled_command_path).should == "#{host_ip} #{host_port}"
+  end
+
+  it 'uploads compiled command script over to guest machine' do
+    channel.should_receive(:upload).with(compiled_command_path.to_s, target_tmp_path)
+    subject.stub(:host_ip => host_ip)
+    subject.call(@env)
+  end
+
+  it 'installs command for all users' do
+    channel.should_receive(:sudo).with("mv #{target_tmp_path} #{target_path} && chmod +x #{target_path}")
+    subject.stub(:host_ip => host_ip)
+    subject.call(@env)
+  end
+
+  it 'notifies user about script installation' do
+    @env[:ui].should_receive(:info).with('Compiling and installing notify-send script on guest machine')
+    subject.call(@env)
+  end
+end

data/spec/middleware/start_server_spec.rb

@@ -0,0 +1,69 @@
+describe Vagrant::Notify::Middleware::StartServer do
+  let(:start_stack) { Vagrant.actions[:start].send(:stack) }
+  let(:server_pid)  { 1234 }
+  let(:local_data)  { Hash.new }
+
+  subject { described_class.new(@app, @env) }
+
+  before do
+    @app, @env = action_env(vagrant_env.vms.values.first.env)
+    @env[:vm].env.stub(:local_data => local_data)
+    local_data.stub(:commit)
+    Vagrant::Notify::Server.stub(:run => server_pid)
+  end
+
+  it 'gets called when starting machine' do
+    start_stack.should include([described_class, [], nil])
+  end
+
+  context 'server is down' do
+    before { Process.stub(:getpgid).and_raise(Errno::ESRCH) }
+
+    it 'fires up notification server when called' do
+      Vagrant::Notify::Server.should_receive(:run)
+      subject.call(@env)
+    end
+
+    it 'notifies user about server start' do
+      @env[:ui].should_receive(:info).with("Notification server fired up (#{server_pid})")
+      subject.call(@env)
+    end
+
+    it "persists server PID on local data" do
+      local_data.should_receive(:commit)
+      subject.call(@env)
+      local_data['vagrant-notify']['pid'].should == server_pid
+    end
+
+    context "and a PID is present on Vagrant's local data" do
+      let(:new_pid) { server_pid + 1 }
+
+      before do
+        Vagrant::Notify::Server.stub(:run => new_pid)
+        local_data['vagrant-notify'] = { 'pid' => server_pid }
+      end
+
+      it 'updates server PID' do
+        subject.call(@env)
+        local_data['vagrant-notify']['pid'].should == new_pid
+      end
+    end
+  end
+
+  context 'server is up' do
+    before do
+      Process.stub(:getpgid => true)
+      local_data['vagrant-notify'] = { 'pid' => server_pid }
+    end
+
+    it 'does not start a new server instance' do
+      Vagrant::Notify::Server.should_not_receive(:run)
+      subject.call(@env)
+    end
+
+    it 'notifies user that server is already running' do
+      @env[:ui].should_receive(:info).with("Notification server is already running (#{server_pid})")
+      subject.call(@env)
+    end
+  end
+end

data/spec/middleware/stop_server_spec.rb

@@ -0,0 +1,49 @@
+describe Vagrant::Notify::Middleware::StopServer do
+  let(:halt_stack) { Vagrant.actions[:halt].send(:stack) }
+  let(:server_pid) { '1234' }
+  let(:local_data) { { 'vagrant-notify' => { 'pid' => server_pid } } }
+
+  subject { described_class.new(@app, @env) }
+
+  before do
+    @app, @env = action_env(vagrant_env.vms.values.first.env)
+    @env[:vm].env.stub(:local_data => local_data)
+    local_data.stub(:commit)
+  end
+
+  it 'gets called when halting machine' do
+    halt_stack.should include([described_class, [], nil])
+  end
+
+  context 'server is down' do
+    before { Process.stub(:getpgid).and_raise(Errno::ESRCH) }
+
+    it 'does not notify user about server stop' do
+      @env[:ui].should_not_receive(:info)
+      subject.call(@env)
+    end
+  end
+
+  context 'server is up' do
+    before do
+      Process.stub(:getpgid => true)
+      local_data['vagrant-notify'] = { 'pid' => server_pid }
+    end
+
+    it 'notifies user that server is stopping' do
+      @env[:ui].should_receive(:info).with('Stopping notification server...')
+      subject.call(@env)
+    end
+
+    it 'kills notification server' do
+      Process.should_receive(:kill).with('KILL', server_pid.to_i)
+      subject.call(@env)
+    end
+
+    it "removes server PID on local data" do
+      local_data.should_receive(:commit)
+      subject.call(@env)
+      local_data['vagrant-notify']['pid'].should be_nil
+    end
+  end
+end

data/spec/server_spec.rb

@@ -0,0 +1,18 @@
+describe Vagrant::Notify::Server do
+  let(:arguments) { "-- '20 examples, 1 failure\n10 seconds'" }
+  let(:client)    { StringIO.new(arguments) }
+
+  before do
+    subject.stub(:system => true)
+  end
+
+  it 'runs notify-send with received data from client' do
+    subject.should_receive(:system).with("notify-send #{arguments}")
+    subject.receive_data(client)
+  end
+
+  it 'closes connection after reading data' do
+    client.should_receive(:close)
+    subject.receive_data(client)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require 'vagrant-notify'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+
+  config.include Vagrant::TestHelpers
+end

data/vagrant-notify.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'vagrant-notify/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "vagrant-notify"
+  gem.version       = Vagrant::Notify::VERSION
+  gem.authors       = ["Fabio Rehm"]
+  gem.email         = ["fgrehm@gmail.com"]
+  gem.description   = 'A Vagrant plugin that redirects system notifications from guest to host machine.'
+  gem.summary       = gem.description
+  gem.homepage      = "https://github.com/fgrehm/vagrant-notify"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'vagrant'
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec'
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: vagrant-notify
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Fabio Rehm
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: vagrant
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A Vagrant plugin that redirects system notifications from guest to host
+  machine.
+email:
+- fgrehm@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- files/notify-send.erb
+- lib/vagrant-notify.rb
+- lib/vagrant-notify/middleware.rb
+- lib/vagrant-notify/middleware/install_command.rb
+- lib/vagrant-notify/middleware/start_server.rb
+- lib/vagrant-notify/middleware/stop_server.rb
+- lib/vagrant-notify/server.rb
+- lib/vagrant-notify/version.rb
+- lib/vagrant_init.rb
+- spec/middleware/install_command_spec.rb
+- spec/middleware/start_server_spec.rb
+- spec/middleware/stop_server_spec.rb
+- spec/server_spec.rb
+- spec/spec_helper.rb
+- vagrant-notify.gemspec
+homepage: https://github.com/fgrehm/vagrant-notify
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -675474948593784751
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -675474948593784751
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A Vagrant plugin that redirects system notifications from guest to host machine.
+test_files:
+- spec/middleware/install_command_spec.rb
+- spec/middleware/start_server_spec.rb
+- spec/middleware/stop_server_spec.rb
+- spec/server_spec.rb
+- spec/spec_helper.rb