costan-zerg_support 0.0.9

data/lib/zerg_support/spawn.rb

@@ -0,0 +1,185 @@
+#:nodoc:
+module Zerg::Support::Process
+  # perhaps this should be merged in process
+end
+
+if RUBY_PLATFORM =~ /win/ and RUBY_PLATFORM !~ /darwin/
+  require 'win32/process'
+
+  #:nodoc: all
+  module Zerg::Support::Process
+    def self.spawn(binary, args = [], options = {})
+      # command line processing
+      command_line = '"' + binary + '" "' +
+          args.map { |a| a.gsub '"', '""' }.join('" "') + '"'
+      
+      # environment processing
+      environment_string = nil
+      if options[:env]
+        if options[:unsetenv_others]
+          environment = options[:env]
+        else
+          environment = Hash.new.merge(ENV).merge(options[:env])
+        end
+        environment_string = environment.keys.sort.
+            map { |k| "#{k}=#{environment[k]}" }.join "\0"
+        environment_string << "\0"
+      end
+      
+      # redirection processing
+      startup_info = {}
+      files = {}
+      stream_files = {}
+      deferred_opens = []
+      [[STDIN, :stdin], [STDOUT, :stdout], [STDERR, :stderr]].each do |pair|
+        next unless options[pair.first]
+        if options[pair.first].kind_of? String
+          filename = options[pair.first]
+          files[filename] ||= File.open(filename,
+                                        (pair.last == :stdin) ? 'r' : 'w+')
+          startup_info[pair.last] = files[filename]
+          stream_files[pair.first] = files[filename]
+        else
+          deferred_opens << Kernel.proc do
+            io = stream_files[options[pair.first]] || pair.first
+            startup_info[pair.last] = stream_files[pair.first] = io
+          end
+        end
+      end
+      deferred_opens.each { |d| d.call }
+      
+      # process leader
+      creation_flags = 0
+      if options[:pgroup]
+        creation_flags |= Process::DETACHED_PROCESS
+        if options[:pgroup].kind_of? Numeric and options[:pgroup] > 0
+          # TODO: what now?
+        else
+          creation_flags |= Process::CREATE_NEW_PROCESS_GROUP
+        end
+      end
+      
+      info = Process.create :command_line => command_line,
+                            :cwd => options[:chdir] || Dir.pwd,
+                            :environment => environment_string,
+                            :creation_flags => creation_flags,
+                            :startup_info => startup_info                            
+      files.each { |name, io| io.close }
+      
+      return info[:process_id]
+    end
+  end
+  
+else
+
+  #:nodoc:
+  module Zerg::Support::Process
+    # Spawns a new process and returns its pid immediately.
+    # Like Kernel.spawn in ruby1.9, except that the environment is passed
+    # as an option with the key :env
+    def self.spawn(binary, args = [], options = {})
+      if Kernel.respond_to? :spawn
+        # ruby1.9+: spawn!
+        options = options.dup
+        env = options.delete(:env)
+        Kernel.spawn *([env, binary] + args + [options])
+      else
+        # below 1.9: emulate
+        
+        # chdir option
+        Dir.chdir options[:chdir] if options[:chdir]
+        
+        child_pid = fork do
+          Helpers.do_redirects options
+          Helpers.close_fds options          
+          Helpers.set_process_group options          
+          Helpers.set_environment options
+          Helpers.set_rlimits options
+          
+          Kernel.exec *([binary] + args)
+        end
+      end
+      
+      return child_pid
+    end
+  end  
+end
+
+# Helpers for spawning processes.
+module Zerg::Support::Process::Helpers
+  # Closes all open file descriptors except for stdin/stdout/stderr
+  def self.close_fds(options)
+    return if options[:close_others] == false
+    
+    ObjectSpace.each_object(IO) do |io|
+      next if [STDIN, STDOUT, STDERR].include? io
+      
+      begin
+        io.close unless io.closed?
+      rescue Exception
+      end
+    end
+  end
+  
+  # Sets process limits (rlimits) according to the given options. The options
+  # follow the convention of Kernel.spawn in ruby1.9
+  def self.set_rlimits(options)
+    # rlimit options
+    options.each do |k, v|
+      next unless k.kind_of? Symbol and k.to_s[0, 7] == 'rlimit_'
+      rconst = Process.const_get k.to_s.upcase.to_sym
+      if v.kind_of? Enumerable
+        Process.setrlimit rconst, v.first, v.last
+      else
+        Process.setrlimit rconst, v
+      end              
+    end    
+  end
+  
+  # Sets the process' group according to the given options. The options
+  # follow the convention of Kernel.spawn in ruby1.9
+  def self.set_process_group(options)
+    return unless options[:pgroup]
+    
+    if options[:pgroup].kind_of? Numeric and options[:pgroup] > 0
+      Process.setpgid 0, options[:pgroup]
+    else
+      Process.setsid
+    end
+  end
+  
+  # Sets the process' environment according to the given options. The options
+  # follow the convention of Kernel.spawn in ruby1.9
+  def self.set_environment(options)
+    return unless options[:env]
+    
+    ENV.clear if options[:unsetenv_others]
+    options[:env].each do |key, value|
+      ENV[key] = value
+    end
+  end
+  
+  # Performs IO redirections according to the given options. The options
+  # follow the convention of Kernel.spawn in ruby1.9
+  def self.do_redirects(options)
+    redirected_files = {}
+    file_redirects = []
+    fd_redirects = []
+    options.each do |key, value|
+      next unless key.kind_of? IO
+      if value.kind_of? String
+        if redirected_files[value]
+          fd_redirects << [key, redirected_files[value]]
+        else
+          file_redirects << [key, value]
+          redirected_files[value] = key
+        end
+      else
+        fd_redirects << [key, value]
+      end
+    end
+    (file_redirects + fd_redirects).each do |r|
+      r.first.reopen r.last
+    end
+  end
+end

