mirrors/puter
1
0
Fork 0
mirror of https://github.com/HeyPuter/puter synced 2024-11-14 22:06:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

dev: puter-wisp

Browse Source
This commit is contained in:
KernelDeimos 2024-08-27 22:20:32 -04:00
parent 2385457d12
commit 2d1cb0050d
8 changed files with 1499 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

102
src/puter-wisp/README.md Normal file
View File

@ -0,0 +1,102 @@
# Wisp Utilities
This is still a work in progress. Thes utilities use my own stream interface
to avoid browser/node compatibility issues and because I found it more
convenient. These streams can by used as async iterator objects just like
other conventional implementations. Currently there is no logic for closing
streams or knowing if a stream has been closed, but this is planned.
## Classes and Factory Functions
### WispPacket (class)
Wraps a Uint8Array containing a Wisp packet. `data` should be a Uint8Array
containing only the Wisp frame, starting at the Packet Type and ending at
the last byte of the payload (inclusive).
```javascript
const packet = new WispPacket({
data: new Uint8Array(...),
direction: WispPacket.SEND, // or RECV
// `extra` is optional, for debugging
extra: { some: 'value', },
});
packet.type; // ex: WispPacket.CONTINUE
```
#### Methods
- `describe()` - outputs a summary string
```javascript
packet.describe();
// ex: "INFO v2.0 f000000000"
```
- `toVirtioFrame` - prepends the size of the Wisp frame (u32LE)
- `log()` - prints a collapsed console group
- `reflect()` - returns a reflected version of the packet (flips `SEND` and `RECV`)
### NewCallbackByteStream (function)
Returns a stream for values that get passed through a callback interface.
The stream object (an async iterator object) has a property called
`listener` which can be passed as a listener or called directly. This
listener expects only one argument which is the data to pass through the
stream (typically a value of type `Uint8Array`).
```javascript
const byteStream = NewCallbackByteStream();
emulator.add_listener('virtio-console0-output-bytes',
byteStream.listener);
```
### NewVirtioFrameStream (function)
Takes in a byte stream (stream of `Uint8Array`) and assumes that this byte
stream contains integers (u32LE) describing the length (in bytes) of data,
followed by the data. Returns a stream which outputs a complete chunk of
data (as per the specified length) as each value, excluding the bytes that
describe the length.
```javascript
const virtioStream = NewVirtioFrameStream(byteStream);
```
### NewWispPacketStream (function)
Takes in a stream of `Uint8Array`s, each containing a complete Wisp packet,
and outputs a stream of instances of **WispPacket**
## Example Use with v86
```javascript
const emulator = new V86(...);
// Get a byte stream for /dev/hvc0
const byteStream = NewCallbackByteStream();
emulator.add_listener('virtio-console0-output-bytes',
byteStream.listener);
// Get a stream of frames with prepended byte lengths
// (for example, `twisp` uses this format)
const virtioStream = NewVirtioFrameStream(byteStream);
// Get a stream of WispPacket objects
const wispStream = NewWispPacketStream(virtioStream);
// Async iterator
(async () => {
for ( const packet of wispStream ) {
console.log('Wisp packet!', packet.describe());
// Let's send back a reflected packet for INFO!
if ( packet.type === WispPacket.INFO ) {
emulator.bus.send(
'virtio-console0-input-bytes',
packet.toVirtioFrame(),
);
}
}
})();
```

412
src/puter-wisp/basic.html Normal file
View File

