grenache-nodejs-http 0.7.13 → 1.0.1

package/test/peer-rpc-server-secure-buffered.js

@@ -0,0 +1,262 @@
+/* eslint-env mocha */
+
+const assert = require('assert')
+const { PassThrough } = require('stream')
+const fs = require('fs')
+const path = require('path')
+const { PeerRPCClient, PeerRPCServer } = require('../')
+const Link = require('grenache-nodejs-link')
+const setupHooks = require('./before-after.js')
+
+const PORT = 1337
+let link, peer, peerSrvBuf, serviceBuf, stop
+describe('RPC integration', () => {
+  setupHooks((grapes) => {
+    link = new Link({
+      grape: 'http://127.0.0.1:30001'
+    })
+    link.start()
+
+    peer = new PeerRPCClient(link, {
+      secure: {
+        key: fs.readFileSync(path.join(__dirname, './certs/client1-key.pem')),
+        cert: fs.readFileSync(path.join(__dirname, './certs/client1-crt.pem')),
+        ca: fs.readFileSync(path.join(__dirname, './certs/ca-crt.pem')),
+        rejectUnauthorized: false // take care, can be dangerous in production!
+      }
+    })
+    peer.init()
+
+    peerSrvBuf = new PeerRPCServer(link, {
+      secure: {
+        key: fs.readFileSync(path.join(__dirname, './certs/server-key.pem')),
+        cert: fs.readFileSync(path.join(__dirname, './certs/server-crt.pem')),
+        ca: fs.readFileSync(path.join(__dirname, './certs/ca-crt.pem')),
+        requestCert: true,
+        rejectUnauthorized: false // take care, can be dangerous in production!
+      },
+      timeout: 300000
+    })
+
+    peerSrvBuf.init()
+    serviceBuf = peerSrvBuf.transport('buffered')
+    serviceBuf.listen(PORT)
+
+    link.announce('rpc_buf', serviceBuf.port, {}, (err, res) => {
+      if (err) throw Error('error in announce, setup')
+    })
+
+    stop = () => {
+      peer.stop()
+      link.stop()
+      serviceBuf.stop()
+    }
+  })
+
+  it('buffered parsing works, objects', (done) => {
+    serviceBuf.on('request', (rid, key, payload, handler, cert, meta) => {
+      assert.ok(typeof rid === 'string')
+      assert.strictEqual(key, 'rpc_buf')
+      assert.deepStrictEqual(payload, { hello: 'world' })
+
+      assert.strictEqual(meta.isStream, false)
+
+      handler.reply(null, { hello: 'helloworld' })
+    })
+
+    const opts = { timeout: 100000 }
+    peer.request('rpc_buf', { hello: 'world' }, opts, (err, result) => {
+      if (err) throw err
+
+      assert.deepStrictEqual(result, { hello: 'helloworld' })
+
+      stop()
+      done()
+    })
+  }).timeout(7000)
+
+  it('buffered parsing works, strings', (done) => {
+    serviceBuf.on('request', (rid, key, payload, handler, cert, meta) => {
+      assert.ok(typeof rid === 'string')
+      assert.strictEqual(key, 'rpc_buf')
+      assert.strictEqual(payload, 'hello')
+
+      assert.strictEqual(meta.isStream, false)
+
+      handler.reply(null, 'world')
+    })
+
+    const opts = { timeout: 100000 }
+    peer.request('rpc_buf', 'hello', opts, (err, result) => {
+      if (err) throw err
+
+      assert.strictEqual(result, 'world')
+
+      stop()
+      done()
+    })
+  }).timeout(7000)
+
+  it('buffered parsing works, compressed strings', (done) => {
+    serviceBuf.on('request', (rid, key, payload, handler, cert, meta) => {
+      assert.ok(typeof rid === 'string')
+      assert.strictEqual(key, 'rpc_buf')
+      assert.strictEqual(payload, 'hello')
+
+      assert.strictEqual(meta.isStream, false)
+      assert.strictEqual(meta.compress, true)
+
+      handler.reply(null, 'world')
+    })
+
+    const opts = { timeout: 100000, compress: true }
+    peer.request('rpc_buf', 'hello', opts, (err, result) => {
+      if (err) throw err
+
+      assert.strictEqual(result, 'world')
+
+      stop()
+      done()
+    })
+  }).timeout(7000)
+
+  it('buffered parsing works, strings from streaming client', (done) => {
+    serviceBuf.on('request', (rid, key, payload, handler, cert, meta) => {
+      assert.ok(typeof rid === 'string')
+      assert.strictEqual(key, 'rpc_buf')
+      assert.strictEqual(payload, 'hello')
+
+      assert.strictEqual(meta.isStream, true)
+
+      handler.reply(null, 'world')
+    })
+
+    const req = peer.stream('rpc_buf', {
+      timeout: 10000
+    })
+
+    req
+      .on('data', (data) => {
+        const d = JSON.parse(data.toString())
+        // ["65c5737f-bbce-40f9-b48a-af8bd8869d66",null,"world"]
+        assert.strictEqual(d[1], null)
+        assert.strictEqual(d[2], 'world')
+        stop()
+        done()
+      })
+      .on('end', () => {})
+      .on('error', (e) => { console.error(e) })
+
+    const writable = new PassThrough()
+    writable.write('["UUID", "rpc_buf", "hello"]')
+    writable.end()
+    writable.pipe(req)
+  }).timeout(7000)
+
+  it('buffered parsing works, objects from streaming client', (done) => {
+    serviceBuf.on('request', (rid, key, payload, handler, cert, meta) => {
+      assert.ok(typeof rid === 'string')
+      assert.strictEqual(key, 'rpc_buf')
+      assert.deepStrictEqual(payload, { hello: 'world' })
+
+      assert.strictEqual(meta.isStream, true)
+
+      handler.reply(null, { hello: 'helloworld' })
+    })
+
+    const req = peer.stream('rpc_buf', {
+      timeout: 10000
+    })
+
+    req
+      .on('data', (data) => {
+        const d = JSON.parse(data.toString())
+        assert.strictEqual(d[1], null)
+        assert.deepStrictEqual(d[2], { hello: 'helloworld' })
+        stop()
+        done()
+      })
+      .on('end', () => {})
+      .on('error', (e) => { console.error(e) })
+
+    const writable = new PassThrough()
+    writable.write('["UUID", "rpc_buf", { "hello": "world" }]')
+    writable.end()
+    writable.pipe(req)
+  }).timeout(7000)
+
+  it('buffered parsing works, extra headers', (done) => {
+    serviceBuf.on('request', (rid, key, payload, handler, cert, meta) => {
+      assert.ok(typeof rid === 'string')
+      assert.strictEqual(key, 'rpc_buf')
+      assert.deepStrictEqual(payload, { hello: 'world' })
+
+      assert.strictEqual(meta.action, 'uploadPublic')
+      assert.deepStrictEqual(meta.args, { foo: 'bar' })
+      assert.strictEqual(meta.isStream, true)
+
+      handler.reply(null, { hello: 'helloworld' })
+    })
+
+    const req = peer.stream('rpc_buf', {
+      timeout: 10000,
+      headers: { _a: 'uploadPublic', _ar: { foo: 'bar' } }
+    })
+
+    req
+      .on('data', (data) => {
+        const d = JSON.parse(data.toString())
+        assert.strictEqual(d[1], null)
+        assert.deepStrictEqual(d[2], { hello: 'helloworld' })
+        stop()
+        done()
+      })
+      .on('end', () => {})
+      .on('error', (e) => { console.error(e) })
+
+    const writable = new PassThrough()
+    writable.write('["UUID", "rpc_buf", { "hello": "world" }]')
+    writable.end()
+    writable.pipe(req)
+  }).timeout(7000)
+
+  it('buf/buf: serialized files work', (done) => {
+    serviceBuf.on('request', (rid, key, payload, handler, cert, meta) => {
+      assert.ok(typeof rid === 'string')
+      assert.strictEqual(key, 'rpc_buf')
+
+      assert.strictEqual(payload.action, 'uploadPublic')
+      assert.strictEqual(payload.args[1].key, 'example-amazon-dynamo-sosp2007-4.pdf')
+      assert.strictEqual(typeof payload.args[0], 'string')
+
+      assert.strictEqual(meta.isStream, false)
+
+      handler.reply(null, 'ok')
+    })
+
+    const opts = { timeout: 100000 }
+    const buf = fs.readFileSync(
+      path.join(__dirname, './example-amazon-dynamo-sosp2007.pdf')
+    )
+
+    const optsPdf = {
+      key: 'example-amazon-dynamo-sosp2007-4.pdf',
+      acl: 'public-read',
+      bucket: 'bfx-dev-robert',
+      contentType: 'application/pdf'
+    }
+
+    const queryUploadPublicPdf = {
+      action: 'uploadPublic',
+      args: [buf.toString('hex'), optsPdf]
+    }
+    peer.request('rpc_buf', queryUploadPublicPdf, opts, (err, result) => {
+      if (err) throw err
+
+      assert.deepStrictEqual(result, 'ok')
+
+      stop()
+      done()
+    })
+  }).timeout(7000)
+})

