@alwaysai/device-agent 0.2.0 → 1.0.0

package/src/cloud-connection/live-updates-handler.ts

@@ -1,20 +1,27 @@
 import {
-  AppLogsMessage,
-  DeviceAgentMessagePayload,
+  AppLogsPayload,
+  ToClientMessagePayload,
   keyMirrors,
-  LiveUpdatesToggles
+  LiveStateUpdatesTogglePayload,
+  ToClientMessage
 } from '@alwaysai/device-agent-schemas';
 import { getAppLogs } from '../application-control';
 import { logger } from '../util/logger';
 import sleep from '../util/sleep';
 import { Publisher } from './publisher';
 import {
-  getAppInstallStatusMessage,
-  getAppStateMessage,
-  getDeviceStatsMessage
+  getStatusResponsePayload,
+  getAppStatePayload,
+  getDeviceStatsPayload
 } from './messages';
-import { AgentMessageTypeValue } from '@alwaysai/device-agent-schemas/lib/constants';
+import { ToClientMessageTypeValue } from '@alwaysai/device-agent-schemas';
 import { ALWAYSAI_LIVE_UPDATES_TIMEOUT_MS } from '../environment';
+import {
+  buildAppLogsMessage,
+  buildAppStateMessage,
+  buildDeviceStatsMessage,
+  buildStatusResponseMessage
+} from './message-builder';
 
 const LIVE_UPDATES_TIMEOUT = ALWAYSAI_LIVE_UPDATES_TIMEOUT_MS
   ? parseInt(ALWAYSAI_LIVE_UPDATES_TIMEOUT_MS)
