org-converge 0.0.13 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d7a97ec8da9f4a8f8821a467698c8610b8a6b87c
-  data.tar.gz: d818011bb528d5db4177f39440fef3714e34f60c
+  metadata.gz: b8f7e90bad105cff350dbb911fe70a553646caa6
+  data.tar.gz: da367c09faae2f51ad7b0efd34c57f5a27ab8057
 SHA512:
-  metadata.gz: 5b319849d03e1d323ee6aee744bf8ad62cb6be0eb408c0a0c14db52829799f89433328cd61a3eb8883af3fef9099a16e03499b21bac50c380d3ef10e29c677be
-  data.tar.gz: 1a24ec44adfc113364f8514595bd3e4d5b319aea0dcbe25cd2c79c5ed32f81e1e64f41cf0b2bd7f21b6c75d94851fb42b8c3022f0298a05382b0b79927b1ceca
+  metadata.gz: 2b099f71b36b2504a9ae922ea1956d2a23eb224478c332fc230a747079105db9214b604d397ab43f0fa8dfd8d29b2349384a00ca4dfcf7f9e2fd72809e0885b8
+  data.tar.gz: 8768bddc3b3273d54164c7325e2f1f5e22b1364ed91ceaecf31f6edd1ee426274500ebd45eec6ed8329e1a048a4041de85f9614a9e443086d5fe83a52f5ef466

data/Gemfile

@@ -4,6 +4,7 @@ group :development, :test do
   gem 'rake'
   gem 'rspec'
   gem 'nats', '0.5.0.beta.12'
+  gem 'sinatra'
 end
 
 gemspec

data/TODO

@@ -2,7 +2,7 @@
 #+TODO:    TODO | DONE CANCELED 
 #+startup: showeverything
 
-* [0/10] 0.1.0 version
+* [0/16] 0.1.0 version
 
 - [ ] Macros can be loaded and applied to the configuration
 - [ ] Actually support converging and idempotency (~--runmode=idempotent~)
@@ -13,25 +13,36 @@
 - [ ] Heuristics for determining which binary to use for running the script
 - [ ] Display how the run would look like without making changes
   : org-converge setupfile.org --dry-run
-- [ ] Use :eval for evaling blocks (off by default)
-- [ ] Can use ~:dir~ for running a process relative to that directory
+- [ ] Use =:eval= for evaling blocks (off by default)
 - [ ] Bugfix for when results blocks have only inline examples or images
 - [ ] Bugfix for when the result from a ~org-spec~ run has non-zero exit status
 - [ ] Bugfixes for spec run
-
-* [0/5] 0.0.14
-
 - [ ] Distributed run helpers for the header arguments
-  : ssh
+  Like remote =:dir= for example.
+- [ ] =:onerror=
+  aborteverything, restart, runhandler
+- [ ] =:asserts=
 - [ ] =:waits:=
   Wait for other processes to start before starting.
   The process does not start until the alive signal to the following
   list of processes succeeds.
 - [ ] =:awaits:=
   Wait for other processes to finish before starting.
-- [ ] =:onerror=
-  aborteverything, restart, runhandler
-- [ ] =:assertedby=
+- [ ] =:file=
+  For storing the output from the evaluation (already done in spec mode)a
+- [ ] Can use =:dir= for running a process remotely via ssh
+  This needs the credentials to be readily available
+
+* [2/2] 0.0.14
+
+All of the following makes it required to 
+track the result from the runs.
+
+- [X] Can use =:dir= for running a process relative to that directory
+- [X] =:if= and =:unless= checks
+  First step at achieving idempotency.
+  This tracks the result from another block.
+  In case the block results in exit 0, then true. Otherwise false.
 
 * [2/2] 0.0.13
 

data/bin/org-converge

@@ -25,5 +25,5 @@ end
 
 exit 1 unless cmd
 
-o = OrgConverge::Command.new(cmd)
+o = OrgConverge::Command.new(cmd.merge({ '--runmode' => 'idempotent' }))
 o.execute!

data/lib/org-converge/command.rb

@@ -4,6 +4,7 @@ module OrgConverge
     attr_reader :logger
     attr_reader :ob
     attr_reader :engine
+    attr_reader :runmode
 
     def initialize(options)
       @options   = options
@@ -27,6 +28,9 @@ module OrgConverge
       logger.formatter = proc do |severity, datetime, progname, msg| 
         "[#{datetime.strftime('%Y-%m-%dT%H:%M:%S %z')}] #{msg}\n"
       end