data/lib/zerg_support.rb

@@ -0,0 +1,21 @@
+# :nodoc
+module Zerg
+end
+
+# TODO(victor): document this
+module Zerg::Support
+end
+
+require 'rubygems'
+require 'zerg_support/gems.rb'
+require 'zerg_support/process.rb'
+require 'zerg_support/open_ssh.rb'
+require 'zerg_support/spawn.rb'
+
+# TODO(victor): document this
+module Zerg::Support::EventMachine  
+end
+
+require 'zerg_support/event_machine/connection_mocks.rb'
+require 'zerg_support/event_machine/frame_protocol.rb'
+require 'zerg_support/event_machine/object_protocol.rb'

data/test/fork_tree.rb

@@ -0,0 +1,34 @@
+# Used in test_process.rb to produce a tree of children.
+# Usage:
+#   ruby test/fork_tree.rb level interval cookie
+# Arguments:
+#   level - the fork level; 0 means don't fork, otherwise fork two children
+#           with fork level-1
+#   interval - the time to sleep (in seconds)
+#   cookie - an argument that's preserved to help track down the process
+#            also, the PID will be written to cookie.pid unless the file already
+#            exists (this means that only the fork tree's root writes it)
+
+require 'English'
+
+# extract arguments
+level = ARGV[1].to_i
+interval = ARGV[2].to_f
+cookie = ARGV[3]
+
+# write PID file
+pid_file = cookie + ".pid"
+unless File.exist? pid_file
+  File.open(pid_file, "w") { |f| f.write $PID.to_s }
+end
+
+# spawn children
+unless level == 0
+  2.times do
+    Thread.new do
+      system "ruby test/fork_tree.rb -- #{level - 1} #{interval} #{cookie}"
+    end
+  end 
+end
+
+sleep interval

data/test/test_connection_mocks.rb

