my head stuck in the computer: Pseudo Visual Compiler using Interface to Ada as the OFP

Pseudo Visual Compiler using Interface to Ada as the OFP - Part 5

Following along with the translation of the C# message delivery framework to Ada of the previous posts, I am once again reporting my progress.

General Discussion

This post concerns the initial C# classes and Ada packages to install the framework components and then the application specific user components followed by the Remote package to support communications with remote applications and the Receive, ReceiveInterface, Transmit, and Heartbeat framework components and the NamedPipe package that actually sends and receives the messages. As well as the Format package to encode and decode particular message delivery framework topics. Also a update to the Library package for topics that remote apps want to consume and hence have the local app transmit to them.

The ability to allow Library to only reject the register of message delivery framework topics from user components, as mentioned in the last post, was added to the Ada package. The Delivery package was updated to deliver messages received from a remote component to a local component.

Since this represents too much code for one post, a second post will follow (Part 5 Continued). This will complete the communication between two Ada applications with one application (app 1) acting in place of the C# Visual Compiler application to transmit OFP Keypush messages to the second application (app 2) to be the stand-in for the OFP as well as including other user components included in the past. The C# replacement is to allow the Named Pipes interface supported by GNAT Ada to be used by both applications before attempting such a usage between C# with its Microsoft C# System supported pipes and the need of the Ada application to use C interfaces.

A future post will switch to a C# Visual Compiler application to allow the selection of MCDU keys to publish the OFP Keypush message to a stand-in Ada OFP application. Thus I will then arrive at the original objective of having a C# application communicate with an Ada application.

Previously mentioned needed updates to the C# message delivery framework classes will be done in this final step.

In addition I had a previous assertion of a logical connection between applications (versus a physical one when the named pipes connected) when three consecutive valid Heartbeat messages were received. With a declaration to disconnect when valid Heartbeat messages failed to be received. In my past exploratory project this worked but while getting the Ada translation of the C# code working, the current implementation as in C# wouldn't allow a logical connection to occur. That is, it reset the logical connection after receiving the first heartbeat since three hadn't been received. Therefore, the C# code will also need to be update to correct this.

Thinking back, the previous exploratory project allowed, in addition to named pipes, the use of TCP/IP for communication between remote PCs. Therefore some protection was built in. Along with valid CRCs, one was that valid heartbeat messages had to be received so when they weren't the connection was disabled. Therefore, in a further development of C# and Ada applications or a mixture thereof I will develop a different method of determining the need to disconnect based upon a variety of checks and, if so determined, close the physical connection. Since this communication method is only for a network of applications supported by Named Pipes, such a method is most likely not really necessary. (Note: The message header allocates space to contain a CRC. However, the Ada version of the C# CRC has yet to be created for Ada so generating the CRC and checking the CRC of a received message is currently ignored.)

In the previous post I commented about when a component wouldn't need a queue. This is the case with the Ada Receive that is also registered as a component (unlike the C# Receive class). It cycles in its ReceiveThread forever loop which is invoked from the Threads package just like other components. However it waits in its loop for the NamedPipe to return a message received via the pipe rather than for a queue wait event to be signaled.

