Fix the use of term client/server according to the spec

Author: Hiroto Shioi

app/NodeIPCServer/Main.hs renamed to app/NodeIPCClient/Main.hs

@@ -1,4 +1,4 @@
-{-| This executable act as an server of an IPC protocol
+{-| This executable act as an client of an IPC protocol
 |-}
 
 {-# LANGUAGE OverloadedStrings #-}
@@ -18,16 +18,16 @@ import           System.IO (BufferMode (..), hClose, hSetBuffering)
 port :: Port
 port = Port 8090
 
--- | Launches the IPC server, the one responses to the message from the client.
+-- | Launches the IPC client, the one responses to the message from the server.
 --
--- Client will pass its handle via environment variable.
--- The server will then decodes the handle and launches IPC listener.
--- It then respond to the client with the handle it has been given.
+-- Server will pass its handle via environment variable.
+-- The client will then decodes the handle and launches IPC listener.
+-- It then respond to the server with the handle it has been given.
 --
--- Because of this, the client must the be the one to execute this function (see @exampleWithProcess@).
--- Call this function directly (ex. @stack exec node-ipc haskell@) will throw an error
--- since there wouldn't be an handle that server will be able to use to communicate with
--- the client.
+-- Because of this, the server must the be the one to execute this function (see @exampleWithProcess@).
+-- Calling this function directly (ex. @stack exec node-ipc haskell@) will throw an error
+-- since there wouldn't be an handle that client will be able to use to communicate with
+-- the server.
 main :: IO ()
 main = do
     (cmd:_) <- getArgs
@@ -38,17 +38,17 @@ main = do
   where
     acquire :: IO Handle
     acquire = do
-        -- Lookup the Handle that the client has set
-        clientWHandle <- getHandleFromEnv "FD_WRITE_HANDLE"
-        hSetBuffering clientWHandle LineBuffering
-        return clientWHandle
+        -- Lookup the Handle that the server has set
+        serverWHandle <- getHandleFromEnv "FD_WRITE_HANDLE"
+        hSetBuffering serverWHandle LineBuffering
+        return serverWHandle
 
     restore :: Handle -> IO ()
     restore = hClose
 
     action :: Handle -> IO ()
-    action clientWHandle = do
-        let clientWriteHandle = WriteHandle clientWHandle
+    action serverWHandle = do
+        let serverWriteHandle = WriteHandle serverWHandle
         let serverReadHandle  = ReadHandle stdin
-        startIPC SingleMessage serverReadHandle clientWriteHandle port
+        startIPC SingleMessage serverReadHandle serverWriteHandle port
 

app/NodeIPCServer/client.js renamed to app/NodeIPCClient/server.js

@@ -114,7 +114,7 @@ executable node-ipc
   other-modules:
       Paths_cardano_shell
   hs-source-dirs:
-      app/NodeIPCServer
+      app/NodeIPCClient
   ghc-options: -threaded -rtsopts -with-rtsopts=-N
   build-depends:
       base >=4.7 && <5

cardano-shell.cabal

@@ -15,6 +15,7 @@
 -- This allows the two proccesses to send the message to the other while
 -- reading the response that other had sent.
 -}
+
 module Cardano.Shell.NodeIPC.Example
     ( exampleWithFD
     , exampleWithProcess
@@ -61,31 +62,31 @@ nodePort = Port 8090
 exampleWithFD :: MsgIn -> IO (MsgOut, MsgOut)
 exampleWithFD msgin = do
 
-    (clientReadHandle, clientWriteHandle) <- getReadWriteHandles
+    (serverReadHandle, serverWriteHandle) <- getReadWriteHandles
 
     (_, responses) <- do
-        (serverReadHandle, serverWriteHandle) <- getReadWriteHandles
-        -- Send message to server
-        sendMessage serverWriteHandle msgin
-        startIPC SingleMessage serverReadHandle clientWriteHandle nodePort
+        (clientReadHandle, clientWriteHandle) <- getReadWriteHandles
+        -- Send message to client
+        sendMessage clientWriteHandle msgin
+        startIPC SingleMessage clientReadHandle serverWriteHandle nodePort
         `concurrently`
-        receieveMessages clientReadHandle
+        receieveMessages serverReadHandle
 
     return responses
 
--- | Example of an IPC client that is using haskell executable as an server.
+-- | Example of an IPC server that is using haskell executable as an server.
 --
--- This will be the client, the one which sends the message (such as @Ping@, @QueryPort@)
--- to get the response from the other.
--- The server is executed via @stack exec node-ipc haskell@
+-- This will be the server, the one which sends the message (such as @Ping@, @QueryPort@)
+-- to get the response from the client.
+-- The client is executed via @stack exec node-ipc haskell@
 exampleWithProcess :: MsgIn -> IO (MsgOut, MsgOut)
 exampleWithProcess msg = bracket acquire restore (action msg)
   where
     acquire :: IO (ReadHandle, Handle)
     acquire = do
         (rFd, wFd) <- createPipeFd
         -- Set the write file descriptor to the envrionment variable
-        -- the server will look this up, and use it to talk the client
+        -- the client will look this up, and use it to talk the server
         setEnv "FD_WRITE_HANDLE" (show wFd)
         readHandle  <- ReadHandle <$> fdToHandle rFd
         -- Since closeFd only exists in 'unix' library,
@@ -110,11 +111,11 @@ exampleWithProcess msg = bracket acquire restore (action msg)
 
 -- | Read message wigh given 'ReadHandle'
 receieveMessages :: ReadHandle -> IO (MsgOut, MsgOut)
-receieveMessages clientReadHandle = do
-    let readClientMessage :: IO MsgOut
-        readClientMessage = readMessage clientReadHandle
-    started <- readClientMessage -- Started
-    reply   <- readClientMessage -- Reply
+receieveMessages serverReadHandle = do
+    let readServerMessage :: IO MsgOut
+        readServerMessage = readMessage serverReadHandle
+    started <- readServerMessage -- Started
+    reply   <- readServerMessage -- Reply
     return (started, reply)
 
 getHandleFromEnv :: String -> IO Handle