text: /*
    MIT License,
    Copyright (c) 2015-2017, Richard Rodger and other contributors.
  */
  
  'use strict'
  
  var Assert = require('assert')
  var Util = require('util')
  
  var Lab = require('lab')
  var Code = require('code')
  var Seneca = require('seneca')
  var Rif = require('rif')
  
  var lab = (exports.lab = Lab.script())
  var describe = lab.describe
  var it = lab.it
  var expect = Code.expect
  
  var Mesh = require('..')
  
  var intern = Mesh.intern
  
  var test_discover = {
    stop: true,
    guess: { active: true },
    multicast: { active: false },
    registry: { active: false }
  }
  
  describe('#mesh', function() {
    it('nextgen-single-with-base', { parallel: false, timeout: 5555 }, function(
      fin
    ) {
      var b0 = Seneca({ tag: 'b0', legacy: { transport: false } })
        .test(fin)
        .use('..', { base: true, discover: test_discover })
  
      var s0 = Seneca({ tag: 's0', legacy: { transport: false } })
        .test(fin)
        .add('a:1', function(msg, reply) {
          reply({ x: msg.x })
        })
  
      b0.ready(function() {
        s0.use('..', { pin: 'a:1', discover: test_discover }).ready(function() {
          b0.act('a:1,x:0', function(ignore, out) {
            Assert.equal(0, out.x)
  
            b0.act('a:1,x:1', function(ignore, out) {
              Assert.equal(1, out.x)
  
              s0.close(b0.close.bind(b0, setTimeout.bind(this, fin, 555)))
            })
          })
        })
      })
    })
  
    it('intern.resolve_bases', function(done) {
      var rif = make_rif()
  
      Assert.equal('', '' + intern.resolve_bases())
  
      Assert.equal(
        Mesh.DEFAULT_HOST +
          ':' +
          Mesh.DEFAULT_PORT +
          ',192.168.1.2:' +
          Mesh.DEFAULT_PORT,
        '' +
          intern.resolve_bases(
            [':' + Mesh.DEFAULT_PORT],
            { host: '192.168.1.2' },
            rif
          )
      )
  
      Assert.equal(
        'foo:' + Mesh.DEFAULT_PORT + ',' + 'bar:' + Mesh.DEFAULT_PORT,
        '' + intern.resolve_bases(['foo', 'bar'], null, rif)
      )
  
      Assert.equal(
        Mesh.DEFAULT_HOST + ':33333',
        '' + intern.resolve_bases([':33333'], null, rif)
      )
  
      Assert.equal(
        Mesh.DEFAULT_HOST + ':33333,' + 'zed:33333',
        '' + intern.resolve_bases([':33333'], { host: 'zed' }, rif)
      )
  
      Assert.equal(
        '127.0.0.1:' + Mesh.DEFAULT_PORT,
        '' + intern.resolve_bases(['@lo'], null, rif)
      )
  
      done()
    })
  
    it('intern.make_pin_config', function(done) {
      var si = Seneca({ log: 'silent' })
  
      expect(
        intern.make_pin_config(si, { identifier$: 'i0' }, 'a:1', {
          pin: 'a:1',
          x: 1
        })
      ).to.equal({
        id: 'pin:a:1,x:1~i0',
        pin: 'a:1',
        x: 1
      })
  
      expect(
        intern.make_pin_config(si, { identifier$: 'i0' }, 'a:1', {
          pins: [{ a: 1 }, 'b:1'],
          x: 1
        })
      ).to.equal({
        id: 'pin:a:1,x:1~i0',
        pin: 'a:1',
        x: 1
      })
  
      done()
    })
  
    it('intern.resolve_pins', function(done) {
      var si = Seneca({ log: 'silent' })
  
      expect(intern.resolve_pins(si, { pin: 'a:1' })).to.equal(['a:1'])
  
      expect(intern.resolve_pins(si, { pin: { a: 1 } })).to.equal(['a:1'])
  
      expect(intern.resolve_pins(si, { pins: 'a:1' })).to.equal(['a:1'])
  
      expect(intern.resolve_pins(si, { pins: { a: 1 } })).to.equal(['a:1'])
  
      expect(intern.resolve_pins(si, { pin: ['a:1'] })).to.equal(['a:1'])
  
      expect(intern.resolve_pins(si, { pin: [{ a: 1 }] })).to.equal(['a:1'])
  
      expect(intern.resolve_pins(si, { pins: ['a:1'] })).to.equal(['a:1'])
  
      expect(intern.resolve_pins(si, { pins: [{ a: 1 }] })).to.equal(['a:1'])
  
      expect(intern.resolve_pins(si, { pin: 'a:1,b:2' })).to.equal(['a:1,b:2'])
  
      expect(intern.resolve_pins(si, { pin: 'b:2,a:1' })).to.equal(['a:1,b:2'])
  
      expect(intern.resolve_pins(si, { pin: 'a:1;b:2' })).to.equal(['a:1', 'b:2'])
  
      expect(intern.resolve_pins(si, { pin: 'b:2;a:1' })).to.equal(['b:2', 'a:1'])
  
      expect(intern.resolve_pins(si, { pin: 'a:1;a:1' })).to.equal(['a:1', 'a:1'])
  
      expect(intern.resolve_pins(si, { pins: 'a:1;b:2' })).to.equal([
        'a:1',
        'b:2'
      ])
  
      expect(intern.resolve_pins(si, { pins: ['a:1;b:2'] })).to.equal([
        'a:1',
        'b:2'
      ])
  
      expect(intern.resolve_pins(si, { pins: [{ a: 1 }, { b: 2 }] })).to.equal([
        'a:1',
        'b:2'
      ])
  
      expect(intern.resolve_pins(si, { pins: ['a:1', 'b:2'] })).to.equal([
        'a:1',
        'b:2'
      ])
  
      expect(intern.resolve_pins(si, { pin: 'a:1,b:2;c:3' })).to.equal([
        'a:1,b:2',
        'c:3'
      ])
  
      expect(intern.resolve_pins(si, { pin: 'c:3;a:1,b:2' })).to.equal([
        'c:3',
        'a:1,b:2'
      ])
  
      done()
    })
  
    it('base', { timeout: 5555, parallel: false }, function(done) {
      Seneca({ tag: 'b0a', log: 'test', debug: { short_logs: true } })
        .error(done)
        .use('..', { isbase: true, discover: test_discover })
        .ready(function() {
          this.close(setTimeout.bind(this, done, 555))
        })
    })
  
    it('single-with-base', { parallel: false, timeout: 5555 }, function(done) {
      var b0b, s0b
  
      b0b = Seneca({ tag: 'b0b', log: 'silent', debug: { short_logs: true } })
        .error(done)
        .use('..', { isbase: true, discover: test_discover })
  
      s0b = Seneca({ tag: 's0b', log: 'silent', debug: { short_logs: true } })
        .error(done)
        .add('a:1', function(msg) {
          this.good({ x: msg.i })
        })
  
      b0b.ready(function() {
        s0b.use('..', { pin: 'a:1', discover: test_discover }).ready(function() {
          s0b.act('role:mesh,get:members', function(err, out) {
            if (err) {
              done(err)
            }
            Assert.equal(1, out.list.length)
  
            b0b.act('a:1,i:0', function(err, out) {
              if (err) {
                done(err)
              }
              Assert.equal(0, out.x)
  
              b0b.act('a:1,i:1', function(err, out) {
                if (err) {
                  done(err)
                }
                Assert.equal(1, out.x)
  
                s0b.close(b0b.close.bind(b0b, setTimeout.bind(this, done, 555)))
              })
            })
          })
        })
      })
    })
  
    it('happy', { parallel: false, timeout: 5555 }, function(fin) {
      var b0, s0, s1, c0
  
      b0 = Seneca({ id$: 'b0' })
        .test(fin)
        .use('..', {
          base: true,
          discover: test_discover,
          sneeze: { silent: true }
        })
  
      s0 = Seneca({ id$: 's0' })
        .test(fin)
        .use('..', {
          pin: 'a:1',
          discover: test_discover,
          sneeze: { silent: true }
        })
        .add('a:1', function(m, r) {
          r({ x: 0 })
        })
  
      s1 = Seneca({ id$: 's1' })
        .test(fin) //, 'print')
        .use('..', {
          pin: 'a:1',
          discover: test_discover,
          sneeze: { silent: true }
        })
        .add('a:1', function(m, r) {
          r({ x: 1 })
        })
        .add('a:1', function(m, r) {
          this.prior(m, r)
        })
  
      c0 = Seneca({ id$: 'c0' })
        .test(fin)
        .use('..', { discover: test_discover, sneeze: { silent: true } })
  
      b0.ready(
        s0.ready.bind(
          s0,
          s1.ready.bind(
            s1,
            c0.ready.bind(c0, function() {
              c0
                .gate()
                .act(
                  { role: 'transport', type: 'balance', get: 'target-map' },
                  function(e, o) {
                    expect(o['a:1']['a:1'].targets.length).equal(2)
                  }
                )
                .act({ role: 'mesh', get: 'members' }, function(e, o) {
                  expect(o.list.length).equal(3)
                })
                .act('a:1,s:0', function(e, o) {
                  expect(o.x).equal(0)
                })
                .act('a:1,s:1', function(e, o) {
                  expect(o.x).equal(1)
                })
                .act('a:1,s:2', function(e, o) {
                  expect(o.x).equal(0)
                })
                .ready(function() {
                  b0.act('role:mesh,get:members', function(e, o) {
                    expect(o.list.length).equal(3)
  
                    s0.close(
                      setTimeout.bind(
                        null,
                        function() {
                          c0
                            .act('a:1,s:3', function(e, o) {
                              expect(o.x).equal(1)
                            })
                            .act('a:1,s:4', function(e, o) {
                              expect(o.x).equal(1)
                            })
                            .close(s1.close.bind(s1, b0.close.bind(b0, fin)))
                        },
                        1555
                      )
                    )
                  })
                })
            })
          )
        )
      )
    })
  
    it('many-actors', { parallel: false, timeout: 19999 }, function(done) {
      var b0, s0, s1, s2, c0, c1
  
      b0 = Seneca({ tag: 'b0', log: 'test', debug: { short_logs: true } }).error(
        done
      )
  
      s0 = Seneca({ tag: 's0', log: 'test', debug: { short_logs: true } })
        .error(done)
        .add('a:1', function(m) {
          this.good({ x: m.x + 1 })
        })
  
      s1 = Seneca({ tag: 's1', log: 'test', debug: { short_logs: true } })
        .error(done)
        .add('a:1', function(m) {
          this.good({ x: m.x + 2 })
        })
  
      s2 = Seneca({ tag: 's2', log: 'test', debug: { short_logs: true } })
        .error(done)
        .add('a:1', function(m) {
          this.good({ x: m.x + 3 })
        })
  
      c0 = Seneca({ tag: 'c0', log: 'test', debug: { short_logs: true } }).error(
        done
      )
  
      c1 = Seneca({ tag: 'c1', log: 'test', debug: { short_logs: true } }).error(
        done
      )
  
      b0
        .use('..', {
          isbase: true,
          discover: test_discover,
          sneeze: { silent: true }
        })
        .ready(function() {
          s0
            .use('..', {
              pin: 'a:1',
              model: 'actor',
              discover: test_discover,
              sneeze: { silent: true }
            })
            .ready(function() {
              s1
                .use('..', {
                  pin: 'a:1',
                  model: 'actor',
                  discover: test_discover,
                  sneeze: { silent: true }
                })
                .ready(function() {
                  s2
                    .use('..', {
                      pin: 'a:1',
                      model: 'actor',
                      discover: test_discover,
                      sneeze: { silent: true }
                    })
                    .ready(function() {
                      c0
                        .use('..', {
                          discover: test_discover,
                          sneeze: { silent: true }
                        })
                        .ready(function() {
                          c1
                            .use('..', {
                              discover: test_discover,
                              sneeze: { silent: true }
                            })
                            .ready(setTimeout.bind(null, do_topology, 1222))
                        })
                    })
                })
            })
        })
  
      function do_topology() {
        c0.act('role:mesh,get:members', function(err, o) {
          if (err) {
            done(err)
          }
          Assert.equal(5, o.list.length)
  
          c1.act('role:mesh,get:members', function(err, o) {
            if (err) {
              done(err)
            }
            Assert.equal(5, o.list.length)
  
            c0.act(
              'role:transport,type:balance,get:target-map,pg:"a:1"',
              function(err, c0map) {
                if (err) {
                  done(err)
                }
                Assert.equal(3, c0map['a:1'].targets.length)
  
                c1.act(
                  'role:transport,type:balance,get:target-map,pg:"a:1"',
                  function(err, c1map) {
                    if (err) {
                      done(err)
                    }
                    Assert.equal(3, c1map['a:1'].targets.length)
  
                    do_actors(c0map, c1map)
                  }
                )
              }
            )
          })
        })
      }
  
      function do_actors(c0map, c1map) {
        // var i = 0
        // console.log(i++,'c0',c0map['a:1'].index,c0map.x,'c1',c1map['a:1'].index,c1map.x)
  
        c0.act('a:1,x:0', function(e, o) {
          // console.log(i++,'c0',c0map['a:1'].index,'c1',c1map['a:1'].index)
          Assert.equal(1, o.x)
  
          c1.act('a:1,x:0', function(e, o) {
            // console.log(i++,'c0',c0map['a:1'].index,'c1',c1map['a:1'].index)
            Assert.equal(1, o.x)
  
            c0.act('a:1,x:0', function(e, o) {
              Assert.equal(2, o.x)
  
              c1.act('a:1,x:0', function(e, o) {
                Assert.equal(2, o.x)
  
                c0.act('a:1,x:0', function(e, o) {
                  Assert.equal(3, o.x)
  
                  c1.act('a:1,x:0', function(e, o) {
                    Assert.equal(3, o.x)
  
                    c0.act('a:1,x:0', function(e, o) {
                      Assert.equal(1, o.x)
  
                      c1.act('a:1,x:0', function(e, o) {
                        Assert.equal(1, o.x)
  
                        c0.act('a:1,x:0', function(e, o) {
                          Assert.equal(2, o.x)
  
                          c1.act('a:1,x:0', function(e, o) {
                            Assert.equal(2, o.x)
  
                            c0.act('a:1,x:0', function(e, o) {
                              Assert.equal(3, o.x)
  
                              c1.act('a:1,x:0', function(e, o) {
                                Assert.equal(3, o.x)
  
                                s1.close(setTimeout.bind(this, do_s1_down, 2555))
                              })
                            })
                          })
                        })
                      })
                    })
                  })
                })
              })
            })
          })
        })
      }
  
      function do_s1_down() {
        c0.act('a:1,x:0', function(e, o) {
          Assert.equal(1, o.x)
  
          c1.act('a:1,x:0', function(e, o) {
            Assert.equal(1, o.x)
  
            c0.act('a:1,x:0', function(e, o) {
              Assert.equal(3, o.x)
  
              c1.act('a:1,x:0', function(e, o) {
                Assert.equal(3, o.x)
  
                c0.act('a:1,x:0', function(e, o) {
                  Assert.equal(1, o.x)
  
                  c1.act('a:1,x:0', function(e, o) {
                    Assert.equal(1, o.x)
  
                    c0.act('a:1,x:0', function(e, o) {
                      Assert.equal(3, o.x)
  
                      c1.act('a:1,x:0', function(e, o) {
                        Assert.equal(3, o.x)
  
                        c0.act('a:1,x:0', function(e, o) {
                          Assert.equal(1, o.x)
  
                          c1.act('a:1,x:0', function(e, o) {
                            Assert.equal(1, o.x)
  
                            c0.act('a:1,x:0', function(e, o) {
                              Assert.equal(3, o.x)
  
                              c1.act('a:1,x:0', function(e, o) {
                                Assert.equal(3, o.x)
  
                                close()
                              })
                            })
                          })
                        })
                      })
                    })
                  })
                })
              })
            })
          })
        })
      }
  
      function close() {
        c1.close()
        c0.close()
        s2.close()
        s0.close()
        b0.close()
        setTimeout(done, 1555)
      }
    })
  
    it('observe-consume-basic', { parallel: false, timeout: 9999 }, function(
      done
    ) {
      var b0, s0, s1, c0
      var s0x = 0
      var s1z = 0
      var s0y = []
      var s1y = []
  
      b0 = Seneca({ tag: 'b0', log: 'test' }).error(done)
  
      s0 = Seneca({ tag: 's0', log: 'test' })
        .error(done)
        .add('a:1', function(m) {
          this.good({ x: m.x + ++s0x })
        })
        .add('b:1', function(m) {
          s0y.push(m.y)
          this.good()
        })
  
      s1 = Seneca({ tag: 's1', log: 'test' })
        .error(done)
        .add('b:1', function(m) {
          s1y.push(m.y)
          this.good()
        })
        .add('c:1', function(m) {
          this.good({ z: m.z + ++s1z })
        })
  
      c0 = Seneca({ tag: 'c0', log: 'test' }).error(done)
  
      b0
        .use('..', {
          isbase: true,
          discover: test_discover,
          sneeze: { silent: true }
        })
        .ready(function() {
          s0
            .use('..', {
              listen: [{ pin: 'a:1' }, { pin: 'b:1', model: 'observe' }],
              discover: test_discover
            })
            .ready(function() {
              s1
                .use('..', {
                  listen: [{ pin: 'c:1' }, { pin: 'b:1', model: 'observe' }],
                  discover: test_discover
                })
                .ready(function() {
                  c0
                    .use('..', {
                      discover: test_discover,
                      sneeze: { silent: true }
                    })
                    .ready(do_abc)
                })
            })
        })
  
      function do_abc() {
        c0.act('a:1,x:0', function(e, o) {
          Assert.equal(1, o.x)
  
          c0.act('a:1,x:0', function(e, o) {
            Assert.equal(2, o.x)
  
            c0.act('b:1,y:0')
            c0.act('b:1,y:1')
            c0.act('b:1,y:2')
            c0.act('b:1,y:3')
  
            setTimeout(function() {
              Assert.deepEqual([0, 1, 2, 3], s0y)
              Assert.deepEqual([0, 1, 2, 3], s1y)
  
              c0.act('c:1,z:0', function(e, o) {
                Assert.equal(1, o.z)
  
                c0.act('c:1,z:0', function(e, o) {
                  Assert.equal(2, o.z)
  
                  close()
                })
              })
            }, 111)
          })
        })
      }
  
      function close() {
        c0.close()
        s1.close()
        s0.close()
        b0.close()
        setTimeout(done, 555)
      }
    })
  
    it('single-custom', { parallel: false, timeout: 5555 }, function(done) {
      var b0b, s0b
  
      function custom_bases(seneca, options, bases, next) {
        next(['127.0.0.1:39901'])
      }
  
      b0b = Seneca({ tag: 'b0b', log: 'silent', debug: { short_logs: true } })
        .error(done)
        .use('..', {
          isbase: true,
          port: 39901,
          sneeze: {
            silent: true
          },
          discover: {
            custom: {
              active: true,
              find: custom_bases
            }
          }
        })
  
      s0b = Seneca({ tag: 's0b', log: 'silent', debug: { short_logs: true } })
        .error(done)
        .add('a:1', function(msg) {
          this.good({ x: msg.i })
        })
  
      b0b.ready(function() {
        s0b
          .use('..', {
            pin: 'a:1',
            discover: {
              custom: {
                active: true,
                find: custom_bases
              }
            }
          })
          .ready(function() {
            s0b.act('role:mesh,get:members', function(err, out) {
              if (err) {
                done(err)
              }
              Assert.equal(1, out.list.length)
  
              b0b.act('a:1,i:0', function(err, out) {
                if (err) {
                  done(err)
                }
                Assert.equal(0, out.x)
  
                b0b.act('a:1,i:1', function(err, out) {
                  if (err) {
                    done(err)
                  }
                  Assert.equal(1, out.x)
  
                  s0b.close()
                  b0b.close()
                  setTimeout(done, 555)
                })
              })
            })
          })
      })
    })
  
    // Tests https://github.com/senecajs/seneca-mesh/issues/11
    it('canonical-pins', { parallel: false, timeout: 5555 }, function(done) {
      var b0 = Seneca({ legacy: { transport: false } })
        .test(done)
        .use('..', { base: true })
      var s0 = Seneca({ legacy: { transport: false } })
        .test(done)
        .use('..', { pin: 'a:1,b:2;c:3' })
      var s1 = Seneca({ legacy: { transport: false } })
        .test(done)
        .use('..', { pin: 'c:3;b:2,a:1' })
      var c0 = Seneca({ legacy: { transport: false } })
        .test(done)
        .use('..')
  
      s0.add('a:1,b:2', function(msg, reply) {
        reply({ s: 0, x: msg.x })
      })
      s1.add('a:1,b:2', function(msg, reply) {
        reply({ s: 1, x: msg.x })
      })
  
      s0.add('c:3', function(msg, reply) {
        reply({ s: 0, y: msg.y })
      })
      s1.add('c:3', function(msg, reply) {
        reply({ s: 1, y: msg.y })
      })
  
      setTimeout(function() {
        c0
          .gate()
          .act('role:transport,type:balance,get:target-map', function(
            ignore,
            out
          ) {
            expect(out['a:1,b:2']['a:1,b:2'].targets.length).to.equal(2)
            expect(out['c:3']['c:3'].targets.length).to.equal(2)
            //console.dir(out,{depth:null})
          })
          .act('c:3,y:100', function(ignore, out) {
            expect(out).to.equal({ s: 0, y: 100 })
          })
          .act('c:3,y:200', function(ignore, out) {
            expect(out).to.equal({ s: 1, y: 200 })
          })
          .act('c:3,y:300', function(ignore, out) {
            expect(out).to.equal({ s: 0, y: 300 })
          })
          .act('a:1,b:2,x:400', function(ignore, out) {
            expect(out).to.equal({ s: 0, x: 400 })
          })
          .act('a:1,b:2,x:500', function(ignore, out) {
            expect(out).to.equal({ s: 1, x: 500 })
          })
          .act('a:1,b:2,x:600', function(ignore, out) {
            expect(out).to.equal({ s: 0, x: 600 })
  
            c0.close()
            s0.close()
            s1.close()
            b0.close()
  
            done()
          })
      }, 2555)
    })
  
    it('rejoin', { parallel: false, timeout: 8888 }, function(done) {
      var b0b, s0b
  
      function custom_bases(seneca, options, bases, next) {
        next(['127.0.0.1:39901'])
      }
  
      b0b = Seneca({ tag: 'b0b', log: 'silent', debug: { short_logs: true } })
        .error(done)
        .use('..', {
          isbase: true,
          port: 39901,
          sneeze: {
            silent: true
          },
          discover: {
            custom: {
              active: true,
              find: custom_bases
            }
          }
        })
  
      s0b = Seneca({ tag: 's0b', log: 'silent', debug: { short_logs: true } })
        .error(done)
        .add('a:1', function(msg) {
          this.good({ x: msg.i })
        })
  
      b0b.ready(function() {
        s0b
          .use('..', {
            pin: 'a:1',
            discover: {
              rediscover: true,
              custom: {
                active: true,
                find: custom_bases
              }
            }
          })
          .ready(function() {
            s0b.act('role:mesh,get:members', function(err, out) {
              if (err) {
                done(err)
              }
              Assert.equal(1, out.list.length)
  
              b0b.close()
              b0b = null
              function delayEmpty(cb) {
                setTimeout(function() {
                  s0b.act('role:mesh,get:members', function(err, out) {
                    Assert.equal(0, out.list.length)
                    cb()
                  })
                }, 1111)
              }
  
              delayEmpty(function() {
                b0b = Seneca({
                  tag: 'b0b',
                  log: 'silent',
                  debug: { short_logs: true }
                })
                  .error(done)
                  .use('..', {
                    isbase: true,
                    port: 39901,
                    sneeze: {
                      silent: true
                    },
                    discover: {
                      custom: {
                        active: true,
                        find: custom_bases
                      }
                    }
                  })
                  .ready(function() {
                    setTimeout(function() {
                      s0b.act('role:mesh,get:members', function(err, out) {
                        Assert.equal(1, out.list.length)
                        b0b.close()
                        s0b.close()
                        done()
                      })
                    }, 2222)
                  })
              })
            })
          })
      })
    })
  })
  
  function make_rif() {
    var netif = {
      lo: [
        {
          address: '127.0.0.1',
          netmask: '255.0.0.0',
          family: 'IPv4',
          mac: '00:00:00:00:00:00',
          internal: true
        },
        {
          address: '::1',
          netmask: 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff',
          family: 'IPv6',
          mac: '00:00:00:00:00:00',
          scopeid: 0,
          internal: true
        }
      ],
      eth0: [
        {
          address: '10.0.2.15',
          netmask: '255.255.255.0',
          family: 'IPv4',
          mac: '08:00:27:1b:bc:e9',
          internal: false
        },
        {
          address: 'fe80::a00:27ff:fe1b:bce9',
          netmask: 'ffff:ffff:ffff:ffff::',
          family: 'IPv6',
          mac: '08:00:27:1b:bc:e9',
          scopeid: 2,
          internal: false
        }
      ]
    }
  
    return Rif(netif)
  }
  