@@ -0,0 +1,57 @@
+require 'test/unit'
+
+require 'zerg_support'
+
+require 'rubygems'
+require 'flexmock/test_unit'
+
+class HollowReceiveMock < Zerg::Support::EventMachine::ReceiveMock
+end
+
+# Collects groups of 3 letters, stores them into idenity hashes.
+class ReceiveFooMock < Zerg::Support::EventMachine::ReceiveMock
+  object_name :foo
+  
+  def receive_data(data)
+    @s ||= ''
+    data.each_byte do |c|
+      @s << c
+      if @s.length == 3
+        receive_foo @s => @s
+        @s = ''
+      end
+    end
+  end
+end
+
+class ConnectionMocksTest < Test::Unit::TestCase
+  def test_send_mock
+    send_mock = Zerg::Support::EventMachine::SendMock.new    
+    assert_equal send_mock.string, ''
+    
+    send_mock.send_data('a')
+    assert_equal send_mock.string, 'a'
+
+    send_mock.send_data('bcd')
+    assert_equal send_mock.string, 'abcd'
+
+    send_mock.send_data('em')
+    assert_equal send_mock.string, 'abcdem'
+  end
+  
+  def test_receive_mock_calls_recieve_data
+    recv_mock = HollowReceiveMock.new ['a', 'bcd', 'em']
+    flexmock(recv_mock).should_receive(:receive_data).with('a').once
+    flexmock(recv_mock).should_receive(:receive_data).with('bcd').once
+    flexmock(recv_mock).should_receive(:receive_data).with('em').once
+    recv_mock.replay
+  end
+  
+  def test_receive_mock_collects_objects
+    foos = ReceiveFooMock.new(['a', 'bcd', 'emx']).replay.foos
+    assert_equal [{'abc' => 'abc'}, {'dem' => 'dem'}], foos
+
+    foos = ReceiveFooMock.new('ab').replay.foos
+    assert_equal [], foos
+  end
+end

data/test/test_frame_protocol.rb

@@ -0,0 +1,119 @@
+require 'zerg_support'
+
+require 'test/unit'
+
+class TestFrameProtocol < Test::Unit::TestCase
+  FP = Zerg::Support::EventMachine::FrameProtocol
+
+  # Send mock for frames.
+  class SendFramesMock < Zerg::Support::EventMachine::SendMock
+    include FP
+  end
+
+  # Receive mock for frames.
+  class ReceiveFramesMock < Zerg::Support::EventMachine::ReceiveMock
+    include FP
+    object_name :frame
+  end
+
+  def setup
+    super
+    @send_mock = SendFramesMock.new
+  end
+  
+  def teardown
+    super
+  end
+
+  def continuous_data_test(frames)
+    truncated_data_test frames, []
+  end
+  
+  def truncated_data_test(frames, sub_lengths)
+    frames.each { |frame| @send_mock.send_frame frame }
+    in_string = @send_mock.string
+    in_strings, i = [], 0
+    sub_lengths.each do |sublen|
+      in_strings << in_string[i, sublen]
+      i += sublen
+    end
+    in_strings << in_string[i..-1] if i < in_string.length
+    out_frames = ReceiveFramesMock.new(@send_mock.string).replay.frames
+    assert_equal frames, out_frames
+  end
+
+  def test_empty_frame
+    continuous_data_test ['']    
+  end
+  
+  def test_byte_frame
+    continuous_data_test ['F']
+  end
+
+  def test_string_frame
+    continuous_data_test [(32...128).to_a.pack('C*')]
+  end
+  
+  def test_multiple_frames
+    continuous_data_test [(32...128).to_a.pack('C*'), '', 'F', '', '1234567890']
+  end
+  
+  def test_truncated_border
+    truncated_data_test ['A', 'A'], [1, 0, 2, 0]
+  end
+  
+  def test_truncated_border_and_joined_data_size
+    truncated_data_test ['A', 'A'], [1, 1, 1, 1]
+  end
+  
+  def test_truncated_size
+    long_frame = (32...128).to_a.pack('C*') * 5
+    truncated_data_test [long_frame], [1]
+  end
+
+  def test_truncated_size_and_data
+    long_frame = (32...128).to_a.pack('C*') * 5
+    truncated_data_test [long_frame], [1, 16]
+  end
+  
+  def test_badass
+    # TODO(not_me): this test takes 4 seconds; replace with more targeted tests
+    
+    # build the badass string
+    s2_frame = 'qwertyuiopasdfgh' * 8 * 128 # 16384 characters, size is 3 bytes
+    @send_mock.send_frame s2_frame
+    s2_string = @send_mock.string
+    s2_count = 3
+    send_string = s2_string * s2_count
+    ex_frames = [s2_frame] * s2_count
+    
+    # build cut points in a string
+    s2_points = [0, 1, 2, 3, 4, 5, 127, 128, 8190, 16381, 16382, 16383]
+    cut_points = []
+    0.upto(s2_count - 1) do |i|
+      cut_points += s2_points.map { |p| p + i * s2_string.length }
+    end
+    
+    # try all combinations of cutting up the string in 4 pieces
+    0.upto(cut_points.length - 1) do |i|
+      (i + 1).upto(cut_points.length - 1) do |j|
+        (j + 1).upto(cut_points.length - 1) do |k|
+          packets = [0...cut_points[i], cut_points[i]...cut_points[j],
+                     cut_points[j]...cut_points[k], cut_points[k]..-1].
+                    map { |r| send_string[r] }
+          assert_equal ex_frames, ReceiveFramesMock.new(packets).replay.frames
+        end
+      end
+    end
+  end  
+  
+  def test_natural_encoding
+    table = [[0, "\0"], [1, "\x01"], [127, "\x7f"], [128, "\x80\x01"],
+             [65535, "\xff\xff\x03"], [0xf0f0f0, "\xf0\xe1\xc3\x07"],
+             [0xaa55aa55aa55, "\xd5\xd4\xd6\xd2\xda\xca\x2a"]]
+    table.each do |entry|
+      assert_equal entry.last, FP.encode_natural(entry.first) 
+      assert_equal entry.first, FP.decode_natural(entry.last) 
+    end
+  end
+end