package/test/peer-rpc-server-secure-streaming.js

@@ -0,0 +1,224 @@
+/* eslint-env mocha */
+
+const assert = require('assert')
+const fs = require('fs')
+const path = require('path')
+const { PassThrough } = require('stream')
+const { PeerRPCClient, PeerRPCServer } = require('../')
+const Link = require('grenache-nodejs-link')
+const setupHooks = require('./before-after.js')
+
+const PORT = 1337
+let link, peer, peerSrvStr, serviceStr, stop
+describe('RPC integration', () => {
+  setupHooks((grapes) => {
+    link = new Link({
+      grape: 'http://127.0.0.1:30001'
+    })
+    link.start()
+
+    peer = new PeerRPCClient(link, {
+      secure: {
+        key: fs.readFileSync(path.join(__dirname, './certs/client1-key.pem')),
+        cert: fs.readFileSync(path.join(__dirname, './certs/client1-crt.pem')),
+        ca: fs.readFileSync(path.join(__dirname, './certs/ca-crt.pem')),
+        rejectUnauthorized: false // take care, can be dangerous in production!
+      }
+    })
+    peer.init()
+
+    peerSrvStr = new PeerRPCServer(link, {
+      secure: {
+        key: fs.readFileSync(path.join(__dirname, './certs/server-key.pem')),
+        cert: fs.readFileSync(path.join(__dirname, './certs/server-crt.pem')),
+        ca: fs.readFileSync(path.join(__dirname, './certs/ca-crt.pem')),
+        requestCert: true,
+        rejectUnauthorized: false // take care, can be dangerous in production!
+      },
+      timeout: 300000,
+      disableBuffered: true
+    })
+
+    peerSrvStr.init()
+    serviceStr = peerSrvStr.transport('stream')
+    serviceStr.listen(PORT)
+
+    link.announce('rpc_stream', serviceStr.port, {}, (err, res) => {
+      if (err) throw Error('error in announce, setup')
+    })
+
+    stop = () => {
+      peer.stop()
+      link.stop()
+      serviceStr.stop()
+    }
+  })
+
+  it('streaming works, objects, buffered client, reply handler', (done) => {
+    serviceStr.on('stream', (req, res, meta, handler) => {
+      assert.strictEqual(meta.isStream, false)
+
+      req.on('data', (d) => {
+        const [rid, key, args] = JSON.parse(d.toString())
+
+        assert.deepStrictEqual(args, { hello: 'world' })
+        assert.ok(typeof rid === 'string')
+        assert.strictEqual(key, 'rpc_stream')
+
+        handler.reply(rid, null, { hello: 'helloworld' })
+      })
+    })
+
+    const opts = { timeout: 100000 }
+    peer.request('rpc_stream', { hello: 'world' }, opts, (err, result) => {
+      if (err) throw err
+      assert.deepStrictEqual(result, { hello: 'helloworld' })
+
+      stop()
+      done()
+    })
+  }).timeout(7000)
+
+  it('streaming works, string, buffered client, reply handler', (done) => {
+    serviceStr.on('stream', (req, res, meta, handler) => {
+      assert.strictEqual(meta.isStream, false)
+
+      req.on('data', (d) => {
+        const [rid, key, args] = JSON.parse(d.toString())
+
+        assert.strictEqual(args, 'hello')
+        assert.ok(typeof rid === 'string')
+        assert.strictEqual(key, 'rpc_stream')
+
+        handler.reply(rid, null, 'world')
+      })
+    })
+
+    const opts = { timeout: 100000 }
+    peer.request('rpc_stream', 'hello', opts, (err, result) => {
+      if (err) throw err
+      assert.strictEqual(result, 'world')
+
+      stop()
+      done()
+    })
+  }).timeout(7000)
+
+  it('streaming works, string, buffered client, stream sent back', (done) => {
+    serviceStr.on('stream', (req, res, meta, handler) => {
+      assert.strictEqual(meta.isStream, false)
+
+      req.on('data', (d) => {
+        const [rid, key, args] = JSON.parse(d.toString())
+
+        assert.strictEqual(args, 'hello')
+        assert.ok(typeof rid === 'string')
+        assert.strictEqual(key, 'rpc_stream')
+
+        const writable = new PassThrough()
+        const payload = JSON.stringify([rid, null, 'world2'])
+        writable.pipe(res)
+        writable.write(payload)
+        writable.end()
+      })
+    })
+
+    const opts = { timeout: 100000 }
+    peer.request('rpc_stream', 'hello', opts, (err, result) => {
+      if (err) throw err
+      assert.strictEqual(result, 'world2')
+
+      stop()
+      done()
+    })
+  }).timeout(7000)
+
+  it('streaming works, buffer, stream client, stream on server', (done) => {
+    const reqPayload = Buffer.from('megalargefile')
+    const resPayload = Buffer.from('superlargefile')
+
+    serviceStr.on('stream', (req, res, meta, handler) => {
+      assert.strictEqual(meta.isStream, true)
+
+      req.on('data', (d) => {
+        const [rid, key] = meta.infoHeaders
+
+        assert.ok(d.equals(reqPayload), 'received Buffer equals payload on server')
+
+        assert.ok(typeof rid === 'string')
+        assert.strictEqual(key, 'rpc_stream')
+
+        const writable = new PassThrough()
+        writable.pipe(res)
+        writable.write(resPayload)
+        writable.end()
+      })
+    })
+
+    const req = peer.stream('rpc_stream', {
+      timeout: 10000
+    })
+
+    req
+      .on('data', (data) => {
+        assert.ok(data.equals(resPayload), 'received Buffer equals payload on client')
+
+        stop()
+        done()
+      })
+      .on('end', () => {})
+      .on('error', (e) => { console.error(e) })
+
+    const writable = new PassThrough()
+    writable.write(reqPayload)
+    writable.pipe(req)
+  }).timeout(7000)
+
+  it('streaming works, buffer, stream client, stream on server, additional headers', (done) => {
+    const reqPayload = Buffer.from('megalargefile')
+    const resPayload = Buffer.from('superlargefile')
+
+    serviceStr.on('stream', (req, res, meta, handler) => {
+      assert.strictEqual(meta.isStream, true)
+
+      req.on('data', (d) => {
+        const [rid, key] = meta.infoHeaders
+
+        assert.ok(d.equals(reqPayload), 'received Buffer equals payload on server')
+
+        assert.ok(typeof rid === 'string')
+        assert.strictEqual(key, 'rpc_stream')
+
+        assert.strictEqual(meta.action, 'uploadPublic')
+        assert.strictEqual(meta.args.foo, 'bar')
+
+        const writable = new PassThrough()
+        writable.pipe(res)
+        writable.write(resPayload)
+        writable.end()
+      })
+    })
+
+    const req = peer.stream('rpc_stream', {
+      timeout: 10000,
+      headers: {
+        _a: 'uploadPublic',
+        _ar: { foo: 'bar' }
+      }
+    })
+
+    req
+      .on('data', (data) => {
+        assert.ok(data.equals(resPayload), 'received Buffer equals payload on client')
+
+        stop()
+        done()
+      })
+      .on('end', () => {})
+      .on('error', (e) => { console.error(e) })
+
+    const writable = new PassThrough()
+    writable.write(reqPayload)
+    writable.pipe(req)
+  }).timeout(7000)
+})

