redis 3.3.5 → 4.5.1

data/test/sentinel_test.rb

@@ -1,255 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
-
-class SentinelTest < Test::Unit::TestCase
-
-  include Helper::Client
-
-  def test_sentinel_connection
-    sentinels = [{:host => "127.0.0.1", :port => 26381},
-                 {:host => "127.0.0.1", :port => 26382}]
-
-    commands = {
-      :s1 => [],
-      :s2 => [],
-    }
-
-    handler = lambda do |id|
-      {
-        :sentinel => lambda do |command, *args|
-          commands[id] << [command, *args]
-          ["127.0.0.1", "6381"]
-        end
-      }
-    end
-
-    RedisMock.start(handler.call(:s1)) do |s1_port|
-      RedisMock.start(handler.call(:s2)) do |s2_port|
-        sentinels[0][:port] = s1_port
-        sentinels[1][:port] = s2_port
-        redis = Redis.new(:url => "redis://master1", :sentinels => sentinels, :role => :master)
-
-        assert redis.ping
-      end
-    end
-
-    assert_equal commands[:s1], [%w[get-master-addr-by-name master1]]
-    assert_equal commands[:s2], []
-  end
-
-  def test_sentinel_failover
-    sentinels = [{:host => "127.0.0.1", :port => 26381},
-                 {:host => "127.0.0.1", :port => 26382}]
-
-    commands = {
-      :s1 => [],
-      :s2 => [],
-    }
-
-    s1 = {
-      :sentinel => lambda do |command, *args|
-        commands[:s1] << [command, *args]
-        "$-1" # Nil
-      end
-    }
-
-    s2 = {
-      :sentinel => lambda do |command, *args|
-        commands[:s2] << [command, *args]
-        ["127.0.0.1", "6381"]
-      end
-    }
-
-    RedisMock.start(s1) do |s1_port|
-      RedisMock.start(s2) do |s2_port|
-        sentinels[0][:port] = s1_port
-        sentinels[1][:port] = s2_port
-        redis = Redis.new(:url => "redis://master1", :sentinels => sentinels, :role => :master)
-
-        assert redis.ping
-      end
-    end
-
-    assert_equal commands[:s1], [%w[get-master-addr-by-name master1]]
-    assert_equal commands[:s2], [%w[get-master-addr-by-name master1]]
-  end
-
-  def test_sentinel_failover_prioritize_healthy_sentinel
-    sentinels = [{:host => "127.0.0.1", :port => 26381},
-                 {:host => "127.0.0.1", :port => 26382}]
-
-    commands = {
-      :s1 => [],
-      :s2 => [],
-    }
-
-    s1 = {
-      :sentinel => lambda do |command, *args|
-        commands[:s1] << [command, *args]
-        "$-1" # Nil
-      end
-    }
-
-    s2 = {
-      :sentinel => lambda do |command, *args|
-        commands[:s2] << [command, *args]
-        ["127.0.0.1", "6381"]
-      end
-    }
-
-    RedisMock.start(s1) do |s1_port|
-      RedisMock.start(s2) do |s2_port|
-        sentinels[0][:port] = s1_port
-        sentinels[1][:port] = s2_port
-        redis = Redis.new(:url => "redis://master1", :sentinels => sentinels, :role => :master)
-
-        assert redis.ping
-
-        redis.quit
-
-        assert redis.ping
-      end
-    end
-
-    assert_equal commands[:s1], [%w[get-master-addr-by-name master1]]
-    assert_equal commands[:s2], [%w[get-master-addr-by-name master1], %w[get-master-addr-by-name master1]]
-  end
-
-  def test_sentinel_with_non_sentinel_options
-    sentinels = [{:host => "127.0.0.1", :port => 26381}]
-
-    commands = {
-      :s1 => [],
-      :m1 => []
-    }
-
-    sentinel = lambda do |port|
-      {
-        :auth => lambda do |pass|
-          commands[:s1] << ["auth", pass]
-          "-ERR unknown command 'auth'"
-        end,
-        :select => lambda do |db|
-          commands[:s1] << ["select", db]
-          "-ERR unknown command 'select'"
-        end,
-        :sentinel => lambda do |command, *args|
-          commands[:s1] << [command, *args]
-          ["127.0.0.1", port.to_s]
-        end
-      }
-    end
-
-    master = {
-      :auth => lambda do |pass|
-        commands[:m1] << ["auth", pass]
-        "+OK"
-      end,
-      :role => lambda do
-        commands[:m1] << ["role"]
-        ["master"]
-      end
-    }
-
-    RedisMock.start(master) do |master_port|
-      RedisMock.start(sentinel.call(master_port)) do |sen_port|
-        sentinels[0][:port] = sen_port
-        redis = Redis.new(:url => "redis://:foo@master1/15", :sentinels => sentinels, :role => :master)
-
-        assert redis.ping
-      end
-    end
-
-    assert_equal [%w[get-master-addr-by-name master1]], commands[:s1]
-    assert_equal [%w[auth foo], %w[role]], commands[:m1]
-  end
-
-  def test_sentinel_role_mismatch
-    sentinels = [{:host => "127.0.0.1", :port => 26381}]
-
-    sentinel = lambda do |port|
-      {
-        :sentinel => lambda do |command, *args|
-          ["127.0.0.1", port.to_s]
-        end
-      }
-    end
-
-    master = {
-      :role => lambda do
-        ["slave"]
-      end
-    }
-
-    ex = assert_raise(Redis::ConnectionError) do
-      RedisMock.start(master) do |master_port|
-        RedisMock.start(sentinel.call(master_port)) do |sen_port|
-          sentinels[0][:port] = sen_port
-          redis = Redis.new(:url => "redis://master1", :sentinels => sentinels, :role => :master)
-
-          assert redis.ping
-        end
-      end
-    end
-
-    assert_match(/Instance role mismatch/, ex.message)
-  end
-
-  def test_sentinel_retries
-    sentinels = [{:host => "127.0.0.1", :port => 26381},
-                 {:host => "127.0.0.1", :port => 26382}]
-
-    connections = []
-
-    handler = lambda do |id, port|
-      {
-        :sentinel => lambda do |command, *args|
-          connections << id
-
-          if connections.count(id) < 2
-            :close
-          else
-            ["127.0.0.1", port.to_s]
-          end
-        end
-      }
-    end
-
-    master = {
-      :role => lambda do
-        ["master"]
-      end
-    }
-
-    RedisMock.start(master) do |master_port|
-      RedisMock.start(handler.call(:s1, master_port)) do |s1_port|
-        RedisMock.start(handler.call(:s2, master_port)) do |s2_port|
-          sentinels[0][:port] = s1_port
-          sentinels[1][:port] = s2_port
-          redis = Redis.new(:url => "redis://master1", :sentinels => sentinels, :role => :master, :reconnect_attempts => 1)
-
-          assert redis.ping
-        end
-      end
-    end
-
-    assert_equal [:s1, :s2, :s1], connections
-
-    connections.clear
-
-    ex = assert_raise(Redis::CannotConnectError) do
-      RedisMock.start(master) do |master_port|
-        RedisMock.start(handler.call(:s1, master_port)) do |s1_port|
-          RedisMock.start(handler.call(:s2, master_port)) do |s2_port|
-            redis = Redis.new(:url => "redis://master1", :sentinels => sentinels, :role => :master, :reconnect_attempts => 0)
-
-            assert redis.ping
-          end
-        end
-      end
-    end
-
-    assert_match(/No sentinels available/, ex.message)
-  end
-end