data/test/test_gems.rb

@@ -0,0 +1,29 @@
+require 'digest/sha1'
+require 'test/unit'
+
+require 'zerg_support'
+
+class TestGems < Test::Unit::TestCase
+  def hash_gems_file
+    file_path = File.join(File.dirname(__FILE__),
+                          '../lib/zerg_support/gems.rb')
+    Digest::SHA1.hexdigest File.read(file_path)
+  end
+  
+  def test_source_is_manually_tested
+    golden_hash = '21ba9ca1e8fa3aa205b468a884746eb37697df9b'
+    source_hash = hash_gems_file
+    
+    assert_equal golden_hash, source_hash, <<END_MESSAGE
+lib/zerg_support/zerg_support.rb has changed
+
+You need to manually test the file, then replace golden_hash in this test.
+Manual testing plan:
+1. rake install this gem (zerg_support)
+2. install zerg
+3. validate that the installation does not crash and the binary gets symlinked
+in the correct place
+4. replace golden_hash with #{source_hash}
+END_MESSAGE
+  end
+end

data/test/test_object_protocol.rb

@@ -0,0 +1,55 @@
+require 'test/unit'
+
+require 'zerg_support'
+
+class ObjectProtocolTest < Test::Unit::TestCase
+  OP = Zerg::Support::EventMachine::ObjectProtocol
+  
+  class SendObjectMock < Zerg::Support::EventMachine::SendMock
+    include OP
+  end
+  class ReceiveObjectMock < Zerg::Support::EventMachine::ReceiveMock
+    include OP
+    object_name :object
+  end
+  
+  def one_test(*objects)
+    send_mock = SendObjectMock.new
+    objects.each { |o| send_mock.send_object o }
+    assert_equal objects, ReceiveObjectMock.new(send_mock.string).replay.objects
+  end
+  
+  def test_border_cases
+    one_test({})
+    one_test(nil)
+    one_test('')
+    one_test(false)
+    one_test(0)
+    one_test([])
+  end
+  
+  def test_literals
+    one_test(1)
+    one_test(true)
+    one_test('A')
+    one_test("A\nB\nC\tD")
+  end
+  
+  def test_arrays
+    one_test(['A'])
+    one_test(['B', 'C'])
+    one_test([0, 'C', [9, 'e'], true])
+  end
+  
+  def test_hashes
+    one_test({:command => 'run', :binary => '/bin/sh', :quick => false})
+    one_test({:command => 'run', :args => { :key => 'v3', :log => true}})
+  end
+  
+  def test_multiple_nested
+    one_test({:command => 'init', :user => "m\0e", :key => false },
+             {:command => 'package', :map => {'dir' => 1, 'NA' => true} },
+             "1234567890",
+             {:command => 'run', :sequence => [1, nil, 2, true, "Q\n"]})
+  end
+end

data/test/test_open_ssh.rb