+
+      # Keep track of the exit status from the process for idempotency checks
+      @procs_exit_status = Hash.new { |h,k| h[k] = { } }
     end
 
     def execute!
@@ -48,7 +52,7 @@ module OrgConverge
 
     def converge!
       tangle!
-      runmode = @options['--runmode'] || ob.in_buffer_settings['RUNMODE']
+      @runmode = @options['--runmode'] || ob.in_buffer_settings['RUNMODE']
       case
       when @options['--name']
         if runmode == 'sequentially'
@@ -65,7 +69,7 @@ module OrgConverge
       case runmode
       when 'parallel'
         run_blocks_in_parallel!
-      when 'sequential'
+      when 'sequential', 'idempotent'
         run_blocks_sequentially!
       when 'chained', 'chain', 'tasks'
         run_blocks_chain!
@@ -131,7 +135,6 @@ module OrgConverge
     end
 
     def run_blocks_sequentially!
-      @engine = OrgConverge::Engine.new(:logger => @logger, :babel => @babel)
       babel.tangle_runnable_blocks!(@run_dir)
 
       runlist_stack = []
@@ -141,17 +144,17 @@ module OrgConverge
 
       while not runlist_stack.empty?
         key, script = runlist_stack.shift
-
         # Decision: Only run blocks which have a name
         next unless script[:header][:name]
-
         display_name = script[:header][:name]
-        with_running_engine do |engine|
+        exit_status_list = with_running_engine(:runmode => @runmode) \
+        do |engine|
           file = File.expand_path("#{@run_dir}/#{key}")
           bin = determine_lang_bin(script)
           cmd = "#{bin} #{file}"
           run_procs(script, cmd, engine)
         end
+        @procs_exit_status.merge!(exit_status_list)
       end
       logger.info "Run has completed successfully.".fg 'green'
     end
@@ -209,7 +212,7 @@ module OrgConverge
           file = File.expand_path("#{@run_dir}/#{key}")
           bin = determine_lang_bin(script)
           cmd = "#{bin} #{file}"
-          engine.register display_name, cmd, { :cwd => @root_dir, :logger => logger }
+          run_procs(script, cmd, engine)
         end
       end
       logger.info "Run has completed successfully.".fg 'green'
@@ -344,6 +347,26 @@ module OrgConverge
     def run_procs(script, cmd, engine=nil)
       engine ||= @engine
       display_name = script[:header][:name]
+
+      if @runmode == 'idempotent'
+        case
+        when script[:header][:if]
+          block_name = script[:header][:if]
+          exit_status = @procs_exit_status[block_name]
+          unless exit_status == 0
+            logger.info "#{display_name.fg 'green'} -- Skipped since :if clause matches check from '#{block_name.fg 'yellow'}'"
+            return
+          end
+        when script[:header][:unless]
+          block_name = script[:header][:unless]
+          exit_status = @procs_exit_status[block_name]
+          if exit_status == 0
+            logger.info "#{display_name.fg 'green'} -- Skipped since :unless clause matches check from '#{block_name.fg 'yellow'}'"
+            return
+          end
+        end
+      end
+
       if script[:header][:procs]
         procs = script[:header][:procs].to_i
         1.upto(procs) do |i|

data/lib/org-converge/engine.rb

@@ -5,6 +5,7 @@
 require 'foreman/engine'
 require 'foreman/process'
 require 'tco'
+require 'fileutils'
 
 module OrgConverge
   class Engine < Foreman::Engine
@@ -23,6 +24,10 @@ module OrgConverge
       # Code blocks whose start invocation is manipulated run inside a thread
       @threads = []
       @running_threads = { }
+
+      # Returns a list in the end with the exit status code from the code blocks
+      # that were run in parallel
+      @procs_exit_status = { }
     end
 
     # We allow other processes to exit with 0 status
@@ -33,7 +38,7 @@ module OrgConverge
       watch_for_output
       sleep 0.1
       begin
-        status = watch_for_termination do 
+        status = watch_for_termination do
           @threads.each do |t|
             unless t.alive?
               t.exit
@@ -42,6 +47,8 @@ module OrgConverge
           end
         end
       end while (@running.count > 0 or @running_threads.count > 0)
+
+      @procs_exit_status
     end
 
     # Overriden: we do not consider process formations
