Merge pull request #526 from coderoad/fallback-to-file

fallback session state to file

Author: ShMcK

docs/docs/env-vars.md

@@ -20,6 +20,8 @@ CodeRoad has a number of configurations:
 
 -`CODEROAD_WEBHOOK_TOKEN` - an optional token for authenticating/authorizing webhook endpoints. Passed to the webhook endpoint in a `CodeRoad-User-Token` header.
 
+-`CODEROAD_SESSION_STORAGE_PATH` - the path to a directory for writing session storage to files. Helps preserves state across containers. Example: `../tmp`.
+
 ## How to Use Variables
 
 ### Local

src/actions/onStartup.ts

@@ -35,8 +35,8 @@ const onStartup = async (context: Context): Promise<void> => {
 
 // NEW: no stored tutorial, must start new tutorial
 if(!tutorial||!tutorial.id){
-if(!!TUTORIAL_URL){
-// NEW_FROM_URL
+if(TUTORIAL_URL){
+// if a tutorial URL is added, launch on startup
 try{
 consttutorialRes=awaitfetch(TUTORIAL_URL)
 consttutorial=awaittutorialRes.json()

src/environment.ts

@@ -46,3 +46,6 @@ export const CONTENT_SECURITY_POLICY_EXEMPTIONS: string | null =
 
 // optional token for authorization/authentication of webhook calls
 exportconstWEBHOOK_TOKEN=process.env.CODEROAD_WEBHOOK_TOKEN||null
+
+// a path to write session state to a file. Useful for maintaining session across containers
+exportconstSESSION_STORAGE_PATH=process.env.CODEROAD_SESSION_STORAGE_PATH||null

src/services/context/state/Position.ts

@@ -19,6 +19,7 @@ class Position {
 setTutorial(workspaceState: vscode.Memento,tutorial: TT.Tutorial): void{
 this.storage=newStorage<T.Position>({
 key: `coderoad:position:${tutorial.id}:${tutorial.version}`,
+filePath: 'coderoad_position',
 storage: workspaceState,
  defaultValue,
 })

src/services/context/state/Tutorial.ts

@@ -9,6 +9,7 @@ class Tutorial {
 constructor(workspaceState: vscode.Memento){
 this.storage=newStorage<TT.Tutorial|null>({
 key: 'coderoad:currentTutorial',
+filePath: 'coderoad_tutorial',
 storage: workspaceState,
 defaultValue: null,
 })

src/services/node/index.ts

@@ -7,25 +7,41 @@ import { WORKSPACE_ROOT } from '../../environment'
 constasyncExec=promisify(cpExec)
 constasyncRemoveFile=promisify(fs.unlink)
 constasyncReadFile=promisify(fs.readFile)
+constasyncWriteFile=promisify(fs.writeFile)
 
 interfaceExecParams{
 command: string
 dir?: string
 }
 
+// correct paths to be from workspace root rather than extension folder
+constgetWorkspacePath=(...paths: string[])=>{
+returnjoin(WORKSPACE_ROOT, ...paths)
+}
+
 exportconstexec=(params: ExecParams): Promise<{stdout: string;stderr: string}>|never=>{
 constcwd=join(WORKSPACE_ROOT,params.dir||'')
 returnasyncExec(params.command,{ cwd })
 }
 
 exportconstexists=(...paths: string[]): boolean|never=>{
-returnfs.existsSync(join(WORKSPACE_ROOT,...paths))
+returnfs.existsSync(getWorkspacePath(...paths))
 }
 
 exportconstremoveFile=(...paths: string[])=>{
-returnasyncRemoveFile(join(WORKSPACE_ROOT, ...paths))
+returnasyncRemoveFile(getWorkspacePath(...paths))
+}
+
+exportconstreadFile=(...paths: string[]): Promise<string|void>=>{
+constfilePath=getWorkspacePath(...paths)
+returnasyncReadFile(getWorkspacePath(...paths),'utf8').catch((err)=>{
+console.warn(`Failed to read from ${filePath}: ${err.message}`)
+})
 }
 
-exportconstreadFile=(...paths: string[])=>{
-returnasyncReadFile(join(...paths))
+exportconstwriteFile=(data: any, ...paths: string[]): Promise<void>=>{
+constfilePath=getWorkspacePath(...paths)
+returnasyncWriteFile(filePath,data).catch((err)=>{
+console.warn(`Failed to write to ${filePath}: ${err.message}`)
+})
 }

src/services/storage/index.ts

@@ -1,4 +1,6 @@
 import*asvscodefrom'vscode'
+import{readFile,writeFile}from'../node'
+import{SESSION_STORAGE_PATH}from'../../environment'
 
 // NOTE: localStorage is not available on client
 // and must be stored in editor
@@ -8,31 +10,75 @@ import * as vscode from 'vscode'
 // forcing it to be passed in through activation and down to other tools
 classStorage<T>{
 privatekey: string
+privatefilePath: string
 privatestorage: vscode.Memento
 privatedefaultValue: T
-constructor({ key, storage, defaultValue }: {key: string;storage: vscode.Memento;defaultValue: T}){
+constructor({
+ key,
+ filePath,
+ storage,
+ defaultValue,
+}: {
+key: string
+filePath: string
+storage: vscode.Memento
+defaultValue: T
+}){
 this.storage=storage
 this.key=key
+this.filePath=filePath
 this.defaultValue=defaultValue
 }
 publicget=async(): Promise<T>=>{
 constvalue: string|undefined=awaitthis.storage.get(this.key)
 if(value){
 returnJSON.parse(value)
+}elseif(SESSION_STORAGE_PATH){
+try{
+// optionally read from file as a fallback to local storage
+constsessionFile=awaitreadFile(SESSION_STORAGE_PATH,`${this.filePath}.json`)
+if(!sessionFile){
+thrownewError('No session file found')
+}
+constdata: T=JSON.parse(sessionFile)
+
+if(data){
+// validate session
+constkeys=Object.keys(data)
+if(keys.length){
+returndata
+}
+}
+}catch(err){
+console.warn(`Failed to read or parse session file: ${SESSION_STORAGE_PATH}/${this.filePath}.json`)
+}
 }
 returnthis.defaultValue
 }
 publicset=(value: T): void=>{
 conststringValue=JSON.stringify(value)
 this.storage.update(this.key,stringValue)
+this.writeToSessionFile(stringValue)
 }
 publicupdate=async(value: T): Promise<void>=>{
 constcurrent=awaitthis.get()
 constnext=JSON.stringify({
  ...current,
  ...value,
 })
-this.storage.update(this.key,next)
+awaitthis.storage.update(this.key,next)
+
+this.writeToSessionFile(next)
+}
+publicwriteToSessionFile(data: string){
+// optionally write state to file, useful when state cannot be controlled across containers
+if(SESSION_STORAGE_PATH){
+try{
+writeFile(data,SESSION_STORAGE_PATH,`${this.filePath}.json`)
+}catch(err: any){
+console.warn(`Failed to write coderoad session to path: ${SESSION_STORAGE_PATH}/${this.filePath}.json`)
+}
+}
 }
 publicreset=()=>{
 this.set(this.defaultValue)