package/test/peer-rpc-server-secure.js

@@ -0,0 +1,96 @@
+/* eslint-env mocha */
+
+const assert = require('assert')
+const fs = require('fs')
+const path = require('path')
+const { PeerRPCClient, PeerRPCServer } = require('../')
+const Link = require('grenache-nodejs-link')
+const setupHooks = require('./before-after.js')
+
+const PORT = 1337
+let link, peer, peerSrv, service, stop
+describe('RPC integration', () => {
+  setupHooks((grapes) => {
+    link = new Link({
+      grape: 'http://127.0.0.1:30001'
+    })
+    link.start()
+
+    peer = new PeerRPCClient(link, {
+      secure: {
+        key: fs.readFileSync(path.join(__dirname, './certs/client1-key.pem')),
+        cert: fs.readFileSync(path.join(__dirname, './certs/client1-crt.pem')),
+        ca: fs.readFileSync(path.join(__dirname, './certs/ca-crt.pem')),
+        rejectUnauthorized: false // take care, can be dangerous in production!
+      }
+    })
+    peer.init()
+
+    peerSrv = new PeerRPCServer(link, {
+      secure: {
+        key: fs.readFileSync(path.join(__dirname, './certs/server-key.pem')),
+        cert: fs.readFileSync(path.join(__dirname, './certs/server-crt.pem')),
+        ca: fs.readFileSync(path.join(__dirname, './certs/ca-crt.pem')),
+        requestCert: true,
+        rejectUnauthorized: false // take care, can be dangerous in production!
+      },
+      timeout: 300000
+    })
+
+    peerSrv.init()
+    service = peerSrv.transport('server')
+    service.listen(PORT)
+
+    link.announce('rpc_test', service.port, {}, (err, res) => {
+      if (err) throw Error('error in announce, setup')
+    })
+
+    stop = () => {
+      peer.stop()
+      link.stop()
+      service.stop()
+    }
+  })
+
+  it('secure request, objects', (done) => {
+    service.on('request', (rid, key, payload, handler, cert) => {
+      assert.ok(typeof rid === 'string')
+      assert.strictEqual(key, 'rpc_test')
+      assert.deepStrictEqual(payload, { hello: 'world' })
+      assert.strictEqual(cert.fingerprint, 'E1:63:C1:46:B3:B6:46:3B:5E:92:98:34:40:A1:AB:FB:0E:92:D0:76')
+
+      handler.reply(null, { hello: 'helloworld' })
+    })
+
+    const opts = { timeout: 100000 }
+    peer.request('rpc_test', { hello: 'world' }, opts, (err, result) => {
+      if (err) throw err
+
+      assert.deepStrictEqual(result, { hello: 'helloworld' })
+
+      stop()
+      done()
+    })
+  }).timeout(7000)
+
+  it('secure map, strings', (done) => {
+    service.on('request', (rid, key, payload, handler, cert) => {
+      assert.ok(typeof rid === 'string')
+      assert.strictEqual(key, 'rpc_test')
+      assert.strictEqual(payload, 'hello')
+      assert.strictEqual(cert.fingerprint, 'E1:63:C1:46:B3:B6:46:3B:5E:92:98:34:40:A1:AB:FB:0E:92:D0:76')
+
+      handler.reply(null, 'world')
+    })
+
+    const opts = { timeout: 100000 }
+    peer.map('rpc_test', 'hello', opts, (err, result) => {
+      if (err) throw err
+
+      assert.deepStrictEqual(result, ['world'])
+
+      stop()
+      done()
+    })
+  }).timeout(7000)
+})

