poolparty 0.2.69 → 0.2.84

data/lib/erlang/messenger/lib/eunit/Makefile

@@ -0,0 +1,28 @@
+
+APPNAME=eunit
+
+SUB_DIRECTORIES = src
+
+include vsn.mk
+
+DOC_OPTS={def,{version,\"$(EUNIT_VSN)\"}}
+
+
+all: subdirs
+
+subdirs:
+	@for d in $(SUB_DIRECTORIES); do \
+	  	(cd $$d; $(MAKE)); \
+	done
+
+clean:
+	@for d in $(SUB_DIRECTORIES); do \
+	  	(cd $$d; $(MAKE) clean); \
+	done
+
+docs:
+	erl -noshell -eval "edoc:application($(APPNAME), \".\", [$(DOC_OPTS)])" -s init stop
+
+test: subdirs
+	@echo Testing...
+	@erl -noshell -pa ebin -s eunit test -s init stop

data/lib/erlang/messenger/lib/eunit/src/Makefile

@@ -0,0 +1,46 @@
+
+include ../vsn.mk
+
+EMULATOR=beam
+EBIN=../ebin
+INCLUDE=../include
+
+APP_TARGET=$(EBIN)/eunit.app
+APPUP_TARGET=$(EBIN)/eunit.appup
+
+ERL_COMPILE_FLAGS += -I$(INCLUDE) +warn_unused_vars +nowarn_shadow_vars +warn_unused_import
+
+SOURCES= \
+	eunit_autoexport.erl \
+	eunit_striptests.erl \
+	eunit.erl \
+	eunit_tests.erl \
+	eunit_server.erl \
+	eunit_proc.erl \
+	eunit_serial.erl \
+	eunit_test.erl \
+	eunit_lib.erl \
+	eunit_data.erl \
+	eunit_tty.erl \
+	code_monitor.erl \
+	file_monitor.erl \
+	autoload.erl
+
+OBJECTS=$(SOURCES:%.erl=$(EBIN)/%.$(EMULATOR)) $(APP_TARGET) $(APPUP_TARGET)
+
+all: $(OBJECTS)
+
+$(OBJECTS): eunit_internal.hrl \
+	$(INCLUDE)/eunit.hrl 
+
+clean:
+	rm -f $(OBJECTS)
+
+$(EBIN)/%.$(EMULATOR):%.erl
+	erlc -pa $(EBIN) -W $(ERL_COMPILE_FLAGS) -o$(EBIN) $<
+
+$(APP_TARGET): eunit.app.src ../vsn.mk
+	sed -e 's;%VSN%;$(EUNIT_VSN);' $< > $@
+
+$(APPUP_TARGET): eunit.appup.src ../vsn.mk
+	sed -e 's;%VSN%;$(EUNIT_VSN);' $< > $@

data/lib/erlang/messenger/src/pm_master.erl

@@ -105,6 +105,11 @@ handle_call({get_current_load, Types}, _From, State) ->
 	LoadForType = [utils:average_of_list(get_load_for_type(Type, State)) || Type <- Types],
 	?TRACE("LoadForType: ",[LoadForType]),
 	{reply, LoadForType, State};
+% Handle puppet needs
+handle_call({clear_cert_for, Name}, _From, State) ->
+	String = string:concat(". /etc/profile && /usr/bin/puppetcleaner ",Name),
+	os:cmd(String),
+	{reply, ok, State};
 handle_call({get_current_nodes, _Args}, _From, State) ->
 	{reply, get_live_nodes(State), State}.
 	

data/lib/erlang/messenger/src/pm_node.erl

@@ -133,7 +133,7 @@ init(Args) ->
 %% Description: Handling call messages
 %%--------------------------------------------------------------------
 handle_call({run_command, Cmd}, _From, State) ->
-	Reply = os:cmd(". /etc/profile && server-fire-cmd \""++Cmd++"\""),
+	Reply = os:cmd(Cmd),
 	{reply, Reply, State};
 handle_call({update_load, Type, Load}, _From, State) ->
 	{Type, NewState} = store_load_for_type(Type, Load, State),
@@ -197,5 +197,4 @@ code_change(_OldVsn, State, _Extra) ->
   {ok, State}.
 
 % Private
-server_location() ->
-	global:whereis_name(node()).
+server_location() -> global:whereis_name(node()).

data/lib/erlang/messenger/src/pm_spawner.erl

@@ -0,0 +1,213 @@
+% 
+%  pm_spawner.erl
+%  Spawn a process in this gen_server remotely
+%  	and hear back from it when it's got stuff to say
+%  
+%  Created by Ari Lerner on 2008-12-05.
+%  Copyright 2008 CitrusByte. All rights reserved.
+% 
+-module (pm_spawner).
+-behaviour(gen_server).
+
+-include_lib("../include/defines.hrl").
+
+%% API
+-export([start_link/0]).
+-export ([run_command/1, run_command/2, check_command/1]).
+
+%% gen_server callbacks
+-export([init/1, handle_call/3, handle_cast/2, handle_info/2, terminate/2, code_change/3]).
+
+-record(state, { 
+		processes = ?DICT:new() % Array of the output
+	}).
+-define(SERVER, ?MODULE).
+
+%%--------------------------------------------------------------------
+%% Function: start_link() -> {ok,Pid} | ignore | {error,Error}
+%% Description: Starts the server
+%%--------------------------------------------------------------------
+start_link() -> gen_server:start_link({global, ?MODULE}, ?MODULE, [], []).
+
+%%====================================================================
+%% gen_server callbacks
+%%====================================================================
+
+%%--------------------------------------------------------------------
+%% Function: init(Args) -> {ok, State} |
+%%                         {ok, State, Timeout} |
+%%                         ignore               |
+%%                         {stop, Reason}
+%% Description: Initiates the server
+%%--------------------------------------------------------------------
+init([]) ->
+	% process_flag(trap_exit, true),
+  {ok, #state{
+		processes = ?DICT:new()
+	}}.
+
+%%--------------------------------------------------------------------
+%% Function: %% handle_call(Request, From, State) -> {reply, Reply, State} |
+%%                                      {reply, Reply, State, Timeout} |
+%%                                      {noreply, State} |
+%%                                      {noreply, State, Timeout} |
+%%                                      {stop, Reason, Reply, State} |
+%%                                      {stop, Reason, State}
+%% Description: Handling call messages
+%%--------------------------------------------------------------------
+handle_call({run_command, Cmds}, _From, State) ->
+	{ok, NewState} = run_command(Cmds, State),
+	?TRACE("storing into state from call", [Cmds, NewState]),
+	{reply, ok, NewState};
+handle_call({check_command, Cmd}, _From, State) ->
+	AtomCommand = erlang:list_to_atom(Cmd),
+	?TRACE("is_key for ", [AtomCommand, ?DICT:is_key(AtomCommand, State#state.processes)]),
+	case ?DICT:is_key(AtomCommand, State#state.processes) of
+		false -> 
+			Reply = nil,
+			NewState = State;
+		true ->
+			Pid = ?DICT:fetch(AtomCommand, State#state.processes),
+			case erlang:is_pid(Pid) of
+				true ->
+					Pid ! {self(), collect},
+					receive
+						{command_response, OutFromCommand} -> 					
+							Reply = OutFromCommand,
+							NewState = State#state{processes = ?DICT:store(AtomCommand, OutFromCommand, State#state.processes)};
+						Msg ->
+							NewState = State,
+							Reply = Msg
+					after 
+						1000 -> 
+							Pid ! {self(), collect},
+							NewState = State,
+							Reply = "no output"
+					end;
+				false ->
+					NewState = State,
+					Reply = Pid
+			end
+	end,
+	{reply, Reply, NewState};
+handle_call(_Request, _From, State) ->
+	Reply = ok,
+	{reply, Reply, State}.
+%%--------------------------------------------------------------------
+%% Function: handle_cast(Msg, State) -> {noreply, State} |
+%%                                      {noreply, State, Timeout} |
+%%                                      {stop, Reason, State}
+%% Description: Handling cast messages
+%%--------------------------------------------------------------------
+handle_cast({run_command, Cmd}, State) ->
+	{ok, NewState} = run_command(Cmd, State),
+	{noreply, NewState};
+handle_cast(_Msg, State) ->
+  {noreply, State}.
+
+%%--------------------------------------------------------------------
+%% Function: handle_info(Info, State) -> {noreply, State} |
+%%                                       {noreply, State, Timeout} |
+%%                                       {stop, Reason, State}
+%% Description: Handling all non call/cast messages
+%%--------------------------------------------------------------------
+handle_info(_Info, State) ->
+  {noreply, State}.
+
+%%--------------------------------------------------------------------
+%% Function: terminate(Reason, State) -> void()
+%% Description: This function is called by a gen_server when it is about to
+%% terminate. It should be the opposite of Module:init/1 and do any necessary
+%% cleaning up. When it returns, the gen_server terminates with Reason.
+%% The return value is ignored.
+%%--------------------------------------------------------------------
+terminate(_Reason, _State) ->
+  ok.
+
+%%--------------------------------------------------------------------
+%% Func: code_change(OldVsn, State, Extra) -> {ok, NewState}
+%% Description: Convert process state when code is changed
+%%--------------------------------------------------------------------
+code_change(_OldVsn, State, _Extra) ->
+  {ok, State}.
+
+% Quick helper for running commands
+run_command(Cmd) -> gen_server:call(server_location(), {run_command, Cmd}).
+check_command(Cmd) -> 
+	Command = lists:flatten(io_lib:format("~s", [Cmd])),
+	gen_server:call(server_location(), {check_command, Command}).
+
+% Run the command, start up the 
+run_command(Cmd, State) ->
+	Command = lists:flatten(io_lib:format("~s", [Cmd])),
+	AtomCommand = erlang:list_to_atom(Command),
+	Pid = spawn(fun() -> spawn_command(Command) end),
+	Storage = Pid,
+	?TRACE("storing into state", [AtomCommand]),
+	NewState = State#state{processes = ?DICT:store(AtomCommand, Storage, State#state.processes)},
+	{ok, NewState}.
+
+spawn_command(Command) ->
+	Port = erlang:open_port({spawn, Command}, [stream, exit_status, stderr_to_stdout, use_stdio]),
+	ResponsePid = response_reader(Port),
+	spawn_command_loop(Command, Port, ResponsePid).
+	
+spawn_command_loop(Command, Port, Responses) ->
+	receive
+		{Pid, collect} ->
+			case erlang:is_pid(Responses) of
+				true ->
+					io:format("There is no output on your command yet, try again in a few seconds ~p~n", [Responses]),
+					spawn_command_loop(Command, Port, Responses);
+				false ->
+					Pid ! {command_response, Responses}
+			end;
+		{exit_status, _} -> 
+			spawn_command_loop(Command, Port, Responses);
+		{done, Port, Response} ->			
+			?TRACE("Received done message", Response),
+			spawn_command_loop(Command, Port, Response);
+	  {Port, {exit_status, 0}} ->			
+			?TRACE("Received exit_status", [Port]),
+			Responses ! {Port, {exit_status, 0, self()}},
+			receive
+				{ok, Resp} ->
+					?TRACE("Received ok back", [Resp]),
+					spawn_command_loop(Command, Port, Resp)
+			end;
+		Mes ->
+			?TRACE("received message", [Mes]),
+			Responses ! Mes,
+			spawn_command_loop(Command, Port, Responses)
+	end.
+
+response_reader(Port) -> 
+	ResponsePid = spawn(fun() -> response_reader_loop(Port, []) end),
+	ResponsePid.
+	
+response_reader_loop(Port, Acc) ->
+	receive
+		{Port, {data, Bin}} ->
+			?TRACE("received data", [Bin]),
+			response_reader_loop(Port, [Bin|Acc]);
+    {Port, {exit_status, 0, Pid}} ->			
+      catch erlang:port_close(Port),
+      Response = lists:flatten(lists:reverse(Acc)),
+			?TRACE("received exit_status", [Response, Port]),
+			Pid ! {ok, Response};
+    {Port, {exit_status, _}} ->
+      catch erlang:port_close(Port),
+      Output = lists:flatten(lists:reverse(Acc)),
+			{error, Output};
+		{Pid, get_data} ->
+			?TRACE("get_data for", [Pid, Acc]),
+			Pid ! {data, Port, Acc},			
+			response_reader_loop(Port, Acc);
+		{_, collect} ->
+			response_reader_loop(Port, Acc);
+		Mes ->
+			io:format("Unexpected message in response_reader_loop ~p~n", [Mes]),
+			response_reader_loop(Port, Acc)
+	end.
+
+server_location() -> global:whereis_name(?SERVER).

data/lib/poolparty/base_packages/heartbeat.rb

@@ -2,57 +2,71 @@ module PoolParty
   class Base
     plugin :heartbeat do
       
-      # TODO: Reimplement heartbeat
       def enable
-        # execute_if("$hostname", "master") do
-        #   has_package(:name => "heartbeat-2", :ensure => "installed") do
-        #     # These can also be passed in via hash
-        #     has_service(:name => "heartbeat", :hasstatus => true)
-        #     
-        #     has_remotefile(:name => "/etc/ha.d/ha.cf") do
-        #       mode 444
-        #       notify service(:name => "heartbeat")
-        #       template File.join(File.dirname(__FILE__), "..", "templates/ha.cf")
-        #     end
-        #     
-        #     has_exec(:name => "heartbeat-update-cib", :command => "/usr/sbin/cibadmin -R -x /etc/ha.d/cib.xml", :refreshonly => true)
-        # 
-        #     has_remotefile(:name => "/etc/ha.d/authkeys") do
-        #       mode 400
-        #       notify service(:name => "heartbeat")
-        #       template File.join(File.dirname(__FILE__), "..", "templates/authkeys")
-        #     end
-        # 
-        #     has_remotefile(:name => "/etc/ha.d/cib.xml") do
-        #       mode 444
-        #       notify exec(:name => "heartbeat-update-cib")
-        #       template File.join(File.dirname(__FILE__), "..", "templates/cib.xml")
-        #     end            
-        #   end
-        #   
-        #   if @parent.provisioning?
-        #     variable(:name => "ha_nodenames", :value => "#{list_of_running_instances.map{|a| "#{a.send :name}" }.join("\t")}")
-        #     variable(:name => "ha_node_ips",  :value => "#{list_of_running_instances.map{|a| "#{a.send :ip}" }.join("\t")}")
-        #   else
-        #     # variables for the templates
-        #     variable(:name => "ha_nodenames", :value => "generate('/usr/bin/env', '/var/lib/gems/1.8/bin/server-list-active', '-c', 'name')")
-        #     variable(:name => "ha_node_ips",  :value => "generate('/usr/bin/env', '/var/lib/gems/1.8/bin/server-list-active', '-c', 'ip')")
-        #   end
-        #   
-        #   has_variable({:name => "ha_timeout",  :value => (self.respond_to?(:timeout) ? timeout : "5s")})
-        #   has_variable({:name => "ha_port", :value => (self.respond_to?(:port) ? port : Base.port)})
-        #   
-        # end
-        # 
-        # execute_if("$hostname", "master") do
+        # execute_on_master do
+          has_package(:name => "heartbeat") do
+            has_service(:name => "heartbeat", :hasstatus => true, :hasrestart => true)
+            has_directory(:name => "/etc/ha.d")
+            
+            has_remotefile(:name => "/etc/ha.d/ha.cf") do
+              mode 444
+              notify service(:name => "heartbeat")
+              template File.join(File.dirname(__FILE__), "..", "templates/ha.cf")
+            end
+            
+            has_remotefile(:name => "/etc/ha.d/logd.cf") do
+              mode 600
+              notify service(:name => "heartbeat")
+              template File.join(File.dirname(__FILE__), "..", "templates/logd.cf")
+            end
+            
+            has_exec(:name => "heartbeat-update-cib", :command => "/usr/sbin/cibadmin -R -x /etc/ha.d/cib.xml", :refreshonly => true)
+        
+            has_remotefile(:name => "/etc/ha.d/authkeys") do
+              mode 600
+              notify service(:name => "heartbeat")
+              template File.join(File.dirname(__FILE__), "..", "templates/authkeys")
+            end
+        
+            has_remotefile(:name => "/etc/ha.d/cib.xml") do
+              mode 444
+              notify exec(:name => "heartbeat-update-cib")
+              template File.join(File.dirname(__FILE__), "..", "templates/cib.xml")
+            end
+            
+            has_remotefile(:name => "/etc/ha.d/haresources") do
+              mode 644
+              template File.join(File.dirname(__FILE__), "..", "templates/haresources")
+            end
+          # end
+          
+          # variables for the templates
+          has_variable(:name => "ha_nodenames", :value => "generate('/usr/bin/env', '/usr/bin/server-list-active', '-c', 'name', '-n', '#{cloud.name}')")
+          has_variable(:name => "ha_node_ips",  :value => "generate('/usr/bin/env', '/usr/bin/server-list-active', '-c', 'ip', '-n', '#{cloud.name}')")
+          
+          has_variable({:name => "ha_timeout",  :value => (self.respond_to?(:timeout) ? timeout : "5s")})
+          has_variable({:name => "ha_port", :value => (self.respond_to?(:port) ? port : Base.port)})
+          
+          # Finally, let's set a few options and start it
+#           has_exec(:name => "set and start") do
+#             refreshonly true
+#             command <<-EOC
+# crm_mon -i5            
+#             EOC
+#           end
+          
+        end
+        
+        # execute_on_master do
         #   if list_of_node_names.size > 1
         #     has_exec(:name => "update pem for heartbeat", :refreshonly => true) do
-        #       command "scp /etc/puppet/ssl/ca/ca_crl.pem #{user || Base.user}@#{list_of_node_ips[1]}:/etc/puppet/ssl/ca"
+        #       command "scp /etc/puppet/ssl/ca/ca_crl.pem #{user || Base.user}@#{list_of_node_ips[1]}:#{Base.base_config_directory}/ssl/ca"
         #     end
         #   end
         # end
         
       end
+
     end  
   end
 end

data/lib/poolparty/base_packages/poolparty.rb

@@ -49,12 +49,12 @@ module PoolParty
           template File.join(File.dirname(__FILE__), "..", "templates/puppetrunner")
         end
         
-        execute_on_node do
-          has_cron(:name => "node puppetd runner", :user => Base.user, :minute => "*/5") do
+        # execute_on_node do
+          has_cron(:name => "node puppetd runner", :user => Base.user, :minute => "*/15") do
             requires get_gempackage("poolparty")
             command "/usr/bin/puppetrunner"
           end
-        end
+        # end
         
         # end
         
@@ -68,13 +68,23 @@ module PoolParty
         
         # Custom run puppet to minimize footprint
         # TODO: Update the offsetted times
+        has_remotefile(:name => "/usr/bin/puppetrerun") do
+          mode 744
+          template File.join(File.dirname(__FILE__), "..", "templates/puppetrerun")
+        end
+        
+        has_remotefile(:name => "/usr/bin/puppetcleaner") do
+          mode 744
+          template File.join(File.dirname(__FILE__), "..", "templates/puppetcleaner")
+        end
+        
         execute_on_master do
           has_exec(:name => "update_hosts", :command => ". /etc/profile && server-update-hosts -n #{cloud.name}")
           
-          has_cron(:name => "master puppetd runner", :user => Base.user, :minute => "*/15") do
-            requires get_gempackage("poolparty")
-            command(PoolParty::Remote::RemoteInstance.puppet_runner_command)
-          end
+          # has_cron(:name => "master puppetd runner", :user => Base.user, :minute => "*/15") do
+          #   requires get_gempackage("poolparty")
+          #   command(PoolParty::Remote::RemoteInstance.puppet_runner_command)
+          # end
           has_cron(:name => "Load handler", :user => Base.user, :minute => "*/4") do
             requires get_gempackage("poolparty")
             command(". /etc/profile && cloud-handle-load -n #{cloud.name}")
@@ -93,15 +103,8 @@ module PoolParty
           
           has_cron({:name => "maintain script", :command => ". /etc/profile && cloud-maintain -n #{cloud.name}", :minute => "*/3", :requires => [get_gempackage("poolparty"), get_cron("puppetd runner"), get_cron("Load handler"), get_service("haproxy")]})
           
-          has_remotefile(:name => "/usr/bin/puppetcleaner") do
-            mode 744
-            template File.join(File.dirname(__FILE__), "..", "templates/puppetcleaner")
-          end
+          has_cron(:name => "ensure puppetmaster is running", :command => ". /etc/profile && puppetmasterd --verbose", :hour => "0")
           
-          has_remotefile(:name => "/usr/bin/puppetrerun") do
-            mode 744
-            template File.join(File.dirname(__FILE__), "..", "templates/puppetrerun")
-          end
         end        
         # has_host(:name => "puppet", :ip => (self.respond_to?(:master) ? self : parent).master.ip)
       end

data/lib/poolparty/capistrano.rb

@@ -0,0 +1,18 @@
+module PoolParty
+  module Capistrano
+    
+    def set_cloud(cld=nil)
+      raise unless cld
+      @cloud = cld
+    end
+    
+    def set_poolparty_roles
+      returning Array.new do |arr|
+        arr << "role 'master.#{@cloud.name}'.to_sym, '#{@cloud.master.ip}'"
+        arr << "role :master, '#{@cloud.master.ip}'"
+        arr << "role :slaves, '#{@cloud.nonmaster_nonterminated_instances.map{|a| a.ip}.join('", "')}'" if @cloud.nonmaster_nonterminated_instances.size > 0
+      end.join("\n")
+    end
+    
+  end
+end

data/lib/poolparty/core/class.rb

@@ -1,2 +1,26 @@
+# Taken from rspec with high respect. 
+# Mainly unused, for now
 class Class
+  # Creates a new subclass of self, with a name "under" our own name.
+  # Example:
+  #
+  #   x = Foo::Bar.subclass('Zap'){}
+  #   x.name # => Foo::Bar::Zap_1
+  #   x.superclass.name # => Foo::Bar
+  def subclass(base_name, &body)
+    klass = Class.new(self)
+    class_name = "#{base_name}_#{class_count!}"
+    instance_eval do
+      const_set(class_name, klass)
+    end
+    klass.instance_eval(&body)
+    klass
+  end
+
+  private
+  def class_count!
+    @class_count ||= 0
+    @class_count += 1
+    @class_count
+  end
 end

data/lib/poolparty/core/kernel.rb

@@ -24,14 +24,21 @@ module Kernel
   ensure
     $-v = saved_verbosity
   end
+
+  #redirect stdout and stderr to /dev/null and reopen after block
   def hide_output
     begin
       old_stdout = STDOUT.dup
+      old_stderr = STDERR.dup
       STDOUT.reopen(File.open((PLATFORM =~ /mswin/ ? "NUL" : "/dev/null"), 'w'))
+      STDERR.reopen(File.open((PLATFORM =~ /mswin/ ? "NUL" : "/dev/null"), 'w'))
       yield if block_given?
     ensure
       STDOUT.flush
       STDOUT.reopen(old_stdout)
+      STDERR.flush
+      STDERR.reopen(old_stderr)
     end
   end
+
 end

data/lib/poolparty/core/module.rb

@@ -34,7 +34,7 @@ class Module
     end
     nil
   end
-  def set(*args)
+  def instance_variables_from_hash(h={})
+    h.each {|k,v| instance_eval "@#{k} = #{v}"}
   end
-  alias_method :custom, :set
 end