pair programming: required fixes found when rebuilding sample app

Signed-off-by: Amber Torrise <at895452@broadcom.net>

packages/imperative/src/events/src/EventEmitter.ts

@@ -17,6 +17,7 @@ import { ConfigUtils } from "../../config/src/ConfigUtils";
 import { LoggerManager } from "../../logger/src/LoggerManager";
 import { ImperativeConfig } from "../../utilities";
 import { EventUtils } from "./EventUtils";
+import { IRegisteredAction } from "./doc";
 
 /**
  * The EventEmitter class is responsible for managing event subscriptions and emissions for a specific application.
@@ -26,7 +27,7 @@ import { EventUtils } from "./EventUtils";
  * @class EventEmitter
  */
 export class EventEmitter {
-    public events: Map<string, Event> = new Map();
+    public subscribedEvents: Map<string, Event> = new Map();
     public eventTimes: Map<string, string>;
     public appName: string;
     public logger: Logger;
@@ -38,7 +39,7 @@ export class EventEmitter {
      * @param {Logger} logger The logger instance used for logging information and errors.
      */
     public constructor(appName: string, logger?: Logger) {
-        this.events = new Map();
+        this.subscribedEvents = new Map();
         this.appName = appName;
 
         // Ensure we have correct environmental conditions to setup a custom logger,
@@ -58,22 +59,25 @@ export class EventEmitter {
      *
      * @param {string} eventName
      */
-    public subscribeShared(eventName: string): void {
+    public subscribeShared(eventName: string, callbacks: Function[] | Function): IRegisteredAction {
         const isCustom = EventUtils.isSharedEvent(eventName);
         const eventType = isCustom ? EventTypes.CustomSharedEvents : EventTypes.SharedEvents;
-        EventUtils.createSubscription(this, eventName, eventType);
+        const disposable = EventUtils.createSubscription(this, eventName, eventType);
+        EventUtils.setupWatcher(this, eventName, callbacks);
+        return disposable;
     }
 
     /**
      * Subscribes to a user event. This method determines whether the event is custom and creates a subscription accordingly.
      *
      * @param {string} eventName
      */
-    public subscribeUser(eventName: string, callbacks: Function[]): void {
+    public subscribeUser(eventName: string, callbacks: Function[] | Function): IRegisteredAction {
         const isCustom = EventUtils.isUserEvent(eventName);
         const eventType = isCustom ? EventTypes.CustomUserEvents : EventTypes.UserEvents;
-        EventUtils.createSubscription(this, eventName, eventType);
+        const disposable = EventUtils.createSubscription(this, eventName, eventType);
         EventUtils.setupWatcher(this, eventName, callbacks);
+        return disposable;
     }
 
     /**
@@ -85,7 +89,7 @@ export class EventEmitter {
      */
     public emitEvent(eventName: string): void {
         try {
-            const event = this.events.get(eventName);
+            const event = this.subscribedEvents.get(eventName);
             event.eventTime = new Date().toISOString();
             EventUtils.writeEvent(event);
         } catch (err) {
@@ -103,10 +107,10 @@ export class EventEmitter {
     public unsubscribe(eventName: string): void {
         try{
             // find watcher list and close everything
-            this.events.get(eventName).subscriptions.forEach((watcher)=>{
+            this.subscribedEvents.get(eventName).subscriptions.forEach((watcher)=>{
                 watcher.removeAllListeners(eventName).close();
             });
-            this.events.delete(eventName);
+            this.subscribedEvents.delete(eventName);
         } catch(err){
             throw new ImperativeError({ msg: `Error unsubscribing from event: ${eventName}`, causeErrors: err });
         }

packages/imperative/src/events/src/EventEmitterManager.ts

@@ -27,9 +27,9 @@ export class EventEmitterManager {
      *
      * @static
      * @param {string} appName key to KVP for managed event emitter instances
-     * @return {(EventEmitter | undefined)} Returns the EventEmitter instance or undefined if it cannot be created.
+     * @return {EventEmitter} Returns the EventEmitter instance
      */
-    public static getEmitter(appName: string): EventEmitter | undefined {
+    public static getEmitter(appName: string): EventEmitter {
         if (!this.instances.has(appName)) {
             const newInstance = new EventEmitter(appName);
             this.instances.set(appName, newInstance);

packages/imperative/src/events/src/EventUtils.ts

@@ -10,7 +10,7 @@
 */
 
 import { ImperativeError } from "../../error/src/ImperativeError";
-import { dirname, join } from "path";
+import { join } from "path";
 import { UserEvents, SharedEvents, EventTypes } from "./EventConstants";
 import * as fs from "fs";
 import { ConfigUtils } from "../../config/src/ConfigUtils";
@@ -48,7 +48,7 @@ export class EventUtils {
     }
 
     /**
-     * Retrieves the directory path for events based on the event type and application name.
+     * Modifies path to include appName if a custom event type
      *
      * @param {EventTypes} eventType
      * @param {string} appName
@@ -75,6 +75,20 @@ export class EventUtils {
         }
     }
 
+    /**
+     * Check to see if the file path exists, otherwise, create it : )
+     * @param filePath Zowe or User path where we will write the events
+     */
+    public static ensureFileExists(filePath: string) {
+        try {
+            if (!fs.existsSync(filePath)) {
+                fs.closeSync(fs.openSync(filePath, 'w'));
+            }
+        } catch (err) {
+            throw new ImperativeError({ msg: `Unable to create event file. Path: ${filePath}`, causeErrors: err });
+        }
+    }
+
     /**
      * Creates a subscription for an event. It configures and stores an event instance within the EventEmitter's subscription map.
      *
@@ -85,8 +99,11 @@ export class EventUtils {
      */
     public static createSubscription(eeInst: EventEmitter, eventName: string, eventType: EventTypes): IRegisteredAction {
         const dir = this.getEventDir(eventType, eeInst.appName);
-        this.ensureEventsDirExists(dir);
-        const filePath = join(dirname(ConfigUtils.getZoweDir()), eventName);
+        this.ensureEventsDirExists(join(ConfigUtils.getZoweDir(), '.events'));
+        this.ensureEventsDirExists(join(ConfigUtils.getZoweDir(), dir));
+
+        const filePath = join(ConfigUtils.getZoweDir(), dir, eventName);
+        this.ensureFileExists(filePath);
 
         const newEvent = new Event({
             eventTime: new Date().toISOString(),
@@ -97,22 +114,25 @@ export class EventUtils {
             subscriptions: []
         });
 
-        eeInst.events.set(eventName, newEvent);
+        eeInst.subscribedEvents.set(eventName, newEvent);
 
         return {
             close: () => eeInst.unsubscribe(eventName)
         };
     }
 
-    public static setupWatcher(eeInst: EventEmitter, eventName: string, callbacks: Function[] = []): fs.FSWatcher {
-        const event = eeInst.events.get(eventName);
+    public static setupWatcher(eeInst: EventEmitter, eventName: string, callbacks: Function[] | Function ): fs.FSWatcher {
+        const event = eeInst.subscribedEvents.get(eventName);
         const watcher = fs.watch(event.filePath, (trigger: "rename" | "change") => {
             // Accommodates for the delay between actual file change event and fsWatcher's perception
             //(Node.JS triggers this notification event 3 times)
             if (eeInst.eventTimes.get(eventName) !== event.eventTime) {
                 eeInst.logger.debug(`EventEmitter: Event "${trigger}" emitted: ${eventName}`);
-                // Promise.all(callbacks)
-                callbacks.forEach(cb => cb());
+                if (Array.isArray(callbacks)){
+                    callbacks.forEach(cb => cb());
+                }else {
+                    callbacks();
+                }
                 eeInst.eventTimes.set(eventName, event.eventTime);
             }
         });
@@ -126,8 +146,6 @@ export class EventUtils {
      * @param {Event} event
      */
     public static writeEvent(event: Event) {
-        const eventPath = join(ConfigUtils.getZoweDir(), event.filePath);
-        this.ensureEventsDirExists(eventPath);
-        fs.writeFileSync(eventPath, JSON.stringify(event.toJson(), null, 2));
+        fs.writeFileSync(event.filePath, JSON.stringify(event.toJson(), null, 2));
     }
 }