package/test/peer-rpc-server.js

@@ -0,0 +1,76 @@
+/* eslint-env mocha */
+
+const assert = require('assert')
+const { PeerRPCClient, PeerRPCServer } = require('../')
+const Link = require('grenache-nodejs-link')
+const setupHooks = require('./before-after.js')
+
+const PORT = 1337
+let link, peer, peerSrv, service, stop
+describe('RPC integration', () => {
+  setupHooks((grapes) => {
+    link = new Link({
+      grape: 'http://127.0.0.1:30001'
+    })
+    link.start()
+
+    peer = new PeerRPCClient(link, {})
+    peer.init()
+
+    peerSrv = new PeerRPCServer(link, { timeout: 300000 })
+
+    peerSrv.init()
+    service = peerSrv.transport('server')
+    service.listen(PORT)
+
+    link.announce('rpc_test', service.port, {}, (err, res) => {
+      if (err) throw Error('error in announce, setup')
+    })
+
+    stop = () => {
+      peer.stop()
+      link.stop()
+      service.stop()
+    }
+  })
+
+  it('secure request, objects', (done) => {
+    service.on('request', (rid, key, payload, handler) => {
+      assert.ok(typeof rid === 'string')
+      assert.strictEqual(key, 'rpc_test')
+      assert.deepStrictEqual(payload, { hello: 'world' })
+
+      handler.reply(null, { hello: 'helloworld' })
+    })
+
+    const opts = { timeout: 100000 }
+    peer.request('rpc_test', { hello: 'world' }, opts, (err, result) => {
+      if (err) throw err
+
+      assert.deepStrictEqual(result, { hello: 'helloworld' })
+
+      stop()
+      done()
+    })
+  }).timeout(7000)
+
+  it('secure map, strings', (done) => {
+    service.on('request', (rid, key, payload, handler) => {
+      assert.ok(typeof rid === 'string')
+      assert.strictEqual(key, 'rpc_test')
+      assert.strictEqual(payload, 'hello')
+
+      handler.reply(null, 'world')
+    })
+
+    const opts = { timeout: 100000 }
+    peer.map('rpc_test', 'hello', opts, (err, result) => {
+      if (err) throw err
+
+      assert.deepStrictEqual(result, ['world'])
+
+      stop()
+      done()
+    })
+  }).timeout(7000)
+})