@ -0,0 +1,412 @@
<!doctype html>
<title>Basic Emulator</title><!-- not BASIC! -->
<style>
div {
font-size: 12px;
line-height: 16px;
}
BODY {
background-color: #111;
display: flex;
justify-content: center;
align-items: center;
height: 100vh;
overflow: hidden;
}
</style>
<script src="../build/libv86.js"></script>
<script>
"use strict";
// Libs
// SO: 40031688
function buf2hex(buffer) { // buffer is an ArrayBuffer
return [...new Uint8Array(buffer)]
.map(x => x.toString(16).padStart(2, '0'))
.join('');
}
class ATStream {
constructor ({ delegate, acc, transform, observe }) {
this.delegate = delegate;
if ( acc ) this.acc = acc;
if ( transform ) this.transform = transform;
if ( observe ) this.observe = observe;
this.state = {};
this.carry = [];
}
[Symbol.asyncIterator]() { return this; }
async next_value_ () {
if ( this.carry.length > 0 ) {
console.log('got from carry!', this.carry);
return {
value: this.carry.shift(),
done: false,
};
}
return await this.delegate.next();
}
async acc ({ value }) {
return value;
}
async next_ () {
for (;;) {
const ret = await this.next_value_();
if ( ret.done ) return ret;
const v = await this.acc({
state: this.state,
value: ret.value,
carry: v => this.carry.push(v),
});
if ( this.carry.length >= 0 && v === undefined ) {
throw new Error(`no value, but carry value exists`);
}
if ( v === undefined ) continue;
// We have a value, clear the state!
this.state = {};
if ( this.transform ) {
const new_value = await this.transform(
{ value: ret.value });
return { ...ret, value: new_value };
}
return { ...ret, value: v };
}
}
async next () {
const ret = await this.next_();
if ( this.observe && !ret.done ) {
this.observe(ret);
}
return ret;
}
async enqueue_ (v) {
this.queue.push(v);
}
}
const NewCallbackByteStream = () => {
let listener;
let queue = [];
const NOOP = () => {};
let signal = NOOP;
(async () => {
for (;;) {
const v = await new Promise((rslv, rjct) => {
listener = rslv;
});
queue.push(v);
signal();
}
})();
const stream = {
[Symbol.asyncIterator](){
return this;
},
async next () {
if ( queue.length > 0 ) {
return {
value: queue.shift(),
done: false,
};
}
await new Promise(rslv => {
signal = rslv;
});
signal = NOOP;
const v = queue.shift();
return { value: v, done: false };
}
};
stream.listener = data => {
listener(data);
};
return stream;
}
// Tiny inline little-endian integer library
const get_int = (n_bytes, array8, signed=false) => {
return (v => signed ? v : v >>> 0)(
array8.slice(0,n_bytes).reduce((v,e,i)=>v|=e<<8*i,0));
}
const to_int = (n_bytes, num) => {
return (new Uint8Array()).map((_,i)=>(num>>8*i)&0xFF);
}
const NewVirtioFrameStream = byteStream => {
return new ATStream({
delegate: byteStream,
async acc ({ value, carry }) {
if ( ! this.state.buffer ) {
const size = get_int(4, value);
// 512MiB limit in case of attempted abuse or a bug
// (assuming this won't happen under normal conditions)
if ( size > 512*(1024**2) ) {
throw new Error(`Way too much data! (${size} bytes)`);
}
value = value.slice(4);
this.state.buffer = new Uint8Array(size);
this.state.index = 0;
}
const needed = this.state.buffer.length - this.state.index;
if ( value.length > needed ) {
const remaining = value.slice(needed);
console.log('we got more bytes than we needed',
needed,
remaining,
value.length,
this.state.buffer.length,
this.state.index,
);
carry(remaining);
}
const amount = Math.min(value.length, needed);
const added = value.slice(0, amount);
this.state.buffer.set(added, this.state.index);
this.state.index += amount;
if ( this.state.index > this.state.buffer.length ) {
throw new Error('WUT');
}
if ( this.state.index == this.state.buffer.length ) {
return this.state.buffer;
}
}
});
};
const wisp_types = [
{
id: 3,
label: 'CONTINUE',
describe: ({ payload }) => {
return `buffer: ${get_int(4, payload)}B`;
},
getAttributes ({ payload }) {
return {
buffer_size: get_int(4, payload),
};
}
},
{
id: 5,
label: 'INFO',
describe: ({ payload }) => {
return `v${payload[0]}.${payload[1]} ` +
buf2hex(payload.slice(2));
},
getAttributes ({ payload }) {
return {
version_major: payload[0],
version_minor: payload[1],
extensions: payload.slice(2),
}
}
},
];
class WispPacket {
static SEND = Symbol('SEND');
static RECV = Symbol('RECV');
constructor ({ data, direction, extra }) {
this.direction = direction;
this.data_ = data;
this.extra = extra ?? {};
this.types_ = {
1: { label: 'CONNECT' },
2: { label: 'DATA' },
4: { label: 'CLOSE' },
};
for ( const item of wisp_types ) {
this.types_[item.id] = item;
}
}
get type () {
const i_ = this.data_[0];
return this.types_[i_];
}
get attributes () {
if ( ! this.type.getAttributes ) return {};
const attrs = {};
Object.assign(attrs, this.type.getAttributes({
payload: this.data_.slice(5),
}));
Object.assign(attrs, this.extra);
return attrs;
}
toVirtioFrame () {
const arry = new Uint8Array(this.data_.length + 4);
arry.set(to_int(4, this.data_.length), 0);
arry.set(this.data_, 4);
return arry;
}
describe () {
return this.type.label + '(' +
(this.type.describe?.({
payload: this.data_.slice(5),
}) ?? '?') + ')';
}
log () {
const arrow =
this.direction === this.constructor.SEND ? '->' :
this.direction === this.constructor.RECV ? '<-' :
'<>' ;
console.groupCollapsed(`WISP ${arrow} ${this.describe()}`);
const attrs = this.attributes;
for ( const k in attrs ) {
console.log(k, attrs[k]);
}
console.groupEnd();
}
reflect () {
const reflected = new WispPacket({
data: this.data_,
direction:
this.direction === this.constructor.SEND ?
this.constructor.RECV :
this.direction === this.constructor.RECV ?
this.constructor.SEND :
undefined,
extra: {
reflectedFrom: this,
}
});
return reflected;
}
}
for ( const item of wisp_types ) {
WispPacket[item.label] = item;
}
const NewWispPacketStream = frameStream => {
return new ATStream({
delegate: frameStream,
transform ({ value }) {
return new WispPacket({
data: value,
direction: WispPacket.RECV,
});
},
observe ({ value }) {
value.log();
}
});
}
class WispClient {
constructor ({
packetStream,
sendFn,
}) {
this.packetStream = packetStream;
this.sendFn = sendFn;
}
send (packet) {
packet.log();
this.sendFn(packet);
}
}
window.onload = async function()
{
const resp = await fetch(
'./image/build/x86images/rootfs.bin'
);
const arrayBuffer = await resp.arrayBuffer();
var emulator = window.emulator = new V86({
wasm_path: "../build/v86.wasm",
memory_size: 512 * 1024 * 1024,
vga_memory_size: 2 * 1024 * 1024,
screen_container: document.getElementById("screen_container"),
bios: {
url: "../bios/seabios.bin",
},
vga_bios: {
url: "../bios/vgabios.bin",
},
initrd: {
url: './image/build/x86images/boot/initramfs-lts',
},
bzimage: {
url: './image/build/x86images/boot/vmlinuz-lts',
async: false
},
cmdline: 'rw root=/dev/sda init=/sbin/init rootfstype=ext4',
// cmdline: 'rw root=/dev/sda init=/bin/bash rootfstype=ext4',
// cmdline: "rw init=/sbin/init root=/dev/sda rootfstype=ext4",
// cmdline: "rw init=/sbin/init root=/dev/sda rootfstype=ext4 random.trust_cpu=on 8250.nr_uarts=10 spectre_v2=off pti=off mitigations=off",
// cdrom: {
// // url: "../images/al32-2024.07.10.iso",
// url: "./image/build/x86images/rootfs.bin",
// },
hda: {
buffer: arrayBuffer,
// url: './image/build/x86images/rootfs.bin',
async: true,
// size: 1073741824,
// size: 805306368,
},
// bzimage_initrd_from_filesystem: true,
autostart: true,
network_relay_url: "wisp://127.0.0.1:3000",
virtio_console: true,
});
const decoder = new TextDecoder();
const byteStream = NewCallbackByteStream();
emulator.add_listener('virtio-console0-output-bytes',
byteStream.listener);
const virtioStream = NewVirtioFrameStream(byteStream);
const wispStream = NewWispPacketStream(virtioStream);
class PTYManager {
constructor ({ client }) {
this.client = client;
}
init () {
this.run_();
}
async run_ () {
const handlers_ = {
[WispPacket.INFO.id]: ({ packet }) => {
// console.log('guess we doing info packets now', packet);
this.client.send(packet.reflect());
}
};
for await ( const packet of this.client.packetStream ) {
// console.log('what we got here?',
// packet.type,
// packet,
// );
handlers_[packet.type.id]?.({ packet });
}
}
}
const ptyMgr = new PTYManager({
client: new WispClient({
packetStream: wispStream,
sendFn: packet => {
emulator.bus.send(
"virtio-console0-input-bytes",
packet.toVirtioFrame(),
);
}
})
});
ptyMgr.init();
}
</script>
<!-- A minimal structure for the ScreenAdapter defined in browser/screen.js -->
<div id="screen_container">
<div style="white-space: pre; font: 14px monospace; line-height: 14px"></div>
<canvas style="display: none"></canvas>
</div>

