marionette 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+pkg/*
+*.gem
+.bundle

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in marionette.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,28 @@
+PATH
+  remote: .
+  specs:
+    marionette (0.0.1)
+      daemons
+      ffi
+      ffi-rzmq
+      zmq
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    daemons (1.1.0)
+    ffi (1.0.4)
+      rake (>= 0.8.7)
+    ffi-rzmq (0.7.0)
+    rake (0.8.7)
+    zmq (2.1.0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  daemons
+  ffi
+  ffi-rzmq
+  marionette!
+  zmq

data/README.md

@@ -0,0 +1,39 @@
+Headstartapp::Marionette - ZMQ connection to puppet master
+============================================================
+
+Marionette connects a headstartapp server instance (puppet node) to its 
+master and executes puppet runs on demand. Marionette uses fast and lightweight 
+0MQ <http://zeromq.org> messaging system.
+
+For more about Headstartapp see <http://headstartapp.com>.
+
+Installation
+------------
+
+    gem install marionette
+
+Example
+-------
+
+    Ruby:
+
+    require 'marionette'
+    # By default, Marionette connects to "tcp://master.headstartapp.com:5555"
+    Headstartapp::Marionette::Connect.new.master
+    # Connect to a different master
+    Headstartapp::Marionette::Connect.new("tcp://master.example.com:5555").master
+
+
+    CLI (start as a daemon):
+
+    marionette-master start tcp://master.example.com:5555
+    marionette-puppet start tcp://master.example.com:5555
+
+
+Meta
+----
+
+Created and Maintained by Dan Lee
+
+Released under the [MIT license](http://www.opensource.org/licenses/mit-license.php).
+<http://github.com/headstartapp/marionette>

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/bin/marionette-master

@@ -0,0 +1,9 @@
+#!/usr/local/bin/ruby
+
+require 'rubygems'
+require 'daemons'
+require 'marionette'
+ 
+Daemons.run_proc('marionette-master',:dir => '/var/run', :log_output => true) do
+  HeadStartApp::Marionette::Connect.new.master
+end

data/bin/marionette-puppet

@@ -0,0 +1,13 @@
+#!/usr/local/bin/ruby
+
+require 'rubygems'
+require 'daemons'
+require 'marionette'
+
+tcp = ARGV[1] rescue nil
+options = { :uri => tcp } unless ARGV.nil?
+puts "Connecting on #{tcp}..."
+
+Daemons.run_proc('marionette-puppet',:dir => '/var/run', :log_output => true) do
+  HeadStartApp::Marionette::Connect.new(options).puppet
+end

data/lib/marionette/connect.rb

@@ -0,0 +1,58 @@
+module HeadStartApp
+  module Marionette
+
+    require 'uri'
+    require 'marionette/master'
+    require 'marionette/puppet'
+  
+  
+    # PuppetString class establishes a zmq messaging system connection with the puppet master
+    # and sends back stats and receives instructions to execute puppet runs or ad hoc system commands.
+    class Connect
+      attr_accessor :uri, :connection      
+  
+      def initialize(options = nil)
+        
+        # Set default(s)
+        options = { :uri => "tcp://127.0.0.1:5555" } if options.nil?
+        
+        # Set URI
+        @uri = URI(options[:uri])
+  
+      end
+      
+      # Connect puppet
+      # require 'zmq'
+      def puppet
+        require 'zmq'
+
+        # Set ZMQ context
+        context = ZMQ::Context.new(1)
+  
+        # Set socket to talk to master
+        socket = context.socket(ZMQ::REP)
+        socket.bind(@uri.to_s)
+        @connection = HeadStartApp::Marionette::Puppet.new(socket)
+  
+      end
+      
+      # Connect master
+      # require 'ffi-rzmq'
+      def master
+        require 'ffi-rzmq'
+
+        # Set ZMQ context
+        context = ZMQ::Context.new(1)
+  
+        # Set socket to talk to puppet
+        socket = context.socket(ZMQ::REQ)
+        socket.connect(@uri.to_s)
+        @connection = HeadStartApp::Marionette::Master.new(socket)
+  
+      end
+      
+    end
+    
+  end
+        
+end

data/lib/marionette/master.rb

@@ -0,0 +1,51 @@
+module HeadStartApp
+  module Marionette
+
+    require 'uri'
+  
+  
+    # Master class is the ZMQ socket connection on the puppet master
+    class Master
+      attr_accessor :socket, :threads
+  
+      def initialize(socket)
+  
+        # Set socket
+        @socket = socket
+  
+      end
+  
+      # Sends a msg to puppet node
+      def send(msg)
+  
+        # Send and Receive
+        @socket.send_string Marshal.dump(msg)
+
+      end
+      
+      # Stands by for the next msg from puppet
+      # Processes and returns response 
+      def receive
+        
+        # Stand by for a response
+        begin
+          
+          response = socket.recv_string
+          @response = Marshal.load(response)
+          
+        rescue
+          
+          # Catch non-marshal-able response
+          @response = response
+
+        end
+        
+        @response
+          
+      end
+      
+    end
+
+  end
+
+end

data/lib/marionette/puppet.rb

@@ -0,0 +1,111 @@
+module HeadStartApp
+  module Marionette
+
+    require 'uri'
+  
+  
+    # Puppet class is the active ZMQ connection on the puppet node
+    class Puppet
+      attr_accessor :socket, :thread
+  
+      def initialize(socket)
+
+        @socket = socket
+        start
+        
+      end
+      
+      # Starts send and response thread
+      def start
+        
+        # Kill existing and create new pull-loop thread
+        @thread.kill unless @thread.nil?
+        Thread.abort_on_exception = true
+        @thread = Thread.new do 
+          while true do
+            pull
+          end
+        end
+        
+      end
+      
+      # Pulls down messages from the master and pushes up stats
+      def pull
+        
+        # Stand by for a response msg
+        @response = @socket.recv
+        
+        begin
+          
+          # Execute a puppet run and/or ad hoc system commands
+          @response = Marshal.load(@response)
+          puppet_run if @response[:run][:puppet]
+          system_run if @response[:run][:system]
+          
+        rescue
+          
+          # Catch non-hash responses
+          puts @response
+          
+        end
+
+        # Send back system stats
+        # @socket.send Marshal.dump(stats)
+        @socket.send Marshal.dump(Time.now)
+
+      end
+      
+      # Fetches thread status
+      def status
+  
+        # Returns Thread status
+        @thread.status
+        
+      end
+      
+      # Stop the pull-loop thread
+      def disconnect
+        
+        # Exit returns the Thread
+        # - Note: @thread was never joined
+        @thread.exit
+        
+      end
+  
+      # Executes ad hoc system command msg'd from the master
+      def system_run
+  
+        system "#{@response[:system][:command]}"
+  
+      end
+      
+      # Executes a puppet run
+      def puppet_run
+  
+        if @response[:puppet].nil?
+          system "puppetd --onetime --no-daemonize"
+        else
+          system "puppetd #{@response[:puppet][:args]}"
+        end
+  
+      end
+  
+      # Gathers stats
+      # - to be set up as a fact(s) later
+      def stats
+  
+        stats = {}
+        stats[:disk] = `df -h -P` rescue nil
+        stats[:network] = `vnstat` rescue nil
+        stats[:memory] = `vmstat -a` rescue nil
+        stats[:process] = `monit status` rescue nil
+        stats[:cpu] = `mpstat -P ALL | awk 'NR>2' | cut -c14-` rescue nil
+        stats
+  
+      end
+        
+    end
+    
+  end
+
+end

data/lib/marionette/version.rb

@@ -0,0 +1,5 @@
+module HeadStartApp
+  module Marionette
+    VERSION = "0.0.1"
+  end  
+end

data/lib/marionette.rb

@@ -0,0 +1 @@
+require 'marionette/connect'

data/marionette.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "marionette/version"
+
+Gem::Specification.new do |s|
+  s.name        = "marionette"
+  s.version     = HeadStartApp::Marionette::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Dan Lee"]
+  s.email       = ["dan@headstartapp.com"]
+  s.homepage    = "http://headstartapp.com"
+  s.summary     = %q{0MQ connection between puppet and master.}
+  s.description = %q{Marionette connects a headstartapp server instance (puppet node) to its master and executes puppet runs on demand. Marionette uses fast and lightweight 0MQ <http://zeromq.org> messaging system.}
+
+  s.rubyforge_project = "marionette"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.executables << 'marionette-master'
+  s.executables << 'marionette-puppet'
+  s.add_dependency('zmq')
+  s.add_dependency('ffi')
+  s.add_dependency('ffi-rzmq')
+  s.add_dependency('daemons')
+  s.require_paths = ["lib"]
+  s.bindir        = "bin"
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification 
+name: marionette
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Dan Lee
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-08 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: zmq
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: ffi
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: ffi-rzmq
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: daemons
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id004
+description: Marionette connects a headstartapp server instance (puppet node) to its master and executes puppet runs on demand. Marionette uses fast and lightweight 0MQ <http://zeromq.org> messaging system.
+email: 
+- dan@headstartapp.com
+executables: 
+- marionette-master
+- marionette-puppet
+- marionette-master
+- marionette-puppet
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/marionette-master
+- bin/marionette-puppet
+- lib/marionette.rb
+- lib/marionette/connect.rb
+- lib/marionette/master.rb
+- lib/marionette/puppet.rb
+- lib/marionette/version.rb
+- marionette.gemspec
+has_rdoc: true
+homepage: http://headstartapp.com
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: marionette
+rubygems_version: 1.4.1
+signing_key: 
+specification_version: 3
+summary: 0MQ connection between puppet and master.
+test_files: []
+