@@ -22,22 +29,24 @@ const LIVE_UPDATES_TIMEOUT = ALWAYSAI_LIVE_UPDATES_TIMEOUT_MS
 
 export class LiveUpdatesHandler {
   private publisher: Publisher;
+  private clientId: string;
 
   private liveUpdatesTimeout: ReturnType<typeof setTimeout>;
   private liveUpdatesAlive = {
-    [keyMirrors.agentMessageType.device_stats]: false,
-    [keyMirrors.agentMessageType.app_state]: false,
-    [keyMirrors.agentMessageType.app_logs]: false,
-    [keyMirrors.agentMessageType.app_install_status]: false
+    [keyMirrors.toClientMessageType.device_stats]: false,
+    [keyMirrors.toClientMessageType.app_state]: false,
+    [keyMirrors.toClientMessageType.app_logs]: false,
+    [keyMirrors.toClientMessageType.status_response]: false
   };
   private liveUpdatesSleepIntervals = {
-    [keyMirrors.agentMessageType.device_stats]: 5000,
-    [keyMirrors.agentMessageType.app_state]: 5000,
-    [keyMirrors.agentMessageType.app_logs]: 5000,
-    [keyMirrors.agentMessageType.app_install_status]: 5000
+    [keyMirrors.toClientMessageType.device_stats]: 5000,
+    [keyMirrors.toClientMessageType.app_state]: 5000,
+    [keyMirrors.toClientMessageType.app_logs]: 5000,
+    [keyMirrors.toClientMessageType.status_response]: 5000
   };
+
   private appLogStreams = new Set<string>();
-  private appInstallStatuses = new Set<string>();
+  private transactionStatuses = new Set<string>();
 
   private async startAppLogStream(projectId: string) {
     logger.info(`Starting log stream for ${projectId}`);
@@ -46,7 +55,7 @@ export class LiveUpdatesHandler {
       projectId,
       args: ['--tail', '100', '--no-log-prefix']
     });
-    readable.on('data', (chunk: Buffer) => {
+    readable.on('data', async (chunk: Buffer) => {
       if (!this.appLogStreams.has(projectId)) {
         // why doesn't typescript know about this function?
         // @ts-ignore
@@ -55,13 +64,11 @@ export class LiveUpdatesHandler {
         return;
       }
       const logStr = chunk.toString();
-      const message: AppLogsMessage = {
-        messageType: keyMirrors.agentMessageType.app_logs,
-        appLogs: {
-          projectId,
-          logChunk: logStr
-        }
+      const payload: AppLogsPayload = {
+        projectId,
+        logChunk: logStr
       };
+      const message = await buildAppLogsMessage(payload, this.clientId);
       this.publisher.publishToClient(message);
     });
 
@@ -77,18 +84,18 @@ export class LiveUpdatesHandler {
   }
 
   private continuePublishing(
-    flag: AgentMessageTypeValue,
-    projectId?: string
+    flag: ToClientMessageTypeValue,
+    txId?: string
   ): boolean {
     switch (flag) {
-      case keyMirrors.agentMessageType.device_stats:
-      case keyMirrors.agentMessageType.app_state:
+      case keyMirrors.toClientMessageType.device_stats:
+      case keyMirrors.toClientMessageType.app_state:
         return this.liveUpdatesAlive[flag];
-      case keyMirrors.agentMessageType.app_install_status: {
-        if (!projectId) {
-          throw new Error(`Project ID not provided to continuePublishing!`);
+      case keyMirrors.toClientMessageType.status_response: {
+        if (!txId) {
+          throw new Error(`Transaction ID not provided to continuePublishing!`);
         }
-        return this.appInstallStatuses.has(projectId);
+        return this.transactionStatuses.has(txId);
       }
       default:
         logger.error(`Unrecognized publishable flag ${flag}`);
@@ -96,7 +103,7 @@ export class LiveUpdatesHandler {
     }
   }
 
-  private getLiveUpdatesInterval(flag: AgentMessageTypeValue): number {
+  private getLiveUpdatesInterval(flag: ToClientMessageTypeValue): number {
     const exists = this.liveUpdatesSleepIntervals[flag];
     if (exists) {
       return exists;
@@ -105,12 +112,12 @@ export class LiveUpdatesHandler {
     return -1;
   }
 
-  private setLiveUpdates(toggles: LiveUpdatesToggles) {
+  private setLiveUpdates(toggles: LiveStateUpdatesTogglePayload) {
     if (toggles.deviceStats !== undefined) {
       this.liveUpdatesAlive.device_stats = toggles.deviceStats;
     }
     if (toggles.appState !== undefined) {
-      this.liveUpdatesAlive.app_state = toggles.appState;
+      this.liveUpdatesAlive.app_logs = toggles.appState;
     }
   }
 
@@ -126,20 +133,33 @@ export class LiveUpdatesHandler {
   }
 
   private async startPublishingLiveUpdates<T extends any[]>(
-    messageType: AgentMessageTypeValue,
-    getMessageData: (...args: T) => Promise<DeviceAgentMessagePayload>,
+    messageType: ToClientMessageTypeValue,
+    payloadBuilderFunction: (...args: T) => Promise<ToClientMessagePayload>,
+    messageBuilderFunction: (
+      payload: ToClientMessagePayload,
+      txId: string
+    ) => Promise<ToClientMessage>,
     args: T,
-    projectId?: string
+    txId: string
   ) {
     logger.info(`Turned on live updates for ${messageType}`);
     // eslint-disable-next-line no-constant-condition
     while (true) {
       try {
-        const message = await getMessageData(...args);
-        if (!this.continuePublishing(messageType, projectId)) {
+        if (!this.continuePublishing(messageType, txId)) {
           logger.info(`Turned off live updates for ${messageType}`);
           break;
         }
+        const payload: ToClientMessagePayload = await payloadBuilderFunction(
+          ...args
+        );
+        logger.debug(
+          `payload returned from builder: ${JSON.stringify(payload)}`
+        );
+        const message = await messageBuilderFunction(payload, txId);
+        logger.debug(
+          `message returned from builder: ${JSON.stringify(message)}`
+        );
         this.publisher.publishToClient(message);
       } catch (e) {
         logger.error(
@@ -154,8 +174,9 @@ export class LiveUpdatesHandler {
                             Public interface
   =================================================================*/
 
-  constructor(publisher: Publisher) {
+  constructor(publisher: Publisher, clientId: string) {
     this.publisher = publisher;
+    this.clientId = clientId;
     logger.debug(
       `Toggle live updates timeout set to ${LIVE_UPDATES_TIMEOUT} ms`
     );
@@ -173,34 +194,35 @@ export class LiveUpdatesHandler {
     return this.liveUpdatesAlive.app_logs;
   }
 
-  public async enableAppInstallStatus(props: {
-    projectId: string;
-    appReleaseHash: string;
-  }) {
-    const { projectId, appReleaseHash } = props;
-    this.liveUpdatesAlive.app_install_status = true;
-    if (!this.appInstallStatuses.has(projectId)) {
-      this.appInstallStatuses.add(projectId);
+  public async enableTransactionStatus(props: { txId: string }) {
+    const { txId } = props;
+    this.liveUpdatesAlive.status_response = true;
+    if (!this.transactionStatuses.has(txId)) {
+      this.transactionStatuses.add(txId);
       // Don't wait for this call to finish since it loops until disabled
       void this.startPublishingLiveUpdates(
-        keyMirrors.agentMessageType.app_install_status,
-        getAppInstallStatusMessage,
-        [keyMirrors.appInstallStatus.in_progress, '', appReleaseHash],
-        projectId
+        keyMirrors.toClientMessageType.status_response,
+        getStatusResponsePayload,
+        buildStatusResponseMessage,
+        [keyMirrors.statusResponse.in_progress, ''],
+        txId
       );
     }
   }
 
-  public async disableAppInstallStatus(props: { projectId: string }) {
-    const { projectId } = props;
-    this.appInstallStatuses.delete(projectId);
+  public async disableTransactionStatus(props: { txId: string }) {
+    const { txId } = props;
+    this.transactionStatuses.delete(txId);
 
-    if (this.appInstallStatuses.size === 0) {
-      this.liveUpdatesAlive.app_install_status = false;
+    if (this.transactionStatuses.size === 0) {
+      this.liveUpdatesAlive.status_response = false;
     }
   }
 
-  public async handleToggles(toggles: LiveUpdatesToggles) {
+  public async handleToggles(
+    toggles: LiveStateUpdatesTogglePayload,
+    txId: string
+  ) {
     const { deviceStats, appState, appLogs } = toggles;
     this.restartLiveUpdatesTimeout();
 
@@ -210,9 +232,11 @@ export class LiveUpdatesHandler {
       if (deviceStats && currentDeviceStats !== true) {
         // Don't wait for this call to finish since it loops until disabled
         void this.startPublishingLiveUpdates(
-          keyMirrors.agentMessageType.device_stats,
-          getDeviceStatsMessage,
-          []
+          keyMirrors.toClientMessageType.device_stats,
+          getDeviceStatsPayload,
+          buildDeviceStatsMessage,
+          [],
+          txId
         );
       }
     }
@@ -223,9 +247,11 @@ export class LiveUpdatesHandler {
       if (appState && currentAppState !== true) {
         // Don't wait for this call to finish since it loops until disabled
         void this.startPublishingLiveUpdates(
-          keyMirrors.agentMessageType.app_state,
-          getAppStateMessage,
-          []
+          keyMirrors.toClientMessageType.app_state,
+          getAppStatePayload,
+          buildAppStateMessage,
+          [],
+          txId
         );
       }
     }

package/src/cloud-connection/message-builder.ts

@@ -0,0 +1,117 @@
+import {
+  AppLogsMessage,
+  AppLogsMessageType,
+  AppLogsPayload,
+  AppStateMessage,
+  AppStateMessageType,
+  AppStatePayload,
+  BaseToClientMessage,
+  DeviceStatsMessage,
+  DeviceStatsMessageType,
+  DeviceStatsPayload,
+  SignedUrlsRequestMessage,
+  SignedUrlsRequestMessageType,
+  SignedUrlsRequestPayload,
+  StatusResponseMessage,
+  StatusResponseMessageType,
+  StatusResponsePayload,
+  generateTxId,
+  getToClientTopic,
+  keyMirrors,
+  validateToDeviceAgentMessage
+} from '@alwaysai/device-agent-schemas';
+import { getDeviceUuid } from '../util/get-device-id';
+
+function buildBaseClientMessage(txId?: string): BaseToClientMessage {
+  const clientId = getDeviceUuid();
+  const baseClientMessage = {
+    timestamp: new Date().toUTCString(),
+    deviceId: clientId,
+    topic: getToClientTopic(clientId),
+    txId: txId || generateTxId()
+  };
+  return baseClientMessage;
+}
+
+// Public Message Builders
+
+// app logs
+export async function buildAppLogsMessage(
+  payload: AppLogsPayload,
+  txId?: string
+): Promise<AppLogsMessage> {
+  const baseMessage = buildBaseClientMessage(txId);
+  const messageType: AppLogsMessageType =
+    keyMirrors.toClientMessageType.app_logs;
+  const message = {
+    ...baseMessage,
+    messageType,
+    payload
+  };
+  return message;
+}
+
+// app state
+export async function buildAppStateMessage(
+  payload: AppStatePayload,
+  txId?: string
+): Promise<AppStateMessage> {
+  const baseMessage = buildBaseClientMessage(txId);
+  const messageType: AppStateMessageType =
+    keyMirrors.toClientMessageType.app_state;
+  const message = {
+    ...baseMessage,
+    messageType,
+    payload
+  };
+  return message;
+}
+
+// signed URLs
+export async function buildSignedUrlsRequestMessage(
+  payload: SignedUrlsRequestPayload,
+  txId?: string
+): Promise<SignedUrlsRequestMessage> {
+  const baseMessage = buildBaseClientMessage(txId);
+  const messageType: SignedUrlsRequestMessageType =
+    keyMirrors.toCloudMessageType.signed_urls_request;
+  const message = {
+    ...baseMessage,
+    messageType,
+    payload
+  };
+  return message;
+}
+
+// status response
+export async function buildStatusResponseMessage(
+  payload: StatusResponsePayload,
+  txId?: string
+): Promise<StatusResponseMessage> {
+  const baseMessage = buildBaseClientMessage(txId);
+  const messageType: StatusResponseMessageType =
+    keyMirrors.toClientMessageType.status_response;
+  const message = {
+    ...baseMessage,
+    messageType,
+    payload
+  };
+  const valid = validateToDeviceAgentMessage(message);
+  return message;
+}
+
+// device stats
+export async function buildDeviceStatsMessage(
+  payload: DeviceStatsPayload,
+  txId?: string
+): Promise<DeviceStatsMessage> {
+  const messageType: DeviceStatsMessageType =
+    keyMirrors.toClientMessageType.device_stats;
+  const baseMessage = buildBaseClientMessage(txId);
+  const message = {
+    ...baseMessage,
+    messageType,
+    payload
+  };
+  return message;
+}

package/src/cloud-connection/messages.ts

@@ -1,10 +1,11 @@
 import {
-  AppInstallStatusMessage,
-  AppStatePacket,
-  keyMirrors
+  AppState,
+  AppStatePayload,
+  DeviceStatsPayload,
+  StatusResponsePayload
 } from '@alwaysai/device-agent-schemas';
-import { AppInstallStatusValue } from '@alwaysai/device-agent-schemas/lib/constants';
-import { getAppStatus } from '../application-control';
+import { StatusResponseValue } from '@alwaysai/device-agent-schemas/lib/constants';
+import { getAppState } from '../application-control';
 import {
   getCpuUtil,
   getDiskUtil,
@@ -12,49 +13,40 @@ import {
 } from '../device-control/device-control';
 import { AgentConfigFile } from '../infrastructure/agent-config';
 
-export async function getAppStateMessage() {
-  const appStateMessage: AppStatePacket[] = [];
+export async function getAppStatePayload(): Promise<AppStatePayload> {
+  const appState: AppState[] = [];
   const apps = await AgentConfigFile().getApps();
   for (const app of apps) {
     const projectId = app.projectId;
-    const status = await getAppStatus({ projectId });
-    appStateMessage.push(status);
+    const status = await getAppState({ projectId });
+    appState.push(status);
   }
-  const appStatePackage = {
-    messageType: keyMirrors.agentMessageType.app_state,
-    appState: appStateMessage
+  const appStatePayload = {
+    appState: appState
   };
-  return appStatePackage;
+  return appStatePayload;
 }
 
-export async function getAppInstallStatusMessage(
-  status: AppInstallStatusValue,
-  message: string,
-  appReleaseHash: string
-): Promise<AppInstallStatusMessage> {
-  const appInstallStatusMessage: AppInstallStatusMessage = {
-    messageType: keyMirrors.agentMessageType.app_install_status,
-    appInstallStatus: {
-      status,
-      message,
-      appReleaseHash
-    }
+export async function getStatusResponsePayload(
+  status: StatusResponseValue,
+  message: string
+): Promise<StatusResponsePayload> {
+  const statusResponsePayload: StatusResponsePayload = {
+    status,
+    message
   };
-  return appInstallStatusMessage;
+  return statusResponsePayload;
 }
 
-export async function getDeviceStatsMessage() {
+export async function getDeviceStatsPayload(): Promise<DeviceStatsPayload> {
   const cpuUsage = await getCpuUtil();
   const diskUtil = await getDiskUtil();
   const memUtil = await getMemUtil();
 
-  const deviceStatsMessage = {
-    messageType: keyMirrors.agentMessageType.device_stats,
-    deviceStats: {
-      cpuUsage,
-      diskUtil,
-      usedMemoryPercentage: memUtil
-    }
+  const deviceStatsPayload: DeviceStatsPayload = {
+    cpuUsage,
+    diskUtil,
+    usedMemoryPercentage: memUtil
   };
-  return deviceStatsMessage;
+  return deviceStatsPayload;
 }

package/src/cloud-connection/publisher.ts

@@ -1,10 +1,10 @@
+import { logger } from '../util/logger';
 import {
-  DeviceAgentMessage,
-  DeviceAgentMessagePayload,
-  getClientTopic,
-  getCloudTopic
+  ToClientMessage,
+  ToCloudMessage,
+  getToClientTopic,
+  getToCloudTopic
 } from '@alwaysai/device-agent-schemas';
-import { logger } from '../util/logger';
 
 export class Publisher {
   private client: any;
@@ -15,21 +15,8 @@ export class Publisher {
   constructor(client: any, clientId: string) {
     this.client = client;
     this.clientId = clientId;
-    this.toClientTopic = getClientTopic(this.clientId);
-    this.toCloudTopic = getCloudTopic(this.clientId);
-  }
-
-  private buildMessagePacket(
-    topic: string,
-    payload: DeviceAgentMessagePayload
-  ): DeviceAgentMessage {
-    const packet = {
-      timestamp: new Date().toUTCString(),
-      deviceId: this.clientId,
-      topic,
-      payload
-    };
-    return packet;
+    this.toClientTopic = getToClientTopic(this.clientId);
+    this.toCloudTopic = getToCloudTopic(this.clientId);
   }
 
   public publish(topic: string, payload: string) {
@@ -63,23 +50,23 @@ export class Publisher {
     });
   }
 
-  public publishDeviceAgentPayload(
+  public publishDeviceAgentMessage(
     topic: string,
-    payload: DeviceAgentMessagePayload
+    message: ToClientMessage | ToCloudMessage
   ) {
-    const packet = this.buildMessagePacket(topic, payload);
-    const packetStr = JSON.stringify(packet);
+    const messageStr = JSON.stringify(message);
     logger.debug(
-      `Publishing message:\n${JSON.stringify({ topic, packet }, null, 2)}`
+      `Publishing message:\n${JSON.stringify({ topic, message }, null, 2)}`
     );
-    this.publish(topic, packetStr);
+    this.publish(topic, messageStr);
   }
 
-  public publishToClient(payload: DeviceAgentMessagePayload) {
-    this.publishDeviceAgentPayload(this.toClientTopic, payload);
+  public publishToClient(message: ToClientMessage) {
+    this.publishDeviceAgentMessage(this.toClientTopic, message);
   }
 
-  public publishToCloud(payload: DeviceAgentMessagePayload) {
-    this.publishDeviceAgentPayload(this.toCloudTopic, payload);
+  public publishToCloud(message: ToCloudMessage) {
+    // Can edit topic field in message here if we want
+    this.publishDeviceAgentMessage(this.toCloudTopic, message);
   }
 }

package/src/cloud-connection/transaction-queue.test.ts

@@ -0,0 +1,55 @@
+import { generateTxId } from '@alwaysai/device-agent-schemas';
+import { TransactionQueue } from './transaction-queue';
+
+describe('Test Transaction Queue', () => {
+  let txnQueue: TransactionQueue;
+
+  beforeEach(() => {
+    txnQueue = new TransactionQueue();
+    jest.clearAllMocks();
+  });
+
+  test('Add new to transaction queue', async () => {
+    const txId = generateTxId();
+    const projectId = '1241fad-agah-gfadg-2352dgzg';
+    txnQueue.addTxIdToQueue(txId, projectId);
+    expect(txnQueue.checkTxnInQueue(txId)).toBeTruthy();
+  });
+
+  test('Attempt to add existing to transaction queue, results in failure', async () => {
+    const txId = generateTxId();
+    const projectId = '1241fad-agah-gfadg-2352dgzg';
+    txnQueue.addTxIdToQueue(txId, projectId);
+    expect(() => txnQueue.addTxIdToQueue(txId, projectId)).toThrow(
+      `txId ${txId} is already added to the queue!`
+    );
+  });
+
+  test('Check current transaction', async () => {
+    const txId = generateTxId();
+    const projectId = '1241fad-agah-gfadg-2352dgzg';
+    txnQueue.addTxIdToQueue(txId, projectId);
+
+    const txId2 = generateTxId();
+    const projectId2 = '1241faegta-agah-gagadg-2352dgzg';
+    txnQueue.addTxIdToQueue(txId2, projectId2);
+    expect(txnQueue.getCurrentTxId()).toEqual(txId);
+  });
+
+  test('Test remove transaction from queue', async () => {
+    const txId = generateTxId();
+    const projectId = '1241fad-agah-gfadg-2352dgzg';
+    txnQueue.addTxIdToQueue(txId, projectId);
+    txnQueue.completeCurrentTxn();
+
+    expect(txnQueue.getCurrentTxId()).toBeUndefined();
+  });
+
+  test('Test get project ID for a given txId', async () => {
+    const txId = generateTxId();
+    const projectId = '1241fad-agah-gfadg-2352dgzg';
+    txnQueue.addTxIdToQueue(txId, projectId);
+
+    expect(txnQueue.getProjectIdForTxnId(txId)).toEqual(projectId);
+  });
+});

package/src/cloud-connection/transaction-queue.ts

@@ -0,0 +1,40 @@
+export class TransactionQueue {
+  private transactionList: string[];
+  private txIdToProjectIdMap: { [txId: string]: string } = {};
+
+  constructor() {
+    this.transactionList = [];
+    this.txIdToProjectIdMap = {};
+  }
+
+  public addTxIdToQueue(txId: string, projectId: string) {
+    if (!this.checkTxnInQueue(txId)) {
+      this.transactionList.push(txId);
+      this.txIdToProjectIdMap[txId] = projectId;
+    } else {
+      throw new Error(`txId ${txId} is already added to the queue!`);
+    }
+  }
+
+  public getCurrentTxId() {
+    return this.transactionList[0];
+  }
+
+  public checkTxnInQueue(txId: string) {
+    return this.transactionList.includes(txId);
+  }
+
+  public getProjectIdForTxnId(txId: string) {
+    return this.txIdToProjectIdMap[txId];
+  }
+
+  public completeTxn(txId: string) {
+    delete this.txIdToProjectIdMap[txId];
+    this.transactionList.splice(this.transactionList.indexOf(txId), 1);
+  }
+
+  public completeCurrentTxn() {
+    delete this.txIdToProjectIdMap[this.transactionList[0]];
+    this.transactionList.shift();
+  }
+}

package/src/local-connection/rabbitmq-connection.ts

@@ -57,7 +57,11 @@ export async function writeRabbitMQDockerComposeFile() {
         ports: [`${LOCAL_CONNECTION_PORT}:${LOCAL_CONNECTION_PORT}`],
         hostname: 'my-rabbit',
         restart: 'on-failure',
-        environment: [`RABBITMQ_NODE_PORT=${LOCAL_CONNECTION_PORT}`]
+        environment: [`RABBITMQ_NODE_PORT=${LOCAL_CONNECTION_PORT}`],
+        volumes: [
+          './rabbitmq/:/var/lib/rabbitmq/',
+          './rabbitmq/log/:/var/log/rabbitmq/'
+        ]
       }
     }
   };

package/src/subcommands/app/index.ts

@@ -5,7 +5,8 @@ import {
   addModelCliLeaf,
   removeModelCliLeaf,
   replaceModelsCliLeaf,
-  updateModelsCliLeaf
+  updateModelsCliLeaf,
+  installModelCliLeaf
 } from './models';
 import {
   getAppStatusCliLeaf,
@@ -39,6 +40,7 @@ export const appCliBranch = CliBranch({
     addModelCliLeaf,
     removeModelCliLeaf,
     replaceModelsCliLeaf,
+    installModelCliLeaf,
     updateModelsCliLeaf,
     getAllEnvsCliLeaf,
     setEnvCliLeaf,