package/examples/ssl/ca-crt.pem

@@ -1,32 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIFgDCCA2gCCQDvmZA10HvRHTANBgkqhkiG9w0BAQUFADCBgTELMAkGA1UEBhMC
-VVMxCzAJBgNVBAgMAk1BMQ8wDQYDVQQHDAZCb3N0b24xEzARBgNVBAoMCkV4YW1w
-bGUgQ28xEDAOBgNVBAsMB3RlY2hvcHMxCzAJBgNVBAMMAmNhMSAwHgYJKoZIhvcN
-AQkBFhFjZXJ0c0BleGFtcGxlLmNvbTAeFw0xNzA1MjIxMzQ0NDNaFw00NDEwMDYx
-MzQ0NDNaMIGBMQswCQYDVQQGEwJVUzELMAkGA1UECAwCTUExDzANBgNVBAcMBkJv
-c3RvbjETMBEGA1UECgwKRXhhbXBsZSBDbzEQMA4GA1UECwwHdGVjaG9wczELMAkG
-A1UEAwwCY2ExIDAeBgkqhkiG9w0BCQEWEWNlcnRzQGV4YW1wbGUuY29tMIICIjAN
-BgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA0SrOAQlmrQTqnXqSiKpvhb/nd79r
-59V8TY81yPiOaVXeIaCrIiDA66JzadzHHHHMt8sEsTI92BULNvQYsauRm8NmBPWJ
-YKYpUj0FguG7NzDLruCsBUq1faZyLLOA2Dr33gTzJFaVtvD0Z9ig2UjTSbqEnCcY
-fF6WkCcYWBE3xkyRZkuVZAaCu3PTKVvAkwxHkg4wS8feW/Z/VGLTmcd/lWvVgC1V
-Kl7wwubE/8MXwjJlQBzkU5WotFHgXJMnepQTuqu5ZlDpOZehLPQ16LUjUIu0xnIt
-8k+YJ3JXdvP5+ifx+0YK9NpoU717spKgsME4z1Q6foDiaGgwWJ5bZYXi2OVD64yj
-FqKN4gdpe037OwgTxCJ2FS23Ijndzi/K+AULYXbjXUo/D+CXuJ/MfOXo8DHfI1ld
-ZgiHw1co2f1KQmL+AJ/YAEoC3228JG31mvX2sXL2p65QU9DmTaOrAYCX/F5T1frs
-jsO560Zpvs6C7Di8eQjrx3UhMz8zYSLT35/0HPPoLA9dkJOEDpg3NtLMuN1MigNZ
-VxRyadXrka4q7s/mTS1+0NbJHv4JYwzYKa1pdFeX102I9GVS9VZXpmRqriki1Sh1
-rb7YOuK+I92HIzIVpSeI/OB7xguH8rh+/vibB72SY18FJWyfGcr8ewwkPSVocZeu
-9rCXIDLUY0Sojq8CAwEAATANBgkqhkiG9w0BAQUFAAOCAgEAbIPMMkzHlybXIr8z
-4Dp/3czyPWLwjFfgeL4wM5Hm/JMxaFnsWgmkUdrvjlYofzaF+2U29FsDgcrkcCzD
-gTCOOHG0Pw1i8R57Dt68ycP4/e0iPpMmuTpNSqB9DilGscKARhE85o0FivAUzvUY
-RngIOtbf02OoaRbkAsmKdC4+PBNJbiS3U5V55r2HCv0zqXMFj4dXqfyWKkcZt3JR
-8SkzUIhIVnwhTf8ZttXcsWmPMy3nqckcy6k3zLr7Gf63JJZAYecWwhydAtv4wRrm
-f3FwIvRxPLKTc/2YXF77I9YvHgnLOvE2qlLNnajQgOcIYGvxizDVCqnMS+8oBHWb
-uL6mZP4hOCL6ifynkAHltg59heM3WJ2MEwLjiSvMYY4otT4X9KxsRdsg0Gx96bVe
-P4RBlW3ebxcOnFuoMC3WT22/1ETqpQbrWOD5mJkFa6Q8aE6yWLLcdJznxF2M0Mf8
-PTh62cFJMC4E0gN9KRU+E/qBJsqTamHHAHjcaUYDBXsvtFDOlo1dbAzJylpwRUEg
-F115KpRH6DLLexS5YB9bASIsXBK+Afwm0FOjqGiEd527qAk5UiamyomKXxQ+DIbc
-6QdO7XGpM3molI7Zzf79O4QdlRNzNgqPeCRUJWe2L6G7KECNvNjWepN3+0xAq9BO
-t53fDsW6Y1yw2xErpMGUHBQ05y4=
------END CERTIFICATE-----

package/examples/ssl/ca-crt.srl

@@ -1 +0,0 @@
-C02FC8087C0EC89A