rapns 3.0.0-java

data/spec/unit/daemon/interruptible_sleep_spec.rb

@@ -0,0 +1,40 @@
+require "unit_spec_helper"
+
+describe Rapns::Daemon::InterruptibleSleep do
+  class SleepTest
+    extend Rapns::Daemon::InterruptibleSleep
+  end
+
+  let(:rd) { stub(:close => nil) }
+  let(:wr) { stub(:close => nil) }
+
+  before do
+    IO.stub(:pipe)
+    IO.stub(:select)
+  end
+
+  it 'creates a new pipe' do
+    IO.should_receive(:pipe)
+    SleepTest.interruptible_sleep 1
+  end
+
+  it 'selects on the reader' do
+    IO.stub(:pipe => [rd, wr])
+    IO.should_receive(:select).with([rd], nil, nil, 1)
+    SleepTest.interruptible_sleep 1
+  end
+
+  it 'closes both ends of the pipe after the timeout' do
+    IO.stub(:pipe => [rd, wr])
+    rd.should_receive(:close)
+    wr.should_receive(:close)
+    SleepTest.interruptible_sleep 1
+  end
+
+  it 'closes the writer' do
+    IO.stub(:pipe => [rd, wr])
+    SleepTest.interruptible_sleep 1
+    wr.should_receive(:close)
+    SleepTest.interrupt_sleep
+  end
+end

data/spec/unit/daemon/logger_spec.rb