data/test/sorting_test.rb

@@ -1,59 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
-
-class TestSorting < Test::Unit::TestCase
-
-  include Helper::Client
-
-  def test_sort
-    r.set("foo:1", "s1")
-    r.set("foo:2", "s2")
-
-    r.rpush("bar", "1")
-    r.rpush("bar", "2")
-
-    assert_equal ["s1"], r.sort("bar", :get => "foo:*", :limit => [0, 1])
-    assert_equal ["s2"], r.sort("bar", :get => "foo:*", :limit => [0, 1], :order => "desc alpha")
-  end
-
-  def test_sort_with_an_array_of_gets
-    r.set("foo:1:a", "s1a")
-    r.set("foo:1:b", "s1b")
-
-    r.set("foo:2:a", "s2a")
-    r.set("foo:2:b", "s2b")
-
-    r.rpush("bar", "1")
-    r.rpush("bar", "2")
-
-    assert_equal [["s1a", "s1b"]], r.sort("bar", :get => ["foo:*:a", "foo:*:b"], :limit => [0, 1])
-    assert_equal [["s2a", "s2b"]], r.sort("bar", :get => ["foo:*:a", "foo:*:b"], :limit => [0, 1], :order => "desc alpha")
-    assert_equal [["s1a", "s1b"], ["s2a", "s2b"]], r.sort("bar", :get => ["foo:*:a", "foo:*:b"])
-  end
-
-  def test_sort_with_store
-    r.set("foo:1", "s1")
-    r.set("foo:2", "s2")
-
-    r.rpush("bar", "1")
-    r.rpush("bar", "2")
-
-    r.sort("bar", :get => "foo:*", :store => "baz")
-    assert_equal ["s1", "s2"], r.lrange("baz", 0, -1)
-  end
-
-  def test_sort_with_an_array_of_gets_and_with_store
-    r.set("foo:1:a", "s1a")
-    r.set("foo:1:b", "s1b")
-
-    r.set("foo:2:a", "s2a")
-    r.set("foo:2:b", "s2b")
-
-    r.rpush("bar", "1")
-    r.rpush("bar", "2")
-
-    r.sort("bar", :get => ["foo:*:a", "foo:*:b"], :store => 'baz')
-    assert_equal ["s1a", "s1b", "s2a", "s2b"], r.lrange("baz", 0, -1)
-  end
-end

