git ssb

1
const tape = require('tape')
2
const IPFS = require('ipfs')
3
const Hypervisor = require('../')
4
const Message = require('primea-message')
5
6
const node = new IPFS()
7
8
class BaseContainer {
9
  constructor (kernel) {
10
    this.kernel = kernel
11
  }
12
13
  static createState (code) {
14
    return {
15
      nonce: [0],
16
      ports: {}
17
    }
18
  }
19
}
20
21
node.on('error', err => {
22
  console.log(err)
23
})
24
25
node.on('start', () => {
26
  tape('basic', async t => {
27
    const message = new Message()
28
    const expectedState = {
29
      '/': 'zdpuAntkdU7yBJojcBT5Q9wBhrK56NmLnwpHPKaEGMFnAXpv7'
30
    }
31
32
    class testVMContainer extends BaseContainer {
33
      run (m) {
34
        t.true(m === message, 'should recive a message')
35
      }
36
    }
37
38
    try {
39
      const hypervisor = new Hypervisor({dag: node.dag})
40
      hypervisor.registerContainer('test', testVMContainer)
41
42
      const rootContainer = await hypervisor.createInstance('test')
43
      const port = await rootContainer.createPort('test', 'first')
44
45
      await rootContainer.send(port, message)
46
47
      const stateRoot = await hypervisor.createStateRoot(rootContainer, Infinity)
48
      t.deepEquals(stateRoot, expectedState, 'expected root!')
49
    } catch (e) {
50
      console.log(e)
51
    }
52
    t.end()
53
  })
54
55
  tape('one child contract', async t => {
56
    let message = new Message()
57
    const expectedState = {
58
      '/': 'zdpuAtYQujwQMR9SpmFwmkr7d2cD4vzeQk2GCzcEku2nomWj6'
59
    }
60
    let hasResolved = false
61
62
    class testVMContainer2 extends BaseContainer {
63
      run (m) {
64
        t.true(m === message, 'should recive a message 2')
65
        return new Promise((resolve, reject) => {
66
          setTimeout(() => {
67
            this.kernel.incrementTicks(1)
68
            hasResolved = true
69
            resolve()
70
          }, 200)
71
        })
72
      }
73
    }
74
75
    class testVMContainer extends BaseContainer {
76
      async run (m) {
77
        const port = await this.kernel.createPort('test2', 'child')
78
        await this.kernel.send(port, m)
79
        this.kernel.incrementTicks(1)
80
      }
81
    }
82
83
    const hypervisor = new Hypervisor({dag: node.dag})
84
    hypervisor.registerContainer('test', testVMContainer)
85
    hypervisor.registerContainer('test2', testVMContainer2)
86
87
    let root = await hypervisor.createInstance('test')
88
    let port = await root.createPort('test', 'first')
89
90
    await root.send(port, message)
91
    const stateRoot = await hypervisor.createStateRoot(root, Infinity)
92
    t.true(hasResolved, 'should resolve before generating the state root')
93
    t.deepEquals(stateRoot, expectedState, 'expected state')
94
95
    // test reviving the state
96
    class testVMContainer3 extends BaseContainer {
97
      async run (m) {
98
        const port = this.kernel.getPort('child')
99
        this.kernel.send(port, m)
100
        this.kernel.incrementTicks(1)
101
      }
102
    }
103
104
    try {
105
      hypervisor.registerContainer('test', testVMContainer3)
106
      root = await hypervisor.createInstance('test', stateRoot)
107
      port = await root.ports.getRef('first')
108
109
      await root.send(port, message)
110
      console.log('creating SR')
111
      await hypervisor.createStateRoot(root, Infinity)
112
      console.log('end!')
113
      // console.log(hypervisor._vmInstances)
114
    } catch (e) {
115
      console.log(e)
116
    }
117
118
    t.end()
119
  })
120
121
  tape.skip('should wait on parent', async t => {
122
    let r
123
    const lock = new Promise((resolve, reject) => {
124
      r = resolve
125
    })
126
127
    let parentHasFinished = false
128
    let childHasFinished = false
129
    class testVMContainer extends BaseContainer {
130
      async run (m) {
131
        console.log('in parent')
132
        const port = await this.kernel.createPort(this.kernel.ports, 'test2', 'child')
133
        await this.kernel.send(port, m)
134
        await lock
135
        return new Promise((resolve, reject) => {
136
          setTimeout(() => {
137
            console.log('parent done')
138
            this.kernel.incrementTicks(1)
139
            parentHasFinished = true
140
            t.equals(childHasFinished, false, 'child should not have finished at this point')
141
            resolve()
142
          }, 200)
143
        })
144
      }
145
    }
146
147
    // test reviving the state
148
    class testVMContainer2 extends BaseContainer {
149
      async run (m) {
150
        console.log('in child')
151
        childHasFinished = true
152
        r()
153
        this.kernel.incrementTicks(1)
154
        try {
155
          await this.kernel.ports.getNextMessage()
156
        } catch (e) {
157
          console.log(e)
158
        }
159
        t.equals(parentHasFinished, true, 'parent should have finished at this point')
160
      }
161
    }
162
163
    const hypervisor = new Hypervisor({dag: node.dag})
164
    hypervisor.addVM('test', testVMContainer)
165
    hypervisor.addVM('test2', testVMContainer2)
166
    const port = hypervisor.createPort('test')
167
168
    let message = new Message()
169
    try {
170
      await hypervisor.send(port, message)
171
      await hypervisor.createStateRoot(port, Infinity)
172
    } catch (e) {
173
      console.log(e)
174
    }
175
176
    t.end()
177
    node.stop(() => {
178
      process.exit()
179
    })
180
  })
181
})
182