297
src/puter-wisp/devlog/unit_test_usefulness/a.js Normal file
View File

@ -0,0 +1,297 @@
const lib = {};
// SO: 40031688
lib.buf2hex = (buffer) => { // buffer is an ArrayBuffer
return [...new Uint8Array(buffer)]
.map(x => x.toString(16).padStart(2, '0'))
.join('');
}
// Tiny inline little-endian integer library
lib.get_int = (n_bytes, array8, signed=false) => {
return (v => signed ? v : v >>> 0)(
array8.slice(0,n_bytes).reduce((v,e,i)=>v|=e<<8*i,0));
}
lib.to_int = (n_bytes, num) => {
return (new Uint8Array()).map((_,i)=>(num>>8*i)&0xFF);
}
class ATStream {
constructor ({ delegate, acc, transform, observe }) {
this.delegate = delegate;
if ( acc ) this.acc = acc;
if ( transform ) this.transform = transform;
if ( observe ) this.observe = observe;
this.state = {};
this.carry = [];
}
[Symbol.asyncIterator]() { return this; }
async next_value_ () {
if ( this.carry.length > 0 ) {
console.log('got from carry!', this.carry);
return {
value: this.carry.shift(),
done: false,
};
}
return await this.delegate.next();
}
async acc ({ value }) {
return value;
}
async next_ () {
for (;;) {
const ret = await this.next_value_();
if ( ret.done ) return ret;
const v = await this.acc({
state: this.state,
value: ret.value,
carry: v => this.carry.push(v),
});
if ( this.carry.length >= 0 && v === undefined ) {
throw new Error(`no value, but carry value exists`);
}
if ( v === undefined ) continue;
// We have a value, clear the state!
this.state = {};
if ( this.transform ) {
const new_value = await this.transform(
{ value: ret.value });
return { ...ret, value: new_value };
}
return { ...ret, value: v };
}
}
async next () {
const ret = await this.next_();
if ( this.observe && !ret.done ) {
this.observe(ret);
}
return ret;
}
async enqueue_ (v) {
this.queue.push(v);
}
}
const NewCallbackByteStream = () => {
let listener;
let queue = [];
const NOOP = () => {};
let signal = NOOP;
(async () => {
for (;;) {
const v = await new Promise((rslv, rjct) => {
listener = rslv;
});
queue.push(v);
signal();
}
})();
const stream = {
[Symbol.asyncIterator](){
return this;
},
async next () {
if ( queue.length > 0 ) {
return {
value: queue.shift(),
done: false,
};
}
await new Promise(rslv => {
signal = rslv;
});
signal = NOOP;
const v = queue.shift();
return { value: v, done: false };
}
};
stream.listener = data => {
listener(data);
};
return stream;
}
const NewVirtioFrameStream = byteStream => {
return new ATStream({
delegate: byteStream,
async acc ({ value, carry }) {
if ( ! this.state.buffer ) {
const size = lib.get_int(4, value);
// 512MiB limit in case of attempted abuse or a bug
// (assuming this won't happen under normal conditions)
if ( size > 512*(1024**2) ) {
throw new Error(`Way too much data! (${size} bytes)`);
}
value = value.slice(4);
this.state.buffer = new Uint8Array(size);
this.state.index = 0;
}
const needed = this.state.buffer.length - this.state.index;
if ( value.length > needed ) {
const remaining = value.slice(needed);
console.log('we got more bytes than we needed',
needed,
remaining,
value.length,
this.state.buffer.length,
this.state.index,
);
carry(remaining);
}
const amount = Math.min(value.length, needed);
const added = value.slice(0, amount);
this.state.buffer.set(added, this.state.index);
this.state.index += amount;
if ( this.state.index > this.state.buffer.length ) {
throw new Error('WUT');
}
if ( this.state.index == this.state.buffer.length ) {
return this.state.buffer;
}
}
});
};
const wisp_types = [
{
id: 3,
label: 'CONTINUE',
describe: ({ payload }) => {
return `buffer: ${lib.get_int(4, payload)}B`;
},
getAttributes ({ payload }) {
return {
buffer_size: lib.get_int(4, payload),
};
}
},
{
id: 5,
label: 'INFO',
describe: ({ payload }) => {
return `v${payload[0]}.${payload[1]} ` +
lib.buf2hex(payload.slice(2));
},
getAttributes ({ payload }) {
return {
version_major: payload[0],
version_minor: payload[1],
extensions: payload.slice(2),
}
}
},
];
class WispPacket {
static SEND = Symbol('SEND');
static RECV = Symbol('RECV');
constructor ({ data, direction, extra }) {
this.direction = direction;
this.data_ = data;
this.extra = extra ?? {};
this.types_ = {
1: { label: 'CONNECT' },
2: { label: 'DATA' },
4: { label: 'CLOSE' },
};
for ( const item of wisp_types ) {
this.types_[item.id] = item;
}
}
get type () {
const i_ = this.data_[0];
return this.types_[i_];
}
get attributes () {
if ( ! this.type.getAttributes ) return {};
const attrs = {};
Object.assign(attrs, this.type.getAttributes({
payload: this.data_.slice(5),
}));
Object.assign(attrs, this.extra);
return attrs;
}
toVirtioFrame () {
const arry = new Uint8Array(this.data_.length + 4);
arry.set(lib.to_int(4, this.data_.length), 0);
arry.set(this.data_, 4);
return arry;
}
describe () {
return this.type.label + '(' +
(this.type.describe?.({
payload: this.data_.slice(5),
}) ?? '?') + ')';
}
log () {
const arrow =
this.direction === this.constructor.SEND ? '->' :
this.direction === this.constructor.RECV ? '<-' :
'<>' ;
console.groupCollapsed(`WISP ${arrow} ${this.describe()}`);
const attrs = this.attributes;
for ( const k in attrs ) {
console.log(k, attrs[k]);
}
console.groupEnd();
}
reflect () {
const reflected = new WispPacket({
data: this.data_,
direction:
this.direction === this.constructor.SEND ?
this.constructor.RECV :
this.direction === this.constructor.RECV ?
this.constructor.SEND :
undefined,
extra: {
reflectedFrom: this,
}
});
return reflected;
}
}
for ( const item of wisp_types ) {
WispPacket[item.label] = item;
}
const NewWispPacketStream = frameStream => {
return new ATStream({
delegate: frameStream,
transform ({ value }) {
return new WispPacket({
data: value,
direction: WispPacket.RECV,
});
},
observe ({ value }) {
value.log();
}
});
}
class WispClient {
constructor ({
packetStream,
sendFn,
}) {
this.packetStream = packetStream;
this.sendFn = sendFn;
}
send (packet) {
packet.log();
this.sendFn(packet);
}
}
module.exports = {
NewVirtioFrameStream,
NewWispPacketStream,
WispPacket,
};