data/test/ssl_test.rb

@@ -1,73 +0,0 @@
-# encoding: UTF-8
-
-if RUBY_VERSION >= "1.9.3"
-  require File.expand_path("helper", File.dirname(__FILE__))
-
-  class SslTest < Test::Unit::TestCase
-
-    include Helper::Client
-
-    driver(:ruby) do
-
-      def test_verified_ssl_connection
-        RedisMock.start({ :ping => proc { "+PONG" } }, ssl_server_opts("trusted")) do |port|
-          redis = Redis.new(:port => port, :ssl => true, :ssl_params => { :ca_file => ssl_ca_file })
-          assert_equal redis.ping, "PONG"
-        end
-      end
-
-      def test_unverified_ssl_connection
-        assert_raise(OpenSSL::SSL::SSLError) do
-          RedisMock.start({ :ping => proc { "+PONG" } }, ssl_server_opts("untrusted")) do |port|
-            redis = Redis.new(:port => port, :ssl => true, :ssl_params => { :ca_file => ssl_ca_file })
-            redis.ping
-          end
-        end
-      end
-
-      def test_ssl_blocking
-        RedisMock.start({}, ssl_server_opts("trusted")) do |port|
-          redis = Redis.new(:port => port, :ssl => true, :ssl_params => { :ca_file => ssl_ca_file })
-          assert_equal redis.set("boom", "a" * 10_000_000), "OK"
-        end
-      end
-
-    end
-
-    driver(:hiredis, :synchrony) do
-
-      def test_ssl_not_implemented_exception
-        assert_raise(NotImplementedError) do
-          RedisMock.start({ :ping => proc { "+PONG" } }, ssl_server_opts("trusted")) do |port|
-            redis = Redis.new(:port => port, :ssl => true, :ssl_params => { :ca_file => ssl_ca_file })
-            redis.ping
-          end
-        end
-      end
-
-    end
-
-    private
-
-    def ssl_server_opts(prefix)
-      ssl_cert = File.join(cert_path, "#{prefix}-cert.crt")
-      ssl_key  = File.join(cert_path, "#{prefix}-cert.key")
-
-      {
-        :ssl => true,
-        :ssl_params => {
-          :cert => OpenSSL::X509::Certificate.new(File.read(ssl_cert)),
-          :key  => OpenSSL::PKey::RSA.new(File.read(ssl_key))
-        }
-      }
-    end
-
-    def ssl_ca_file
-      File.join(cert_path, "trusted-ca.crt")
-    end
-
-    def cert_path
-      File.expand_path("../support/ssl/", __FILE__)
-    end
-  end
-end

data/test/support/connection/hiredis.rb

@@ -1 +0,0 @@
-require "support/wire/thread"

data/test/support/connection/ruby.rb

@@ -1 +0,0 @@
-require "support/wire/thread"

data/test/support/connection/synchrony.rb

