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.only('one child contract', async t => {
56
    let message = new Message()
57
    const expectedState = { '/': 'zdpuAqtY43BMaTCB5nTt7kooeKAWibqGs44Uwy9jJQHjTnHRK' }
58
    let hasResolved = false
59
60
    class testVMContainer2 extends BaseContainer {
61
      run (m) {
62
        t.true(m === message, 'should recive a message 2')
63
        return new Promise((resolve, reject) => {
64
          setTimeout(() => {
65
            this.kernel.incrementTicks(1)
66
            hasResolved = true
67
            resolve()
68
          }, 200)
69
        })
70
      }
71
    }
72
73
    class testVMContainer extends BaseContainer {
74
      async run (m) {
75
        // console.log('here', this.kernel.entryPort)
76
        const port = await this.kernel.createPort('test2', 'child')
77
        try {
78
          await this.kernel.send(port, m)
79
        } catch (e) {
80
          console.log('error!', e)
81
        }
82
        this.kernel.incrementTicks(1)
83
      }
84
    }
85
86
    try {
87
      const hypervisor = new Hypervisor({dag: node.dag})
88
      hypervisor.registerContainer('test', testVMContainer)
89
      hypervisor.registerContainer('test2', testVMContainer2)
90
91
      const root = await hypervisor.createInstance('test')
92
      const port = await root.createPort('test', 'first')
93
94
      await root.send(port, message)
95
      await hypervisor.createStateRoot(root, Infinity)
96
      console.log('state root generated')
97
      t.true(hasResolved, 'should resolve before generating the state root')
98
    } catch (e) {
99
      console.log(e)
100
    }
101
    // t.deepEquals(port, expectedState, 'expected state')
102
103
    // test reviving the state
104
    // class testVMContainer3 extends BaseContainer {
105
    //   async run (m) {
106
    //     const port = this.kernel.getPort(this.kernel.ports, 'child')
107
    //     this.kernel.send(port, m)
108
    //     this.kernel.incrementTicks(1)
109
    //   }
110
    // }
111
112
    // hypervisor.addVM('test', testVMContainer3)
113
114
    // // revive ports
115
    // message = new Message()
116
    // await hypervisor.graph.tree(expectedState, 1)
117
    // await hypervisor.send(expectedState['/'], message)
118
    // await hypervisor.createStateRoot(expectedState['/'], Infinity)
119
120
    t.end()
121
  })
122
123
  tape('should wait on parent', async t => {
124
    let r
125
    const lock = new Promise((resolve, reject) => {
126
      r = resolve
127
    })
128
129
    let parentHasFinished = false
130
    let childHasFinished = false
131
    class testVMContainer extends BaseContainer {
132
      async run (m) {
133
        console.log('in parent')
134
        const port = await this.kernel.createPort(this.kernel.ports, 'test2', 'child')
135
        await this.kernel.send(port, m)
136
        await lock
137
        return new Promise((resolve, reject) => {
138
          setTimeout(() => {
139
            console.log('parent done')
140
            this.kernel.incrementTicks(1)
141
            parentHasFinished = true
142
            t.equals(childHasFinished, false, 'child should not have finished at this point')
143
            resolve()
144
          }, 200)
145
        })
146
      }
147
    }
148
149
    // test reviving the state
150
    class testVMContainer2 extends BaseContainer {
151
      async run (m) {
152
        console.log('in child')
153
        childHasFinished = true
154
        r()
155
        this.kernel.incrementTicks(1)
156
        try {
157
          await this.kernel.ports.getNextMessage()
158
        } catch (e) {
159
          console.log(e)
160
        }
161
        t.equals(parentHasFinished, true, 'parent should have finished at this point')
162
      }
163
    }
164
165
    const hypervisor = new Hypervisor({dag: node.dag})
166
    hypervisor.addVM('test', testVMContainer)
167
    hypervisor.addVM('test2', testVMContainer2)
168
    const port = hypervisor.createPort('test')
169
170
    let message = new Message()
171
    try {
172
      await hypervisor.send(port, message)
173
      await hypervisor.createStateRoot(port, Infinity)
174
    } catch (e) {
175
      console.log(e)
176
    }
177
178
    t.end()
179
    node.stop(() => {
180
      process.exit()
181
    })
182
  })
183
})
184