307
src/puter-wisp/devlog/unit_test_usefulness/b.js Normal file
View File

@ -0,0 +1,307 @@
const lib = {};
// SO: 40031688
lib.buf2hex = (buffer) => { // buffer is an ArrayBuffer
return [...new Uint8Array(buffer)]
.map(x => x.toString(16).padStart(2, '0'))
.join('');
}
// Tiny inline little-endian integer library
lib.get_int = (n_bytes, array8, signed=false) => {
return (v => signed ? v : v >>> 0)(
array8.slice(0,n_bytes).reduce((v,e,i)=>v|=e<<8*i,0));
}
lib.to_int = (n_bytes, num) => {
return (new Uint8Array()).map((_,i)=>(num>>8*i)&0xFF);
}
class ATStream {
constructor ({ delegate, acc, transform, observe }) {
this.delegate = delegate;
if ( acc ) this.acc = acc;
if ( transform ) this.transform = transform;
if ( observe ) this.observe = observe;
this.state = {};
this.carry = [];
}
[Symbol.asyncIterator]() { return this; }
async next_value_ () {
if ( this.carry.length > 0 ) {
return {
value: this.carry.shift(),
done: false,
};
}
return await this.delegate.next();
}
async acc ({ value }) {
return value;
}
async next_ () {
for (;;) {
const ret = await this.next_value_();
if ( ret.done ) return ret;
const v = await this.acc({
state: this.state,
value: ret.value,
carry: v => this.carry.push(v),
});
if ( this.carry.length > 0 && v === undefined ) {
throw new Error(`no value, but carry value exists`);
}
if ( v === undefined ) continue;
// We have a value, clear the state!
this.state = {};
if ( this.transform ) {
const new_value = await this.transform(
{ value: ret.value });
return { ...ret, value: new_value };
}
return { ...ret, value: v };
}
}
async next () {
const ret = await this.next_();
if ( this.observe && !ret.done ) {
this.observe(ret);
}
return ret;
}
async enqueue_ (v) {
this.queue.push(v);
}
}
const NewCallbackByteStream = () => {
let listener;
let queue = [];
const NOOP = () => {};
let signal = NOOP;
(async () => {
for (;;) {
const v = await new Promise((rslv, rjct) => {
listener = rslv;
});
queue.push(v);
signal();
}
})();
const stream = {
[Symbol.asyncIterator](){
return this;
},
async next () {
if ( queue.length > 0 ) {
return {
value: queue.shift(),
done: false,
};
}
await new Promise(rslv => {
signal = rslv;
});
signal = NOOP;
const v = queue.shift();
return { value: v, done: false };
}
};
stream.listener = data => {
listener(data);
};
return stream;
}
const NewVirtioFrameStream = byteStream => {
return new ATStream({
delegate: byteStream,
async acc ({ value, carry }) {
if ( ! this.state.buffer ) {
if ( this.state.hold ) {
const old_val = value;
let size = this.state.hold.length + value.length;
value = new Uint8Array(size);
value.set(this.state.hold, 0);
value.set(old_val, this.state.hold.length);
}
if ( value.length < 4 ) {
this.state.hold = value;
return undefined;
}
const size = lib.get_int(4, value);
// 512MiB limit in case of attempted abuse or a bug
// (assuming this won't happen under normal conditions)
if ( size > 512*(1024**2) ) {
throw new Error(`Way too much data! (${size} bytes)`);
}
value = value.slice(4);
this.state.buffer = new Uint8Array(size);
this.state.index = 0;
}
const needed = this.state.buffer.length - this.state.index;
if ( value.length > needed ) {
const remaining = value.slice(needed);
console.log('we got more bytes than we needed',
needed,
remaining,
value.length,
this.state.buffer.length,
this.state.index,
);
carry(remaining);
}
const amount = Math.min(value.length, needed);
const added = value.slice(0, amount);
this.state.buffer.set(added, this.state.index);
this.state.index += amount;
if ( this.state.index > this.state.buffer.length ) {
throw new Error('WUT');
}
if ( this.state.index == this.state.buffer.length ) {
return this.state.buffer;
}
}
});
};
const wisp_types = [
{
id: 3,
label: 'CONTINUE',
describe: ({ payload }) => {
return `buffer: ${lib.get_int(4, payload)}B`;
},
getAttributes ({ payload }) {
return {
buffer_size: lib.get_int(4, payload),
};
}
},
{
id: 5,
label: 'INFO',
describe: ({ payload }) => {
return `v${payload[0]}.${payload[1]} ` +
lib.buf2hex(payload.slice(2));
},
getAttributes ({ payload }) {
return {
version_major: payload[0],
version_minor: payload[1],
extensions: payload.slice(2),
}
}
},
];
class WispPacket {
static SEND = Symbol('SEND');
static RECV = Symbol('RECV');
constructor ({ data, direction, extra }) {
this.direction = direction;
this.data_ = data;
this.extra = extra ?? {};
this.types_ = {
1: { label: 'CONNECT' },
2: { label: 'DATA' },
4: { label: 'CLOSE' },
};
for ( const item of wisp_types ) {
this.types_[item.id] = item;
}
}
get type () {
const i_ = this.data_[0];
return this.types_[i_];
}
get attributes () {
if ( ! this.type.getAttributes ) return {};
const attrs = {};
Object.assign(attrs, this.type.getAttributes({
payload: this.data_.slice(5),
}));
Object.assign(attrs, this.extra);
return attrs;
}
toVirtioFrame () {
const arry = new Uint8Array(this.data_.length + 4);
arry.set(lib.to_int(4, this.data_.length), 0);
arry.set(this.data_, 4);
return arry;
}
describe () {
return this.type.label + '(' +
(this.type.describe?.({
payload: this.data_.slice(5),
}) ?? '?') + ')';
}
log () {
const arrow =
this.direction === this.constructor.SEND ? '->' :
this.direction === this.constructor.RECV ? '<-' :
'<>' ;
console.groupCollapsed(`WISP ${arrow} ${this.describe()}`);
const attrs = this.attributes;
for ( const k in attrs ) {
console.log(k, attrs[k]);
}
console.groupEnd();
}
reflect () {
const reflected = new WispPacket({
data: this.data_,
direction:
this.direction === this.constructor.SEND ?
this.constructor.RECV :
this.direction === this.constructor.RECV ?
this.constructor.SEND :
undefined,
extra: {
reflectedFrom: this,
}
});
return reflected;
}
}
for ( const item of wisp_types ) {
WispPacket[item.label] = item;
}
const NewWispPacketStream = frameStream => {
return new ATStream({
delegate: frameStream,
transform ({ value }) {
return new WispPacket({
data: value,
direction: WispPacket.RECV,
});
},
observe ({ value }) {
value.log();
}
});
}
class WispClient {
constructor ({
packetStream,
sendFn,
}) {
this.packetStream = packetStream;
this.sendFn = sendFn;
}
send (packet) {
packet.log();
this.sendFn(packet);
}
}
module.exports = {
NewVirtioFrameStream,
NewWispPacketStream,
WispPacket,
};