@@ -78,6 +85,7 @@ module OrgConverge
     def register(name, command, options={})
       options[:env] ||= env
       options[:cwd] ||= File.dirname(command.split(" ").first)
+
       process = OrgConverge::CodeBlockProcess.new(command, options)
       @names[process] = name
       @processes << process
@@ -125,6 +133,20 @@ module OrgConverge
     rescue Errno::ECHILD
     end
 
+    def termination_message_for(status)
+      n = name_for(status.pid).split('.').first
+
+      if status.exited?
+        @procs_exit_status[n] = status.exitstatus
+        "exited with code #{status.exitstatus}"
+      elsif status.signaled?
+        # TODO: How to handle exit by signals? Non-zero exit status so idempotency check fails?
+        "terminated by SIG#{Signal.list.invert[status.termsig]}"
+      else
+        "died a mysterious death"
+      end
+    end
+
     def name_for(pid)
       process = nil
       index   = nil
@@ -144,46 +166,64 @@ module OrgConverge
   # Need to expose the options to make the process be aware
   # of the possible running mode (specially spec mode)
   # and where to put the results output
-  require 'timeout'
   class CodeBlockProcess < Foreman::Process
     attr_reader :options
 
     def run(options={})
       env    = @options[:env].merge(options[:env] || {})
       output = options[:output] || $stdout
-      runner = "#{Foreman.runner}".shellescape      
+      runner = "#{Foreman.runner}".shellescape
 
       # whitelist the modifiers which manipulate how to the block is started
       block_modifiers = { }
       if options[:header]
         block_modifiers[:waitfor] = options[:header][:waitsfor]  || options[:header][:waitfor] || options[:header][:sleep]
         block_modifiers[:timeout] = options[:header][:timeoutin] || options[:header][:timeout] || options[:header][:timeoutafter]
+        if options[:header][:dir]
+          block_modifiers[:cwd] = File.expand_path(File.join(self.options[:cwd], options[:header][:dir]))
+        end
       end
 
       pid     = nil
       thread  = nil
-      process = nil
 
-      if block_modifiers and (block_modifiers[:waitfor] || block_modifiers[:timeout])
-        thread = Thread.new do
-          waitfor = block_modifiers[:waitfor].to_i
-          timeout = block_modifiers[:timeout].to_i
-          process = proc do
-            sleep waitfor if waitfor > 0
-            wrapped_command = "exec #{runner} -d '#{cwd}' -p -- #{command}"
-            pid = Process.spawn env, wrapped_command, :out => output, :err => output
-          end
-          timeout > 0 ? Timeout::timeout(timeout, &process) : process.call
-        end
-      else    
-        if Foreman.windows?
-          Dir.chdir(cwd) do
-            pid = Process.spawn env, expanded_command(env), :out => output, :err => output
-          end
+      process = proc do
+        wrapped_command = ''
+        if block_modifiers[:cwd]
+          @options[:cwd] = block_modifiers[:cwd]
+          # Need to adjust the path by having the run file at the same place
+          bin, original_script = command.split(' ')
+          new_script           = File.join(block_modifiers[:cwd], ".#{options[:header][:name]}")
+          FileUtils.cp(original_script, new_script)
+          cmd = [bin, new_script].join(' ')
+          wrapped_command = "exec #{runner} -d '#{cwd}' -p -- #{cmd}"
         else
           wrapped_command = "exec #{runner} -d '#{cwd}' -p -- #{command}"
-          pid = Process.spawn env, wrapped_command, :out => output, :err => output
         end
+        opts = { :out => output, :err => output }
+        pid  = Process.spawn env, wrapped_command, opts
+      end
+
+      # In case we modify the run block, we run it in a Thread
+      # otherwise we continue treating it as a forked process.
+      if block_modifiers and (block_modifiers[:waitfor] || block_modifiers[:timeout] || block_modifiers[:dir])
+        waitfor = block_modifiers[:waitfor].to_i
+        timeout = block_modifiers[:timeout].to_i
+
+        thread = Thread.new do
+          sleep waitfor if waitfor > 0
+          pid = process.call
+          if timeout > 0
+            sleep timeout
+            # FIXME: Kill children properly
+            o = `ps -ef | awk '$3 == #{pid} { print $2 }'`
+            o.each_line { |cpid| Process.kill(:TERM, cpid.to_i) }
+            Process.kill(:TERM, pid)
+            Thread.current.kill
+          end
+        end
+      else
+        pid = process.call
       end
 
       # In case of thread, pid will be nil

