vagrant-bosh 0.0.1

data/go/src/boshprovisioner/vm/runit_provisioner.go

@@ -0,0 +1,225 @@
+package vm
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+	"time"
+
+	bosherr "bosh/errors"
+	boshlog "bosh/logger"
+	boshsys "bosh/system"
+)
+
+const runitProvisionerLogTag = "RunitProvisioner"
+
+var (
+	// Matches 'svlogd -tt /var/vcap/bosh/log'
+	runitSvlogdRegex = regexp.MustCompile(`\s*svlogd\s+\-tt\s+(.+)\s*`)
+
+	// Matches 'down: agent: 3s, normally up; run: log: (pid 15318) 7762s'
+	runitStatusDownRegex = regexp.MustCompile(`\Adown: [a-z\/]+: \d+`)
+)
+
+// RunitProvisioner installs runit via apt-get and
+// adds specified service under runit's control.
+type RunitProvisioner struct {
+	fs           boshsys.FileSystem
+	cmds         SimpleCmds
+	runner       boshsys.CmdRunner
+	assetManager AssetManager
+	logger       boshlog.Logger
+}
+
+func NewRunitProvisioner(
+	fs boshsys.FileSystem,
+	cmds SimpleCmds,
+	runner boshsys.CmdRunner,
+	assetManager AssetManager,
+	logger boshlog.Logger,
+) RunitProvisioner {
+	return RunitProvisioner{
+		fs:           fs,
+		cmds:         cmds,
+		runner:       runner,
+		assetManager: assetManager,
+		logger:       logger,
+	}
+}
+
+func (p RunitProvisioner) Provision(name string) error {
+	err := p.installRunit()
+	if err != nil {
+		return bosherr.WrapError(err, "Installing runit")
+	}
+
+	err = p.setUpService(name)
+	if err != nil {
+		return bosherr.WrapError(err, "Setting up service")
+	}
+
+	return nil
+}
+
+func (p RunitProvisioner) installRunit() error {
+	p.logger.Info(runitProvisionerLogTag, "Installing runit")
+
+	// todo non-bash
+	cmd := boshsys.Command{
+		Name: "bash",
+		Args: []string{
+			"-c", "apt-get -q -y -o Dpkg::Options::='--force-confdef' -o Dpkg::Options::='--force-confold' install runit",
+		},
+		Env: map[string]string{
+			"DEBIAN_FRONTEND": "noninteractive",
+		},
+	}
+
+	_, _, _, err := p.runner.RunComplexCommand(cmd)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (p RunitProvisioner) setUpService(name string) error {
+	p.logger.Info(runitProvisionerLogTag, "Setting up %s service", name)
+
+	servicePath := fmt.Sprintf("/etc/sv/%s", name)
+	enableServicePath := fmt.Sprintf("/etc/service/%s", name)
+
+	err := p.stopRunAndLog(servicePath, enableServicePath, name)
+	if err != nil {
+		return bosherr.WrapError(err, "Stopping run and log")
+	}
+
+	err = p.setUpRun(servicePath, name)
+	if err != nil {
+		return bosherr.WrapError(err, "Setting up run")
+	}
+
+	err = p.setUpLog(servicePath, name)
+	if err != nil {
+		return bosherr.WrapError(err, "Setting up log")
+	}
+
+	err = p.startRunAndLog(servicePath, enableServicePath, name)
+	if err != nil {
+		return bosherr.WrapError(err, "Starting run and log")
+	}
+
+	return nil
+}
+
+// setUpRun sets up script that runit will execute for the primary process
+func (p RunitProvisioner) setUpRun(servicePath, name string) error {
+	err := p.cmds.MkdirP(servicePath)
+	if err != nil {
+		return err
+	}
+
+	runPath := fmt.Sprintf("%s/run", servicePath)
+
+	err = p.assetManager.Place(fmt.Sprintf("%s/%s-run", name, name), runPath)
+	if err != nil {
+		return err
+	}
+
+	return p.cmds.ChmodX(runPath)
+}
+
+// setUpLog sets up logging destination for the service
+func (p RunitProvisioner) setUpLog(servicePath, name string) error {
+	logPath := fmt.Sprintf("%s/log", servicePath)
+
+	err := p.cmds.MkdirP(logPath)
+	if err != nil {
+		return err
+	}
+
+	logRunPath := fmt.Sprintf("%s/run", logPath)
+
+	err = p.assetManager.Place(fmt.Sprintf("%s/%s-log", name, name), logRunPath)
+	if err != nil {
+		return err
+	}
+
+	err = p.cmds.ChmodX(logRunPath)
+	if err != nil {
+		return err
+	}
+
+	contens, err := p.fs.ReadFileString(logRunPath)
+	if err != nil {
+		return err
+	}
+
+	// First match is the whole string
+	svlogdPaths := runitSvlogdRegex.FindStringSubmatch(contens)
+
+	// Create log file destination so that runit process can properly log
+	if len(svlogdPaths) == 2 {
+		err = p.cmds.MkdirP(svlogdPaths[1])
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (p RunitProvisioner) stopRunAndLog(servicePath, enableServicePath, name string) error {
+	err := p.stopRunsv(name)
+	if err != nil {
+		return bosherr.WrapError(err, "Stopping service")
+	}
+
+	err = p.stopRunsv(fmt.Sprintf("%s/log", name))
+	if err != nil {
+		return bosherr.WrapError(err, "Stopping log service")
+	}
+
+	err = p.fs.RemoveAll(enableServicePath)
+	if err != nil {
+		return err
+	}
+
+	// Clear out all service state kept in supervise/ and control/ dirs
+	return p.fs.RemoveAll(servicePath)
+}
+
+func (p RunitProvisioner) startRunAndLog(servicePath, enableServicePath, name string) error {
+	// Enabling service will kick in monitoring
+	_, _, _, err := p.runner.RunCommand("ln", "-sf", servicePath, enableServicePath)
+
+	return err
+}
+
+func (p RunitProvisioner) stopRunsv(name string) error {
+	p.logger.Info(runitProvisionerLogTag, "Stopping runsv")
+
+	downStdout, _, _, err := p.runner.RunCommand("sv", "down", name)
+	if err != nil {
+		p.logger.Error(runitProvisionerLogTag, "Ignoring down error %s", err.Error())
+	}
+
+	// If runsv configuration does not exist, service was never started
+	if strings.Contains(downStdout, "file does not exist") {
+		return nil
+	}
+
+	var lastStatusStdout string
+
+	for i := 0; i < 20; i++ {
+		lastStatusStdout, _, _, _ = p.runner.RunCommand("sv", "status", name)
+
+		if runitStatusDownRegex.MatchString(lastStatusStdout) {
+			return nil
+		}
+
+		time.Sleep(100 * time.Millisecond)
+	}
+
+	return bosherr.New("Failed to stop runsv for %s. Output: %s", name, lastStatusStdout)
+}

data/go/src/boshprovisioner/vm/simple_cmds.go

@@ -0,0 +1,54 @@
+package vm
+
+import (
+	boshlog "bosh/logger"
+	boshsys "bosh/system"
+)
+
+type SimpleCmds struct {
+	runner boshsys.CmdRunner
+	logger boshlog.Logger
+}
+
+func NewSimpleCmds(
+	runner boshsys.CmdRunner,
+	logger boshlog.Logger,
+) SimpleCmds {
+	return SimpleCmds{
+		runner: runner,
+		logger: logger,
+	}
+}
+
+func (r SimpleCmds) MkdirP(path string) error {
+	return r.run("mkdir", "-p", path)
+}
+
+func (r SimpleCmds) ChmodX(path string) error {
+	return r.run("chmod", "+x", path)
+}
+
+func (r SimpleCmds) Touch(path string) error {
+	return r.run("touch", path)
+}
+
+func (r SimpleCmds) Mv(srcPath, dstPath string) error {
+	return r.run("mv", srcPath, dstPath)
+}
+
+func (r SimpleCmds) Chmod(mode, path string) error {
+	return r.run("chmod", mode, path)
+}
+
+func (r SimpleCmds) Chown(user, group, path string) error {
+	return r.run("chmod", user+":"+group, path)
+}
+
+func (r SimpleCmds) Bash(script string) error {
+	return r.run("bash", "-c", script)
+}
+
+func (r SimpleCmds) run(cmd string, args ...string) error {
+	_, _, _, err := r.runner.RunCommand(cmd, args...)
+	return err
+}

data/go/src/boshprovisioner/vm/vcap_user_provisioner.go

@@ -0,0 +1,120 @@
+package vm
+
+import (
+	bosherr "bosh/errors"
+	boshlog "bosh/logger"
+	boshsys "bosh/system"
+
+	bpeventlog "boshprovisioner/eventlog"
+)
+
+const vcapUserProvisionerLogTag = "VCAPUserProvisioner"
+
+// VCAPUserProvisioner adds and configures vcap user.
+type VCAPUserProvisioner struct {
+	cmds     SimpleCmds
+	runner   boshsys.CmdRunner
+	eventLog bpeventlog.Log
+	logger   boshlog.Logger
+}
+
+func NewVCAPUserProvisioner(
+	cmds SimpleCmds,
+	runner boshsys.CmdRunner,
+	eventLog bpeventlog.Log,
+	logger boshlog.Logger,
+) VCAPUserProvisioner {
+	return VCAPUserProvisioner{
+		cmds:     cmds,
+		runner:   runner,
+		eventLog: eventLog,
+		logger:   logger,
+	}
+}
+
+func (p VCAPUserProvisioner) Provision() error {
+	stage := p.eventLog.BeginStage("Setting up vcap user", 2)
+
+	task := stage.BeginTask("Adding vcap user")
+
+	err := task.End(p.setUpVcapUser())
+	if err != nil {
+		return bosherr.WrapError(err, "Setting up vcap user")
+	}
+
+	task = stage.BeginTask("Harden permissions")
+
+	err = task.End(p.hardenPermissinons())
+	if err != nil {
+		return bosherr.WrapError(err, "Harden permissions")
+	}
+
+	return nil
+}
+
+func (p VCAPUserProvisioner) setUpVcapUser() error {
+	p.logger.Info(vcapUserProvisionerLogTag, "Setting up vcap user")
+
+	userBash := `
+    groupadd --system admin
+    useradd -m --comment 'BOSH System User' vcap
+
+    echo "vcap:c1oudc0w" | chpasswd
+    echo "root:c1oudc0w" | chpasswd
+
+    usermod -G admin,adm,audio,cdrom,dialout,floppy,video,dip,plugdev vcap
+    usermod -s /bin/bash vcap
+  `
+
+	err := p.cmds.Bash(userBash)
+	if err != nil {
+		return err
+	}
+
+	// todo setup vcap no-password sudo access
+	_, _, _, err = p.runner.RunCommand("usermod", "-a", "-G", "vcap", "vagrant")
+	if err != nil {
+		return err
+	}
+
+	envBashs := []string{
+		"echo 'export PATH=/var/vcap/bosh/bin:$PATH' >> /root/.bashrc",
+		"echo 'export PATH=/var/vcap/bosh/bin:$PATH' >> /home/vcap/.bashrc",
+
+		// Configure vcap user locale (postgres initdb fails if mismatched)
+		"echo 'LANG=en_US.UTF-8\nLC_ALL=en_US.UTF-8' > /etc/default/locale",
+	}
+
+	for _, bash := range envBashs {
+		err := p.cmds.Bash(bash)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (p VCAPUserProvisioner) hardenPermissinons() error {
+	permsBash := `
+    echo 'vcap' > /etc/cron.allow
+    echo 'vcap' > /etc/at.allow
+
+    chmod 0770 /var/lock
+    chown -h root:vcap /var/lock
+    chown -LR root:vcap /var/lock
+
+    chmod 0640 /etc/cron.allow
+    chown root:vcap /etc/cron.allow
+
+    chmod 0640 /etc/at.allow
+    chown root:vcap /etc/at.allow
+  `
+
+	err := p.cmds.Bash(permsBash)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

data/go/src/boshprovisioner/vm/vm.go

@@ -0,0 +1,19 @@
+package vm
+
+import (
+	bpagclient "boshprovisioner/agent/client"
+)
+
+// VM represents already provisioned machine
+// that can be communicated with via an AgentClient.
+type VM struct {
+	agentClient bpagclient.Client
+}
+
+func NewVM(agentClient bpagclient.Client) VM {
+	return VM{agentClient: agentClient}
+}
+
+func (vm VM) AgentClient() bpagclient.Client {
+	return vm.agentClient
+}

data/go/src/boshprovisioner/vm/vm_provisioner.go

@@ -0,0 +1,57 @@
+package vm
+
+import (
+	bosherr "bosh/errors"
+	boshlog "bosh/logger"
+
+	bpdep "boshprovisioner/deployment"
+)
+
+const vmProvisionerLogTag = "VMProvisioner"
+
+// VMProvisioner installs system dependencies that
+// are usually found on a stemcell, adds vcap user,
+// and finally install Agent and Monit.
+type VMProvisioner struct {
+	vcapUserProvisioner VCAPUserProvisioner
+	depsProvisioner     DepsProvisioner
+	agentProvisioner    AgentProvisioner
+
+	logger boshlog.Logger
+}
+
+func NewVMProvisioner(
+	vcapUserProvisioner VCAPUserProvisioner,
+	depsProvisioner DepsProvisioner,
+	agentProvisioner AgentProvisioner,
+	logger boshlog.Logger,
+) VMProvisioner {
+	return VMProvisioner{
+		vcapUserProvisioner: vcapUserProvisioner,
+		depsProvisioner:     depsProvisioner,
+		agentProvisioner:    agentProvisioner,
+
+		logger: logger,
+	}
+}
+
+func (p VMProvisioner) Provision(instance bpdep.Instance) (VM, error) {
+	var vm VM
+
+	err := p.vcapUserProvisioner.Provision()
+	if err != nil {
+		return vm, bosherr.WrapError(err, "Provisioning vcap user")
+	}
+
+	err = p.depsProvisioner.Provision()
+	if err != nil {
+		return vm, bosherr.WrapError(err, "Provisioning dependencies")
+	}
+
+	agentClient, err := p.agentProvisioner.Provision(instance)
+	if err != nil {
+		return vm, bosherr.WrapError(err, "Provisioning agent")
+	}
+
+	return NewVM(agentClient), nil
+}

data/go/src/boshprovisioner/vm/vm_provisioner_factory.go

@@ -0,0 +1,97 @@
+package vm
+
+import (
+	boshlog "bosh/logger"
+	boshsys "bosh/system"
+
+	bpeventlog "boshprovisioner/eventlog"
+)
+
+type VMProvisionerFactory struct {
+	fs     boshsys.FileSystem
+	runner boshsys.CmdRunner
+
+	assetsDir       string
+	mbus            string
+	blobstoreConfig map[string]interface{}
+
+	eventLog bpeventlog.Log
+	logger   boshlog.Logger
+}
+
+func NewVMProvisionerFactory(
+	fs boshsys.FileSystem,
+	runner boshsys.CmdRunner,
+	assetsDir string,
+	mbus string,
+	blobstoreConfig map[string]interface{},
+	eventLog bpeventlog.Log,
+	logger boshlog.Logger,
+) VMProvisionerFactory {
+	return VMProvisionerFactory{
+		fs:     fs,
+		runner: runner,
+
+		assetsDir:       assetsDir,
+		mbus:            mbus,
+		blobstoreConfig: blobstoreConfig,
+
+		eventLog: eventLog,
+		logger:   logger,
+	}
+}
+
+func (f VMProvisionerFactory) NewVMProvisioner() VMProvisioner {
+	cmds := NewSimpleCmds(f.runner, f.logger)
+
+	vcapUserProvisioner := NewVCAPUserProvisioner(
+		cmds,
+		f.runner,
+		f.eventLog,
+		f.logger,
+	)
+
+	assetManager := NewAssetManager(f.assetsDir, f.fs, f.runner, f.logger)
+
+	runitProvisioner := NewRunitProvisioner(
+		f.fs,
+		cmds,
+		f.runner,
+		assetManager,
+		f.logger,
+	)
+
+	monitProvisioner := NewMonitProvisioner(
+		cmds,
+		assetManager,
+		runitProvisioner,
+		f.logger,
+	)
+
+	depsProvisioner := NewDepsProvisioner(
+		f.runner,
+		f.eventLog,
+		f.logger,
+	)
+
+	agentProvisioner := NewAgentProvisioner(
+		f.fs,
+		cmds,
+		assetManager,
+		runitProvisioner,
+		monitProvisioner,
+		f.blobstoreConfig,
+		f.mbus,
+		f.eventLog,
+		f.logger,
+	)
+
+	vmProvisioner := NewVMProvisioner(
+		vcapUserProvisioner,
+		depsProvisioner,
+		agentProvisioner,
+		f.logger,
+	)
+
+	return vmProvisioner
+}

data/lib/vagrant-bosh/asset_uploader.rb

@@ -0,0 +1,53 @@
+require "log4r"
+require "tempfile"
+require "securerandom"
+
+module VagrantPlugins
+  module VagrantBosh
+    class AssetUploader
+      def initialize(communicator, ui, assets_path)
+        @c = communicator
+        @ui = ui.for(:asset_uploader)
+        @assets_path = assets_path
+        @logger = Log4r::Logger.new("vagrant::provisioners::bosh::asset_uploader")
+      end
+
+      def sync(dst_path)
+        @ui.timed_msg(:upload, dst_path: dst_path) do
+          upload_path(@assets_path, dst_path)
+        end
+      end
+
+      def upload_text(text, dst_path)
+        @ui.timed_msg(:upload, dst_path: dst_path) do
+          begin
+            f = Tempfile.new("asset-uploader-upload-text")
+            f.write(text)
+            f.flush
+            upload_path(f.path, dst_path)
+          ensure
+            f.close if f
+          end
+        end
+      end
+
+      private
+
+      def upload_path(src_path, dst_path)
+        dst_tmp_path = "/tmp/#{SecureRandom.hex(5)}"
+
+        @c.upload(src_path, dst_tmp_path)
+
+        if File.directory?(src_path)
+          @c.mkdir_p(dst_path) # create nested dst path
+          @c.rm_rf(dst_path)
+          @c.mv(dst_tmp_path, dst_path)
+          @c.chown("root", "root", dst_path, true)
+        else
+          @c.mv(dst_tmp_path, dst_path)
+          @c.chown("root", "root", dst_path)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-bosh/assets/agent/agent-log

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+set -e
+
+exec svlogd -tt /var/vcap/bosh/log

data/lib/vagrant-bosh/assets/agent/agent-run

@@ -0,0 +1,12 @@
+#!/bin/bash
+
+set -e
+
+export PATH=/var/vcap/bosh/bin:$PATH
+
+exec 2>&1
+
+# Get into directory with agent.{cert,key}
+cd /var/vcap/bosh
+
+exec nice -n -10 /var/vcap/bosh/bin/bosh-agent -I warden -P ubuntu -C /var/vcap/bosh/agent.json

data/lib/vagrant-bosh/assets/agent/agent.cert

@@ -0,0 +1,18 @@
+-----BEGIN CERTIFICATE-----
+MIIC3zCCAcegAwIBAgIBADANBgkqhkiG9w0BAQUFADAzMQswCQYDVQQGEwJVUzEQ
+MA4GA1UECgwHUGl2b3RhbDESMBAGA1UEAwwJbG9jYWxob3N0MB4XDTEzMTIwMTIy
+MTEzMloXDTE2MTIwMTIyMTEzMlowMzELMAkGA1UEBhMCVVMxEDAOBgNVBAoMB1Bp
+dm90YWwxEjAQBgNVBAMMCWxvY2FsaG9zdDCCASIwDQYJKoZIhvcNAQEBBQADggEP
+ADCCAQoCggEBALra3YIx0O6PLcQsHAXbFzJye1M/Am3gCMcX5BTui+I7vfyMXG4w
+FyXHLf9lWwe23ypvP4c1+LNTq7UTTZuidrnadlADgdDned0C09bOKv5Nzk466XTR
+fNyBEyxaZzHQLa9SmDLgq1GUun8oEsxZ+uXhMq6kikRu5LBCChtVCW6LzG/FE1qm
+jSSH6iaOwk2yQxKVqUKNPfz1PqtRgaUBjVWrh2+Wf22KzOTORouBOrSfdxep1Cjz
+lQWt2W5l05dvf2vZTlaqDCk8PBF36FWPlwmZxRsHGACVuckl3yJ69jIaa+i+mK3k
+cfi05ZafWeFwm21ahqzwK/kGsK1ofPHKxE8CAwEAATANBgkqhkiG9w0BAQUFAAOC
+AQEAD1VzwtWCx32pQi5l0oFfjWqktnqfhs/Rr0ZpwacBBXHBvKuz9ENXmblt5pZu
+JP7je+uXQD+da/oVhl0US2L0upIdMmD1utVXYHfRji5r/tIPl2SEKTrFiNZR1Wp6
+J0nE/BW7nm41dXRBIAZR71yproaQrt1tFDFZvdfhwHGLC51L6toOhk/7S604sxbk
+qV0tzT+VaR4hh09FEt9xGmB/3yFh329Yib8ScT94nKzSzoNoDp4Ms/smFhF4lUio
+7SD2+b2/nt8Mcz7q58nYvZteipRrmkOFszlNF5dU31FjvRLITn0bhiOOFRD3qAou
+cSOr1qwsAKuu6MzYNh2ubsLvfg==
+-----END CERTIFICATE-----

data/lib/vagrant-bosh/assets/agent/agent.json

@@ -0,0 +1,9 @@
+{
+  "Platform": {
+    "Linux": {
+      "UseDefaultTmpDir": true,
+      "UsePreformattedPersistentDisk": true,
+      "BindMountPersistentDisk": true
+    }
+  }
+}

data/lib/vagrant-bosh/assets/agent/agent.key

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEogIBAAKCAQEAutrdgjHQ7o8txCwcBdsXMnJ7Uz8CbeAIxxfkFO6L4ju9/Ixc
+bjAXJcct/2VbB7bfKm8/hzX4s1OrtRNNm6J2udp2UAOB0Od53QLT1s4q/k3OTjrp
+dNF83IETLFpnMdAtr1KYMuCrUZS6fygSzFn65eEyrqSKRG7ksEIKG1UJbovMb8UT
+WqaNJIfqJo7CTbJDEpWpQo09/PU+q1GBpQGNVauHb5Z/bYrM5M5Gi4E6tJ93F6nU
+KPOVBa3ZbmXTl29/a9lOVqoMKTw8EXfoVY+XCZnFGwcYAJW5ySXfInr2Mhpr6L6Y
+reRx+LTllp9Z4XCbbVqGrPAr+QawrWh88crETwIDAQABAoIBAFh3DrB5TWXku9JI
+3+uV0uG7ec/r4QaMLxuzn/SZC/lMN6K+AXTZp9vm9UwZfIOmfPnmObmWP+0HDCBq
+xy+MN5G+cI1pW6jALt4IXKsyaQCFbctz8Nux4t+y7JTvKDRZT4fWHuDXpcS2GaXi
+HyRI5ZS4jfpJRH0p03PvkEFofVKsZfLAlwnx7HhPqztyc6huu7njjP6XUYbvrhOS
+otE/wyyLyT36rQvUVLHfrco2Ib1r58sWb1hL84/5HnbxwsEelBAAGL5VGu2f0zLP
+qxmy4XWJg9U/UKzG9gXmbcpDUn1pUcZV1rSSJ/wfbdvBSLF+dQaE6QdjGeAyrt7M
+I7gCViECgYEA5ui1aXomHIwqbzll/qotebYNL8AOcpgRJTtzODcnzoe/5aA7yVox
+vOFTD9rODaVRhtdC/ZHsU6rID+tx9gQdjLUEXUqS3KsPXSiwbYBPXnEtpgWz/RAu
+qpxpMn3kfVbQgJjkfksWvlHNzLj5q4ZhZyL/WV3P9DON8vuP/hwwQLMCgYEAzyiv
+rXx/ERnEQOpXEvPtCj04QUGCyW2o4nYIrN3OfO3PM8PnNfB8Z2LKDyuzX9qvWghg
+z81KSNByW4OLdvrnX5natfxdu/6qAl18N+z/DFXuTgXi8nG9/2R5c3Gn5CQ5yab7
+S4G4Pt7YwfoiqFv9j2b0DE3e5UVicGQIuWmaQ/UCgYBf61swraUXRsJ54YYU++xY
+Gt/vbgCSacj1hnSebYsDqDB22tD7G5R9ubwfYe0mjf4H3XPekbdyKgdhVZTJdXww
+7yEY/9lyAT0onbZsRliyCqHDzaqu/QHlrYOljdZUmrOSN/Dy5Y5VEPZEjLJqJjBf
+/5HDNc0kzCWzQfzWui7xMQKBgGNA8ysEAz2GQul3XdDO3juRqWpaoPcxe0FFnFJ2
+04A30JbUveqyFmjShE1QetjqRim06e2mRnksph4CoMeY31KGvKuFBsQT+BC6CdIh
+0vFuGod3eoz+wjGjSi1tvysn0Cg1wSEkPcqhqukFl6VirdIPWc6rYKgo3klLJILx
+feAhAoGABC0apuKQD2IZZXZtDuUI9I4AemPPh0yKvFfTJxmxQ0fTlWjqdcG5nYdh
+tSMBlZwsd6DRlK7dWJ/WHZXuXNeOX6ehSQFmql5/XPNd7INa5My6DDPZr1chh0WJ
+QgK94NXJDoDd1OZjpUBMPLVa8d20/RdGNW8OMolJpzEPhg0r7Ac=
+-----END RSA PRIVATE KEY-----