@@ -0,0 +1,156 @@
+require "unit_spec_helper"
+
+module Rails
+  def self.logger
+    @logger
+  end
+
+  def self.logger=(logger)
+    @logger = logger
+  end
+end
+
+module HoptoadNotifier
+  def self.notify(e)
+  end
+end
+
+module Airbrake
+  def self.notify(e)
+  end
+end
+
+describe Rapns::Daemon::Logger do
+  let(:log) { stub(:sync= => true) }
+  let(:config) { stub(:airbrake_notify => true) }
+
+  before do
+    Rails.stub(:root).and_return("/rails_root")
+    @buffered_logger = mock("BufferedLogger", :info => nil, :error => nil, :level => 0, :auto_flushing => 1, :auto_flushing= => nil)
+    Rails.logger = @buffered_logger
+    ActiveSupport::BufferedLogger.stub(:new).and_return(@buffered_logger)
+    Rapns::Daemon.stub(:config => config)
+    File.stub(:open => log)
+    STDERR.stub(:puts)
+  end
+
+  it "disables logging if the log file cannot be opened" do
+    File.stub(:open).and_raise(Errno::ENOENT)
+    STDERR.should_receive(:puts).with(/No such file or directory/)
+    STDERR.should_receive(:puts).with(/Logging disabled/)
+    Rapns::Daemon::Logger.new(:foreground => true)
+  end
+
+  it "should open the a log file in the Rails log directory" do
+    File.should_receive(:open).with('/rails_root/log/rapns.log', 'a')
+    Rapns::Daemon::Logger.new(:foreground => true)
+  end
+
+  it 'sets sync mode on the log descriptor' do
+    log.should_receive(:sync=).with(true)
+    Rapns::Daemon::Logger.new(:foreground => true)
+  end
+
+  it 'instantiates the BufferedLogger' do
+    ActiveSupport::BufferedLogger.should_receive(:new).with(log, Rails.logger.level)
+    Rapns::Daemon::Logger.new(:foreground => true)
+  end
+
+  it "should print out the msg if running in the foreground" do
+    logger = Rapns::Daemon::Logger.new(:foreground => true)
+    STDOUT.should_receive(:puts).with(/hi mom/)
+    logger.info("hi mom")
+  end
+
+  it "should not print out the msg if not running in the foreground" do
+    logger = Rapns::Daemon::Logger.new(:foreground => false)
+    STDOUT.should_not_receive(:puts).with(/hi mom/)
+    logger.info("hi mom")
+  end
+
+  it "should prefix log lines with the current time" do
+    now = Time.now
+    Time.stub(:now).and_return(now)
+    logger = Rapns::Daemon::Logger.new(:foreground => false)
+    @buffered_logger.should_receive(:info).with(/#{Regexp.escape("[#{now.to_s(:db)}]")}/)
+    logger.info("blah")
+  end
+
+  it "should prefix error logs with the ERROR label" do
+    logger = Rapns::Daemon::Logger.new(:foreground => false)
+    @buffered_logger.should_receive(:error).with(/#{Regexp.escape("[ERROR]")}/)
+    logger.error("eeek")
+  end
+
+  it "should prefix warn logs with the WARNING label" do
+    logger = Rapns::Daemon::Logger.new(:foreground => false)
+    @buffered_logger.should_receive(:warn).with(/#{Regexp.escape("[WARNING]")}/)
+    logger.warn("eeek")
+  end
+
+  it "should handle an Exception instance" do
+    e = RuntimeError.new("hi mom")
+    e.stub(:backtrace => [])
+    logger = Rapns::Daemon::Logger.new(:foreground => false)
+    @buffered_logger.should_receive(:error).with(/RuntimeError, hi mom/)
+    logger.error(e)
+  end
+
+  it "should notify Airbrake of the exception" do
+    e = RuntimeError.new("hi mom")
+    e.stub(:backtrace => [])
+    logger = Rapns::Daemon::Logger.new(:foreground => false, :airbrake_notify => true)
+    Airbrake.should_receive(:notify_or_ignore).with(e)
+    logger.error(e)
+  end
+
+  context "without Airbrake defined" do
+    before do
+      Object.send(:remove_const, :Airbrake)
+    end
+
+    after do
+      module Airbrake
+        def self.notify(e)
+        end
+      end
+    end
+
+    it "should notify using HoptoadNotifier" do
+      e = RuntimeError.new("hi mom")
+      e.stub(:backtrace => [])
+      logger = Rapns::Daemon::Logger.new(:foreground => false, :airbrake_notify => true)
+      HoptoadNotifier.should_receive(:notify_or_ignore).with(e)
+      logger.error(e)
+    end
+  end
+
+  it "should not notify Airbrake of the exception if the airbrake_notify option is false" do
+    e = RuntimeError.new("hi mom")
+    e.stub(:backtrace => [])
+    logger = Rapns::Daemon::Logger.new(:foreground => false, :airbrake_notify => false)
+    Airbrake.should_not_receive(:notify_or_ignore).with(e)
+    logger.error(e)
+  end
+
+  it "should not notify Airbrake if explicitly disabled in the call to error" do
+    e = RuntimeError.new("hi mom")
+    e.stub(:backtrace => [])
+    logger = Rapns::Daemon::Logger.new(:foreground => false, :airbrake_notify => true)
+    Airbrake.should_not_receive(:notify_or_ignore).with(e)
+    logger.error(e, :airbrake_notify => false)
+  end
+
+  it "should not attempt to notify Airbrake of the error is not an Exception" do
+    logger = Rapns::Daemon::Logger.new(:foreground => false)
+    Airbrake.should_not_receive(:notify_or_ignore)
+    logger.error("string error message")
+  end
+
+  it 'defaults auto_flushing to true if the Rails logger does not respond to auto_flushing' do
+    rails_logger = mock(:info => nil, :error => nil, :level => 0)
+    Rails.logger = rails_logger
+    logger = Rapns::Daemon::Logger.new({})
+    @buffered_logger.auto_flushing.should be_true
+  end
+end

data/spec/unit/daemon_spec.rb

@@ -0,0 +1,139 @@
+require "unit_spec_helper"
+
+describe Rapns::Daemon, "when starting" do
+  module Rails; end
+
+  let(:certificate) { stub }
+  let(:password) { stub }
+  let(:config) { stub(:pid_file => nil, :push_poll => 2, :airbrake_notify => false, :foreground => true) }
+  let(:logger) { stub(:info => nil, :error => nil, :warn => nil) }
+
+  before do
+    Rapns.stub(:config => config)
+    Rapns::Daemon::Feeder.stub(:start)
+    Rapns::Daemon::Logger.stub(:new).and_return(logger)
+    Rapns::Daemon::AppRunner.stub(:sync => nil, :stop => nil)
+    Rapns::Daemon.stub(:daemonize => nil, :reconnect_database => nil, :exit => nil, :puts => nil)
+    File.stub(:open)
+    Rails.stub(:root).and_return("/rails_root")
+  end
+
+  it "forks into a daemon if the foreground option is false" do
+    config.stub(:foreground => false)
+    ActiveRecord::Base.stub(:establish_connection)
+    Rapns::Daemon.should_receive(:daemonize)
+    Rapns::Daemon.start
+  end
+
+  it "does not fork into a daemon if the foreground option is true" do
+    config.stub(:foreground => true)
+    Rapns::Daemon.should_not_receive(:daemonize)
+    Rapns::Daemon.start
+  end
+
+  it "writes the process ID to the PID file" do
+    Rapns::Daemon.should_receive(:write_pid_file)
+    Rapns::Daemon.start
+  end
+
+  it "logs an error if the PID file could not be written" do
+    config.stub(:pid_file => '/rails_root/rapns.pid')
+    File.stub(:open).and_raise(Errno::ENOENT)
+    logger.should_receive(:error).with("Failed to write PID to '/rails_root/rapns.pid': #<Errno::ENOENT: No such file or directory>")
+    Rapns::Daemon.start
+  end
+
+  it "starts the feeder" do
+    Rapns::Daemon::Feeder.should_receive(:start).with(2)
+    Rapns::Daemon.start
+  end
+
+  it "syncs apps" do
+    Rapns::Daemon::AppRunner.should_receive(:sync)
+    Rapns::Daemon.start
+  end
+
+  it "sets up the logger" do
+    config.stub(:airbrake_notify => true)
+    Rapns::Daemon::Logger.should_receive(:new).with(:foreground => true, :airbrake_notify => true)
+    Rapns::Daemon.start
+  end
+
+  it "makes the logger accessible" do
+    Rapns::Daemon.start
+    Rapns::Daemon.logger.should == logger
+  end
+
+  it 'prints a warning if there are no apps' do
+    Rapns::App.stub(:count => 0)
+    logger.should_receive(:warn).any_number_of_times
+    Rapns::Daemon.start
+  end
+
+  it 'prints a warning exists if rapns has not been upgraded' do
+    Rapns::App.stub(:count).and_raise(ActiveRecord::StatementInvalid)
+    Rapns::Daemon.should_receive(:puts).any_number_of_times
+    Rapns::Daemon.should_receive(:exit).with(1)
+    Rapns::Daemon.start
+  end
+
+  it 'warns if rapns.yml still exists' do
+    File.should_receive(:exists?).with('/rails_root/config/rapns/rapns.yml').and_return(true)
+    logger.should_receive(:warn).with("Since 2.0.0 rapns uses command-line options and a Ruby based configuration file.\nPlease run 'rails g rapns' to generate a new configuration file into config/initializers.\nRemove config/rapns/rapns.yml to avoid this warning.\n")
+    Rapns::Daemon.start
+  end
+end
+
+describe Rapns::Daemon, "when being shutdown" do
+  let(:config) { stub(:pid_file => '/rails_root/rapns.pid') }
+
+  before do
+    Rapns.stub(:config => config)
+    Rapns::Daemon.stub(:puts => nil)
+    Rapns::Daemon::Feeder.stub(:stop)
+    Rapns::Daemon::AppRunner.stub(:stop)
+  end
+
+  # These tests do not work on JRuby.
+  unless defined? JRUBY_VERSION
+    it "shuts down when signaled signaled SIGINT" do
+      Rapns::Daemon.setup_signal_hooks
+      Rapns::Daemon.should_receive(:shutdown)
+      Process.kill("SIGINT", Process.pid)
+    end
+
+    it "shuts down when signaled signaled SIGTERM" do
+      Rapns::Daemon.setup_signal_hooks
+      Rapns::Daemon.should_receive(:shutdown)
+      Process.kill("SIGTERM", Process.pid)
+    end
+  end
+
+  it "stops the feeder" do
+    Rapns::Daemon::Feeder.should_receive(:stop)
+    Rapns::Daemon.send(:shutdown)
+  end
+
+  it "stops the app runners" do
+    Rapns::Daemon::AppRunner.should_receive(:stop)
+    Rapns::Daemon.send(:shutdown)
+  end
+
+  it "removes the PID file if one was written" do
+    File.stub(:exists?).and_return(true)
+    File.should_receive(:delete).with("/rails_root/rapns.pid")
+    Rapns::Daemon.send(:shutdown)
+  end
+
+  it "does not attempt to remove the PID file if it does not exist" do
+    File.stub(:exists?).and_return(false)
+    File.should_not_receive(:delete)
+    Rapns::Daemon.send(:shutdown)
+  end
+
+  it "does not attempt to remove the PID file if one was not written" do
+    config.stub(:pid_file).and_return(nil)
+    File.should_not_receive(:delete)
+    Rapns::Daemon.send(:shutdown)
+  end
+end

data/spec/unit/gcm/app_spec.rb

@@ -0,0 +1,5 @@
+require 'unit_spec_helper'
+
+describe Rapns::Gcm::App do
+  it { should validate_presence_of(:auth_key) }
+end

data/spec/unit/gcm/notification_spec.rb

@@ -0,0 +1,55 @@
+require 'unit_spec_helper'
+require 'unit/notification_shared.rb'
+
+describe Rapns::Gcm::Notification do
+  it_should_behave_like 'an Notification subclass'
+
+  let(:app) { Rapns::Gcm::App.create!(:name => 'test', :auth_key => 'abc') }
+  let(:notification_class) { Rapns::Gcm::Notification }
+  let(:notification) { notification_class.new }
+  let(:data_setter) { 'data=' }
+  let(:data_getter) { 'data' }
+
+  it { should validate_presence_of :registration_ids }
+
+  it 'has a payload limit of 4096 bytes' do
+    notification.data = { :key => "a" * 4096 }
+    notification.valid?.should be_false
+    notification.errors[:base].should == ["GCM notification payload cannot be larger than 4096 bytes."]
+  end
+
+  it 'allows assignment of many registration IDs' do
+    notification.app = app
+    notification.registration_ids = ['a', 'b']
+    notification.save!
+    reloaded_notification = notification_class.find(notification.id)
+    reloaded_notification.registration_ids.should == ['a', 'b']
+  end
+
+  it 'allows assignment of a single registration ID' do
+    notification.app = app
+    notification.registration_ids = 'a'
+    notification.save!
+    reloaded_notification = notification_class.find(notification.id)
+    reloaded_notification.registration_ids.should == ['a']
+  end
+
+  it 'validates expiry is present if collapse_key is set' do
+    notification.collapse_key = 'test'
+    notification.expiry = nil
+    notification.valid?.should be_false
+    notification.errors[:expiry].should == ['must be set when using a collapse_key']
+  end
+
+  it 'does not include time_to_live in the payload if collapse_key is not set' do
+    notification.expiry = 100
+    notification.collapse_key = nil
+    notification.as_json.key?('time_to_live').should be_false
+  end
+
+  it 'includes time_to_live in the payload if collapse_key is set' do
+    notification.expiry = 100
+    notification.collapse_key = 'sync'
+    notification.as_json['time_to_live'].should == 100
+  end
+end

data/spec/unit/notification_shared.rb

@@ -0,0 +1,38 @@
+shared_examples_for "an Notification subclass" do
+  describe "when assigning data for the device" do
+    it "calls MultiJson.dump when multi_json responds to :dump" do
+      notification = notification_class.new
+      MultiJson.stub(:respond_to?).with(:dump).and_return(true)
+      MultiJson.should_receive(:dump).with(any_args())
+      notification.send(data_setter, { :pirates => 1 })
+    end
+
+    it "calls MultiJson.encode when multi_json does not respond to :dump" do
+      notification = notification_class.new
+      MultiJson.stub(:respond_to?).with(:dump).and_return(false)
+      MultiJson.should_receive(:encode).with(any_args())
+      notification.send(data_setter, { :ninjas => 1 })
+    end
+
+    it "raises an ArgumentError if something other than a Hash is assigned" do
+      expect do
+        notification.send(data_setter, Array.new)
+      end.to raise_error(ArgumentError, "must be a Hash")
+    end
+
+    it "encodes the given Hash as JSON" do
+      notification.send(data_setter, { :hi => "mom" })
+      notification.read_attribute(:data).should == "{\"hi\":\"mom\"}"
+    end
+
+    it "decodes the JSON when using the reader method" do
+      notification.send(data_setter, { :hi => "mom" })
+      notification.send(data_getter).should == {"hi" => "mom"}
+    end
+
+    it 'warns if attributes_for_device is assigned via mass-assignment' do
+      ActiveSupport::Deprecation.should_receive(:warn)
+      notification_class.new(:attributes_for_device => {:hi => 'mom'})
+    end
+  end
+end

data/spec/unit/notification_spec.rb

@@ -0,0 +1,6 @@
+require "unit_spec_helper"
+
+describe Rapns::Notification do
+  it { should validate_numericality_of(:expiry) }
+  it { should validate_presence_of(:app) }
+end

data/spec/unit_spec_helper.rb

@@ -0,0 +1,145 @@
+ENV['RAILS_ENV'] = 'test'
+
+begin
+  require './spec/support/simplecov_helper'
+  include SimpleCovHelper
+  start_simple_cov("unit-#{RUBY_VERSION}")
+rescue LoadError
+  puts "Coverage disabled."
+end
+
+require 'active_record'
+
+jruby = defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+
+$adapter = ENV['ADAPTER'] || 'postgresql'
+$adapter = 'jdbc' + $adapter if jruby
+
+DATABASE_CONFIG = YAML.load_file(File.expand_path("../config/database.yml", File.dirname(__FILE__)))
+
+if DATABASE_CONFIG[$adapter].nil?
+  puts "No such adapter '#{$adapter}'. Valid adapters are #{DATABASE_CONFIG.keys.join(', ')}."
+  exit 1
+end
+
+if ENV['TRAVIS']
+  DATABASE_CONFIG[$adapter]['username'] = 'postgres'
+else
+  require 'etc'
+  DATABASE_CONFIG[$adapter]['username'] = Etc.getlogin
+end
+
+puts "Using #{$adapter} adapter."
+
+ActiveRecord::Base.establish_connection(DATABASE_CONFIG[$adapter])
+
+require 'generators/templates/create_rapns_notifications'
+require 'generators/templates/create_rapns_feedback'
+require 'generators/templates/add_alert_is_json_to_rapns_notifications'
+require 'generators/templates/add_app_to_rapns'
+require 'generators/templates/create_rapns_apps'
+require 'generators/templates/add_gcm'
+
+[CreateRapnsNotifications, CreateRapnsFeedback,
+ AddAlertIsJsonToRapnsNotifications, AddAppToRapns, CreateRapnsApps, AddGcm].each do |migration|
+  migration.down rescue ActiveRecord::StatementInvalid
+  migration.up
+end
+
+require 'bundler'
+Bundler.require(:default)
+
+require 'shoulda'
+require 'database_cleaner'
+
+DatabaseCleaner.strategy = :truncation
+
+require 'rapns'
+require 'rapns/daemon'
+
+Rapns::Notification.reset_column_information
+Rapns::App.reset_column_information
+Rapns::Apns::Feedback.reset_column_information
+
+RSpec.configure do |config|
+  # config.before :suite do
+  #   PerfTools::CpuProfiler.start('/tmp/rapns_profile')
+  # end
+  # config.after :suite do
+  #   PerfTools::CpuProfiler.stop
+  # end
+
+  config.before(:each) { DatabaseCleaner.clean }
+end
+
+# a test certificate that contains both an X509 certificate and
+# a private key, similar to those used for connecting to Apple
+# push notification servers.
+#
+# Note that we cannot validate the certificate and private key
+# because we are missing the certificate chain used to validate
+# the certificate, and this is private to Apple. So if the app
+# has a certificate and a private key in it, the only way to find
+# out if it really is valid is to connect to Apple's servers.
+#
+TEST_CERT = <<EOF
+Bag Attributes
+    friendlyName: test certificate
+    localKeyID: 00 93 8F E4 A3 C3 75 64 3D 7E EA 14 0B 0A EA DD 15 85 8A D5
+subject=/CN=test certificate/O=Example/OU=Example/ST=QLD/C=AU/L=Example/emailAddress=user@example.com
+issuer=/CN=test certificate/O=Example/OU=Example/ST=QLD/C=AU/L=Example/emailAddress=user@example.com
+-----BEGIN CERTIFICATE-----
+MIID5jCCAs6gAwIBAgIBATALBgkqhkiG9w0BAQswgY0xGTAXBgNVBAMMEHRlc3Qg
+Y2VydGlmaWNhdGUxEDAOBgNVBAoMB0V4YW1wbGUxEDAOBgNVBAsMB0V4YW1wbGUx
+DDAKBgNVBAgMA1FMRDELMAkGA1UEBhMCQVUxEDAOBgNVBAcMB0V4YW1wbGUxHzAd
+BgkqhkiG9w0BCQEWEHVzZXJAZXhhbXBsZS5jb20wHhcNMTIwOTA5MDMxODMyWhcN
+MjIwOTA3MDMxODMyWjCBjTEZMBcGA1UEAwwQdGVzdCBjZXJ0aWZpY2F0ZTEQMA4G
+A1UECgwHRXhhbXBsZTEQMA4GA1UECwwHRXhhbXBsZTEMMAoGA1UECAwDUUxEMQsw
+CQYDVQQGEwJBVTEQMA4GA1UEBwwHRXhhbXBsZTEfMB0GCSqGSIb3DQEJARYQdXNl
+ckBleGFtcGxlLmNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKF+
+UDsN1sLen8g+97PNTiWju9+wkSv+H5rQlvb6YFLPx11YvqpK8ms6kFU1OmWeLfmh
+cpsT+bZtKupC7aGPoSG3RXzzf/YUMgs/ZSXA0idZHA6tkReAEzIX6jL5otfPWbaP
+luCTUoVMeP4u9ywk628zlqh9IQHC1Agl0R1xGCpULDk8kn1gPyEisl38wI5aDbzy
+6lYQGNUKOqt1xfVjtIFe/jyY/v0sxFjIJlRLcAFBuJx4sRV+PwRBkusOQtYwcwpI
+loMxJj+GQe66ueATW81aC4iOU66DAFFEuGzwIwm3bOilimGGQbGb92F339RfmSOo
+TPAvVhsakI3mzESb4lkCAwEAAaNRME8wDgYDVR0PAQH/BAQDAgeAMCAGA1UdJQEB
+/wQWMBQGCCsGAQUFBwMCBggrBgEFBQcDATAbBgNVHREEFDASgRB1c2VyQGV4YW1w
+bGUuY29tMA0GCSqGSIb3DQEBCwUAA4IBAQA5UbNR+83ZdI2DiaB4dRmy0V5RDAqJ
+k9+QskcTV4gBTjsOBS46Dw1tI6iTrfTyjYJdnyH0Y2Y2YVWBnvtON41UCZak+4ed
+/IqyzU0dtfZ+frWa0RY4reyl80TwqnzyJfni0nDo4zGGvz70cxyaz2u1BWqwLjqb
+dh8Dxvt+aHW2MQi0iGKh/HNbgwVanR4+ubNwziK9sR1Rnq9MkHWtwBw16SXQG6ao
+SZKASWNaH8VL08Zz0E98cwd137UJkPsldCwJ8kHR5OzkcjPdXvnGD3d64yy2TC1Z
+Gy1Aazt98wPcTYBytlhK8Rvzg9OoY9QmsdpmWxz1ZCXECJNqCa3IKsqO
+-----END CERTIFICATE-----
+Bag Attributes
+    friendlyName: test certificate
+    localKeyID: 00 93 8F E4 A3 C3 75 64 3D 7E EA 14 0B 0A EA DD 15 85 8A D5
+Key Attributes: <No Attributes>
+-----BEGIN RSA PRIVATE KEY-----
+MIIEpQIBAAKCAQEAoX5QOw3Wwt6fyD73s81OJaO737CRK/4fmtCW9vpgUs/HXVi+
+qkryazqQVTU6ZZ4t+aFymxP5tm0q6kLtoY+hIbdFfPN/9hQyCz9lJcDSJ1kcDq2R
+F4ATMhfqMvmi189Zto+W4JNShUx4/i73LCTrbzOWqH0hAcLUCCXRHXEYKlQsOTyS
+fWA/ISKyXfzAjloNvPLqVhAY1Qo6q3XF9WO0gV7+PJj+/SzEWMgmVEtwAUG4nHix
+FX4/BEGS6w5C1jBzCkiWgzEmP4ZB7rq54BNbzVoLiI5TroMAUUS4bPAjCbds6KWK
+YYZBsZv3YXff1F+ZI6hM8C9WGxqQjebMRJviWQIDAQABAoIBAQCTiLIDQUFSBdAz
+QFNLD+S0vkCEuunlJuP4q1c/ir006l1YChsluBJ/o6D4NwiCjV+zDquEwVsALftm
+yH4PewfZpXT2Ef508T5GyEO/mchj6iSXxDkpHvhqay6qIyWBwwxSnBtaTzy0Soi+
+rmlhCtmLXbXld2sQEM1kJChGnWtWPtvSyrn+mapNPZviGRtgRNK+YsrAti1nUext
+2syO5mTdHf1D8GR7I98OaX6odREuSocEV9PzfapWZx2GK5tvRiS1skiug5ciieTd
+Am5/C+bb31h4drFslihLb5BRGO5SFQJvMJL2Sx1f19BCC4XikS01P4/zZbxQNq79
+kxEQuDGBAoGBANP4pIYZ5xshCkx7cTYqmxzWLClGKE2S7Oa8N89mtOwfmqT9AFun
+t9Us9Ukbi8BaKlKhGpQ1HlLf/KVcpyW0x2qLou6AyIWYH+/5VaR3graNgUnzpK9f
+1F5HoaNHbhlAoebqhzhASFlJI2aqUdQjdOv73z+s9szJU4gpILNwGDFnAoGBAMMJ
+j+vIxtG9J2jldyoXzpg5mbMXSj9u/wFLBVdjXWyOoiqVMMBto53RnoqAom7Ifr9D
+49LxRAT1Q3l4vs/YnM3ziMsIg2vQK1EbrLsY9OnD/kvPaLXOlNIOdfLM8UeVWZMc
+I4LPbbZrhv/7CC8RjbRhMoWWdGYPvxmvD6V4ZDY/AoGBALoI6OxA45Htx4okdNHj
+RstiNNPsnQaoQn6nBhxiubraafEPkzbd1fukP4pwQJELEUX/2sHkdL6rkqLW1GPF
+a5dZAiBsqpCFWNJWdBGqSfBJ9QSgbxLz+gDcwUH6OOi0zuNJRm/aCyVBiW5bYQHc
+NIvAPMk31ksZDtTbs7WIVdNVAoGBALZ1+KWNxKqs+fSBT5UahpUUtfy8miJz9a7A
+/3M8q0cGvSF3Rw+OwpW/aEGMi+l2OlU27ykFuyukRAac9m296RwnbF79TO2M5ylO
+6a5zb5ROXlWP6RbE96b4DlIidssQJqegmHwlEC+rsrVBpOtb0aThlYEyOxzMOGyP
+wOR9l8rDAoGADZ4TUHFM6VrvPlUZBkGbqiyXH9IM/y9JWk+22JQCEGnM6RFZemSs
+jxWqQiPAdJtb3xKryJSCMtFPH9azedoCrSgaMflJ1QgoXgpiKZyoEXWraVUggh/0
+CEavgZcTZ6SvMuayqJdGGB+zb1V8XwXMtCjApR/kTm47DjxO4DmpOPs=
+-----END RSA PRIVATE KEY-----
+EOF