data/lib/org-converge/version.rb

@@ -1,3 +1,3 @@
 module OrgConverge
-  VERSION = "0.0.13"
+  VERSION = "0.0.14"
 end

data/spec/converge_examples/block_modifiers/run.org

@@ -7,6 +7,7 @@ We have the following process, but it will take 5 seconds to start...
 echo "Wait..."
 for i in `seq 1 4`;
 do
+echo $i
 echo $i >> out.log
 sleep 1
 done
@@ -21,7 +22,7 @@ echo "whoosh" > out.log
 #+end_src
 
 #+name: timeout-in-3-seconds
-#+begin_src sh :timeout 3
+#+begin_src sh :timeout 5
 while true; do
   echo "Eventually will timeout..."
   sleep 1

data/spec/converge_examples/chdir/local-run.org

@@ -0,0 +1,42 @@
+#+TITLE:   Changing directories locally
+#+runmode: sequential
+
+Like in the original Org babel from Emacs, it should be possible
+to run the block with a different root.  This avoids having to implement
+changing dir within the language as well.
+
+#+begin_src python :tangle subdir/greetings/greetings.py :mkdirp true
+def hello():
+  f = open('out.log', 'w')
+  f.write("Hi\n")
+  print "Finished writing."
+#+end_src
+
+#+begin_src python :tangle subdir/greetings/__init__.py :mkdirp true
+# greetings module
+#+end_src
+
+#+name: load-and-greet-test
+#+begin_src python :results output code :dir subdir
+from greetings import greetings
+
+print dir(greetings)
+
+for i in range(0, 10):
+  greetings.hello()
+#+end_src
+
+#+name: path-test
+#+begin_src python :results output code :dir subdir
+import os
+
+print os.getcwd()
+print os.path.realpath(__file__)
+print os.path.dirname(os.path.realpath(__file__))
+#+end_src
+
+#+name: bash-cwd-text
+#+begin_src sh :results output :dir subdir
+echo "within subdir"  > out.log
+cat out.log
+#+end_src

data/spec/converge_examples/idempotency/conditions.org

