@scrypted/server 0.7.23 → 0.7.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrypted/server",
-  "version": "0.7.23",
+  "version": "0.7.25",
   "description": "",
   "dependencies": {
     "@mapbox/node-pre-gyp": "^1.0.10",

package/python/plugin_remote.py

@@ -373,8 +373,14 @@ class PluginRemote:
                 sys.version_info[0])+"."+str(sys.version_info[1])
             print('python version:', python_version)
 
+            python_versioned_directory = '%s-%s-%s' % (python_version, platform.system(), platform.machine())
+            SCRYPTED_BASE_VERSION = os.environ.get('SCRYPTED_BASE_VERSION')
+            if SCRYPTED_BASE_VERSION:
+                python_versioned_directory += SCRYPTED_BASE_VERSION
+
             python_prefix = os.path.join(
-                plugin_volume, '%s-%s-%s' % (python_version, platform.system(), platform.machine()))
+                plugin_volume, python_versioned_directory)
+
             if not os.path.exists(python_prefix):
                 os.makedirs(python_prefix)
 

package/python/rpc-iterator-test.py

@@ -1,13 +1,13 @@
 import asyncio
 import rpc
-from  rpc_reader import prepare_peer_readloop
+from  rpc_reader import prepare_peer_readloop, RpcFileTransport
 import traceback
 
 class Bar:
     pass
 
 async def main():
-    peer, peerReadLoop = await prepare_peer_readloop(loop, 4, 3)
+    peer, peerReadLoop = await prepare_peer_readloop(loop, RpcFileTransport(4, 3))
     peer.params['foo'] = 3
     jsoncopy = {}
     jsoncopy[rpc.RpcPeer.PROPERTY_JSON_COPY_SERIALIZE_CHILDREN] = True
@@ -35,8 +35,12 @@ async def main():
     test = await peer.getParam('test')
     print(test)
     try:
-        async for c in test:
+        i = 0
+        async for c in await test():
             print(c)
+            if i == 5:
+                break
+            i = i + 1
     except:
         traceback.print_exc()
     print('all done iterating')

package/python/rpc.py

@@ -79,6 +79,14 @@ class RpcProxy(object):
                 raise
         raise Exception('RpcProxy is not an async iterable')
 
+    async def aclose(self):
+        if self.__dict__[RpcPeer.PROPERTY_PROXY_PROPERTIES] and 'Symbol(Symbol.asyncIterator)' in self.__dict__[RpcPeer.PROPERTY_PROXY_PROPERTIES]:
+            try:
+                return await RpcProxyMethod(self, self.__dict__[RpcPeer.PROPERTY_PROXY_PROPERTIES]['Symbol(Symbol.asyncIterator)']['return'])()
+            except RPCResultError as e:
+                pass
+        raise Exception('RpcProxy is not an async iterable')
+
     def __getattr__(self, name):
         if name == '__proxy_finalizer_id':
             return self.dict['__proxy_entry']['finalizerId']

package/src/plugin/plugin-npm-dependencies.ts

@@ -1,18 +1,22 @@
-import { ensurePluginVolume } from "./plugin-volume";
-import fs from 'fs';
 import child_process from 'child_process';
-import path from 'path';
 import { once } from 'events';
-import process from 'process';
+import fs from 'fs';
 import mkdirp from "mkdirp";
-import semver from 'semver';
 import os from 'os';
+import path from 'path';
+import process from 'process';
 import rimraf from "rimraf";
+import semver from 'semver';
+import { ensurePluginVolume } from "./plugin-volume";
 
 export function getPluginNodePath(name: string) {
     const pluginVolume = ensurePluginVolume(name);
     const nodeMajorVersion = semver.parse(process.version).major;
-    const nodePrefix = path.join(pluginVolume, `node${nodeMajorVersion}-${process.platform}-${process.arch}`);
+    let nodeVersionedDirectory = `node${nodeMajorVersion}-${process.platform}-${process.arch}`;
+    const scryptedBase = process.env.SCRYPTED_BASE_VERSION;
+    if (scryptedBase)
+        nodeVersionedDirectory += '-' + nodeVersionedDirectory;
+    const nodePrefix = path.join(pluginVolume, nodeVersionedDirectory);
     return nodePrefix;
 }
 

package/test/rpc-python-test.ts

@@ -1,9 +1,8 @@
 import child_process from 'child_process';
+import net from 'net';
 import path from 'path';
 import type { Readable, Writable } from "stream";
 import { createDuplexRpcPeer } from '../src/rpc-serializer';
-import assert from 'assert';
-import net from 'net';
 
 async function main() {
     const server = net.createServer(client => {
@@ -21,12 +20,17 @@ async function main() {
     const rpcPeer = createDuplexRpcPeer('node', 'python', cp.stdio[3] as Readable, cp.stdio[4] as Writable);
 
     async function* test() {
-        yield 1;
-        yield 2;
-        yield 3;
+        try {
+            for (let i = 0; ; i++) {
+                yield i;
+            }
+        }
+        finally {
+            console.log('closed');
+        }
     }
 
-    rpcPeer.params['test'] = test();
+    rpcPeer.params['test'] = test;
 
     // const foo = await rpcPeer.getParam('foo');
     // assert.equal(foo, 3);