angry_mob 0.1.0

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2010 PLUS2 Pty. Ltd.
+
+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 PURPOa AND
+NONINFRINGEMENT. IN NO EVENT SaALL 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,123 @@
+# This is AngryMob
+AngryMob (AM) is the automated system configuration component of [YesMaster](http://yesmasterapp.com).
+
+It combines:
+
+* convenient configuration data (`the node`)
+* idempotent code to ensure the configuration of the parts of a system (`targets`)
+* and a method of controlling the flow of the setup (`acts`)
+
+AngryMob values having:
+
+* zero external dependencies.
+* a small, simple core.
+* Rubiness.
+
+Having *zero external dependencies* means that AM can be used from the very moment a bare ruby interpreter is installed on a server.
+
+A *small, simple core* means that debugging and testing the code is simplified. It also allows AM to be embedded directly into other projects.
+
+Please note that **AngryMob is a reaction to Chef**. Despite this, I retain the utmost respect the Chef movement and the guys who've built it.
+
+AM purposely omits or eschews the following features you might be familiar with from Chef:
+
+* **The client and server and its dependencies.** AM operates similarly to "chef-solo" or is combined with other components for network based "chef-client"-like operation.
+* **A built in, fixed cookbook layout and metadata.** You can define your own ResourceLocator, or use the basic supplied one.
+* **A single copy nirvana implementation.** Again, define it yourself if you want it.
+* **The puppet resource/provider separation.** I don't have a particular solution to supporting multiple operating systems, but its strongly YAGNI for now.
+* **Exhaustive system discovery like Ohai.** I think Ohai is great, but running it before every AM run to find the hostname and IP is excessive.
+* **Type-checking of data.** This is ruby, where ducks rule the roost.
+
+### Status
+AngryMob is young and fluid, but I'm using it a lot in the maintainence of VPSes at PLUS2.
+
+In particular, AM lacks any unit-level specs or tests so far. The servers it maintains are valid functional testing in my eyes ;)
+
+### Taxonomy
+
+* The `node` is a glob of data representing the thing you're configuring.
+* `targets` are things you want to configure.
+* `acts` are groups of target invocations. They can also schedule the execution of other acts.
+* `mobs` are groups of acts and targets.
+
+#### The Node
+The Node is a place to hang your data. In essence its a `Hash` (though more specifically its an [AngryHash](http://github.com/plus2/angry_hash), which is similar to `Hashie::Mash`)
+
+#### Targets
+Targets are parts of the server which you want to configure, for example:
+
+* directories
+* templates
+* users
+
+*Note* the targets interface is likely to change soon. Its overly complicated right now.
+
+Targets perform a similar role to Chef/puppet resource/providers.
+
+**TODO** talk about Target definition dsl and SingletonTargets
+
+#### Acts
+Acts are groups of targets. They're conceptually similar to a rake task. Subsequent acts can be scheduled.
+
+#### Mobs
+Mobs are groups of target definitions and acts. They can be mixed and matched.
+
+##### common mob
+
+http://github.com/plus2/common_mob
+
+A small toolkit of handy targets:
+
+* dir
+* file
+* template - ERB
+* symlink
+* tarball
+* fetch
+* git
+* user
+* apt - apt-get package
+* gem - a rubygem
+* block - a ruby block
+* sh - a shell command
+* service - a super-class for defining ubuntu service targets
+
+## The mob command
+
+"chef-solo"-like command for setting an AngryMob on your server.
+
+**TODO** write!
+
+## Meta
+
+AngryMob was written by [Lachie Cox](http://github.com/lachie) for [PLUS2](http://plus2.com.au) and [YesMaster](http://yesmasterapp.com).
+
+It lives at [http://github.com/plus2/angry_mob](http://github.com/plus2/angry_mob).
+
+Please try it out and send us feedback via the github page.
+
+## License
+
+Copyright (c) 2010 PLUS2
+
+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/bin/mob

@@ -0,0 +1,139 @@
+#!/usr/bin/env ruby
+
+
+require 'pathname'
+@root = Pathname(__FILE__).dirname.parent.expand_path
+
+%w{json thor angry_hash}.each do |lib|
+  root = @root+'vendor'+lib
+  $: << (root+'lib')
+end
+
+require 'thor'
+
+$:.unshift @root+'lib'
+require 'angry_mob'
+
+class MobCLI < Thor
+
+  default_task 'riot'
+  desc 'riot', 'riot the mob'
+  method_option :nodename , :type => :string, :required => true
+  method_option :json_file, :type => :string, :required => true
+  method_option :act      , :type => :string, :required => true
+
+  method_option :hooks      , :type => :string
+
+  method_option :debug            , :type => :boolean, :default => false
+  method_option :dry_run          , :type => :boolean, :default => false
+  method_option :allow_missing_act, :type => :boolean, :default => false
+
+  method_option :mobs, :type => :array, :default => []
+
+  attr_reader :config
+  def riot
+    begin
+      @config = AngryHash[ options ]
+
+      load_hooks(config.hooks)
+
+      @hooks.pre
+
+      ui = AngryMob::UI.new(:debug => config.debug?)
+
+      attributes = build_attributes
+
+      @hooks.attrs( attributes )
+
+      AngryMob::Mob.ui = ui   # XXX not threadsafe, but what is?
+      mob_loader = AngryMob::MobLoader.new
+      
+      config.mobs.each {|mob_path| mob_loader.add_mob(mob_path)}
+
+      mob = mob_loader.to_mob
+      mob.riot!( config.nodename, attributes )
+
+    rescue
+      $stdout.flush
+      $stderr.flush
+
+      puts "\nerror [#{$!.class}] #{$!}"
+      $!.backtrace.each {|b| puts "  #{b}"}
+      exit(1)
+    end
+  end
+
+  protected
+  def build_attributes
+    attributes = load_attributes
+
+    attributes.acts = [ config.act ]
+
+    if config.allow_missing_act?
+      attributes.raise_on_missing_act = false
+    end
+
+    attributes.dry_run = config.dry_run?
+
+    attributes
+  end
+
+  def load_attributes
+    return AngryHash.new unless config.json_file?
+
+    if config.json_file.to_s[/^https?:/]
+      require 'net/http'
+      require 'uri'
+      json = Net::HTTP.get(URI.parse(config.json_file))
+    else
+      json = Pathname(config.json_file.tapp("loading attributes from")).expand_path.read
+    end
+
+    require 'json/pure'
+    attributes = JSON.parse( json )
+
+    AngryHash[attributes || {}]
+  end
+
+  def load_hooks(file)
+    @hooks = MobHooks.new( self, file )
+  end    
+end
+
+
+class MobHooks
+  attr_reader :cli
+  def initialize(cli,file=nil)
+    @cli = cli
+    if file
+      @building = true
+      instance_eval( Pathname(file).read )
+      @building = false
+    end
+  end
+
+  def pre(&block)
+    if building?
+      pre_blocks << block
+    else
+      pre_blocks.each {|b| b.call}
+    end
+  end
+
+  def attrs( *args, &block )
+    if building?
+      attr_blocks << block
+    else
+      attr_blocks.each {|b| b.call(*args)}
+    end
+  end
+
+  protected
+
+  def building?; @building end
+  def pre_blocks ; @pre_blocks ||= [] end
+  def attr_blocks; @attr_blocks ||= [] end
+end
+
+
+MobCLI.start

data/lib/angry_mob.rb

@@ -0,0 +1,28 @@
+require 'pathname'
+here = Pathname(__FILE__).dirname
+
+require 'angry_hash'
+
+# XXX duckpunches aren't good for not stepping on other codes' toes
+require 'angry_mob/extend'
+
+class AngryMob
+  autoload :Mob            , 'angry_mob/mob'
+  autoload :Node           , 'angry_mob/node'
+
+  autoload :Target         , 'angry_mob/target'
+  autoload :SingletonTarget, 'angry_mob/singleton_target'
+  autoload :Action         , 'angry_mob/action'
+
+  autoload :Notifier       , 'angry_mob/notifier'
+
+  autoload :Act            , 'angry_mob/act'
+
+  autoload :Log            , 'angry_mob/log'
+  autoload :UI             , 'angry_mob/ui'
+  autoload :Util           , 'angry_mob/util'
+
+  autoload :Builder        , 'angry_mob/builder'
+  autoload :MobLoader      , 'angry_mob/mob_loader'
+
+end

data/lib/angry_mob/act.rb

@@ -0,0 +1,111 @@
+class AngryMob
+  # A `Builder::Act` groups target calls.
+  class Act
+    autoload :Scheduler, "angry_mob/act/scheduler"
+
+    attr_reader :mob, :name, :definition_file
+
+    def initialize(name,multi,&blk)
+      @name = name
+      @multi = multi
+      @blk = blk
+    end
+
+    def ui; mob.ui end
+    def log(message); mob.ui.log message end
+
+    def multi?; !!@multi end
+
+    # Binds the act to the mob and the file from which it came.
+    def bind(mob,file)
+      @mob  = mob
+      @definition_file = file
+
+      mob.act_scheduler.add_act @name, self
+    end
+
+    def self.synthesise(mob,name,&blk)
+      act = new(name,true,&blk)
+      act.bind(mob,"name")
+      act.run!
+    end
+
+    #### Compilation
+
+    # Executes the block via `instance_exec`
+    def run!(*arguments)
+      ui.push("act '#{name}'", :bubble => true) do
+        @running = true
+
+        instance_exec *arguments, &@blk
+
+        @running = false
+      end
+    end
+
+    # bundler + rubygems clusterfuck
+    def gem(*args,&blk)
+      __run_target(:gem,*args,&blk)
+    end
+
+    # TODO - de-mm
+    def method_missing(nickname,*args,&blk)
+      return super unless @running
+      __run_target(nickname,*args,&blk)
+    end
+
+    # Schedules a target, adding call-location context along the way.
+    def __run_target(nickname,*args,&blk)
+      call = mob.target_mother.target_call(nickname,*args,&blk)
+
+      call.merge_defaults(defaults.defaults_for(nickname))
+      call.call(self)
+
+      call.target
+    end
+
+    def in_sub_act(*args,&blk)
+      sub_act = self.class.new("#{name}-sub-act",true,&blk)
+      sub_act.bind(@mob,@definition_file)
+      sub_act.run!(*args)
+    end
+
+    #### Definition helpers
+
+    def defaults
+      @defaults ||= Target::Defaults.new
+    end
+
+    def notify
+      Target::Notify.new(self)
+    end
+
+    def notifications
+      mob.notifier
+    end
+    
+    # directly schedule a call on the delayed list
+    def later
+      n = Target::Notify.new(self)
+      mob.notifier.schedule_notification n
+      n
+    end
+
+    def node
+      mob.node
+    end
+
+    def act_now act_name, *args
+      mob.act_scheduler.act_now(act_name,*args)
+    end
+
+    def schedule_act act_name
+      mob.act_scheduler.schedule_act(act_name)
+    end
+
+    def schedule_acts_matching(regex,&block)
+      mob.act_scheduler.schedule_acts_matching(regex,&block)
+    end
+
+  end
+end

data/lib/angry_mob/act/scheduler.rb

@@ -0,0 +1,143 @@
+class AngryMob
+  class Act
+    class Scheduler
+      attr_writer :node
+      attr_reader :acted, :mob
+
+      def initialize(mob)
+        @mob = mob
+        reset!
+      end
+
+      def ui; @mob.ui end
+
+      def reset!
+        @act_names = nil
+        @acted = []
+      end
+
+      def act_names
+        @act_names ||= @node.acts || []
+      end
+
+      def acts
+        @acts ||= Dictionary.new
+      end
+
+      def add_act(name,act)
+        acts[name.to_s] = act
+      end
+
+      def run!
+        ui.task "running acts #{act_names.inspect}"
+        each_act {|act| act_now(act)}
+        ui.good "finished running acts"
+        finalise_acts!
+      end
+
+      def each_act
+        while act_name = next_act
+          ui.debug "acting out #{act_name}"
+
+          act = acts[act_name]
+
+          unless act
+            act_missing!(act_name)
+            next
+          end
+          
+          yield act
+        end
+        @iterating = false
+      end
+
+      def start_iterating!(with=act_names)
+        unless @iterating
+          @iterating_act_names = with.dup
+          @iterating = true
+        end
+      end
+
+      def next_act
+        start_iterating!
+        @iterating_act_names.shift
+      end
+
+      def schedule_act(*acts)
+        raise(CompilationError, "schedule_act called when not compiling") unless @iterating
+        ui.info "scheduling #{acts.inspect}"
+        @iterating_act_names += acts
+      end
+
+      def schedule_acts_matching(regex=nil,&block)
+        raise(CompilationError, "schedule_act called when not compiling") unless @iterating
+
+        act_keys = acts.keys
+
+        acts_to_schedule = if regex
+                              act_keys.grep(regex)
+                            else
+                              act_keys.select(&block)
+                            end
+
+        schedule_act(*acts_to_schedule)
+      end
+
+      def finalise_acts!
+        # notifications only act as necessary, so its safe to run them all.
+        ui.task "running notifications"
+        to_notify = acts.keys.select {|k| k[%r{^notifications_for/}]}
+
+        unless to_notify.empty?
+          ui.info "running notifiers #{to_notify.inspect}"
+
+          start_iterating!(to_notify)
+          each_act {|act| act_now(act)}
+        end
+
+
+        # finalisers should only run if the act of the same name has run first
+        ui.task "running finalisations"
+
+        to_finalise = acted.map {|name| "finalise/#{name}"} & acts.keys
+        unless to_finalise.empty?
+          ui.info "running acts finalisers #{to_finalise.inspect}"
+
+          start_iterating!(to_finalise)
+          each_act {|act| act_now(act)}
+        end
+      end
+
+      def raise_on_missing_act?
+        !( FalseClass === mob.node.raise_on_missing_act )
+      end
+
+      def act_missing!(name)
+        raise(AngryMob::MobError, "no act named '#{name}'") if raise_on_missing_act?
+      end
+
+      def act_now(act_name,*arguments)
+        if AngryMob::Act === act_name
+          act = act_name
+          act_name = act.name
+        else
+          act = acts[act_name]
+        end
+
+        unless act
+          act_missing!(act_name) 
+          return
+        end
+
+        if !act.multi? && acted.include?(act_name)
+          ui.skipped! "(not re-running act #{act_name} - already run)"
+          return
+        end
+
+        acted << act_name
+
+        act.run!(*arguments)
+      end
+    end
+  end
+end