422 строки
16 KiB
TypeScript
422 строки
16 KiB
TypeScript
namespace jacdac._rolemgr {
|
|
const roleSettingPrefix = "#jdr:"
|
|
|
|
export function clearRoles() {
|
|
settings.list(roleSettingPrefix).forEach(settings.remove)
|
|
jacdac.bus.clearAttachCache()
|
|
}
|
|
|
|
export function getRole(devid: string, servIdx: number) {
|
|
return settings.readString(roleSettingPrefix + devid + ":" + servIdx)
|
|
}
|
|
|
|
export function setRole(devid: string, servIdx: number, role: string) {
|
|
const key = roleSettingPrefix + devid + ":" + servIdx
|
|
if (role) {
|
|
// drop query
|
|
const i = role.indexOf("?")
|
|
const name = i < 0 ? role : role.substr(0, i)
|
|
settings.writeString(key, name)
|
|
console.add(
|
|
jacdac.logPriority,
|
|
`role: set ${name} -> ${devid}:${servIdx}`
|
|
)
|
|
} else {
|
|
settings.remove(key)
|
|
console.add(
|
|
jacdac.logPriority,
|
|
`role: clear binding ${devid}:${servIdx}`
|
|
)
|
|
}
|
|
jacdac.bus.clearAttachCache()
|
|
}
|
|
|
|
class DeviceWrapper {
|
|
bindings: RoleBinding[] = []
|
|
score = -1
|
|
constructor(public device: Device) {}
|
|
}
|
|
|
|
class RoleBinding {
|
|
boundToDev: Device
|
|
boundToServiceIdx: number
|
|
|
|
constructor(
|
|
public readonly role: string,
|
|
public readonly serviceClass: number,
|
|
public readonly roleQuery: ClientRoleQuery
|
|
) {}
|
|
|
|
host() {
|
|
if (this.roleQuery.device) return this.roleQuery.device
|
|
const slashIdx = this.role.indexOf("/")
|
|
if (slashIdx < 0) return this.role
|
|
else return this.role.slice(0, slashIdx - 1)
|
|
}
|
|
|
|
select(devwrap: DeviceWrapper, serviceIdx: number) {
|
|
const dev = devwrap.device
|
|
if (
|
|
dev == this.boundToDev &&
|
|
serviceIdx == this.boundToServiceIdx
|
|
) {
|
|
return
|
|
}
|
|
if (this.boundToDev)
|
|
setRole(this.boundToDev.deviceId, this.boundToServiceIdx, null)
|
|
devwrap.bindings[serviceIdx] = this
|
|
setRole(dev.deviceId, serviceIdx, this.role)
|
|
this.boundToDev = dev
|
|
this.boundToServiceIdx = serviceIdx
|
|
}
|
|
}
|
|
|
|
class ServerBindings {
|
|
bindings: RoleBinding[] = []
|
|
constructor(public host: string) {}
|
|
|
|
get fullyBound() {
|
|
return this.bindings.every(b => b.boundToDev != null)
|
|
}
|
|
|
|
// candidate devices are ordered by [numBound, numPossible, device_id]
|
|
// where numBound is number of clients already bound to this device
|
|
// and numPossible is number of clients that can possibly be additionally bound
|
|
scoreFor(devwrap: DeviceWrapper, select = false) {
|
|
let numBound = 0
|
|
let numPossible = 0
|
|
const dev = devwrap.device
|
|
let missing: RoleBinding[] = []
|
|
for (const b of this.bindings) {
|
|
if (b.boundToDev) {
|
|
if (b.boundToDev == dev) numBound++
|
|
} else {
|
|
missing.push(b)
|
|
}
|
|
}
|
|
|
|
const nsrv = dev.serviceClassLength
|
|
|
|
// find next one in order of serviceOffset
|
|
for (let mi = 0; mi < missing.length; ++mi) {
|
|
const mis = missing[mi]
|
|
if (mis.roleQuery.serviceOffset >= 0) {
|
|
// lookup the serviceIndex
|
|
const serviceIndex = dev.serviceIndexAtOffset(
|
|
mis.serviceClass,
|
|
mis.roleQuery.serviceOffset
|
|
)
|
|
if (serviceIndex < 0 || devwrap.bindings[serviceIndex])
|
|
continue
|
|
// we've got a match!
|
|
numPossible++ // this can be assigned
|
|
// in fact, assign if requested
|
|
if (select) {
|
|
mis.select(devwrap, serviceIndex)
|
|
console.add(
|
|
jacdac.logPriority,
|
|
`bind srvo: ${missing[mi].role} -> ${dev.shortId}:${serviceIndex} -> ${missing[mi].boundToDev}:${missing[mi].boundToServiceIdx}`
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
missing = missing.filter(m => !m.boundToDev)
|
|
|
|
// find next one in order
|
|
for (let serviceIndex = 1; serviceIndex < nsrv; serviceIndex++) {
|
|
// if service is already bound to some client, move on
|
|
if (devwrap.bindings[serviceIndex]) continue
|
|
|
|
const serviceClass = dev.serviceClassAt(serviceIndex)
|
|
for (let mi = 0; mi < missing.length; ++mi) {
|
|
if (missing[mi].serviceClass == serviceClass) {
|
|
// we've got a match!
|
|
numPossible++ // this can be assigned
|
|
// in fact, assign if requested
|
|
if (select) {
|
|
missing[mi].select(devwrap, serviceIndex)
|
|
console.add(
|
|
jacdac.logPriority,
|
|
`bind order: ${missing[mi].role} -> ${dev.shortId}:${serviceIndex} -> ${missing[mi].boundToDev}:${missing[mi].boundToServiceIdx}`
|
|
)
|
|
}
|
|
// this one is no longer missing
|
|
missing.splice(mi, 1)
|
|
// move on to the next service in announce
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// if nothing can be assigned, the score is zero
|
|
if (numPossible == 0) return 0
|
|
|
|
// otherwise the score is [numBound, numPossible], lexicographic
|
|
// numPossible can't be larger than ~64, leave it a few more bits
|
|
return (numBound << 8) | numPossible
|
|
}
|
|
}
|
|
|
|
function maxIn<T>(
|
|
arr: T[],
|
|
cmp: (a: T, b: T) => number,
|
|
cmdTie: (a: T, b: T) => number
|
|
) {
|
|
let maxElt = arr[0]
|
|
for (let i = 1; i < arr.length; ++i) {
|
|
const c = cmp(maxElt, arr[i])
|
|
if (c < 0 || (c == 0 && cmdTie(maxElt, arr[i]) < 0)) maxElt = arr[i]
|
|
}
|
|
return maxElt
|
|
}
|
|
|
|
export class RoleManagerServer extends Server {
|
|
private _oldBindingsHash: number
|
|
public autoBind = true
|
|
|
|
constructor() {
|
|
super(jacdac.SRV_ROLE_MANAGER)
|
|
}
|
|
|
|
public handlePacket(packet: JDPacket) {
|
|
this.autoBind = this.handleRegBool(
|
|
packet,
|
|
jacdac.RoleManagerReg.AutoBind,
|
|
this.autoBind
|
|
)
|
|
|
|
switch (packet.serviceCommand) {
|
|
case jacdac.RoleManagerReg.AllRolesAllocated | CMD_GET_REG:
|
|
this.sendReport(
|
|
JDPacket.jdpacked(
|
|
jacdac.RoleManagerReg.AllRolesAllocated |
|
|
CMD_GET_REG,
|
|
jacdac.RoleManagerRegPack.AllRolesAllocated,
|
|
[
|
|
jacdac.bus.allClients.every(
|
|
c => c.broadcast || !!c.device
|
|
)
|
|
? 1
|
|
: 0,
|
|
]
|
|
)
|
|
)
|
|
break
|
|
case jacdac.RoleManagerCmd.SetRole:
|
|
if (packet.data.length >= 9)
|
|
setRole(
|
|
packet.data.slice(0, 8).toHex(),
|
|
packet.data[8],
|
|
packet.data.slice(9).toString()
|
|
)
|
|
break
|
|
case jacdac.RoleManagerCmd.ListRoles:
|
|
OutPipe.respondForEach(
|
|
packet,
|
|
jacdac.bus.allClients,
|
|
packName
|
|
)
|
|
break
|
|
case jacdac.RoleManagerCmd.ClearAllRoles:
|
|
clearRoles()
|
|
break
|
|
default:
|
|
packet.possiblyNotImplemented()
|
|
break
|
|
}
|
|
|
|
function packName(c: Client) {
|
|
const devid = c.device
|
|
? Buffer.fromHex(c.device.deviceId)
|
|
: Buffer.create(8)
|
|
const servidx = c.device ? c.serviceIndex : 0
|
|
return jdpack("b[8] u32 u8 s", [
|
|
devid,
|
|
c.serviceClass,
|
|
servidx,
|
|
c.role,
|
|
])
|
|
}
|
|
}
|
|
|
|
private bindingHash() {
|
|
let r = ""
|
|
const n = jacdac.bus.allClients.length
|
|
for (let i = 0; i < n; ++i) {
|
|
const client = jacdac.bus.allClients[i]
|
|
r += `${client.role || ""}:${
|
|
client.broadcast ||
|
|
(client.device && client.device.deviceId) ||
|
|
""
|
|
}:${client.serviceIndex}`
|
|
}
|
|
const buf = Buffer.fromUTF8(r)
|
|
return buf.hash(32)
|
|
}
|
|
|
|
bindRoles() {
|
|
if (!this.running) return
|
|
|
|
// sanity check and unbind any self roles if the self device is running
|
|
for (const cl of jacdac.bus.allClients) {
|
|
if (!cl.broadcast && cl.role && !!cl.device) {
|
|
const query = cl.roleQuery
|
|
if (query && query.device === "self") {
|
|
// check if we have a server running on this device
|
|
// that matches
|
|
const serviceClass = cl.serviceClass
|
|
const services = jacdac.bus.servers.filter(
|
|
server => server.serviceClass == serviceClass
|
|
)
|
|
if (services.length) {
|
|
if (cl.device != jacdac.bus.selfDevice) {
|
|
// we have a server running on this device
|
|
// so we can unbind it
|
|
//console.log(`unbind role: reassign to self`)
|
|
setRole(cl.device.deviceId, cl.serviceIndex, "")
|
|
} else {
|
|
const serviceOffset = query.serviceOffset
|
|
if (
|
|
!isNaN(serviceOffset) &&
|
|
(!services[query.serviceOffset] ||
|
|
services[query.serviceOffset]
|
|
.serviceIndex != cl.serviceIndex)
|
|
) {
|
|
//console.log(`unbind role: reassign to service offset`)
|
|
setRole(
|
|
cl.device.deviceId,
|
|
cl.serviceIndex,
|
|
""
|
|
)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (jacdac.bus.unattachedClients.length == 0) {
|
|
//console.log(`all clients bound`)
|
|
this.checkChanges()
|
|
return
|
|
}
|
|
this.log(
|
|
`autobind: devs:${jacdac.bus.devices.length}, clients:${jacdac.bus.allClients.length}, unbound:${jacdac.bus.unattachedClients.length}`
|
|
)
|
|
|
|
const bindings: RoleBinding[] = []
|
|
const wraps = bus.devices.map(d => new DeviceWrapper(d))
|
|
|
|
for (const cl of jacdac.bus.allClients) {
|
|
if (!cl.broadcast && cl.role) {
|
|
const b = new RoleBinding(
|
|
cl.role,
|
|
cl.serviceClass,
|
|
cl.roleQuery
|
|
)
|
|
if (cl.device) {
|
|
b.boundToDev = cl.device
|
|
b.boundToServiceIdx = cl.serviceIndex
|
|
for (const w of wraps)
|
|
if (w.device == cl.device) {
|
|
w.bindings[cl.serviceIndex] = b
|
|
break
|
|
}
|
|
}
|
|
bindings.push(b)
|
|
}
|
|
}
|
|
|
|
let servers: ServerBindings[] = []
|
|
|
|
// Group all clients by host
|
|
for (const b of bindings) {
|
|
const hn = b.host()
|
|
let h = servers.find(h => h.host == hn)
|
|
if (!h) {
|
|
h = new ServerBindings(hn)
|
|
servers.push(h)
|
|
}
|
|
h.bindings.push(b)
|
|
}
|
|
|
|
this.log(`found ${servers.length} servers`)
|
|
// exclude hosts that have already everything bound
|
|
servers = servers.filter(h => !h.fullyBound)
|
|
|
|
this.log(`binding ${servers.length} servers`)
|
|
|
|
while (servers.length > 0) {
|
|
// Get host with maximum number of clients (resolve ties by name)
|
|
// This gives priority to assignment of "more complicated" hosts, which are generally more difficult to assign
|
|
const h = maxIn(
|
|
servers,
|
|
(a, b) => a.bindings.length - b.bindings.length,
|
|
(a, b) => b.host.compare(a.host)
|
|
)
|
|
//console.log(`bind server: ${h.host}, ${h.bindings.length} bindings`)
|
|
|
|
for (const d of wraps) {
|
|
d.score = h.scoreFor(d)
|
|
//console.log(`bind score: ${d.device.deviceId} ${d.score}`)
|
|
}
|
|
|
|
const dev = maxIn(
|
|
wraps,
|
|
(a, b) => a.score - b.score,
|
|
(a, b) => b.device.deviceId.compare(a.device.deviceId)
|
|
)
|
|
if (dev.score == 0) {
|
|
// nothing can be assigned, on any device
|
|
//console.log(`bind server: ${h.host}, nothing can be assigned`)
|
|
servers.removeElement(h)
|
|
continue
|
|
}
|
|
|
|
// assign services in order of names - this way foo/servo1 will be assigned before foo/servo2
|
|
// in list of advertised services and svro
|
|
h.bindings.sort((a, b) => {
|
|
let c = a.serviceClass - b.serviceClass
|
|
if (c) return c
|
|
c = a.roleQuery.serviceOffset - b.roleQuery.serviceOffset
|
|
if (c) return c
|
|
return a.role.compare(b.role)
|
|
})
|
|
|
|
// "recompute" score, assigning names in process
|
|
const score = h.scoreFor(dev, true)
|
|
//console.log(`bind score: ${score} (${h.fullyBound ? "bound" : "needs bindings"})`)
|
|
|
|
// if everything bound on this host, remove it from further consideration
|
|
if (h.fullyBound) servers.removeElement(h)
|
|
else {
|
|
// otherwise, remove bindings on the current device, to update sort order
|
|
// it's unclear we need this
|
|
h.bindings = h.bindings.filter(
|
|
b => b.boundToDev != dev.device
|
|
)
|
|
}
|
|
}
|
|
this.checkChanges()
|
|
}
|
|
|
|
private checkChanges() {
|
|
// notify clients that something changed
|
|
const newHash = this.bindingHash()
|
|
if (this._oldBindingsHash !== newHash) {
|
|
this._oldBindingsHash = newHash
|
|
this.log(`roles: bindings changed`)
|
|
this.sendChangeEvent()
|
|
} else {
|
|
//console.log(`auto bind: no changes`)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
namespace jacdac {
|
|
//% fixedInstance whenUsed weight=1 block="role manager"
|
|
export const roleManagerServer = new _rolemgr.RoleManagerServer()
|
|
}
|