@@ -1,17 +0,0 @@
-require "support/wire/synchrony"
-
-module Helper
-  def around
-    rv = nil
-
-    EM.synchrony do
-      begin
-        rv = yield
-      ensure
-        EM.stop
-      end
-    end
-
-    rv
-  end
-end

data/test/support/redis_mock.rb

@@ -1,130 +0,0 @@
-require "socket"
-
-module RedisMock
-  class Server
-    def initialize(options = {}, &block)
-      tcp_server = TCPServer.new(options[:host] || "127.0.0.1", 0)
-      tcp_server.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
-
-      if options[:ssl]
-        ctx = OpenSSL::SSL::SSLContext.new
-
-        ssl_params = options.fetch(:ssl_params, {})
-        ctx.set_params(ssl_params) unless ssl_params.empty?
-
-        @server = OpenSSL::SSL::SSLServer.new(tcp_server, ctx)
-      else
-        @server = tcp_server
-      end
-    end
-
-    def port
-      @server.addr[1]
-    end
-
-    def start(&block)
-      @thread = Thread.new { run(&block) }
-    end
-
-    def shutdown
-      @thread.kill
-    end
-
-    def run
-      begin
-        loop do
-          session = @server.accept
-
-          begin
-            return if yield(session) == :exit
-          ensure
-            session.close
-          end
-        end
-      rescue => ex
-        $stderr.puts "Error running mock server: #{ex.message}"
-        $stderr.puts ex.backtrace
-        retry
-      ensure
-        @server.close
-      end
-    end
-  end
-
-  # Starts a mock Redis server in a thread.
-  #
-  # The server will use the lambda handler passed as argument to handle
-  # connections. For example:
-  #
-  #   handler = lambda { |session| session.close }
-  #   RedisMock.start_with_handler(handler) do
-  #     # Every connection will be closed immediately
-  #   end
-  #
-  def self.start_with_handler(blk, options = {})
-    server = Server.new(options)
-    port = server.port
-
-    begin
-      server.start(&blk)
-      yield(port)
-    ensure
-      server.shutdown
-    end
-  end
-
-  # Starts a mock Redis server in a thread.
-  #
-  # The server will reply with a `+OK` to all commands, but you can
-  # customize it by providing a hash. For example:
-  #
-  #   RedisMock.start(:ping => lambda { "+PONG" }) do |port|
-  #     assert_equal "PONG", Redis.new(:port => port).ping
-  #   end
-  #
-  def self.start(commands, options = {}, &blk)
-    handler = lambda do |session|
-      while line = session.gets
-        argv = Array.new(line[1..-3].to_i) do
-          bytes = session.gets[1..-3].to_i
-          arg = session.read(bytes)
-          session.read(2) # Discard \r\n
-          arg
-        end
-
-        command = argv.shift
-        blk = commands[command.to_sym]
-        blk ||= lambda { |*_| "+OK" }
-
-        response = blk.call(*argv)
-
-        # Convert a nil response to :close
-        response ||= :close
-
-        if response == :exit
-          break :exit
-        elsif response == :close
-          break :close
-        elsif response.is_a?(Array)
-          session.write("*%d\r\n" % response.size)
-
-          response.each do |resp|
-            if resp.is_a?(Array)
-              session.write("*%d\r\n" % resp.size)
-              resp.each do |r|
-                session.write("$%d\r\n%s\r\n" % [r.length, r])
-              end
-            else
-              session.write("$%d\r\n%s\r\n" % [resp.length, resp])
-            end
-          end
-        else
-          session.write(response)
-          session.write("\r\n") unless response.end_with?("\r\n")
-        end
-      end
-    end
-
-    start_with_handler(handler, options, &blk)
-  end
-end

data/test/support/ssl/gen_certs.sh