@@ -0,0 +1,125 @@
+require 'zerg_support'
+
+require 'test/unit'
+
+module OpenSSHData; end
+
+class OpenSshTest < Test::Unit::TestCase
+  include OpenSSHData
+  OpenSSH = Zerg::Support::OpenSSH
+
+  def setup
+    @rsa_key = OpenSSH.load_key StringIO.new(obsidian_rsa_privkey)
+    @dsa_key = OpenSSH.load_key StringIO.new(obsidian_dsa_privkey)
+  end
+  
+  @@mpi_test_table = [[0, "\0"], [0x80, "\0\x80"], [0x1234, "\x12\x34"],
+                      [0xAA55, "\0\xAA\x55"]]
+  def test_encode_mpi
+    @@mpi_test_table.each {|e| assert_equal e.last, OpenSSH.encode_mpi(e.first) }
+  end
+  
+  def test_decode_mpi
+    @@mpi_test_table.each {|e| assert_equal e.first, OpenSSH.decode_mpi(e.last) }
+  end
+
+  @@pubkey_pack_table =  [[[], ''], [[''], "\0\0\0\0"],
+                          [['A'], "\0\0\0\1A"],
+                          [['A', 'BC'], "\0\0\0\1A\0\0\0\2BC"]]
+  
+  def test_pack_pubkey_components
+    @@pubkey_pack_table.each do |e|
+      assert_equal e.last, OpenSSH.pack_pubkey_components(e.first)
+    end    
+  end
+  
+  def test_unpack_pubkey_components
+    @@pubkey_pack_table.each do |e|
+      assert_equal e.first, OpenSSH.unpack_pubkey_components(e.last)
+    end
+  end
+  
+  def test_load_key
+    assert_equal obsidian_rsa_privkey, @rsa_key.to_pem
+    assert_equal obsidian_dsa_privkey, @dsa_key.to_pem
+  end
+  
+  def test_encode_pubkey
+    assert_equal obsidian_rsa_pubkey, OpenSSH.encode_pubkey(@rsa_key)
+    assert_equal obsidian_dsa_pubkey, OpenSSH.encode_pubkey(@dsa_key)
+  end
+  
+  def test_decode_pubkey
+    assert_equal @rsa_key.public_key.to_pem,
+                 OpenSSH.decode_pubkey(obsidian_rsa_pubkey).to_pem
+    assert_equal @dsa_key.public_key.to_pem,
+                 OpenSSH.decode_pubkey(obsidian_dsa_pubkey).to_pem
+  end
+end
+
+module OpenSSHData
+  def known_hosts_file
+    <<END_KH
+github.com,65.74.177.129 ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAq2A7hRGmdnm9tUDbO9IDSwBK6TbQa+PXYPCPy6rbTrTtw7PHkccKrpp0yVhp5HdEIcKr6pLlVDBfOLX9QUsyCOV0wzfjIJNlGEYsdlLJizHhbn2mUjvSAHQqZETYP81eFzLQNnPHt4EVVUh7VfDESU84KezmD5QlWpXLmvU31/yMf+Se8xhHTvKSCZIFImWwoG6mbUoWf9nzpIoaSjB+weqqUUmpaaasXVal72J+UX2B+2RPW3RcT0eOzQgqlJL3RKrTJvdsjE3JEAvGq3lGHSZXy28G3skua2SmVi/w4yCE6gbODqnTWlg7+wC604ydGXA8VJiS5ap43JXiUFFAaQ==
+obsidian.local ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAq7VciLo2wB+/2ThHXejC/kgkN205zlyS5cvN40Mqi3qvRVS75X1RawDoLot8eJ9KCYqZFr2Dr73d/EQNltN7dKJoPIj1IKxoraWkyNFbhhzpYuOltg9oO5UBSTNLupqla7zcdj4IwCCkBYk4+TS0dwmi20buOJ0FPY5PgbzmMnUiV9ipBqeJSdZB+TePH1gqlt7AP/6ti/0gxb2K7F69dZl/BSxMEzRCfBlTFC3f/4n8IdCuSJvNxxY+TtRnLL5CKUhj9QaIBan6JCkdRvVOBY7wmsNT8nGDzfDFSDD3KKn93g4LRkyMeaYlSDLxKy8PnNhjWgBNH1YNYyicsGfBKQ==
+rubyforge.org,205.234.109.19 ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEA3tPhdPUFGAYyrT1quRSOevLbAdKAJ6Ovwqw0m99R0QkqUwMUh09pgedWZeij7HtAHtoWPrNFev8FrwcwnL14NgA/gwNnXxbqd4twC1HyFShUf7POry8bz3Qk+84STHeMY8++hhn8LgNyfuVQswHoW661aqieLM6pF8q8xIUtkXA7daNpJAL4nTN1TxgUoCDpCa0EbUPkGpwFPNtGPuokRXNOCR9g8T6LmPQbzGUTc4CzFfQ9rrHaimqkEmRWJbBOaik1bdQNqOh6MUDDuUSpkJV7fwu3bl4fF5/1kw2HCREEjJmESOYnZhOS+MCp1qAUcuXqpMqXD8ATNsuXqrIhTQ==
+END_KH
+  end
+
+  def obsidian_rsa_pubkey
+    'AAAAB3NzaC1yc2EAAAABIwAAAQEAq7VciLo2wB+/2ThHXejC/kgkN205zlyS5cvN40Mqi3qvRVS75X1RawDoLot8eJ9KCYqZFr2Dr73d/EQNltN7dKJoPIj1IKxoraWkyNFbhhzpYuOltg9oO5UBSTNLupqla7zcdj4IwCCkBYk4+TS0dwmi20buOJ0FPY5PgbzmMnUiV9ipBqeJSdZB+TePH1gqlt7AP/6ti/0gxb2K7F69dZl/BSxMEzRCfBlTFC3f/4n8IdCuSJvNxxY+TtRnLL5CKUhj9QaIBan6JCkdRvVOBY7wmsNT8nGDzfDFSDD3KKn93g4LRkyMeaYlSDLxKy8PnNhjWgBNH1YNYyicsGfBKQ=='
+  end
+  
+  def obsidian_dsa_pubkey
+    'AAAAB3NzaC1kc3MAAACBAPdWp4HhWUoNawosyEBvrhPSbjhCJiKnVWiUS6bo0BCGzTHhugrkv2HgtlKhWo8nqTw5E4YxzFVyZ0YQt4m7NYDLTZVjrqbIpL/3F5qNXco127O/im0cG27AKC8Jf7knmUTjd8EBhtK65tNDmxPtzKQtemlNTVPX1VccOn6eLtn1AAAAFQDtQC21TJrf/p5WNsU9UIJzO9/hIwAAAIEAgwTrIfleQMEAK9N3xeMVZpAGfSAoX6owLtk3z+iQ3rM9FRvM/CgezOgezLowJghkw/bcQDmMuudBUuijrM3zZWdr6eqoNbFTR/KKiUx3cYf0LAHNPbXfVz+P7BXqjcEj75qnwuHQMp7vNMg+dmV40UA2TiC5/8QlaZVwkOSPN6gAAACAPMGJEFkoR0ayfkd0S/tnY9ilO17T6rdoDuF25ATtNUd6Zji6tslxBkQFWtTeinO3rGkqJRPndq0wp3E33AOHhJE/FOIlWl4Tf6aeU95Y4enYujKQDiImSTXmdiw5wq/LFdc3a2waOUvuI+647wxgHhqTmD7xI2biGZLYN9Oasy0='    
+  end
+
+  def obsidian_rsa_privkey
+    <<END_RSAK
+-----BEGIN RSA PRIVATE KEY-----
+MIIEoQIBAAKCAQEAq7VciLo2wB+/2ThHXejC/kgkN205zlyS5cvN40Mqi3qvRVS7
+5X1RawDoLot8eJ9KCYqZFr2Dr73d/EQNltN7dKJoPIj1IKxoraWkyNFbhhzpYuOl
+tg9oO5UBSTNLupqla7zcdj4IwCCkBYk4+TS0dwmi20buOJ0FPY5PgbzmMnUiV9ip
+BqeJSdZB+TePH1gqlt7AP/6ti/0gxb2K7F69dZl/BSxMEzRCfBlTFC3f/4n8IdCu
+SJvNxxY+TtRnLL5CKUhj9QaIBan6JCkdRvVOBY7wmsNT8nGDzfDFSDD3KKn93g4L
+RkyMeaYlSDLxKy8PnNhjWgBNH1YNYyicsGfBKQIBIwKCAQA/xwUc13Nr7okWKtit
+2hyKVU9HyXve7y8/aPSzf1jx+l5blIBN7LfXSXrPdaNCvtJbULyEygxXN+S8yNHY
+73b/b4XNV3D9gd281x/y0WsjL09fPpyitUP435LDatL8Ks+6TXZ1D7obedaFtqAi
+DEMHpH5Rch33xUsW3RY3gK1F8GHzYh+zMd0llH8w6IVBv0hrWttyp+4By1dhXA3L
+alYYOlGbu5cNuJfz50v4T/uB9F63JqHtAxEjqD7SvjCUbogGPxEH1k4Or+3xGuvR
+yTPaiuR9kehBstjbqc91rTLnGOr5a1VUIq6++0tCVOXQa+x5J5zCu/baGTdfkgRU
+loILAoGBAOHQcGIEgD1xHwFX9AafarF+1j4pPkM1p2u+9DNTIl1f2Rk6yOHlHZGF
+mfozMyh6l4HpvPTT7nflM4YR0JWJNbQIpCY8CdYKMXBVWcH4PXuqwyGKJBZMXWkn
+hKvelJ0UZUwx5+n8fTmSxLcIIlz5uKEE5k23/3cKkP7P6+Z6YuIZAoGBAMKpYBkM
+A4JMJ3QJ5TVsdFOoO0b1wThRgQTZR6ic9rNeXnZiL0mmr44DX2T1rTnEm6KZv2f2
+kWLQp5jx8BPFI+TUv16j4xrnnuHPhuBordCYQizSPcxXqL8b8a/KU+S5xofRjwB6
++8szd/JmGFDY8WgWrtIL32TdRhcIFg0Dg1mRAoGAE1sCUYtbcvsRSUINmirr41QD
+vC9rvJ4y6/pss/Eu1M2zhdHWtEbWphLEDiGlTJzLKGR96Rl61xOlVKJw9t/gCB3/
+cP3U9RbRCaDqb7YxJ9tvz6zBQ71nF6RNM02XtbFKgt+0yunBlzh3QuNwqOI0ZZK0
+p5Ntqx4pr3DoVZV2MKMCgYBprGdeDdYE54MhvDqZWCHkRWIB8x+/fLPAzbkvpap+
+oPFzdyD8GKhxqg82zoKbs991hqm8GCMJwboRMuFp0WtBtVHxjCrUF1ZAEZJckJje
+85GjTY9DCwPVdZHUdSY6VjiS33mD6v23c7YkgJDbbnRrtIrJy+5MsqJkRjfbLcr2
+GwKBgQCWDKVM8mZJcmM3KJwzBWh+b5T7tIbOBFaCvOBq4G0UUZGytWVUaddSbdh5
+YJ+1CoLDB+Wp3U95B1USQuSYwwr0wOYy42HBII7HnkaphT9HgDIhgvttFhX162oC
+bRizr31NgiGtgJbHJ9QPhaLvn3mZtZAFfRaEEdZslUzqRSACww==
+-----END RSA PRIVATE KEY-----
+END_RSAK
+  end
+
+  def obsidian_dsa_privkey
+    <<END_DSAK
+-----BEGIN DSA PRIVATE KEY-----
+MIIBvAIBAAKBgQD3VqeB4VlKDWsKLMhAb64T0m44QiYip1VolEum6NAQhs0x4boK
+5L9h4LZSoVqPJ6k8OROGMcxVcmdGELeJuzWAy02VY66myKS/9xeajV3KNduzv4pt
+HBtuwCgvCX+5J5lE43fBAYbSuubTQ5sT7cykLXppTU1T19VXHDp+ni7Z9QIVAO1A
+LbVMmt/+nlY2xT1QgnM73+EjAoGBAIME6yH5XkDBACvTd8XjFWaQBn0gKF+qMC7Z
+N8/okN6zPRUbzPwoHszoHsy6MCYIZMP23EA5jLrnQVLoo6zN82Vna+nqqDWxU0fy
+iolMd3GH9CwBzT2131c/j+wV6o3BI++ap8Lh0DKe7zTIPnZleNFANk4guf/EJWmV
+cJDkjzeoAoGAPMGJEFkoR0ayfkd0S/tnY9ilO17T6rdoDuF25ATtNUd6Zji6tslx
+BkQFWtTeinO3rGkqJRPndq0wp3E33AOHhJE/FOIlWl4Tf6aeU95Y4enYujKQDiIm
+STXmdiw5wq/LFdc3a2waOUvuI+647wxgHhqTmD7xI2biGZLYN9Oasy0CFQDL/9Z1
+fSLn88m1sUeWAZ4Ys2IIxw==
+-----END DSA PRIVATE KEY-----
+END_DSAK
+  end
+end