@@ -0,0 +1,158 @@
+#+TITLE:   Idempotency examples
+#+runmode: sequential
+
+First steps towards achieving idempotency.
+All of these are identified when tangling and during execution.
+
+- Example resources
+  + command
+    exit status 1 means that the block should be run
+    exit status 0 means that it should not be run
+  + directory
+    Can be covered by :mkdirp
+  + package
+    If package is in the dpkg -l output, don't install
+  + template
+    Makes sense only when tangling.
+    If there was a diff in the template, then apply and notify another block
+  + file
+    if it exists then run
+    else do not run it
+
+*** DONE When =:if <block>= is used, it will execute the block unless conditional block returns 0
+
+The most general case is when we link 2 different code blocks
+so that one can define whether the second one should be executed.
+
+In order to achieve this, the blocks need to be defined sequentially
+this way it will be checked whether sinatra is installed or not first,
+and use the exit status when considering to start the application.
+
+*NOTE*: Because of this constraint, parallel runs cannot run in converge mode.
+Only sequential runs supported.
+
+#+name: install-package
+#+begin_src sh
+echo "brew install something..."
+echo "package is installed" > installed
+#+end_src
+
+#+name: package-already-installed
+#+begin_src sh
+if [ -e installed ]; then
+  echo "Already installed"
+  exit 0
+else
+  echo "Needs install"
+  exit 1
+fi
+#+end_src
+
+#+name: install-package-once-again
+#+begin_src sh :unless package-already-installed
+echo "Installing the package once again..."
+echo "not run" >> installed
+#+end_src
+
+#+name: do-everything-even-if-package-installed
+#+begin_src sh :if package-already-installed
+echo "Doing this even if installed already..." 
+echo "eof" >> installed
+#+end_src
+
+*** COMMENT When it has a results block, then it will be executed unless it matches the spec
+
+Here they would be run sequentially, but it would be better if the =:assert= block
+can be lazily invoked when deploy-app is about to run, not during the preparation step 
+which happens sequentially.
+
+#+name: ruby-version-installed
+#+begin_src sh :results output code :exports none
+ruby --version | awk '{ print $2 }'
+#+end_src
+
+#+RESULTS: ruby-version-installed
+#+BEGIN_SRC sh
+1.8.7
+#+END_SRC
+
+#+name: deploy-app
+#+begin_src sh :assert ruby-version-installed
+echo "Can deploy app because correct Ruby is installed"
+#+end_src
+
+*** COMMENT When =:if file-exists :at <path>= is used, it will execute the block unless the file exists
+
+#+name: execute-if-file-exists
+#+begin_src sh :if file-exists :at /var/run/ntpd.pid
+echo "Starting process because ntpd file exists exists.."
+#+end_src
+
+These =file-exists= kind of checks can be pluggable.
+
+*** COMMENT Ideas
+**** TODO How to support gated checks in parallel runs?
+
+Let's say that we have a run which makes a healthcheck in the end.
+In this case, it would mean that a healthcheck would be run
+once run-web-app is alive.
+
+Run a healthcheck for the application in the end
+to confirm that it boot up correctly:
+
+#+begin_src ruby :tangle sinatra/app.rb :mkdirp true
+require 'sinatra'
+
+get '/' do
+ "OK\n"
+end
+#+end_src
+
+***** Check if Sinatra is installed at least
+      :PROPERTIES:
+      :SRC_ORDER: sequential
+      :END:
+
+One idea is to accumulate them in case they are under
+the same headline, meaning that runlists can be grouped.
+
+#+name: sinatra-is-installed
+#+begin_src sh
+echo "Checking if sinatra is installed"
+gem list | grep sinatra
+#+end_src
+
+...then run it as follows:
+
+#+name: install-sinatra
+#+begin_src sh :unless sinatra-is-installed
+gem install sinatra
+#+end_src
+
+A block which is not executed due to an idempotency check 
+is equivalent to another one that ended with exit status 0.
+
+#+name: server-start
+#+begin_src sh :timeout 5 :if install-sinatra
+ruby sinatra/app.rb
+#+end_src
+
+***** Run a healthcheck for the sinatra application
+      :PROPERTIES:
+      :SRC_ORDER: sequential
+      :END:
+
+#+name: healthcheck-sinatra-app
+#+begin_src sh :sleep 3 :timeout 10 :awaits server-start
+while true; do
+  curl 127.0.0.1:4567 2> /dev/null
+  if [ $? != 0 ]; then
+    echo "NOT OK"
+  fi
+  sleep 1
+done
+#+end_src
+
+#+begin_src sh
+echo "Run"
+#+end_src

data/spec/converge_spec.rb

@@ -159,4 +159,33 @@ describe OrgConverge::Command do
     result = File.open("#{example_dir}/out.log").read
     result.should == "whoosh\n1\n2\n3\n4\n"
   end
+
+  it "should be able to chdir the process directory" do
+    example_dir = File.join(EXAMPLES_DIR, 'chdir')
+    setup_file = File.join(example_dir, 'local-run.org')
+
+    o = OrgConverge::Command.new({ 
+                                   '<org_file>' => setup_file,
+                                   '--root-dir' => example_dir
+                                 })
+    success = o.execute!
+    success.should == true
+    result = File.open("#{example_dir}/subdir/out.log").read
+    result.should == "within subdir\n"
+  end
+
+  it "should support idempotency checks via :if and :unless conditional clauses" do
+    example_dir = File.join(EXAMPLES_DIR, 'idempotency')
+    setup_file = File.join(example_dir, 'conditions.org')
+
+    o = OrgConverge::Command.new({ 
+                                   '<org_file>' => setup_file,
+                                   '--root-dir' => example_dir,
+                                   '--runmode'  => 'idempotent'
+                                 })
+    success = o.execute!
+    success.should == true
+    result = File.open("#{example_dir}/installed").read
+    result.should == "package is installed\neof\n"
+  end
 end

data/vagrant.org