@@ -1,31 +0,0 @@
-#!/bin/sh
-
-get_subject() {
-  if [ "$1" = "trusted" ]
-  then
-    echo "/C=IT/ST=Sicily/L=Catania/O=Redis/OU=Security/CN=127.0.0.1"
-  else
-    echo "/C=XX/ST=Untrusted/L=Evilville/O=Evil Hacker/OU=Attack Department/CN=127.0.0.1"
-  fi
-}
-
-# Generate two CAs: one to be considered trusted, and one that's untrusted
-for type in trusted untrusted; do
-  rm -rf ./demoCA
-  mkdir -p ./demoCA
-  mkdir -p ./demoCA/certs
-  mkdir -p ./demoCA/crl
-  mkdir -p ./demoCA/newcerts
-  mkdir -p ./demoCA/private
-  touch ./demoCA/index.txt
-
-  openssl genrsa -out ${type}-ca.key 2048
-  openssl req -new -x509 -days 12500 -key ${type}-ca.key -out ${type}-ca.crt -subj "$(get_subject $type)"
-  openssl x509 -in ${type}-ca.crt -noout -next_serial -out ./demoCA/serial
-
-  openssl req -newkey rsa:2048 -keyout ${type}-cert.key -nodes -out ${type}-cert.req -subj "$(get_subject $type)"
-  openssl ca -days 12500 -cert ${type}-ca.crt -keyfile ${type}-ca.key -out ${type}-cert.crt -infiles ${type}-cert.req
-  rm ${type}-cert.req
-done
-
-rm -rf ./demoCA

data/test/support/ssl/trusted-ca.crt

@@ -1,25 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIEIDCCAwigAwIBAgIJAM7kyjC89Qj/MA0GCSqGSIb3DQEBCwUAMGcxCzAJBgNV
-BAYTAklUMQ8wDQYDVQQIEwZTaWNpbHkxEDAOBgNVBAcTB0NhdGFuaWExDjAMBgNV
-BAoTBVJlZGlzMREwDwYDVQQLEwhTZWN1cml0eTESMBAGA1UEAxMJMTI3LjAuMC4x
-MCAXDTE2MDQwMjAzMzQ0MVoYDzIwNTAwNjIzMDMzNDQxWjBnMQswCQYDVQQGEwJJ
-VDEPMA0GA1UECBMGU2ljaWx5MRAwDgYDVQQHEwdDYXRhbmlhMQ4wDAYDVQQKEwVS
-ZWRpczERMA8GA1UECxMIU2VjdXJpdHkxEjAQBgNVBAMTCTEyNy4wLjAuMTCCASIw
-DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMeibFqEG38mtN9DSXy6NZdd7AjH
-4/D+VdDzlbJlI5IBACCV9p6P2j5PFlFvkHFE6vr6biMaLXNAmUHYfDzeT95LODHH
-t+8HlR51cNYrnt9B3eiVwEnJ7+axuDHg6nUgLXeKeog+vEqreZwLnFibxt2qpFze
-xzyKJ37Pm+iAey5glCc/v7ECYQ4sWVVV+ciC+sAwmZDfZXCBQtRRokJ6ikqQDwWV
-DugGcV46feTpu79OmkLLM8PI3E7ow2F/3iv67gmdlO5m9wX1ahWzJKUapBTxgf4X
-QG0s60WbC9iJIvgXRGW7wWSsqSVJkfLYllDTPgfpLyl1+FR3A4awrsPiMVUCAwEA
-AaOBzDCByTAdBgNVHQ4EFgQU+YG9kJR3Vy31d7QVyxRAYyKTK18wgZkGA1UdIwSB
-kTCBjoAU+YG9kJR3Vy31d7QVyxRAYyKTK1+ha6RpMGcxCzAJBgNVBAYTAklUMQ8w
-DQYDVQQIEwZTaWNpbHkxEDAOBgNVBAcTB0NhdGFuaWExDjAMBgNVBAoTBVJlZGlz
-MREwDwYDVQQLEwhTZWN1cml0eTESMBAGA1UEAxMJMTI3LjAuMC4xggkAzuTKMLz1
-CP8wDAYDVR0TBAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEAeFKB7DUixmxbdvNw
-n/mNoHK+OOZXmfxZDCo0v2gcQ4WXUiCqL6MagrImCvkEz5RL6Fk2ZflEV2iGQ5Ds
-CmF2n47ISpqG29bfI5R1rcbfqK/5tazUIhQu12ThNmkEh7hCuW/0LqJrnmxpuRLy
-le9e3svCC96lwjFczzU/utWurKt7S7Di3C4P+AXAJJuszDMLMCBLaB/3j24cNpOx
-zzeZo02x4rpsD2+MMfRDWMWezVEyk63KnI0kt3JGnepsKCFc48ZOk09LwFk3Rfaq
-zuKSgEJJw1mfsdBfysM0HQw20yyjSdoTEfQq3bXctTNi+pEOgW6x7TMsnngYYLXV
-9XTrpg==
------END CERTIFICATE-----

