@dxos/echo-pipeline 0.3.11-main.00a28cb → 0.3.11-main.0999ea0

package/src/automerge/automerge-host.test.ts

@@ -4,16 +4,18 @@
 
 import { randomBytes } from 'crypto';
 import expect from 'expect';
+import waitForExpect from 'wait-for-expect';
 
 import { Trigger, asyncTimeout, sleep } from '@dxos/async';
 import { type Message, NetworkAdapter, type PeerId, Repo } from '@dxos/automerge/automerge-repo';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 import { StorageType, createStorage } from '@dxos/random-access-storage';
-import { describe, test } from '@dxos/test';
+import { TestBuilder as TeleportBuilder, TestPeer as TeleportPeer } from '@dxos/teleport/testing';
+import { afterTest, describe, test } from '@dxos/test';
 import { arrayToBuffer, bufferToArray } from '@dxos/util';
 
-import { AutomergeHost, AutomergeStorageAdapter } from './automerge-host';
+import { AutomergeHost, AutomergeStorageAdapter, MeshNetworkAdapter } from './automerge-host';
 
 describe('AutomergeHost', () => {
   test('can create documents', () => {
@@ -46,13 +48,12 @@ describe('AutomergeHost', () => {
   });
 
   test('basic networking', async () => {
-    type Context = { client: Trigger<TestAdapter>; host: Trigger<TestAdapter> };
-    const context: Context = {
-      client: new Trigger<TestAdapter>(),
-      host: new Trigger<TestAdapter>(),
-    };
-    const hostAdapter = new TestAdapter(context, 'host');
-    const clientAdapter = new TestAdapter(context, 'client');
+    const hostAdapter: TestAdapter = new TestAdapter({
+      send: (message: Message) => clientAdapter.receive(message),
+    });
+    const clientAdapter: TestAdapter = new TestAdapter({
+      send: (message: Message) => hostAdapter.receive(message),
+    });
 
     const host = new Repo({
       network: [hostAdapter],
@@ -62,6 +63,10 @@ describe('AutomergeHost', () => {
     });
     hostAdapter.ready();
     clientAdapter.ready();
+    await hostAdapter.onConnect.wait();
+    await clientAdapter.onConnect.wait();
+    hostAdapter.peerCandidate(clientAdapter.peerId!);
+    clientAdapter.peerCandidate(hostAdapter.peerId!);
 
     const handle = host.create();
     const text = 'Hello world';
@@ -70,11 +75,147 @@ describe('AutomergeHost', () => {
     });
 
     const docOnClient = client.find(handle.url);
-    await asyncTimeout(docOnClient.whenReady(), 3_000);
-    expect(docOnClient.docSync().text).toEqual(text);
+    expect((await asyncTimeout(docOnClient.doc(), 1000)).text).toEqual(text);
+  });
+
+  test('recovering from a lost connection', async () => {
+    let connectionState: 'on' | 'off' = 'on';
+
+    const hostAdapter: TestAdapter = new TestAdapter({
+      send: (message: Message) => connectionState === 'on' && sleep(10).then(() => clientAdapter.receive(message)),
+    });
+    const clientAdapter: TestAdapter = new TestAdapter({
+      send: (message: Message) => connectionState === 'on' && sleep(10).then(() => hostAdapter.receive(message)),
+    });
+
+    const host = new Repo({
+      network: [hostAdapter],
+    });
+    const client = new Repo({
+      network: [clientAdapter],
+    });
+
+    // Establish connection.
+    hostAdapter.ready();
+    clientAdapter.ready();
+    await hostAdapter.onConnect.wait();
+    await clientAdapter.onConnect.wait();
+    hostAdapter.peerCandidate(clientAdapter.peerId!);
+    clientAdapter.peerCandidate(hostAdapter.peerId!);
+
+    const handle = host.create();
+    const docOnClient = client.find(handle.url);
+    {
+      const sanityText = 'Hello world';
+      handle.change((doc: any) => {
+        doc.sanityText = sanityText;
+      });
+
+      expect((await asyncTimeout(docOnClient.doc(), 1000)).sanityText).toEqual(sanityText);
+    }
+
+    // Disrupt connection.
+    const offlineText = 'This has been written while the connection was off';
+    {
+      connectionState = 'off';
+
+      handle.change((doc: any) => {
+        doc.offlineText = offlineText;
+      });
+
+      await sleep(100);
+      expect((await asyncTimeout(docOnClient.doc(), 1000)).offlineText).toBeUndefined();
+    }
+
+    // Re-establish connection.
+    const onlineText = 'This has been written after the connection was re-established';
+    {
+      connectionState = 'on';
+      hostAdapter.peerDisconnected(clientAdapter.peerId!);
+      clientAdapter.peerDisconnected(hostAdapter.peerId!);
+      hostAdapter.peerCandidate(clientAdapter.peerId!);
+      clientAdapter.peerCandidate(hostAdapter.peerId!);
+
+      handle.change((doc: any) => {
+        doc.onlineText = onlineText;
+      });
+      await sleep(100);
+      expect((await asyncTimeout(docOnClient.doc(), 1000)).onlineText).toEqual(onlineText);
+      expect((await asyncTimeout(docOnClient.doc(), 1000)).offlineText).toEqual(offlineText);
+    }
   });
 
-  test('doubled connection', async () => {});
+  test('integration test with teleport', async () => {
+    const createAutomergeRepo = () => {
+      const meshAdapter = new MeshNetworkAdapter();
+      const repo = new Repo({
+        network: [meshAdapter],
+      });
+      meshAdapter.ready();
+      return { repo, meshAdapter };
+    };
+    const peer1 = createAutomergeRepo();
+    const peer2 = createAutomergeRepo();
+    const handle = peer1.repo.create();
+
+    const teleportBuilder = new TeleportBuilder();
+    afterTest(() => teleportBuilder.destroy());
+
+    const [teleportPeer1, teleportPeer2] = teleportBuilder.createPeers({ factory: () => new TeleportPeer() });
+    {
+      // Initiate connection.
+      const [connection1, connection2] = await teleportBuilder.connect(teleportPeer1, teleportPeer2);
+      connection1.teleport.addExtension('automerge', peer1.meshAdapter.createExtension());
+      connection2.teleport.addExtension('automerge', peer2.meshAdapter.createExtension());
+
+      // Test connection.
+      const text = 'Hello world';
+      handle.change((doc: any) => {
+        doc.text = text;
+      });
+      const docOnPeer2 = peer2.repo.find(handle.url);
+      await waitForExpect(async () => expect((await asyncTimeout(docOnPeer2.doc(), 1000)).text).toEqual(text), 1000);
+    }
+
+    const offlineText = 'This has been written while the connection was off';
+    {
+      // Disconnect peers.
+      await teleportBuilder.disconnect(teleportPeer1, teleportPeer2);
+
+      // Make offline changes.
+      const offlineText = 'This has been written while the connection was off';
+      handle.change((doc: any) => {
+        doc.offlineText = offlineText;
+      });
+      const docOnPeer2 = peer2.repo.find(handle.url);
+      await sleep(100);
+      expect((await asyncTimeout(docOnPeer2.doc(), 1000)).offlineText).toBeUndefined();
+    }
+
+    {
+      // Reconnect peers.
+      const [connection1, connection2] = await teleportBuilder.connect(teleportPeer1, teleportPeer2);
+      connection1.teleport.addExtension('automerge', peer1.meshAdapter.createExtension());
+      connection2.teleport.addExtension('automerge', peer2.meshAdapter.createExtension());
+
+      // Wait for offline changes to be synced.
+      const docOnPeer2 = peer2.repo.find(handle.url);
+      await waitForExpect(
+        async () => expect((await asyncTimeout(docOnPeer2.doc(), 1000)).offlineText).toEqual(offlineText),
+        1000,
+      );
+
+      // Test connection.
+      const onlineText = 'This has been written after the connection was re-established';
+      handle.change((doc: any) => {
+        doc.onlineText = onlineText;
+      });
+      await waitForExpect(
+        async () => expect((await asyncTimeout(docOnPeer2.doc(), 1000)).onlineText).toEqual(onlineText),
+        1000,
+      );
+    }
+  });
 
   describe('storage', () => {
     test('load range on node', async () => {
@@ -100,13 +241,135 @@ describe('AutomergeHost', () => {
         ]);
       }
     });
+
+    test('removeRange on node', async () => {
+      const root = `/tmp/${randomBytes(16).toString('hex')}`;
+      {
+        const storage = createStorage({ type: StorageType.NODE, root });
+        const adapter = new AutomergeStorageAdapter(storage.createDirectory());
+        await adapter.save(['test', '1'], bufferToArray(Buffer.from('one')));
+        await adapter.save(['test', '2'], bufferToArray(Buffer.from('two')));
+        await adapter.save(['bar', '1'], bufferToArray(Buffer.from('bar')));
+      }
+
+      {
+        const storage = createStorage({ type: StorageType.NODE, root });
+        const adapter = new AutomergeStorageAdapter(storage.createDirectory());
+        await adapter.removeRange(['test']);
+        const range = await adapter.loadRange(['test']);
+        expect(range.map((chunk) => arrayToBuffer(chunk.data!).toString())).toEqual([]);
+        const range2 = await adapter.loadRange(['bar']);
+        expect(range2.map((chunk) => arrayToBuffer(chunk.data!).toString())).toEqual(['bar']);
+        expect(range2.map((chunk) => chunk.key)).toEqual([['bar', '1']]);
+      }
+    });
+  });
+
+  test('replication though a 4 peer chain', async () => {
+    const pairAB = TestAdapter.createPair();
+    const pairBC = TestAdapter.createPair();
+    const pairCD = TestAdapter.createPair();
+
+    const repoA = new Repo({
+      peerId: 'A' as any,
+      network: [pairAB[0]],
+      sharePolicy: async () => true,
+    });
+    const _repoB = new Repo({
+      peerId: 'B' as any,
+      network: [pairAB[1], pairBC[0]],
+      sharePolicy: async () => true,
+    });
+    const _repoC = new Repo({
+      peerId: 'C' as any,
+      network: [pairBC[1], pairCD[0]],
+      sharePolicy: async () => true,
+    });
+    const repoD = new Repo({
+      peerId: 'D' as any,
+      network: [pairCD[1]],
+      sharePolicy: async () => true,
+    });
+
+    for (const pair of [pairAB, pairBC, pairCD]) {
+      pair[0].ready();
+      pair[1].ready();
+      await pair[0].onConnect.wait();
+      await pair[1].onConnect.wait();
+      pair[0].peerCandidate(pair[1].peerId!);
+      pair[1].peerCandidate(pair[0].peerId!);
+    }
+
+    const docA = repoA.create();
+    // NOTE: Doesn't work if the doc is empty.
+    docA.change((doc: any) => {
+      doc.text = 'Hello world';
+    });
+
+    // If we wait here for replication to finish naturally, the test will pass.
+
+    const docD = repoD.find(docA.url);
+
+    await docD.whenReady();
   });
-});
 
-type Context = { client: Trigger<TestAdapter>; host: Trigger<TestAdapter> };
+  test('replication though a 3 peer chain', async () => {
+    const pairAB = TestAdapter.createPair();
+    const pairBC = TestAdapter.createPair();
+
+    const repoA = new Repo({
+      peerId: 'A' as any,
+      network: [pairAB[0]],
+      sharePolicy: async () => true,
+    });
+    const repoB = new Repo({
+      peerId: 'B' as any,
+      network: [pairAB[1], pairBC[0]],
+      sharePolicy: async () => true,
+    });
+    const repoC = new Repo({
+      peerId: 'C' as any,
+      network: [pairBC[1]],
+      sharePolicy: async () => true,
+    });
+
+    for (const pair of [pairAB, pairBC]) {
+      pair[0].ready();
+      pair[1].ready();
+      await pair[0].onConnect.wait();
+      await pair[1].onConnect.wait();
+      pair[0].peerCandidate(pair[1].peerId!);
+      pair[1].peerCandidate(pair[0].peerId!);
+    }
+
+    const docA = repoA.create();
+    // NOTE: Doesn't work if the doc is empty.
+    docA.change((doc: any) => {
+      doc.text = 'Hello world';
+    });
+
+    const _docB = repoB.find(docA.url);
+    const docC = repoC.find(docA.url);
+
+    await docC.whenReady();
+  });
+});
 
 class TestAdapter extends NetworkAdapter {
-  constructor(public readonly context: Context, public readonly role: 'host' | 'client') {
+  static createPair() {
+    const adapter1: TestAdapter = new TestAdapter({
+      send: (message: Message) => sleep(10).then(() => adapter2.receive(message)),
+    });
+    const adapter2: TestAdapter = new TestAdapter({
+      send: (message: Message) => sleep(10).then(() => adapter1.receive(message)),
+    });
+
+    return [adapter1, adapter2];
+  }
+
+  public onConnect = new Trigger();
+
+  constructor(private readonly _params: { send: (message: Message) => void }) {
     super();
   }
 
@@ -118,32 +381,26 @@ class TestAdapter extends NetworkAdapter {
 
   override connect(peerId: PeerId) {
     this.peerId = peerId;
-    this.context[this.role].wake(this);
-    this.context[this.role === 'host' ? 'client' : 'host']
-      .wait()
-      .then((adapter) => {
-        invariant(adapter.peerId, 'Peer id is not set');
-        this.emit('peer-candidate', { peerId: adapter.peerId });
-      })
-      .catch((error) => {
-        log.catch(error);
-      });
+    this.onConnect.wake();
+  }
+
+  peerCandidate(peerId: PeerId) {
+    invariant(peerId, 'PeerId is required');
+    this.emit('peer-candidate', { peerId, peerMetadata: {} });
+  }
+
+  peerDisconnected(peerId: PeerId) {
+    invariant(peerId, 'PeerId is required');
+    this.emit('peer-disconnected', { peerId });
   }
 
   override send(message: Message) {
-    this.context[this.role === 'host' ? 'client' : 'host']
-      .wait()
-      .then((adapter) => {
-        adapter.receive(message);
-      })
-      .catch((error) => {
-        log.catch(error);
-      });
+    log('send', { from: message.senderId, to: message.targetId, type: message.type });
+    this._params.send(message);
   }
 
   override disconnect() {
     this.peerId = undefined;
-    this.context[this.role].reset();
   }
 
   receive(message: Message) {

package/src/automerge/automerge-host.ts

@@ -2,6 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
+import { Trigger } from '@dxos/async';
 import {
   Repo,
   NetworkAdapter,
@@ -15,12 +16,13 @@ import {
 import { IndexedDBStorageAdapter } from '@dxos/automerge/automerge-repo-storage-indexeddb';
 import { Stream } from '@dxos/codec-protobuf';
 import { invariant } from '@dxos/invariant';
+import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { type HostInfo, type SyncRepoRequest, type SyncRepoResponse } from '@dxos/protocols/proto/dxos/echo/service';
 import { type PeerInfo } from '@dxos/protocols/proto/dxos/mesh/teleport/automerge';
 import { StorageType, type Directory } from '@dxos/random-access-storage';
 import { AutomergeReplicator } from '@dxos/teleport-extension-automerge-replicator';
-import { arrayToBuffer, bufferToArray } from '@dxos/util';
+import { ComplexMap, ComplexSet, arrayToBuffer, bufferToArray, defaultMap } from '@dxos/util';
 
 export class AutomergeHost {
   private readonly _repo: Repo;
@@ -28,6 +30,11 @@ export class AutomergeHost {
   private readonly _clientNetwork: LocalHostNetworkAdapter;
   private readonly _storage: StorageAdapter;
 
+  /**
+   * spaceKey -> deviceKey[]
+   */
+  private readonly _authorizedDevices = new ComplexMap<PublicKey, ComplexSet<PublicKey>>(PublicKey.hash);
+
   constructor(storageDirectory: Directory) {
     this._meshNetwork = new MeshNetworkAdapter();
     this._clientNetwork = new LocalHostNetworkAdapter();
@@ -38,11 +45,52 @@ export class AutomergeHost {
         ? new IndexedDBStorageAdapter(storageDirectory.path, 'data')
         : new AutomergeStorageAdapter(storageDirectory);
     this._repo = new Repo({
+      peerId: `host-${PublicKey.random().toHex()}` as PeerId,
       network: [this._clientNetwork, this._meshNetwork],
       storage: this._storage,
 
       // TODO(dmaretskyi): Share based on HALO permissions and space affinity.
-      sharePolicy: async (peerId, documentId) => true, // Share everything.
+      // Hosts, running in the worker, don't share documents unless requested by other peers.
+      sharePolicy: async (peerId /* device key */, documentId /* space key */) => {
+        if (peerId.startsWith('client-')) {
+          return true;
+        }
+
+        if (!documentId) {
+          return false;
+        }
+
+        const doc = this._repo.handles[documentId]?.docSync();
+        if (!doc) {
+          log('doc not found for share policy check', { peerId, documentId });
+          return false;
+        }
+
+        try {
+          if (!doc.experimental_spaceKey) {
+            log.warn('space key not found for share policy check', { peerId, documentId });
+            return false;
+          }
+
+          const spaceKey = PublicKey.from(doc.experimental_spaceKey);
+          const authorizedDevices = this._authorizedDevices.get(spaceKey);
+
+          // TODO(mykola): Hack, stop abusing `peerMetadata` field.
+          const deviceKeyHex = (this.repo.peerMetadataByPeerId[peerId] as any)?.dxos_deviceKey;
+          if (!deviceKeyHex) {
+            log.warn('device key not found for share policy check', { peerId, documentId });
+            return false;
+          }
+          const deviceKey = PublicKey.from(deviceKeyHex);
+
+          const isAuthorized = authorizedDevices?.has(deviceKey) ?? false;
+          log.info('share policy check', { peerId, documentId, deviceKey, spaceKey, isAuthorized });
+          return isAuthorized;
+        } catch (err) {
+          log.catch(err);
+          return false;
+        }
+      }, // Share everything.
     });
     this._clientNetwork.ready();
     this._meshNetwork.ready();
@@ -53,6 +101,7 @@ export class AutomergeHost {
   }
 
   async close() {
+    this._storage instanceof AutomergeStorageAdapter && (await this._storage.close());
     await this._clientNetwork.close();
   }
 
@@ -68,7 +117,7 @@ export class AutomergeHost {
     return this._clientNetwork.sendSyncMessage(request);
   }
 
-  getHostInfo(): HostInfo {
+  async getHostInfo(): Promise<HostInfo> {
     return this._clientNetwork.getHostInfo();
   }
 
@@ -79,6 +128,10 @@ export class AutomergeHost {
   createExtension(): AutomergeReplicator {
     return this._meshNetwork.createExtension();
   }
+
+  authorizeDevice(spaceKey: PublicKey, deviceKey: PublicKey) {
+    defaultMap(this._authorizedDevices, spaceKey, () => new ComplexSet(PublicKey.hash)).add(deviceKey);
+  }
 }
 
 type ClientSyncState = {
@@ -104,8 +157,11 @@ class LocalHostNetworkAdapter extends NetworkAdapter {
     });
   }
 
+  private _connected = new Trigger();
+
   override connect(peerId: PeerId): void {
     this.peerId = peerId;
+    this._connected.wake();
     // No-op. Client always connects first
   }
 
@@ -146,18 +202,26 @@ class LocalHostNetworkAdapter extends NetworkAdapter {
         },
       });
 
-      this.emit('peer-candidate', {
-        peerId,
-      });
+      this._connected
+        .wait({ timeout: 1_000 })
+        .then(() => {
+          this.emit('peer-candidate', {
+            peerMetadata: {},
+            peerId,
+          });
+        })
+        .catch((err) => log.catch(err));
     });
   }
 
   async sendSyncMessage({ id, syncMessage }: SyncRepoRequest): Promise<void> {
+    await this._connected.wait({ timeout: 1_000 });
     const message = cbor.decode(syncMessage!) as Message;
     this.emit('message', message);
   }
 
-  getHostInfo(): HostInfo {
+  async getHostInfo(): Promise<HostInfo> {
+    await this._connected.wait({ timeout: 1_000 });
     invariant(this.peerId, 'Peer id not set.');
     return {
       peerId: this.peerId,
@@ -172,7 +236,7 @@ class LocalHostNetworkAdapter extends NetworkAdapter {
 /**
  * Used to replicate with other peers over the network.
  */
-class MeshNetworkAdapter extends NetworkAdapter {
+export class MeshNetworkAdapter extends NetworkAdapter {
   private readonly _extensions: Map<string, AutomergeReplicator> = new Map();
 
   /**
@@ -210,7 +274,7 @@ class MeshNetworkAdapter extends NetworkAdapter {
         peerId: this.peerId,
       },
       {
-        onStartReplication: async (info) => {
+        onStartReplication: async (info, remotePeerId /** Teleport ID */) => {
           // Note: We store only one extension per peer.
           //       There can be a case where two connected peers have more than one teleport connection between them
           //       and each of them uses different teleport connections to send messages.
@@ -224,6 +288,10 @@ class MeshNetworkAdapter extends NetworkAdapter {
           // TODO(mykola): Fix race condition?
           this._extensions.set(info.id, extension);
           this.emit('peer-candidate', {
+            // TODO(mykola): Hack, stop abusing `peerMetadata` field.
+            peerMetadata: {
+              dxos_deviceKey: remotePeerId.toHex(),
+            } as any,
             peerId: info.id as PeerId,
           });
         },
@@ -233,10 +301,13 @@ class MeshNetworkAdapter extends NetworkAdapter {
           this.emit('message', message);
         },
         onClose: async () => {
-          peerInfo &&
-            this.emit('peer-disconnected', {
-              peerId: peerInfo.id as PeerId,
-            });
+          if (!peerInfo) {
+            return;
+          }
+          this.emit('peer-disconnected', {
+            peerId: peerInfo.id as PeerId,
+          });
+          this._extensions.delete(peerInfo.id);
         },
       },
     );
@@ -245,11 +316,18 @@ class MeshNetworkAdapter extends NetworkAdapter {
 }
 
 export class AutomergeStorageAdapter extends StorageAdapter {
+  // TODO(mykola): Hack for restricting automerge Repo to access storage if Host is `closed`.
+  //               Automerge Repo do not have any lifetime management.
+  private _state: 'opened' | 'closed' = 'opened';
+
   constructor(private readonly _directory: Directory) {
     super();
   }
 
   override async load(key: StorageKey): Promise<Uint8Array | undefined> {
+    if (this._state !== 'opened') {
+      return undefined;
+    }
     const filename = this._getFilename(key);
     const file = this._directory.getOrCreateFile(filename);
     const { size } = await file.stat();
@@ -261,6 +339,9 @@ export class AutomergeStorageAdapter extends StorageAdapter {
   }
 
   override async save(key: StorageKey, data: Uint8Array): Promise<void> {
+    if (this._state !== 'opened') {
+      return undefined;
+    }
     const filename = this._getFilename(key);
     const file = this._directory.getOrCreateFile(filename);
     await file.write(0, arrayToBuffer(data));
@@ -270,13 +351,19 @@ export class AutomergeStorageAdapter extends StorageAdapter {
   }
 
   override async remove(key: StorageKey): Promise<void> {
+    if (this._state !== 'opened') {
+      return undefined;
+    }
     // TODO(dmaretskyi): Better deletion.
     const filename = this._getFilename(key);
     const file = this._directory.getOrCreateFile(filename);
-    await file.truncate?.(0);
+    await file.destroy();
   }
 
   override async loadRange(keyPrefix: StorageKey): Promise<Chunk[]> {
+    if (this._state !== 'opened') {
+      return [];
+    }
     const filename = this._getFilename(keyPrefix);
     const entries = await this._directory.list();
     return Promise.all(
@@ -295,18 +382,25 @@ export class AutomergeStorageAdapter extends StorageAdapter {
   }
 
   override async removeRange(keyPrefix: StorageKey): Promise<void> {
+    if (this._state !== 'opened') {
+      return undefined;
+    }
     const filename = this._getFilename(keyPrefix);
     const entries = await this._directory.list();
     await Promise.all(
       entries
         .filter((entry) => entry.startsWith(filename))
         .map(async (entry): Promise<void> => {
-          const file = this._directory.getOrCreateFile(filename);
-          await file.truncate?.(0);
+          const file = this._directory.getOrCreateFile(entry);
+          await file.destroy();
         }),
     );
   }
 
+  async close(): Promise<void> {
+    this._state = 'closed';
+  }
+
   private _getFilename(key: StorageKey): string {
     return key.map((k) => k.replaceAll('%', '%25').replaceAll('-', '%2D')).join('-');
   }

package/src/automerge/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2023 DXOS.org
 //
 
-export * from './automerge-host';
+export { AutomergeHost } from './automerge-host';