Serverheartbeat now sent through session to UI

src/dataEditor/core/editor/dataEditor.ts

@@ -20,7 +20,7 @@ export abstract class DataEditor implements ServiceUser<DataSource> {
     protected serviceClient: EditServiceClient,
     protected ui: DataEditorUI
   ) {
-    serviceClient.onDidProcessRequest = (response) => {
+    serviceClient.onDidProcess = (response) => {
       this.ui.updateUI(response)
     }
     ui.onInputEvent = (input) => {

src/dataEditor/core/service/editService.ts

@@ -9,13 +9,12 @@ export interface EditHandler {
 }
 export interface EditService {
   register(source: DataSource): Promise<EditServiceClient>
-  activeUsers(): number
 }
 export interface EditServiceClient {
   close(): void
   id(): string
   request: (request: any) => any
-  onDidProcessRequest: (response: any) => any
+  onDidProcess: (response: any) => any
 }
 
 export interface DataSource {}

src/dataEditor/index.ts

@@ -10,17 +10,13 @@ import {
   StandaloneEditor,
   StandaloneInitializer,
 } from './standalone/standaloneEditor'
-import { OmegaEditServer } from './omegaEdit/tests/utils/fixtures'
-import { OmegaEditServerManager } from './omegaEdit/server'
+import { OmegaEditServerManager } from './omegaEdit/server/server'
 
 const editorCommands: Map<
   EditorCommand['command'],
   EditorCommand['initializer']
 > = new Map()
 
-export function RegisterEditor(command: EditorCommand): void {
-  editorCommands.set(command.command, command.initializer)
-}
 class DataEditorManager implements vscode.Disposable {
   private editors: DataEditor[] = []
   private disposables: vscode.Disposable[] = []
@@ -45,6 +41,22 @@ class DataEditorManager implements vscode.Disposable {
     })
   }
 }
+
+let Manager: DataEditorManager
+
+function registerAllEditorCommands(ctx: vscode.ExtensionContext) {
+  editorCommands.forEach((initer, command) => {
+    ctx.subscriptions.push(
+      vscode.commands.registerCommand(command, async () => {
+        await Manager.Run(initer)
+      })
+    )
+  })
+}
+
+export function RegisterEditor(command: EditorCommand): void {
+  editorCommands.set(command.command, command.initializer)
+}
 export const VSCodeFileSelector: FilePathSourceStrategy = {
   get: () => {
     return new Promise(async (resolve, reject) => {
@@ -66,19 +78,7 @@ const DefaultEditorCommand: EditorCommand = {
   initializer: new StandaloneInitializer(VSCodeFileSelector),
 }
 
-let Manager: DataEditorManager
-
-function registerAllEditorCommands(ctx: vscode.ExtensionContext) {
-  editorCommands.forEach((initer, command) => {
-    ctx.subscriptions.push(
-      vscode.commands.registerCommand(command, async () => {
-        await Manager.Run(initer)
-      })
-    )
-  })
-}
 export function activate(ctx: vscode.ExtensionContext) {
-  const config = editor_config.extractConfigurationVariables() // Omega Edit Server specific configurations
   Manager = new DataEditorManager(ctx)
 
   registerAllEditorCommands(ctx)

src/dataEditor/omegaEdit/index.ts

@@ -1,6 +1,7 @@
 import path from 'path'
 import * as os from 'os'
 import { DataSource, GetDataSourceStrategy } from '../core/service/editService'
+
 export class FilePath implements DataSource {
   private baseName: string
   constructor(private filepath: string) {
@@ -13,9 +14,7 @@ export class FilePath implements DataSource {
     return this.baseName
   }
 }
-export interface FilePathSourceStrategy extends GetDataSourceStrategy {
-  get(): Promise<FilePath>
-}
+
 export namespace FilePath {
   export const SystemTmpDirectory = (): FilePath => {
     return new FilePath(os.tmpdir())
@@ -24,3 +23,7 @@ export namespace FilePath {
     return new FilePath('.')
   }
 }
+
+export interface FilePathSourceStrategy extends GetDataSourceStrategy {
+  get(): Promise<FilePath>
+}

src/dataEditor/omegaEdit/server/config.ts

@@ -0,0 +1,25 @@
+import { FilePath } from '..'
+import { IConfig } from '../../config'
+
+export class Connection {
+  constructor(
+    readonly host: string,
+    readonly port: number
+  ) {}
+}
+
+export type GetServerConfigStrategy = () => Promise<ServerConfig>
+export class ServerConfig {
+  readonly conn: Connection
+  readonly logFile: FilePath
+  readonly logLevel: string
+  readonly checkpointPath: string
+
+  constructor(config: () => IConfig) {
+    const { checkpointPath, logFile, logLevel, port } = config()
+    this.conn = new Connection('127.0.0.1', port)
+    this.logFile = new FilePath(logFile)
+    this.logLevel = logLevel
+    this.checkpointPath = checkpointPath
+  }
+}

src/dataEditor/omegaEdit/server/logging.ts

@@ -0,0 +1,83 @@
+import { createSimpleFileLogger, setLogger } from '@omega-edit/client'
+import { ServerConfig } from './config'
+
+import * as fs from 'fs'
+import path from 'path'
+import XDGAppPaths from 'xdg-app-paths'
+export const APP_DATA_PATH: string = XDGAppPaths({ name: 'omega_edit' }).data()
+
+const MAX_LOG_FILES = 5
+function rotateLogFiles(logFile: string): void {
+  interface LogFile {
+    path: string
+    ctime: Date
+  }
+
+  // assert(
+  //   MAX_LOG_FILES > 0,
+  //   'Maximum number of log files must be greater than 0'
+  // )
+
+  if (fs.existsSync(logFile)) {
+    const logDir = path.dirname(logFile)
+    const logFileName = path.basename(logFile)
+
+    // Get list of existing log files
+    const logFiles: LogFile[] = fs
+      .readdirSync(logDir)
+      .filter((file) => file.startsWith(logFileName) && file !== logFileName)
+      .map((file) => ({
+        path: path.join(logDir, file),
+        ctime: fs.statSync(path.join(logDir, file)).ctime,
+      }))
+      .sort((a, b) => b.ctime.getTime() - a.ctime.getTime())
+
+    // Delete oldest log files if maximum number of log files is exceeded
+    while (logFiles.length >= MAX_LOG_FILES) {
+      const fileToDelete = logFiles.pop() as LogFile
+      fs.unlinkSync(fileToDelete.path)
+    }
+
+    // Rename current log file with timestamp and create a new empty file
+    const timestamp = new Date().toISOString().replace(/:/g, '-')
+    fs.renameSync(logFile, path.join(logDir, `${logFileName}.${timestamp}`))
+  }
+}
+
+export function setupLogging(config: ServerConfig): Promise<void> {
+  return new Promise((res, rej) => {
+    const filePath = config.logFile.fullPath()
+    const level = config.logLevel
+    rotateLogFiles(filePath)
+    setLogger(createSimpleFileLogger(filePath, level))
+    res()
+  })
+}
+
+export function generateLogbackConfigFile(server: ServerConfig): string {
+  const serverLogFile = path.join(APP_DATA_PATH, `serv-${server.conn.port}.log`)
+  const dirname = path.dirname(server.logFile.fullPath())
+  if (!fs.existsSync(dirname)) {
+    fs.mkdirSync(dirname, { recursive: true })
+  }
+  const logbackConfig = `<?xml version="1.0" encoding="UTF-8"?>\n
+<configuration>
+    <appender name="FILE" class="ch.qos.logback.core.FileAppender">
+        <file>${serverLogFile}</file>
+        <encoder>
+            <pattern>[%date{ISO8601}] [%level] [%logger] [%marker] [%thread] - %msg MDC: {%mdc}%n</pattern>
+        </encoder>
+    </appender>
+    <root level="${server.logLevel.toUpperCase()}">
+        <appender-ref ref="FILE" />
+    </root>
+</configuration>
+`
+  const logbackConfigFile = path.join(
+    APP_DATA_PATH,
+    `serv-${server.conn.port}.logconf.xml`
+  )
+  rotateLogFiles(server.logFile.fullPath())
+  fs.writeFileSync(logbackConfigFile, logbackConfig)
+  return logbackConfigFile // Return the path to the logback config file
+}

src/dataEditor/omegaEdit/server.ts → src/dataEditor/omegaEdit/server/server.ts

@@ -1,37 +1,43 @@
-import { FilePath } from '.'
-import { OmegaEditService } from './editService'
+import { FilePath } from '..'
+import { OmegaEditService } from '../service/editService'
 import path from 'path'
 import * as fs from 'fs'
 import * as os from 'os'
-import XDGAppPaths from 'xdg-app-paths'
 import {
-  createSimpleFileLogger,
   getClientVersion,
   getServerHeartbeat,
   getServerInfo,
   IServerHeartbeat,
   IServerInfo,
-  setLogger,
   startServer,
   stopProcessUsingPID,
-  stopServerGraceful,
 } from '@omega-edit/client'
-import { IConfig } from '../config'
-import { IHeartbeatInfo } from '../include/server/heartbeat/HeartBeatInfo'
-export const APP_DATA_PATH: string = XDGAppPaths({ name: 'omega_edit' }).data()
+import { IConfig } from '../../config'
+import { IHeartbeatInfo } from '../../include/server/heartbeat/HeartBeatInfo'
+import { ServerConfig } from './config'
+import {
+  APP_DATA_PATH,
+  generateLogbackConfigFile,
+  setupLogging,
+} from './logging'
 
-export class Connection {
-  constructor(
-    readonly host: string,
-    readonly port: number
-  ) {}
+const activeServers: Map<ServerConfig, OmegaEditServer> = new Map()
+const ServerDisposeAll = {
+  dispose: () => {
+    activeServers.forEach((server) => {
+      server.dispose()
+    })
+  },
 }
 
 export class OmegaEditServer {
   private service: OmegaEditService
+  private heartbeatIntervalId: NodeJS.Timeout | undefined = undefined
   constructor(readonly config: ServerConfig) {
     this.service = new OmegaEditService(new FilePath(config.checkpointPath))
+
     this.service.onAllSessionsClosed(() => {
+      clearInterval(this.heartbeatIntervalId)
       serverStop(this.config)
     })
   }
@@ -45,40 +51,6 @@ export class OmegaEditServer {
   }
 }
 
-function setupLogging(config: ServerConfig): Promise<void> {
-  return new Promise((res, rej) => {
-    const filePath = config.logFile.fullPath()
-    const level = config.logLevel
-    rotateLogFiles(filePath)
-    setLogger(createSimpleFileLogger(filePath, level))
-    res()
-  })
-}
-export class ServerConfig {
-  readonly conn: Connection
-  readonly logFile: FilePath
-  readonly logLevel: string
-  readonly checkpointPath: string
-
-  constructor(config: () => IConfig) {
-    const { checkpointPath, logFile, logLevel, port } = config()
-    this.conn = new Connection('127.0.0.1', port)
-    this.logFile = new FilePath(logFile)
-    this.logLevel = logLevel
-    this.checkpointPath = checkpointPath
-  }
-}
-
-export type GetServerConfigStrategy = () => Promise<ServerConfig>
-
-const activeServers: Map<ServerConfig, OmegaEditServer> = new Map()
-const ServerDisposeAll = {
-  dispose: () => {
-    activeServers.forEach((server) => {
-      server.dispose()
-    })
-  },
-}
 export class OmegaEditServerManager {
   static Connect(config: () => IConfig): Promise<OmegaEditServer> {
     return new Promise(async (res, rej) => {
@@ -119,71 +91,6 @@ function removeDirectory(dirPath: string): void {
     fs.rmdirSync(dirPath)
   }
 }
-const MAX_LOG_FILES = 5
-function rotateLogFiles(logFile: string): void {
-  interface LogFile {
-    path: string
-    ctime: Date
-  }
-
-  // assert(
-  //   MAX_LOG_FILES > 0,
-  //   'Maximum number of log files must be greater than 0'
-  // )
-
-  if (fs.existsSync(logFile)) {
-    const logDir = path.dirname(logFile)
-    const logFileName = path.basename(logFile)
-
-    // Get list of existing log files
-    const logFiles: LogFile[] = fs
-      .readdirSync(logDir)
-      .filter((file) => file.startsWith(logFileName) && file !== logFileName)
-      .map((file) => ({
-        path: path.join(logDir, file),
-        ctime: fs.statSync(path.join(logDir, file)).ctime,
-      }))
-      .sort((a, b) => b.ctime.getTime() - a.ctime.getTime())
-
-    // Delete oldest log files if maximum number of log files is exceeded
-    while (logFiles.length >= MAX_LOG_FILES) {
-      const fileToDelete = logFiles.pop() as LogFile
-      fs.unlinkSync(fileToDelete.path)
-    }
-
-    // Rename current log file with timestamp and create a new empty file
-    const timestamp = new Date().toISOString().replace(/:/g, '-')
-    fs.renameSync(logFile, path.join(logDir, `${logFileName}.${timestamp}`))
-  }
-}
-
-function generateLogbackConfigFile(server: ServerConfig): string {
-  const serverLogFile = path.join(APP_DATA_PATH, `serv-${server.conn.port}.log`)
-  const dirname = path.dirname(server.logFile.fullPath())
-  if (!fs.existsSync(dirname)) {
-    fs.mkdirSync(dirname, { recursive: true })
-  }
-  const logbackConfig = `<?xml version="1.0" encoding="UTF-8"?>\n
-<configuration>
-    <appender name="FILE" class="ch.qos.logback.core.FileAppender">
-        <file>${serverLogFile}</file>
-        <encoder>
-            <pattern>[%date{ISO8601}] [%level] [%logger] [%marker] [%thread] - %msg MDC: {%mdc}%n</pattern>
-        </encoder>
-    </appender>
-    <root level="${server.logLevel.toUpperCase()}">
-        <appender-ref ref="FILE" />
-    </root>
-</configuration>
-`
-  const logbackConfigFile = path.join(
-    APP_DATA_PATH,
-    `serv-${server.conn.port}.logconf.xml`
-  )
-  rotateLogFiles(server.logFile.fullPath())
-  fs.writeFileSync(logbackConfigFile, logbackConfig)
-  return logbackConfigFile // Return the path to the logback config file
-}
 
 async function serverStop(server: ServerConfig) {
   const serverPidFile = getPidFile(server.conn.port)