Since Ada can have instances of generic packages (whereas C# has instances of classes), I attempted to create generic packages for Receive, Transmit, and NamedPipe as I had for Disburse. I needed to have different threads for each Receive and Transmit instance which would then invoke NamedPipe in their particular thread. However I found out that I couldn't get it to work. A difference being that Disburse waited in its instance (with its common code but different assignment of local variables - the queue) for its wakeup event the Receive, Transmit, and NamedPipe instances attempted to invoke the code methods. I suspect that this was the cause of the problem since Ada generic packages only have one instance of the code.

I therefore created a package warehouse for the Receive and Transmit packages. This wasn't much of a problem since, with a maximum of four applications to be supported, only three copies of the Receive and Transmit packages would be necessary to support three pairs of communication pipes. [I thought of referring to this collection as a farm or factory but since they were to exist at build time I decided to refer to the collection as a warehouse – the extra instances waiting in case needed by the configuration.]

For the NamedPipe I decided, instead, to retain just one non-generic package and have it allocate its own separate data areas with the interfaces such as to open a pipe or transmit a message needing to be informed as to which set of data to use. These interfaces were, of course, run in different threads depending upon which Receive or Transmit package invoked them.

Remote and the framework components are implemented somewhat differently than in C#. The Remote package now instantiates an instance of Receive and Transmit to communicate with each possible remote application where Threads will create a separate thread for each instance (as also occurred in C#) but Remote now invokes each component's Install procedure that will actually Register the component. That is, rather than doing the Register from within the Remote package. Therefore, the framework components are very similar in structure to the user components of the last report with each one instantiating their own Disburse queue.

Also, only one instance of the ReceiveInterface component is created. Each of the Receive components then writes to its queue rather than one instance per remote application. Rather than use Delivery to write received messages to the ReceiveInterface Disburse queue, its Write callback function is made visible so that the various Receive components can post to its queue directly. I judge that this isn't a problem since ReceiveInterface is a message delivery framework component rather than a user component so that developers of user components should know that interfacing to it is off limits.

For multiple applications, I created multiple top level folders; one for each application such as App1, App2, and App3 for a three application test of the communications between applications. I created a four application configuration – the maximum allowed at the present time. Under each of these folders were the build folder to compile and link into and a src folder to contain the packages. The src folder was further subdivided into the common packages and the unique ones. The common src subfolder contained the same packages for each application. The unique subfolder had the App_n (App1, App2, App3) code unique to the particular application, the Ada main procedure that is the initial entry point, and the code of the user components.

Therefore, only one instance of the common packages needs to be presented. Also, App3 is really a duplicate of App1 where both have a user component that publishes the OFP KEYPUSH topic that the App2 Com5x components wants to consume. For this test Com4x no longer publishes the topic.

At the beginning, after the NamedPipe pipes have connected to their remote application (via the Receive and Transmit Open methods) the particular Transmit package to send to that remote application does so by sending Heartbeat messages and the receive pipe of the local NamedPipe package of that Receive application will obtain the message and return it to the Receive which will then queue the message to ReceiveInterface. When notified that its end of wait event has been signaled, ReceiveInterface will read the message, verify it, translate it back to a topic message from an array of bytes and act on the message.

Note: The Heartbeat messages are created by the Heartbeat periodic component. Each message is written to the various Transmit components' queues. When the Transmit component receives the message it invokes the TransmitMessage method of NamedPipe without regard to the message topic. TransmitMessage detects the pipe to be used from the To identifier in the message header. If the pipe has yet to be opened, nothing further is done.

When at least three Heartbeat messages have been received, ReceiveInterface initiates the REGISTER REQUEST message which is created to inform the particular remote application of the messages that it desires to consume as found in its Library. (The framework and user components will have first registered the topics that they produce and the ones they want to consume. That is, the install of the Remote package is done after each of the other framework and user components has had a chance to register with the Library.) When the remote component receives this message it adds these message topics to its Library and acknowledges the receipt of the REQUEST message by sending the REGISTER RESPONSE message. When the originating application receives this message it ceases to send the REQUEST.

Later, if the remote application publishes such a topic, its Delivery package will recognize that it is to be sent to another application(s) (as well, perhaps, to user components of its own) and queue it to that application's Transmit package to be forwarded. The ReceiveMessage method of the receive pipe will then return it to the particular Receive package associated with the remote application which, in turn, will queue it to ReceiveInterface. If a general message (rather than a Heartbeat or a Register topic) ReceiveInterface will invoke Delivery to deliver the message just as if it was locally published.

New Packages - Unique

The main procedure is the entry point. As such it is unique to each application and provides the application identifier, launches the general App while providing the identifier, installs the user components (that is, other unique code), and ends up creating the threads for all the registered components - both framework and user.

Main.adb

with App;

with App1;

with Itf;

with Threads;

procedure Main is

AppId : Itf.ApplicationIdType;

begin -- Main

-- Launch the general packages of this application

AppId.Name := "App 1 ";

AppId.Id := 1;

App.Launch(AppId);

-- Install the components of this application

App1.Install;

-- Now, after all the components have been installed, create their threads

Threads.Create;

end Main;

App1.ads

Note: Only the one visible procedure.

package App1 is

procedure Install;

end App1;

App1.adb

Unlike App2, there is only the one user component to be installed.

with ComPublish;

package body App1 is

procedure Install is

begin -- Install

ComPublish.Install;

end Install;

end App1;

ComPublish.ads

Note: Only the one visible procedure. The user components can only be entered via the install. No other code is visible to interface from other components.

package ComPublish is

procedure Install;

end ComPublish;

ComPublish.adb

The Install procedure Registers the component with the Component package supplying the instance of the Disburse queue and finishes by supplying its Wait Event upon the return from Register. It then registers the topics that it will publish or wants to consume – in this case only that it will produce the OFP KEYPUSH topic.

The other methods of the component are its DisburseWrite that will write to its queue when invoked by Component, its Main procedure that will be entered from Threads, a function to create human readable versions of possible received topics, the AnyMessage procedure by which the queue will forward received messages, and a procedure to publish the OFP KEYPUSH message.

The Main procedure has a forever loop and is never terminated. In this user component AnyMessage just outputs text to the console that a message has been received. The Main procedure publishes the OFP KEYPUSH topic that could just as well have been published from the AnyMessage procedure since the Main procedure will continue from its EventWait in the same cycle as the Disburse package will forward the message to AnyMessage. Of course, if there were multiple message topics, both (which ever was used) would need to determine the particular topic that was to cause the OFP KEYPUSH topic to be published.

Notice that this is a periodic component so the wait should be satisfied every 4 seconds causing the topic to be published. That is, there need not be any topics received to trigger the end of wait. And there won't be since no topics are requested to be consumed. Therefore, AnyMessage will not be entered.

with CStrings;

with Component;

with Delivery;

with Disburse;

with ExecItf;

with Itf;

with Library;

with System;

with Text_IO;

with Threads;

with Topic;

with Unchecked_Conversion;

package body ComPublish is

package Int_IO is new Text_IO.Integer_IO( Integer );

Queue : Itf.V_Short_String_Type

:= ( Count => 11,

Data => "QComPublish " );

Key : Itf.ParticipantKeyType := Component.NullKey;

-- Component's key returned from Register

RequestTopic1 : Topic.TopicIdType;

procedure AnyMessage

( Message : in Itf.MessageType );

package DisburseQueue

-- Instantiate disburse queue for component

is new Disburse( QueueName => Queue'Address,

Periodic => True,

Universal => AnyMessage'Address,

Forward => System.Null_Address );

function DisburseWrite

-- Callback to write message to the DisburseQueue

( Message : in Itf.MessageType

) return Boolean;

ComPublishName : Itf.V_Medium_String_Type

:= ( Count => 10,

Data => "ComPublish " );

Result : Component.RegisterResult;

OutIteration : Integer := 0;

procedure Main -- callback

( Topic : in Boolean := False

);

procedure Install is

Status : Library.AddStatus;

use type Component.ComponentStatus;

use type Library.AddStatus;

function to_Callback is new Unchecked_Conversion

( Source => System.Address,

Target => Topic.CallbackType );

begin -- Install

Result :=

Component.Register

( Name => ComPublishName,

Period => 4000, -- 4 sec period

Priority => Threads.LOWER, -- Requested priority of thread

Callback => to_Callback(Main'Address), -- Callback of component

Queue => DisburseQueue.Location,

QueueWrite => DisburseWrite'Address );

if Result.Status = Component.VALID then

DisburseQueue.ProvideWaitEvent( Event => Result.Event );

Key := Result.Key;

RequestTopic1.Topic := Topic.OFP;

RequestTopic1.Ext := Topic.KEYPUSH;

Status := Library.RegisterTopic( RequestTopic1, Result.Key,

Delivery.PRODUCER,

to_Callback(Main'Address) );

if Status /= Library.SUCCESS then

Text_IO.Put_Line( "ERROR: Register of first Topic failed" );

end if;

end Install;

procedure DeliverMessages is

OutMessage : Itf.MessageType;

begin -- DeliverMessages

-- Write 1st message to Component5

Text_IO.Put_Line("ComPublish sending KEYPUSH message");

OutMessage.Data(1..10) := "ComPublish";

OutMessage.Data(11) := ASCII.NUL;

Delivery.Publish( TopicId => ( Topic.OFP, Topic.KEYPUSH ),

ComponentKey => Key,

Message => OutMessage.Data );

end DeliverMessages;

procedure Main -- component callback

( Topic : in Boolean := False

) is

Success : Boolean;

Timer_Sec

-- System time seconds as ASCII

: String(1..2);

System_Time

-- System time

: ExecItf.System_Time_Type;

begin -- Main

Text_IO.Put_Line("in ComPublish callback");

loop -- forever

Text_IO.Put_Line("ComPublish wait for event");

DisburseQueue.EventWait; -- wait for event

System_Time := ExecItf.SystemTime;

CStrings.IntegerToString(System_Time.Second, 2, False, Timer_Sec, Success);

Text_IO.Put("ComPublish ");

Text_IO.Put_Line(Timer_Sec(1..2));

-- Publish messages

DeliverMessages;

end loop;

end Main;

function DisburseWrite

( Message : in Itf.MessageType

) return Boolean is

begin -- DisburseWrite

return DisburseQueue.Write(Message => Message);

end DisburseWrite;

-- Convert Topic Id to a String

function to_Topic( Id : Topic.TopicIdType ) return String is

Temp : String(1..19) := (others => ' ');

begin

case Id.Topic is

when Topic.NONE => Temp(1..4) := "NONE";

when Topic.ANY => Temp(1..3) := "ANY";

when Topic.HEARTBEAT => Temp(1..9) := "HEARTBEAT";

when Topic.REGISTER => Temp(1..8) := "REGISTER";

when Topic.TEST => Temp(1..4) := "TEST";

when Topic.TEST2 => Temp(1..5) := "TEST2";

when Topic.TRIAL => Temp(1..5) := "TRIAL";

when Topic.DATABASE => Temp(1..8) := "DATABASE";

when Topic.OFP => Temp(1..3) := "OFP";

end case;

case Id.Ext is

when Topic.FRAMEWORK => Temp(11..19) := "FRAMEWORK";

when Topic.DEFAULT => Temp(11..17) := "DEFAULT";

when Topic.TABLE => Temp(11..15) := "TABLE";

when Topic.KEYPUSH => Temp(11..17) := "KEYPUSH";

when Topic.REQUEST => Temp(11..17) := "REQUEST";

when Topic.RESPONSE => Temp(11..18) := "RESPONSE";

end case;

return Temp;

end to_Topic;

-- Treat any message

procedure AnyMessage

( Message : in Itf.MessageType

) is

Success : Boolean;

Iteration : String(1..4);

begin -- AnyMessage

Text_IO.Put("Entered ComPublish AnyMessage ");

CStrings.IntegerToString(Message.Header.ReferenceNumber, 4, False,

Iteration, Success);

Int_IO.Put( Integer(Topic.Id_Type'pos(Message.Header.Id.Topic)) );

Text_IO.Put(" ");

Text_IO.Put( to_Topic(Message.Header.Id) );

Text_IO.Put(Iteration(1..4));

Text_IO.Put(" ");

Text_IO.Put_Line(Message.Data(1..Integer(Message.Header.Size)));

end AnyMessage;

end ComPublish;

New Packages - Framework

The App package initiates various message delivery framework packages. The only visible methods are the Launch procedure that is invoked by the Ada Main procedure and FrameworkTopicsAllowed that is used by Library to determine if a message framework topic is allowed. That is, if framework components are being run or whether the application execution has proceeded beyond that possibility.

App.ads

with Itf;

package App is

procedure Launch

( AppId : Itf.ApplicationIdType

);

function FrameworkTopicsAllowed

return Boolean;

-- Return whether framework topics can be registered to the Library

end App;

App.adb

with Component;

with Configuration;

with Delivery;

with Library;

with Remote;

with Topic;

package body App is

AllowFrameworkTopics

-- Only allow FrameworkTopics to be registered until after Remote. After

-- return from the Launch procedure the application specific user components

-- will be installed where the use of the framework topics can not be

-- registered with the Library.

: Boolean := True;

-- Common initializations of the framework packages

procedure InitApplication is

begin -- InitApplication

Topic.Initialize;

Library.Initialize;

Component.Initialize;

Delivery.Initialize;

Configuration.Initialize;

Remote.Initialize;

end InitApplication;

procedure Launch

( AppId : Itf.ApplicationIdType

) is

begin -- Launch

-- Save application id for common access

Itf.ApplicationId := AppId;

-- Do the common initializations of the framework packages

InitApplication;

-- Do the launch of the Remote package to interface with Receive and Transmit

Remote.Launch;

-- Disallow further registration of framework topics.

AllowFrameworkTopics := False;

end Launch;

function FrameworkTopicsAllowed

return Boolean is

begin -- FrameworkTopicsAllowed

return AllowFrameworkTopics;

end FrameworkTopicsAllowed;

end App;

DisburseBytes is a second version of Disburse that handles a queue of messages that are each an array of bytes. This message is what is queued by the Receive packages to ReceiveInterface since the NamedPipe package was implemented to send and receive bytes. I tried to combine this second method into Disburse but I couldn't get it to work so I created a second generic package that is directly similar to the first.

DisburseBytes.ads

with ExecItf;

with Itf;

with System;

with Topic;

generic

-- The parameters to be supplied when instantiating an instance of the package

QueueName : System.Address; -- address of name given to queue by component

Periodic : Boolean; -- True if instantiating component is periodic

Universal : System.Address; -- address of general message callback

Forward : System.Address; -- address of any forward message table

package DisburseBytes is

Location : System.Address;

-- Location of the instance of the QueueBytesType private table

Size : constant Integer := 10;

type QueueBytesType is private;

type QueueBytesPtrType is access QueueBytesType;

for QueueBytesPtrType'storage_size use 0;

type DisburseTablePtrType

is access Itf.DisburseTableType;

for DisburseTablePtrType'storage_size use 0;

procedure Clear;

-- Clear the queue

procedure EventWait;

-- Wait for the provided wait event and then treat any queued messages

procedure ProvideWaitEvent

( Event : in ExecItf.HANDLE );

-- Specify wait event to be used to signal component

-- Note: The Wait Event Handle would be provide with the instantiation

-- parameters except that the queue has to be provided to the

-- Register of the component and the handle isn't known until

-- the Register procedure returns.

function Read

return Itf.BytesType;

-- Return message from queue or null message if queue is empty

function Unread

return Boolean;

-- Return whether there are unread messages in the queue

function Write

( Message : in Itf.BytesType

) return Boolean;

-- Write message to the queue and return if successful

private

type QueueBytesDataArrayType

is array (1..Size) of Itf.BytesType;

type QueueBytesType

is record

Name : Itf.V_Short_String_Type; -- Name given to the queue by the component

WaitHandle : ExecItf.HANDLE;

Unread : Boolean;

NextReadIndex : Integer;

NextWriteIndex : Integer;

List : QueueBytesDataArrayType;

end record;

end DisburseBytes;

DisburseBytes.adb

with Text_IO;

with Unchecked_Conversion;

package body DisburseBytes is

package Int_IO is new Text_IO.Integer_IO( Integer ); --debug

QueueBytes : QueueBytesType; -- queue for byte array messages

procedure Clear is

begin -- Clear

QueueBytes.Unread := False;

QueueBytes.NextReadIndex := 1;

QueueBytes.NextWriteIndex := 1;

end Clear;

-- This procedure is necessary since the instantiation of the queue has to be

-- done before the wait event handle is known.

procedure ProvideWaitEvent

( Event : in ExecItf.HANDLE

) is

begin -- ProvideWaitEvent

QueueBytes.WaitHandle := Event;

end ProvideWaitEvent;

-- This procedure waits for the wait event associated with the queue which is

-- the event associated with the component. The event is that of the thread

-- of the component and so switches from the thread that delivered the message

-- to that of the component.

-- Note: ProvideWaitEvent must be called to provide the particular wait event

-- before the component goes into its wait forever loop.

procedure EventWait is

WaitResult : ExecItf.WaitReturnType;

ResetResult : Boolean;

begin -- EventWait

-- Wait for the event to be signaled

WaitResult := ExecItf.WaitForSingleObject(QueueBytes.WaitHandle, -1);

-- Reset the wait handle

ResetResult := ExecItf.Reset_Event(QueueBytes.WaitHandle);

end EventWait;

function Read

return Itf.BytesType is

RtnNone : Boolean := False;

SavedReadIndex : Integer;

Bytes : Itf.BytesType;

begin -- Read

if QueueBytes.NextReadIndex = QueueBytes.NextWriteIndex then

Text_IO.Put_Line("Disburse Bytes Queue empty");

QueueBytes.Unread := False;

RtnNone := True;

Bytes.Count := 0;

Bytes.Bytes(1) := 0;

return Bytes;

end if;

SavedReadIndex := QueueBytes.NextReadIndex;

if QueueBytes.NextReadIndex >= Size then

QueueBytes.NextReadIndex := 1;

else

QueueBytes.NextReadIndex := QueueBytes.NextReadIndex + 1;

end if;

if QueueBytes.NextReadIndex = QueueBytes.NextWriteIndex then

QueueBytes.Unread := False;

else

QueueBytes.Unread := True;

end if;

Bytes.Count := QueueBytes.List(SavedReadIndex).Count;

Bytes.Bytes := QueueBytes.List(SavedReadIndex).Bytes;

return Bytes;

end Read;

function Unread

return Boolean is

begin -- Unread

return QueueBytes.Unread;

end Unread;

function Write

( Message : in Itf.BytesType

) return Boolean is

Forwarded : Boolean := False;

Rtn : Boolean := True;

CurrentIndex : Integer := QueueBytes.NextWriteIndex;

NextIndex : Integer := CurrentIndex + 1;

Result : Boolean;

use type System.Address;

begin -- Write

-- Queue the message

if NextIndex >= Size then

NextIndex := 1;

end if;

if NextIndex = QueueBytes.NextReadIndex then -- queue overrun

Text_IO.Put("ERROR: Disburse ");

Text_IO.Put(QueueBytes.Name.Data(1..QueueBytes.Name.Count));

Text_IO.Put_Line(" overrun");

Rtn := False;

end if;

if Rtn then

QueueBytes.List(CurrentIndex).Count := Message.Count;

QueueBytes.List(CurrentIndex).Bytes := Message.Bytes;

QueueBytes.NextWriteIndex := NextIndex;

QueueBytes.Unread := True;

end if;

-- End the wait if queue not associated with a periodic component.

-- The end of the wait will result in the thread of the component

-- associated with the queue getting control switching from the

-- thread that delivered the message.

-- Note: Additional messages might be enqueued while the message just

-- queued is being treated since it might be delivered by a higher

-- priority thread that suspends the receiving component.

if QueueBytes.WaitHandle /= System.Null_Address and then

not Periodic

then

Result := ExecItf.Set_Event( Event => QueueBytes.WaitHandle );

elsif not Periodic then

Text_IO.Put("ERROR: No queue wait handle to signal end of wait ");

Text_IO.Put_Line(QueueBytes.Name.Data(1..QueueBytes.Name.Count));

end if;

return Rtn;

end Write;

begin -- instantiation procedure

declare

ComponentQueueName : Itf.V_Short_String_Type;

for ComponentQueueName use at QueueName;

function to_Int is new Unchecked_Conversion

( Source => System.Address,

Target => Integer );

begin

QueueBytes.Name.Count := ComponentQueueName.Count;

QueueBytes.Name.Data := ComponentQueueName.Data;

QueueBytes.WaitHandle := System.Null_Address; -- until provided

QueueBytes.Unread := False;

QueueBytes.NextReadIndex := 1;

QueueBytes.NextWriteIndex := 1;

Location := QueueBytes'Address;

Int_IO.Put(to_Int(Location));

Text_IO.Put_Line(" ");

end;

end DisburseBytes;

The Heartbeat component is a periodic component to publish the HEARTBEAT topic. It is published without specifying a remote application identifier as a indication to Delivery that it should be forwarded to each Transmit component so it can be sent to that component's remote application.

Heartbeat.ads

package Heartbeat is

-- Install the Heartbeat framework package to treat publish Heartbeat messages

procedure Install;

end Heartbeat;

Heartbeat.adb

with Component;

with Delivery;

with DisburseBytes;

with Itf;

with Library;

with System;

with Text_IO;

with Threads;

with Topic;

with Unchecked_Conversion;

package body Heartbeat is

package Int_IO is new Text_IO.Integer_IO( Integer );

QueueName : Itf.V_Short_String_Type

:= ( Count => 9,

Data => "Heartbeat " );

Key : Itf.ParticipantKeyType := Component.NullKey;

-- Component's key returned from Register

RequestTopic : Topic.TopicIdType;

package DisburseQueue

-- Instantiate disburse queue for the component

is new DisburseBytes( QueueName => QueueName'Address,

Periodic => True,

Universal => System.Null_Address,

Forward => System.Null_Address );

HeartbeatName : Itf.V_Medium_String_Type

:= ( Count => 9,

Data => "Heartbeat " );

Result : Component.RegisterResult;

function to_Callback is new Unchecked_Conversion

( Source => System.Address,

Target => Topic.CallbackType );

procedure Main -- Threads callback

( T : in Boolean := False );

-- Install the Heartbeat framework package to publish Heartbeat messages

procedure Install is

Status : Library.AddStatus;

use type Component.ComponentStatus;

use type Library.AddStatus;

begin -- Install

-- Note: Heartbeat has a queue to be signaled when its period has expired.

-- The wait could be done directly instead.

Result :=

Component.Register

( Name => HeartbeatName,

Period => 1500, -- once per 1.5 seconds

Priority => Threads.NORMAL, -- although this is a framework component

Callback => to_Callback(Main'Address),

Queue => DisburseQueue.Location,

QueueWrite => System.Null_Address );

if Result.Status = Component.VALID then

DisburseQueue.ProvideWaitEvent( Event => Result.Event );

Key := Result.Key;

RequestTopic.Topic := Topic.HEARTBEAT;

RequestTopic.Ext := Topic.FRAMEWORK;

Status := Library.RegisterTopic( RequestTopic, Result.Key,

Delivery.PRODUCER,

to_Callback(Main'Address) );

if Status /= Library.SUCCESS then

Text_IO.Put_Line( "ERROR: Register of Topic failed" );

end if;

end Install;

procedure Main -- callback

( T : in Boolean := False

) is

Message : Itf.MessageType := Itf.NullMessage;

begin -- Main

Text_IO.Put_Line("in Heartbeat callback");

loop -- forever

Text_IO.Put_Line("Heartbeat wait for event");

DisburseQueue.EventWait; -- wait for event

-- Publish Heartbeat message to all remote components.

-- Note: The actual message will be created in the particular instance of

-- the Transmit component since it can supply the RemoteAppId.

Message.Header.Id.Topic := Topic.HEARTBEAT;

Message.Header.Id.Ext := Topic.FRAMEWORK;

Delivery.Publish( 0, Message );

end loop; -- forever

end Main;

end Heartbeat;

NamedPipe is the physical interface to Windows pipes that can communicate between applications. As published by Microsoft

"Named Pipes

05/30/2018

2 minutes to read

A named pipe is a named, one-way or duplex pipe for communication between the pipe server and one or more pipe clients. All instances of a named pipe share the same pipe name, but each instance has its own buffers and handles, and provides a separate conduit for client/server communication. The use of instances enables multiple pipe clients to use the same named pipe simultaneously.

Any process can access named pipes, subject to security checks, making named pipes an easy form of communication between related or unrelated processes.

Any process can act as both a server and a client, making peer-to-peer communication possible. As used here, the term pipe server refers to a process that creates a named pipe, and the term pipe client refers to a process that connects to an instance of a named pipe. The server-side function for instantiating a named pipe is CreateNamedPipe. The server-side function for accepting a connection is ConnectNamedPipe. A client process connects to a named pipe by using the CreateFile or CallNamedPipe function.

Named pipes can be used to provide communication between processes on the same computer or between processes on different computers across a network. If the server service is running, all named pipes are accessible remotely. If you intend to use a named pipe locally only, deny access to NT AUTHORITY\NETWORK or switch to local RPC."

The NamedPipe package is created via the Remote package and opened for receive in the threads of the various Receive packages and for transmit via the threads of the various Transmit packages. Whenever a Transmit package is delivered a message it invokes the NamedPipe callback that will output the message to the pipe associated with the remote application. The corresponding server pipe of the remote application will receive the message and return to the associated Receive package to initially treat it and queue it to ReceiveInterface.

The basic pipe names are obtained from NamedPipeNames and then have a necessary prefix applied before they are stored in a ByPair array. The prefix is such that only threads (processes) of the same computer can be connected. These threads will be those of a pair of applications of the Configuration. The ByPair array, sized by the range of PairType, contains other data associated with the local and remote application. The maximum allowed number of pairs is needed for the array is one less than the allowed number applications of the configuration; that is, the number of possible remote applications.

Initialize is invoked from Remote with Pair being the digit of the possible pair, 1, 2, or 3. Index, RemoteId, ReceiveKey, and TransmitKey are left over from when I tried to use a generic package and have been moved from the instantiation parameters. Index is that of the NamedPipeNames array than provides the pair of names for the client and server pipes.

Some of the debug text output to the console has been retained in these packages.

Note: As elsewhere, references to ExecItf is to the interface to the C methods that support the interface to Windows. C# provides these interfaces via its System classes.

NamedPipe.ads

with Configuration;

with Itf;

package NamedPipe is

-- Package to communicate between applications via Named Pipes.

type PairType is new Integer range 1..Configuration.MaxApplications-1;

Index : Integer; -- NamedPipeNames index

RemoteId : Itf.Int8;

ReceiveKey : Itf.ParticipantKeyType;

TransmitKey : Itf.ParticipantKeyType;

procedure Initialize

( Pair : in PairType;

LocalId : in Itf.Int8;

OpenReceive : out Itf.ReceiveOpenCallbackType;

Receive : out Itf.ReceiveCallbackType;

Transmit : out Itf.TransmitCallbackType

);

function OpenReceivePipe

( Pair : in PairType

) return Boolean;

function OpenTransmitPipe

( Pair : in PairType

) return Boolean;

type PipeDirectionType

is ( Receive,

Transmit

);

end NamedPipe;

NamedPipe.adb

with ExecItf;

with Interfaces.C;

with NamedPipeNames;

with Remote;

with System;

with Text_IO;

with Unchecked_Conversion;

package body NamedPipe is

package Int_IO is new Text_IO.Integer_IO( Integer );

function AddrToLPSCSTR -- convert address to ExecItf pointer

is new Unchecked_Conversion( Source => System.Address,

Target => ExecItf.LPCSTR );

function toLPDWORD -- convert address to Exec_Itf pointer

is new Unchecked_Conversion( Source => System.Address,

Target => ExecItf.LPDWORD );

function toLPVOID -- convert address to Exec_Itf pointer

is new Unchecked_Conversion( Source => System.Address,

Target => ExecItf.LPVOID );

type FullPipeName is new String(1..16);

-- Information about a thread and Microsoft Windows named pipes

type CommunicationInfoType

is record

Name : FullPipeName; -- must be of the form \\.\pipe\pipename

-- Name of pipe

Key : Itf.ParticipantKeyType;

-- Key of associated Receive or Transmit component where the local

-- application is the pipe server

Created : Boolean;

-- Whether pipe between server and client has been created

Connected : Boolean;

-- Whether pipe between server and client has connected

Failed : Boolean;

Handle : ExecItf.HANDLE;

-- Pipe handle

end record;

type CommunicationInfoArrayType

is array (1..2) of CommunicationInfoType;

type LookupType

is record

LocalId : Itf.Int8;

RemoteId : Itf.Int8;

end record;

type ByPairAppDataType

is record

PipeInfo : CommunicationInfoArrayType;

PipePair : NamedPipeNames.NamedPipeNameType;

-- Application identifier of the associated remote application

Pair : PairType;

-- Pair index associated with Local and Remote AppIds

LocalAppId : Itf.Int8;

RemoteAppId : Itf.Int8;

TransmitIndex : Integer; -- of pipePair

ReceiveIndex : Integer; -- of pipePair

end record;

type ByPairAppArrayType

is array (PairType)

of ByPairAppDataType;

ByPair : ByPairAppArrayType;

-- Data for possible connections

NullPipeInfo

: constant CommunicationInfoType

:= ( Name => ('\','\','.','\','p','i','p','e','\','P','M','t','o','N',others=>ASCII.NUL),

Key => (0,0,0),

Created => False,

Connected => False,

Failed => False,

Handle => System.Null_Address

);

function LookupPair

( FromTo : in LookupType

) return PairType;

-- Find pair from ByPair table

procedure ReceiveMessage

( Pair : in PairType;

Message : out Itf.BytesType

);

procedure TransmitMessage

( Message : in Itf.BytesType

);

function toOpenReceive is new Unchecked_Conversion

( Source => System.Address,

Target => Itf.ReceiveOpenCallbackType );

function toReceive is new Unchecked_Conversion

( Source => System.Address,

Target => Itf.ReceiveCallbackType );

function toTransmit is new Unchecked_Conversion

( Source => System.Address,

Target => Itf.TransmitCallbackType );

procedure Initialize

( Pair : in PairType;

LocalId : in Itf.Int8;

OpenReceive : out Itf.ReceiveOpenCallbackType;

Receive : out Itf.ReceiveCallbackType;

Transmit : out Itf.TransmitCallbackType

) is

ReceiveIndex : Integer;

TransmitIndex : Integer;

begin -- Initialize

-- Save identifier of the remote application tied to this

-- instance of the Receive class.

ByPair(Pair).Pair := Pair;

ByPair(Pair).LocalAppId := LocalId;

ByPair(Pair).RemoteAppId := RemoteId;

ByPair(Pair).TransmitIndex := 1; -- transmit

ByPair(Pair).ReceiveIndex := 2; -- receive

TransmitIndex := 1;

ReceiveIndex := 2;

ByPair(Pair).PipePair := NamedPipeNames.NamedPipeName.List(Index);

ByPair(Pair).PipeInfo(TransmitIndex) := NullPipeInfo;

ByPair(Pair).PipeInfo(ReceiveIndex) := NullPipeInfo;

for I in 1..4 loop

ByPair(Pair).PipeInfo(TransmitIndex).Name(I+10) :=

ByPair(Pair).PipePair.lPipeName(I);

end loop;

ByPair(Pair).PipeInfo(TransmitIndex).Key := TransmitKey;

for I in 1..4 loop

ByPair(Pair).PipeInfo(ReceiveIndex).Name(I+10) :=

ByPair(Pair).PipePair.rPipeName(I);

end loop;

ByPair(Pair).PipeInfo(ReceiveIndex).Key := ReceiveKey;

OpenReceive := toOpenReceive(OpenReceivePipe'Address);

Receive := toReceive(ReceiveMessage'Address);

Transmit := toTransmit(TransmitMessage'Address );

Delay(1.000); -- 1 second

end Initialize;

function Connect

( Pair : in PairType;

Direction : in PipeDirectionType

) return Boolean is

Handle

-- Handle of pipe

: ExecItf.HANDLE;

Status

-- True means server connected to client

: ExecItf.BOOL;

use type ExecItf.BOOL;

begin -- Connect

-- Wait for the client to connect. If it succeeds, the function returns

-- a nonzero value. If the function returns zero, GetLastError returns

-- ERROR_PIPE_CONNECTED.

if Direction = Transmit then

Handle := ByPair(Pair).PipeInfo(ByPair(Pair).TransmitIndex).Handle;

else

Handle := ByPair(Pair).PipeInfo(ByPair(Pair).ReceiveIndex).Handle;

end if;

Status := ExecItf.ConnectNamedPipe( NamedPipe => Handle,

Overlapped => null );

if Status = 0 then -- FALSE

ByPair(Pair).PipeInfo(Index).Connected := False;

else -- TRUE

ByPair(Pair).PipeInfo(Index).Connected := True;

end if;

return ByPair(Pair).PipeInfo(Index).Connected;

end Connect;

function LookupPair

( FromTo : in LookupType

) return PairType is

use type Itf.Int8;

begin -- LookupPair

for I in PairType loop

if (ByPair(I).LocalAppId = FromTo.LocalId and then

ByPair(I).RemoteAppId = FromTo.RemoteId) or else

(ByPair(I).LocalAppId = FromTo.RemoteId and then

ByPair(I).RemoteAppId = FromTo.LocalId)

then

return ByPair(I).Pair; -- should be the same as I index

end if;

end loop;

-- there has to be a match

return 1; -- for Ada - no invalid value available

end LookupPair;

-- Close the Receive and Transmit pipes

procedure ClosePipes

( Pair : PairType;

Client : in Boolean

) is

Status

-- True means function was successful

: ExecItf.BOOL;

use type System.Address;

begin -- ClosePipes

if Client then

if ByPair(Pair).PipeInfo(ByPair(Pair).ReceiveIndex).Handle /=

ExecItf.Invalid_Handle_Value

then

Text_IO.Put_Line("ClosePipes closing pipeClient and setting to null");

Status := ExecItf.DisconnectNamedPipe

( NamedPipe => ByPair(Pair).PipeInfo(

ByPair(Pair).ReceiveIndex).Name'Address );

ByPair(Pair).PipeInfo(ByPair(Pair).ReceiveIndex).Handle :=

System.Null_Address;

end if;

else

if ByPair(Pair).PipeInfo(ByPair(Pair).TransmitIndex).Handle /=

ExecItf.Invalid_Handle_Value

then

Text_IO.Put_Line("ClosePipes closing pipeServer and setting to null");

Status := ExecItf.DisconnectNamedPipe

( NamedPipe => ByPair(Pair).PipeInfo(

ByPair(Pair).TransmitIndex).Name'Address );

ByPair(Pair).PipeInfo(ByPair(Pair).TransmitIndex).Handle :=

System.Null_Address;

end if;

end ClosePipes;

-- Open the Receive Pipe

function OpenReceivePipe

( Pair : PairType

) return Boolean is

Connected : Boolean;

Name : FullPipeName;

use type Interfaces.C.unsigned_long;

use type System.Address;

function to_Int is new unchecked_conversion

( Source => System.Address,

Target => Integer );

begin -- OpenReceivePipe

Text_IO.Put("OpenReceivePipe ");

Name := ByPair(Pair).PipeInfo(ByPair(Pair).ReceiveIndex).Name;

Text_IO.Put_Line(String(Name));

if not ByPair(Pair).PipeInfo(ByPair(Pair).ReceiveIndex).Created

then

ByPair(Pair).PipeInfo(ByPair(Pair).ReceiveIndex).Handle :=

ExecItf.CreateNamedPipe

( Name => AddrtoLPSCSTR(

ByPair(Pair).PipeInfo(

ByPair(Pair).ReceiveIndex).Name'Address),

OpenMode => ExecItf.PIPE_ACCESS_DUPLEX,

PipeMode => ExecItf.PIPE_TYPE_MESSAGE or

ExecItf.PIPE_READMODE_MESSAGE or

ExecItf.PIPE_WAIT,

MaxInstances => ExecItf.PIPE_UNLIMITED_INSTANCES,

OutBufferSize => Interfaces.C.unsigned_long(Itf.MessageSize),

InBufferSize => Interfaces.C.unsigned_long(Itf.MessageSize),

DefaultTimeOut => 0, -- client timeout in msec

SecurityAttributes => null ); -- default security attributes

-- Note: The client and server processes in this example are intended

-- to run on the same computer, so the server name provided to the

-- NamedPipeClientStream object is ".". If the client and server

-- processes were on separate computers, "." would be replaced with

-- the network name of the computer that runs the server process.

if ByPair(Pair).PipeInfo(ByPair(Pair).ReceiveIndex).Handle =

ExecItf.Invalid_Handle_Value

then

Text_IO.Put_Line("ERROR: PipeClient has become null");

else

Text_IO.Put_Line("Connecting to server...");

Int_IO.Put(to_Int(

ByPair(Pair).PipeInfo(ByPair(Pair).ReceiveIndex).Handle));

Text_IO.Put_Line(" ");

begin

Connected := Connect( Pair, Receive );

exception

when others => null;

end;

Text_IO.Put("PipeClient setting Connected ");

Int_IO.Put(Integer(ByPair(Pair).RemoteAppId));

Text_IO.Put_Line("");

if ByPair(Pair).PipeInfo(ByPair(Pair).ReceiveIndex).Handle =

ExecItf.Invalid_Handle_Value

then

Text_IO.Put_Line("ERROR: PipeClient has become null");

else

ByPair(Pair).PipeInfo(ByPair(Pair).ReceiveIndex).Connected := True;

Text_IO.Put("PipeClient Connected ");

if ByPair(Pair).PipeInfo(ByPair(Pair).ReceiveIndex).Connected

then

Text_IO.Put("True ");

else

Text_IO.Put("False ");

end if;

Int_IO.Put(Integer(ByPair(Pair).RemoteAppId));

Text_IO.Put_Line(" ");

end if;

Remote.SetConnected( ByPair(Pair).RemoteAppId, True );

end if;

return ByPair(Pair).PipeInfo(ByPair(Pair).ReceiveIndex).Connected;

end OpenReceivePipe;

-- Open the Transmit Pipe

function OpenTransmitPipe

( Pair : PairType

) return Boolean is

use type Interfaces.C.unsigned_long;

use type NamedPipeNames.PipeNameType;

use type System.Address;

function to_Int is new unchecked_conversion

( Source => System.Address,

Target => Integer );

begin -- OpenTransmitPipe

Text_IO.Put("OpenTransmitPipe ");

Text_IO.Put_Line(String(

ByPair(Pair).PipeInfo(ByPair(Pair).TransmitIndex).Name));

if ByPair(Pair).PipeInfo(ByPair(Pair).TransmitIndex).Name /= "" then

ByPair(Pair).PipeInfo(ByPair(Pair).TransmitIndex).Handle :=

ExecItf.CreateFile

( FileName => AddrToLPSCSTR(

ByPair(Pair).PipeInfo(

ByPair(Pair).TransmitIndex).Name'Address),

DesiredAccess => ExecItf.GENERIC_READ or ExecItf.GENERIC_WRITE,

ShareMode => 0, -- no sharing

SecurityAttributes => null, -- default security attributes

CreationDisposition => ExecItf.OPEN_ALWAYS,

FlagsAndAttributes => 0, -- default attributes

TemplateFile => System.Null_Address ); -- no template file

if ByPair(Pair).PipeInfo(ByPair(Pair).TransmitIndex).Handle /=

ExecItf.Invalid_Handle_Value

then

ByPair(Pair).PipeInfo(ByPair(Pair).TransmitIndex).Created :=

True;

Text_IO.Put("Server/Transmit connected for remote app ");

Int_IO.Put(to_Int(

ByPair(Pair).PipeInfo(ByPair(Pair).TransmitIndex).Handle));

Text_IO.Put_Line(String(

ByPair(Pair).PipeInfo(ByPair(Pair).TransmitIndex).Name));

end if;

return ByPair(Pair).PipeInfo(ByPair(Pair).TransmitIndex).Created;

else -- error creating pipe

return False;

end if;

end OpenTransmitPipe;

-- Receive a message from the remote pipe client

procedure ReceiveMessage

( Pair : in PairType;

Message : out Itf.BytesType

) is

use type ExecItf.BOOL;

use type Itf.Byte;

use type Itf.BytesType;

use type System.Address;

begin -- ReceiveMessage

if ByPair(Pair).PipeInfo(ByPair(Pair).ReceiveIndex).Handle /=

ExecItf.Invalid_Handle_Value

then

Text_IO.Put("ReceiveMessage fromServer ");

Int_IO.Put(Integer(ByPair(Pair).RemoteAppId));

if Remote.RemoteConnected(ByPair(Pair).RemoteAppId) then

Text_IO.Put_Line(" True");

else

Text_IO.Put_Line(" False");

end if;

if ByPair(Pair).PipeInfo(ByPair(Pair).ReceiveIndex).Connected and then

Remote.RemoteConnected(ByPair(Pair).RemoteAppId)

then

declare

BytesToRead : Interfaces.C.unsigned_long;

BytesRead : Integer;

Start : Integer;

FromServer : Itf.BytesType;

Status : ExecItf.BOOL;

begin

BytesToRead := Interfaces.C.unsigned_long(FromServer.Bytes'Last);

Status :=

ExecItf.ReadFile

( File => ByPair(Pair).PipeInfo(

ByPair(Pair).ReceiveIndex).Handle,

Buffer => toLPVOID(FromServer.Bytes'address),

NumberOfBytesToRead => BytesToRead, -- size of the buffer

NumberOfBytesRead => toLPDWORD(BytesRead'address),

Overlapped => null ); -- not overlapped I/O

if BytesRead > FromServer.Bytes'Last then

Text_IO.Put("Too many bytes read ");

Int_IO.Put(Integer(BytesRead));

Text_IO.Put_Line(" ");

end if;

FromServer.Count := BytesRead;

if Status /= 0 then -- TRUE

if FromServer.Count < Integer(Itf.HeaderSize) + 8 then

-- including NAKs

Text_IO.Put("ERROR: Received less than ");

Int_IO.Put(Integer(Itf.HeaderSize));

Text_IO.Put(" ");

Int_IO.Put(Integer(FromServer.Count));

Text_IO.Put_Line(" ");

end if;

-- Remove any leading NAKs from message.

Start := 0;

for I in 1..FromServer.Count loop

if FromServer.Bytes(I) /= 21 then -- NAK

Start := I;

Exit; -- loop

end if;

end loop;

declare

J : Integer := 0;

Msg : Itf.BytesType;

begin

for I in Start..FromServer.Count loop

J := J + 1;

Msg.Bytes(J) := FromServer.Bytes(I);

end loop;

Msg.Count := J;

Message := Msg;

return;

end;

end if;

end;

end if; -- IsConnected

else -- no longer connected

Text_IO.Put("ReceiveMessage not connected ");

Int_IO.Put(Integer(ByPair(Pair).RemoteAppId));

Text_IO.Put_Line(" ");

if ByPair(Pair).PipeInfo(ByPair(Pair).ReceiveIndex).Connected then

Text_IO.Put("ReceiveMessage invoking Remote ");

Int_IO.Put(Integer(ByPair(Pair).RemoteAppId));

Text_IO.Put_Line(" ");

Remote.SetConnected(ByPair(Pair).RemoteAppId,False);

ByPair(Pair).PipeInfo(ByPair(Pair).ReceiveIndex).Connected := False;

ClosePipes(Pair, True); -- close receive pipe

end if;

-- Return a null message if pipeClient is null.

Message := ( Count => 0,

Bytes => ( others => 0 ) );

end ReceiveMessage;

-- Transmit a message to the remote pipe server.

procedure TransmitMessage

( Message : in Itf.BytesType

) is

Lookup : LookupType;

Pair : PairType;

Status : ExecItf.BOOL;

use type System.Address;

begin -- TransmitMessage

Lookup.LocalId := Itf.Int8(Message.Bytes(5));

Lookup.RemoteId := Itf.Int8(Message.Bytes(8));

Pair := LookupPair(Lookup);

if ByPair(Pair).PipeInfo(ByPair(Pair).TransmitIndex).Handle /=

ExecItf.Invalid_Handle_Value

then

declare

BytesWritten

-- Number of bytes written

: ExecItf.DWORD;

Msg : Itf.BytesType;

use type Interfaces.C.unsigned_long;

function to_Int is new unchecked_conversion

( Source => System.Address,

Target => Integer );

begin

-- Prepend 8 NAK's to the beginning of the message.

for I in 1..8 loop

Msg.Bytes(I) := 21; -- NAK

end loop;

-- Copy the message to follow the NAKs

for I in 1..Message.Count loop --Length loop

Msg.Bytes(I + 8) := Message.Bytes(I);

end loop;

Msg.Count := Message.Count + 8;

Text_IO.Put("TransmitMessage sending ");

Int_IO.Put(Integer(Msg.Count));

Text_IO.Put_Line(" bytes");

-- Send message via the server process.

Status := ExecItf.WriteFile

( File => ByPair(Pair).PipeInfo(

ByPair(Pair).TransmitIndex).

Handle,

Buffer => toLPVOID(Msg.Bytes'address),

NumberOfBytesToWrite => ExecItf.ULONG(Msg.Count),

NumberOfBytesWritten => toLPDWORD(BytesWritten'address),

Overlapped => null ); -- not overlapped I/O

if Integer(Status) > 0 then -- Write successful

if Integer(BytesWritten) /= Msg.Count then

Text_IO.Put("ERROR: Write of wrong length ");

Int_IO.Put(Integer(BytesWritten));

Text_IO.Put(" ");

Int_IO.Put(Integer(Msg.Count));

Text_IO.Put_Line(" ");

end if;

else

Text_IO.Put("ERROR: Write to pipe failed ");

Int_IO.Put(to_Int(ByPair(Pair).PipeInfo(

ByPair(Pair).TransmitIndex).Handle));

Text_IO.Put_Line(" ");

end if;

end;

else

Text_IO.Put_Line("ERROR: null pipeServer");

end if;

-- Catch the IOException that is raised if the pipe is broken

-- or disconnected.

exception

when others =>

Text_IO.Put("ERROR: ");

Text_IO.Put("Setting PipeConnected false for ");

Int_IO.Put(Integer(ByPair(Pair).RemoteAppId));

Text_IO.Put_Line(" ");

Remote.SetConnected(ByPair(Pair).RemoteAppId,False);

end TransmitMessage;

end NamedPipe;

NamedPipeNames.ads

with Configuration;

package NamedPipeNames is

-- These types are included so that NamedPipe can reference the

-- NamedPipeName table directly.

type PipeNameType is new String(1..4);

type NamedPipeNameType

is record

lPipeName : PipeNameType;

rPipeName : PipeNameType;

end record;

type NamedPipeNameArrayType

is array(1..4*Configuration.MaxApplications - 1) of NamedPipeNameType;

type NamedPipeNameTableType

is record

Count : Integer;

List : NamedPipeNameArrayType;

end record;

NamedPipeName

: NamedPipeNameTableType;

procedure Initialize;

end NamedPipeNames;

NamedPipeNames.adb

package body NamedPipeNames is

procedure Initialize is

begin -- Initialize

-- Set the local and remote app basic pipe names of each possible pair

NamedPipeName.List(1).lPipeName := "1to2"; -- App1 the local app

NamedPipeName.List(1).rPipeName := "2to1";