data/test/support/ssl/trusted-ca.key

@@ -1,27 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIIEpQIBAAKCAQEAx6JsWoQbfya030NJfLo1l13sCMfj8P5V0POVsmUjkgEAIJX2
-no/aPk8WUW+QcUTq+vpuIxotc0CZQdh8PN5P3ks4Mce37weVHnVw1iue30Hd6JXA
-Scnv5rG4MeDqdSAtd4p6iD68Sqt5nAucWJvG3aqkXN7HPIonfs+b6IB7LmCUJz+/
-sQJhDixZVVX5yIL6wDCZkN9lcIFC1FGiQnqKSpAPBZUO6AZxXjp95Om7v06aQssz
-w8jcTujDYX/eK/ruCZ2U7mb3BfVqFbMkpRqkFPGB/hdAbSzrRZsL2Iki+BdEZbvB
-ZKypJUmR8tiWUNM+B+kvKXX4VHcDhrCuw+IxVQIDAQABAoIBAQCzbGHiQJXOA+XQ
-O9OSjHGaJ8n6Yl2VvaE3eZXzjj8X/Fo271GGVVgbZE10x8aUZxKim+3dEqwCx+52
-ZbHTqyMxcX2CEDRaWwBFLdxKQU467iIZ5m26ZAp/1v7rpXBT8KWsqQNT7L6ihdd4
-zl6orOlhVPsAlSGQYcL5kHJZ1w/fL0phEbwdISd3PYhGHXMNmqfXorzJYHDQA4R+
-yR7WpP1dmnUeEKrHc9FFcBZ75BGlWjdCPZMFKc7IndZumarhBpWH9yZMUxrUIo4V
-SCweRUFdD5H1lMZ0YiIAE25wKNEQ2iGd3Jfr8Vj1KFSHC9I2FJA3aFRRUgTwxx/W
-h0mJy1ZJAoGBAPYsSSlwQdxZjnyZiVkNSD4MoLdof//nRxeKGejq6AiXDvcsLyJy
-0MKk4YBFw2249TWm/KBbMAFiBE7d8uPtP5pPfjNVPX6VltH3AhSZ7Ugbpo6C3NFA
-GpzFVtNaWgCVDloDVdmsY7ssDFuAIih0paklPAqnLY+Ua9m1BiEPrB+bAoGBAM+a
-i+0NMR4AyKpuo1exdd+7BIHw5HNPwGmR1ggdGWduH0zsOhEawQKKFv1X9xKAcXxW
-PyeD56/Tmn7fkWvuE8dOu9E6em0vgmxhYyn4nyLAFYF5uKXYo78MpIEThdpl1ldT
-iHwG/25vunaBUHhwbHPUD+F989tmRuCjoFkuA5nPAoGAaqPIlcDhZvkMtoE0dHVC
-hE6oGIuWV17y9wmGK9YG6iG2A/EKAhxGvur6HL0b6Z4j6zgJW9Xkt9SkFR4kqAQQ
-d2JUQxx75SgcC5y7M/1yQrhnsHiT+7mPTbZW5HvRXUs0yl2DhSYeleiA+epJ4ciW
-Mu3EUsEVBYvAJLE8lHnbkF0CgYEAhyxpz3+3a4G3JsHDOWYjCfoLhVAEb9CNyC9c
-3QuVbvMVDlEBvgFdivm+3lZYWYOoYP0HQgNw59svzUxks5Hg7vUk9abN8CnvEgKX
-PszTUR0g450NzW6xr8PbmO/NR9bnKRUK2Tb1OkMldePdMY6CDykU7g3EqiZ+H+Zq
-kaaUUaECgYEAmk5W+S94q5jLemnfAChC5lva/0/aHdhtaoH4Lo+j0haMsdiy8/ZE
-sh+3gQ8pqwaCAwnKxAcppt/FNZ7tHRsH3oyY6biypn3WppQj+BA41nuzbspOKJhR
-ZDXKFCItbzUjyi23Dx4P4DgMivkpV+e88RMIuBnv4yjl5iOLq+vf4Rg=
------END RSA PRIVATE KEY-----