@@ -0,0 +1,104 @@
+#+TITLE:   Vagrant environment setup
+#+startup: showeverything
+
+**** Importing the Vagrant keys first
+
+#+begin_src text :tangle vagrant/.git/info/sparse-checkout :mkdirp true
+keys
+#+end_src
+
+#+name: import-vagrant-keys-done
+#+begin_src sh :results output
+[ -e vagrant/keys/vagrant ] && echo "Already cloned"
+#+end_src
+
+#+name: import-vagrant-keys
+#+begin_src sh :unless import-vagrant-keys-done
+cd vagrant
+git init
+git remote add origin https://github.com/mitchellh/vagrant.git
+git config core.sparsecheckout true
+git pull origin master
+git checkout master
+chmod 0600 keys/vagrant
+#+end_src
+
+**** Vagrantfile for Ubuntu 14.04
+
+#+begin_src ruby :tangle Vagrantfile
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+# Vagrantfile API/syntax version. Don't touch unless you know what you're doing!
+VAGRANTFILE_API_VERSION = "2"
+
+Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
+  config.vm.box = "ubuntu-14.04-amd64-vbox.box"
+  config.vm.box_url = "https://oss-binaries.phusionpassenger.com/vagrant/boxes/latest/ubuntu-14.04-amd64-vbox.box"
+
+  # config.vm.network :forwarded_port, guest: 80, host: 8080
+  # config.vm.network :private_network, ip: "192.168.33.10"
+  # config.vm.network :public_network
+  # config.ssh.forward_agent = true
+
+  config.vm.provider :virtualbox do |vb|
+    vb.gui = true
+    vb.customize ["modifyvm", :id, "--memory", "1024"]
+  end
+end
+#+end_src
+
+***** Import
+
+#+name: vagrant-running
+#+begin_src sh
+vagrant status
+#+end_src
+
+#+name: start_vagrant
+#+begin_src sh :unless vagrant-running
+vagrant up
+#+end_src
+
+***** Configure
+
+Install Emacs, Org mode and Org Converge in the VM.
+
+#+name: running-in-ubuntu
+#+begin_src sh :results output
+platform=`uname -a | awk '{print $2}'`
+if [ $platform == "ubuntu-14" ]; then
+  echo "OK"
+  exit 0
+else
+  echo "Only works in Ubuntu"
+  exit 1
+fi
+#+end_src
+
+#+name: apt-get-install
+#+begin_src sh :dir vagrant@localhost:2222/ :if running-in-ubuntu
+sudo apt-get update
+sudo apt-get install build-essentials emacs24-nox org-mode -y
+#+end_src
+
+**** Vagrantfile :: Docker provider
+
+#+begin_src ruby :tangle docker/Vagrantfile :mkdirp true
+Vagrant.configure("2") do |config|
+  config.vm.provider "docker" do |d|
+    d.build_dir = "."
+  end
+end
+#+end_src
+
+#+begin_src conf :tangle docker/Dockerfile
+FROM ubuntu
+RUN  apt-get -y update
+RUN  apt-get -y install emacs24-nox org-mode
+#+end_src
+
+#+name: vagrant-docker-provider
+#+begin_src sh :dir docker
+vagrant up --provider=docker
+#+end_src

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: org-converge
 version: !ruby/object:Gem::Version
-  version: 0.0.13
+  version: 0.0.14
 platform: ruby
 authors:
 - Waldemar Quevedo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-01 00:00:00.000000000 Z
+date: 2014-06-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: docopt
@@ -131,9 +131,11 @@ files:
 - spec/converge_examples/basic_tangle/conf.yml.expected
 - spec/converge_examples/basic_tangle/setup.org
 - spec/converge_examples/block_modifiers/run.org
+- spec/converge_examples/chdir/local-run.org
 - spec/converge_examples/commented_block/run.org
 - spec/converge_examples/expected_results/spec.org
 - spec/converge_examples/expected_results/spec2.org
+- spec/converge_examples/idempotency/conditions.org
 - spec/converge_examples/linked_tasks/tasks.org
 - spec/converge_examples/multi_proc/run.org
 - spec/converge_examples/runlist_example/setup.org
@@ -141,6 +143,7 @@ files:
 - spec/converge_examples/specified_block/run.org
 - spec/converge_spec.rb
 - spec/spec_helper.rb
+- vagrant.org
 homepage: https://github.com/wallyqs/org-converge
 licenses: []
 metadata: {}
@@ -170,9 +173,11 @@ test_files:
 - spec/converge_examples/basic_tangle/conf.yml.expected
 - spec/converge_examples/basic_tangle/setup.org
 - spec/converge_examples/block_modifiers/run.org
+- spec/converge_examples/chdir/local-run.org
 - spec/converge_examples/commented_block/run.org
 - spec/converge_examples/expected_results/spec.org
 - spec/converge_examples/expected_results/spec2.org
+- spec/converge_examples/idempotency/conditions.org
 - spec/converge_examples/linked_tasks/tasks.org
 - spec/converge_examples/multi_proc/run.org
 - spec/converge_examples/runlist_example/setup.org