18
src/puter-wisp/devlog/unit_test_usefulness/test_a_b.diff Normal file
View File

@ -0,0 +1,18 @@
31d30
< console.log('got from carry!', this.carry);
51c50
< if ( this.carry.length >= 0 && v === undefined ) {
---
> if ( this.carry.length > 0 && v === undefined ) {
120a120,130
> if ( this.state.hold ) {
> const old_val = value;
> let size = this.state.hold.length + value.length;
> value = new Uint8Array(size);
> value.set(this.state.hold, 0);
> value.set(old_val, this.state.hold.length);
> }
> if ( value.length < 4 ) {
> this.state.hold = value;
> return undefined;
> }

15
src/puter-wisp/package.json Normal file
View File

@ -0,0 +1,15 @@
{
"name": "puter-wisp",
"version": "1.0.0",
"main": "exports.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"keywords": [],
"author": "",
"license": "UNLICENSED",
"directories": {
"test": "test"
},
"description": ""
}

298
src/puter-wisp/src/exports.js Normal file
View File

@ -0,0 +1,298 @@
const lib = {};
// SO: 40031688
lib.buf2hex = (buffer) => { // buffer is an ArrayBuffer
return [...new Uint8Array(buffer)]
.map(x => x.toString(16).padStart(2, '0'))
.join('');
}
// Tiny inline little-endian integer library
lib.get_int = (n_bytes, array8, signed=false) => {
return (v => signed ? v : v >>> 0)(
array8.slice(0,n_bytes).reduce((v,e,i)=>v|=e<<8*i,0));
}
lib.to_int = (n_bytes, num) => {
return (new Uint8Array()).map((_,i)=>(num>>8*i)&0xFF);
}
// Accumulator and/or Transformer (and/or Observer) Stream
// The Swiss Army Knife* of Streams!
// (* this code is not affiliated with the Swiss Army Knife corporation)
class ATStream {
constructor ({ delegate, acc, transform, observe }) {
this.delegate = delegate;
if ( acc ) this.acc = acc;
if ( transform ) this.transform = transform;
if ( observe ) this.observe = observe;
this.state = {};
this.carry = [];
}
[Symbol.asyncIterator]() { return this; }
async next_value_ () {
if ( this.carry.length > 0 ) {
return {
value: this.carry.shift(),
done: false,
};
}
return await this.delegate.next();
}
async acc ({ value }) {
return value;
}
async next_ () {
for (;;) {
const ret = await this.next_value_();
if ( ret.done ) return ret;
const v = await this.acc({
state: this.state,
value: ret.value,
carry: v => this.carry.push(v),
});
if ( this.carry.length > 0 && v === undefined ) {
throw new Error(`no value, but carry value exists`);
}
if ( v === undefined ) continue;
// We have a value, clear the state!
this.state = {};
if ( this.transform ) {
const new_value = await this.transform(
{ value: ret.value });
return { ...ret, value: new_value };
}
return { ...ret, value: v };
}
}
async next () {
const ret = await this.next_();
if ( this.observe && !ret.done ) {
this.observe(ret);
}
return ret;
}
async enqueue_ (v) {
this.queue.push(v);
}
}
const NewCallbackByteStream = () => {
let listener;
let queue = [];
const NOOP = () => {};
let signal = NOOP;
(async () => {
for (;;) {
const v = await new Promise((rslv, rjct) => {
listener = rslv;
});
queue.push(v);
signal();
}
})();
const stream = {
[Symbol.asyncIterator](){
return this;
},
async next () {
if ( queue.length > 0 ) {
return {
value: queue.shift(),
done: false,
};
}
await new Promise(rslv => {
signal = rslv;
});
signal = NOOP;
const v = queue.shift();
return { value: v, done: false };
}
};
stream.listener = data => {
listener(data);
};
return stream;
}
const NewVirtioFrameStream = byteStream => {
return new ATStream({
delegate: byteStream,
async acc ({ value, carry }) {
if ( ! this.state.buffer ) {
if ( this.state.hold ) {
const old_val = value;
let size = this.state.hold.length + value.length;
value = new Uint8Array(size);
value.set(this.state.hold, 0);
value.set(old_val, this.state.hold.length);
}
if ( value.length < 4 ) {
this.state.hold = value;
return undefined;
}
const size = lib.get_int(4, value);
// 512MiB limit in case of attempted abuse or a bug
// (assuming this won't happen under normal conditions)
if ( size > 512*(1024**2) ) {
throw new Error(`Way too much data! (${size} bytes)`);
}
value = value.slice(4);
this.state.buffer = new Uint8Array(size);
this.state.index = 0;
}
const needed = this.state.buffer.length - this.state.index;
if ( value.length > needed ) {
const remaining = value.slice(needed);
console.log('we got more bytes than we needed',
needed,
remaining,
value.length,
this.state.buffer.length,
this.state.index,
);
carry(remaining);
}
const amount = Math.min(value.length, needed);
const added = value.slice(0, amount);
this.state.buffer.set(added, this.state.index);
this.state.index += amount;
if ( this.state.index > this.state.buffer.length ) {
throw new Error('WUT');
}
if ( this.state.index == this.state.buffer.length ) {
return this.state.buffer;
}
}
});
};
const wisp_types = [
{
id: 3,
label: 'CONTINUE',
describe: ({ payload }) => {
return `buffer: ${lib.get_int(4, payload)}B`;
},
getAttributes ({ payload }) {
return {
buffer_size: lib.get_int(4, payload),
};
}
},
{
id: 5,
label: 'INFO',
describe: ({ payload }) => {
return `v${payload[0]}.${payload[1]} ` +
lib.buf2hex(payload.slice(2));
},
getAttributes ({ payload }) {
return {
version_major: payload[0],
version_minor: payload[1],
extensions: payload.slice(2),
}
}
},
];
class WispPacket {
static SEND = Symbol('SEND');
static RECV = Symbol('RECV');
constructor ({ data, direction, extra }) {
this.direction = direction;
this.data_ = data;
this.extra = extra ?? {};
this.types_ = {
1: { label: 'CONNECT' },
2: { label: 'DATA' },
4: { label: 'CLOSE' },
};
for ( const item of wisp_types ) {
this.types_[item.id] = item;
}
}
get type () {
const i_ = this.data_[0];
return this.types_[i_];
}
get attributes () {
if ( ! this.type.getAttributes ) return {};
const attrs = {};
Object.assign(attrs, this.type.getAttributes({
payload: this.data_.slice(5),
}));
Object.assign(attrs, this.extra);
return attrs;
}
toVirtioFrame () {
const arry = new Uint8Array(this.data_.length + 4);
arry.set(lib.to_int(4, this.data_.length), 0);
arry.set(this.data_, 4);
return arry;
}
describe () {
return this.type.label + '(' +
(this.type.describe?.({
payload: this.data_.slice(5),
}) ?? '?') + ')';
}
log () {
const arrow =
this.direction === this.constructor.SEND ? '->' :
this.direction === this.constructor.RECV ? '<-' :
'<>' ;
console.groupCollapsed(`WISP ${arrow} ${this.describe()}`);
const attrs = this.attributes;
for ( const k in attrs ) {
console.log(k, attrs[k]);
}
console.groupEnd();
}
reflect () {
const reflected = new WispPacket({
data: this.data_,
direction:
this.direction === this.constructor.SEND ?
this.constructor.RECV :
this.direction === this.constructor.RECV ?
this.constructor.SEND :
undefined,
extra: {
reflectedFrom: this,
}
});
return reflected;
}
}
for ( const item of wisp_types ) {
WispPacket[item.label] = item;
}
const NewWispPacketStream = frameStream => {
return new ATStream({
delegate: frameStream,
transform ({ value }) {
return new WispPacket({
data: value,
direction: WispPacket.RECV,
});
},
observe ({ value }) {
// TODO: configurable behavior, or a separate stream decorator
value.log();
}
});
}
module.exports = {
NewCallbackByteStream,
NewVirtioFrameStream,
NewWispPacketStream,
WispPacket,
};

50
src/puter-wisp/test/test.js Normal file
View File

@ -0,0 +1,50 @@
const assert = require('assert');
const {
NewVirtioFrameStream,
NewWispPacketStream,
WispPacket,
} = require('../src/exports');
const NewTestByteStream = uint8array => {
return (async function * () {
for ( const item of uint8array ) {
yield Uint8Array.from([item]);
}
})();
};
const NewTestFullByteStream = uint8array => {
return (async function * () {
yield uint8array;
})();
};
(async () => {
const stream_behaviors = [
NewTestByteStream,
NewTestFullByteStream,
];
for ( const stream_behavior of stream_behaviors ) {
const byteStream = stream_behavior(
Uint8Array.from([
9, 0, 0, 0, // size of frame: 9 bytes (u32-L)
3, // CONTINUE (u8)
0, 0, 0, 0, // stream id: 0 (u32-L)
0x0F, 0x0F, 0, 0, // buffer size (u32-L)
])
);
const virtioStream = NewVirtioFrameStream(byteStream);
const wispStream = NewWispPacketStream(virtioStream);
const packets = [];
for await ( const packet of wispStream ) {
packets.push(packet);
}
assert.strictEqual(packets.length, 1);
const packet = packets[0];
assert.strictEqual(packet.type.id, 3);
assert.strictEqual(packet.type.label, 'CONTINUE');
assert.strictEqual(packet.type, WispPacket.CONTINUE);
}
})();