Abstract:
A method, system and article of manufacture for determining whether a presentation space (PS) is completely built in a TN3270 environment. In general, a TN3270 client is provided with an indication from a TN3270 server that a Systems Network Architecture (SNA) application has completely built the PS. In some cases, the indication prompts the TN3270 client to unlock a device, such as a keyboard.

Description:
BACKGROUND OF THE INVENTION  
         [0001]    1. Field of the Invention  
           [0002]    The present invention generally relates to data processing and more particularly to 3270 applications migrated for use on TN3270 network architecture.  
           [0003]    2. Description of the Related Art  
           [0004]    Data processing systems, methods and computer program products that use a 3270 data stream architecture have been widely used for decades. Systems using the 3270 data stream architecture are often referred to as “legacy” systems. Details regarding the 3270 data stream architecture are described in “IBM 3270 Information Display System Data Stream Programmer&#39;s Reference”, published by International Business Machines Corporation (IBM), the assignee of the present application, IBM Publication Number GA23-0059-07, 1982, the disclosure of which is hereby incorporated herein by reference.  
           [0005]    In general, the 3270 data stream controls the processing and formatting of data with commands, orders, control characters, attributes, and structured fields. The 3270 data stream operations are used primarily for transmitting data between a host application and a client. More specifically, the 3270 data stream architecture is used to communicate between a Primary Logical Unit (PLU) and a Secondary Logical Unit (SLU) using the LU2 protocol. The PLU typically performs functions associated with the host application. It will be understood that the primary and secondary logical units may be mainframe computers, midrange computers, personal computers, terminals, workstations or one or more computer programs that execute on one or more of such computers.  
           [0006]    The above described environment may be further understood with reference to FIG. 1. As shown in FIG. 1, a data processing system ( 100 ) includes a PLU ( 110 ) and an SLU ( 120 ) that communicate with each other over a network ( 130 ) using the 3270 data stream. The PLU ( 110 ) may also be referred to as a host, and the SLU ( 120 ) may be referred to as a terminal, workstation, emulator or client. The SLU ( 120 ) typically includes a keyboard and a display device. The PLU ( 110 ) includes a host application ( 140 ), which communicates with the SLU ( 120 ) via the network ( 130 ). The SLU ( 120 ) includes a presentation space (PS) ( 180 ). The PS ( 180 ) is the collection of information that together comprises the information to be displayed on a screen of a terminal in the SLU, as well as the control data that conveys how and where that information is to represented. It will be understood that, although FIG. 1 illustrates a simple data processing system ( 100 ) including one PLU ( 110 ), one SLU ( 120 ) and a simple network connection ( 130 ), the 3270 data stream architecture is generally used to communicate among many PLUs and SLUs using complex network environments.  
           [0007]    PLUs and SLUs communicate in a Systems Network Architecture (SNA). The SNA is the logical structure, formats, protocols, and operational sequences for transmitting information units through, and controlling the configuration and operation of, networks. Thus, in the context of FIG. 1, where the network ( 130 ) is a SNA network, the host application ( 140 ) is a 3270 application.  
           [0008]    The 3270 data stream is an arrangement of bytes and can be an outbound data stream or an inbound data stream. The outbound data stream is a data stream sent from the host application ( 140 ) to the SLU ( 120 ) and includes data, a command, and if a write type command, a write control character (WCC). An inbound data stream is sent from the SLU to the host application and consists of an attention identifier (AID), followed by data. The AID is a byte that describes the action that caused the transmission of the inbound data stream. The data is the information transferred between the host application and the SLU.  
           [0009]    The command from the host application ( 140 ) is sent to the SLU ( 120 ) to initiate the total or partial writing, reading, or erasing of portions of the PS ( 140 ). Commands are sent as a command code in the first byte of a request/response unit (RU) chain. Examples of typical command codes may be found in TABLE 1 below.  
                               TABLE I                                   Command   EBCDIC   Local Channel non-SNA                           Write   X′F1′   X′01′           Erase/Write   X′F5′   X′05′           Erase/Write Alternate   X′7E′   X′0D′           Read Buffer   X′F2′   X′02′           Read Modified   X′F6′   X′06′           Read Modified All   X′6E′   N/A           Erase All Unprotected   X′6F′   X′0F′           Write Structured Field   X′F3′   X′11′                      
 
           [0010]    Referring to TABLE 1, EBCDIC (Extended Binary-Coded Decimal Interchange Code) is a coded character set consisting of 8-bit coded characters. EBCDIC is the standard decimal interchange code for IBM mainframes. Local Channel non-SNA refers to a network that attaches emulators, terminals, and workstations, which may communicate with other locally attached devices without using the SNA network.  
           [0011]    The WCC is the byte following a write command used to specify that a particular operation, or combination of operations, is to be performed at a terminal or printer. For the write command, the WCC is bit encoded with bits 0-1 set depending on the values in bits 2-7. TABLE 2 below, indicates the functions of the WCC bits.  
                   TABLE 2                       Bit   Function                   0-1   Depends on values in bits 2-7       2-3   For printers       4   Start-printer bit       5   Sound-alarm bit       6   Keyboard restore bit       7   Reset MDT bits in the field attributes                  
 
           [0012]    When bit 6 of the WCC is set to 1, the command unlocks the keyboard, and resets the AID byte.  
           [0013]    Recently, many users have abandoned 3270 terminals in favor of personal computers (PCs). However, because most host applications on the mainframe were written to run on 3270 terminals in a SNA network, a terminal emulator that permits PCs to access an IBM mainframe was necessitated. Generally, the terminal emulator causes the PC to appear as a 3270 terminal to the mainframe. One method of doing this is with a Telnet 3270 terminal emulator (TN3270). Additional information regarding TN3270 can be found in RFC 2355.  
           [0014]    An exemplary illustration of the relationship between a SNA network and a TN3270 network is found in FIG. 2. In FIG. 2, the data processing system ( 100 ), includes the PLU ( 110 ), including a host application ( 140 ), which communicates with the SLU ( 120 ) via the SNA network ( 130 ). In contrast to FIG. 1, the SLU ( 120 ), shown in FIG. 2, is split between two entities, a TN3270 server ( 150 ) and a TN3270 client ( 170 ), which communicate via a TN3270 network ( 160 ). The TN3270 client ( 170 ) has a PS ( 180 ) which is used to display information on a display device.  
           [0015]    The TN3270 performs the function of modifying the display information sent by the host application ( 140 ) on the mainframe, and formatting it for display on the PC. In other words, the TN3270 manipulates the presentation space ( 180 ). In a typical attempt to modify the PS ( 180 ) on the TN3270 client ( 170 ), the host application ( 140 ) communicates the 3270 data stream via the SNA network ( 130 ), using SNA network protocols. The TN3270 server ( 150 ) receives the 3270 data stream and translates the SNA network protocols into TN3270 network protocols, leaving the payload the same, thus, creating a TN3270 data stream. As part of this processing, the TN3270 causes 3270 data streams to be encapsulated in telnet TCP/IP packets. The TN3270 server ( 150 ) then sends the TN3270 data stream to the TN3270 client ( 170 ) via the TN3270 network ( 160 ). The TN3270 client ( 170 ) receives the TN3270 data stream and updates the PS ( 180 ) with the payload.  
           [0016]    After the host application ( 140 ) completes its modification of the PS ( 180 ), the PLU ( 110 ) sends either an end bracket (EB) or a change direction (CD) to the SLU ( 120 ) to indicate that the PLU is done updating the PS ( 180 ). The EB is sent from the PLU ( 110 ) to the TN3270 server ( 150 ), and indicates that the PLU ( 110 ) is done updating the PS ( 180 ), and that either the SLU ( 120 ) or PLU ( 110 ) may begin a communication. In particular, the EB places the session in a contention state. The contention state is when both the PLU and SLU are able to initiate a communication. In the contention state, if both the PLU and SLU simultaneously begin a conversation, the SLU will prevail. When in the contention state, the host application may send a BID or a SIGNAL to the SLU. The BID is a request to begin a communication. The SLU may accept or reject the BID. One reason for rejecting the BID is if the PS has been modified by an entity on the SLU-side, such as a user. In the case of a modification of the PS by the user, the SLU must reject the host application&#39;s BID attempt so that the SLU can report the modifications to the host application. In a typical TN3270 environment, the TN3270 server rejects all BIDs from the host application.  
           [0017]    The SIGNAL is an SNA command that is a demand from the host application to the SLU, or vice versa, to begin a communication. If the SLU receives a SIGNAL it must allow the host application to communicate. Upon receipt of a SIGNAL, the SLU may send all changes to the PS to the host application, as well as a change direction (CD). The CD may be sent by either the PLU or SLU, and indicates that only the PLU may begin a communication, and that the SLU will not interrupt any communications.  
           [0018]    In a pure SNA network (as shown in FIG. 1), the EB would implicitly unlock the keyboard. However, when SNA applications are migrated for use on the TN3270 network (as shown in FIG. 2), there is no implicit unlocking of the keyboard. In general practice, a well-mannered TN3270 server does not pass the EB to the TN3270 client; rather, the server generates and communicates an X′F1C2′ command. An X′F1C2′ command is a write command with WCC having keyboard restore bit on (i.e., bit 6). Thus, the X′F1C2′ command unlocks the keyboard. The current practice of a TN3270 server is to generate and communicate to the TN3270 client an X′F1C2′ upon receipt of an EB from the PLU. However, because X′F1C2′ can be generated by both the TN3270 server and the host application, the TN3270 client is not explicitly aware of the EB and will not know that the host application is done updating the PS. The same is true when the TN3270 receives a CD, except that a CD does not include an implicit keyboard store.  
           [0019]    Therefore, there is a need for determining whether the PS is completely built in a TN3270 environment.  
         SUMMARY OF THE INVENTION  
         [0020]    The present invention generally provides methods, systems and articles of manufacture for determining whether a presentation space (PS) is completely built in a TN3270 environment. In qeneral, a TN3270 client is provided with an indication from a TN3270 server that a SNA application has completely built the PS. In some cases, the indication prompts the TN3270 client to unlock a device, such as a keyboard.  
           [0021]    One embodiment provides a method, comprising sending, from a TN3270 server to a TN3270 client, a command which unambiguously indicates to the TN3270 client that a Systems Network Architecture (SNA) application has completed building a presentation space in the T3270 client.  
           [0022]    Another embodiment provides a method performed within an environment comprising a (i) primary logical unit (PLU) comprising a SNA host application, (ii) a secondary logical unit (SLU) and (iii) a SNA network connecting the PLU and SLU. The method comprises sending, from a TN3270 server of the SLU to a TN3270 client of the SLU, a command which unambiguously indicates to the TN3270 client that the SNA host application has completed building a presentation space of the T3270 client.  
           [0023]    Yet another embodiment provides a secondary logical unit connected to a primary logical unit via a SNA network, comprising: a TN3270 server configured to send a command; and a TN3270 client configured to receive the command, wherein the command unambiguously indicates to the TN3270 client that a SNA host application of the PLU has finished building a presentation space of the TN3270 client.  
           [0024]    Still another embodiment provides a system, comprising: a primary logical unit (PLU) comprising a SNA host application and a secondary logical unit (SLU) connected to the PLU by a SNA network. The SLU comprises a TN3270 server configured to send a write command; a TN3270 client configured to receive the write command, wherein the write command unambiguously indicates to the TN3270 client that the SNA host application has completed building a presentation space of the TN3270 client; and a telnet network connecting the TN3270 server and the TN3270 client.  
           [0025]    Still another embodiment provides a method comprises sending a command from a TN3270 server to a TN3270 client when the TN3270 server receives a signal from a SNA application demanding ownership of a presentation space of the TN3270 client. 
       
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS  
       [0026]    So that the manner in which the above recited features, advantages and objects of the present invention are attained and can be understood in detail, a more particular description of the invention, briefly summarized above, may be had by reference to the embodiments thereof which are illustrated in the appended drawings.  
         [0027]    It is to be noted, however, that the appended drawings illustrate only typical embodiments of this invention and are therefore not to be considered limiting of its scope, for the invention may admit to other equally effective embodiments.  
         [0028]    [0028]FIG. 1 illustrates a prior art pure SNA data processing system.  
         [0029]    [0029]FIG. 2 is an exemplary illustration of the relationship between a SNA network and a TN3270 network.  
         [0030]    [0030]FIG. 3 illustrates one embodiment of a data processing system of the invention.  
         [0031]    [0031]FIG. 4 illustrates an exemplary flow process of one or more embodiments of the present invention. 
     
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS  
       [0032]    The present invention generally provides methods, systems and articles of manufacture for determining whether a presentation space (PS) is completely built in a TN3270 environment. Further, embodiments are provided for defining the ownership of the presentation space by either a PLU or SLU.  
         [0033]    One embodiment of a data processing system ( 300 ) of the invention is shown in FIG. 3. Generally, the data processing system ( 300 ) includes a PLU ( 310 ) and an SLU ( 320 ) that communicate with each other over a SNA network ( 330 ) using the 3270 data stream. The PLU ( 310 ) includes a host application ( 340 ), which communicates with the SLU ( 320 ) via the network ( 330 ). The SLU comprises a TN3270 server ( 350 ) and a TN3270 client ( 370 ), which communicate via a TN3270 network ( 360 ). The TN3270 client ( 370 ) has a PS ( 380 ) which is used to display information on a display device ( 375 ). The PS ( 380 ) is the collection of information that together comprises the information to be displayed on a screen of a terminal ( 385 ) in the SLU, as well as the control data that conveys how and where that information is to represented. It will be understood that, although FIG. 3 illustrates only one PLU ( 310 ) and one SLU ( 320 ) connected via the SNA network ( 330 ), the 3270 data stream architecture is generally used to communicate among many PLUs and SLUs using complex network environments.  
         [0034]    The client ( 370 ) and server ( 350 ) of the SLU ( 320 ) are each configured to communicate information regarding the state of the PS ( 380 ). In particular, the server ( 350 ) is configured with data stream command generation code ( 390 ) and the client ( 370 ) is configured with data stream command interpretation code ( 395 ). In operation, the server ( 350 ) receives one of an EB or CD from the SNA application ( 340 ). In response, the server generates (using the data stream command generation code ( 390 )) and transmits a command (represented as the instruction ( 302 )) indicating to the client ( 370 ) that the host application ( 340 ) is finished building the PS ( 380 ). In this manner, the client ( 370 ) is made aware of the state of the PS ( 380 ).  
         [0035]    In order for the TN3270 client ( 370 ) to know that the PS ( 380 ) has been completely built (i.e., one of an end bracket (EB) or a change direction (CD) has been sent by the host application ( 340 )), the TN3270 server ( 350 ) generates a command (i.e., command  302  in FIG. 3) which unambiguously indicates to the TN3270 client that the command originated with the TN3270 server. In one embodiment, receipt of an EB from the SNA host application ( 340 ) causes the TN3270 server to generate a command having the following format: X′0102′. Where the TN 3270 server receives a CD from the SNA application, the TN3270 server generates a command having the following format: X′0100′. The X′01′ command is defined as a valid local channel non-SNA write command. X′02′ is a WCC having keyboard restore. In combination, the command is X′0102′. Thus, where an EB would previously cause the TN3270 server to generate an X′F1C2′, which would not permit the TN3270 client to know that the PS was completely built, the TN3270 server will instead send a X′0102′. The use of X′01′ as the write command unambiguously indicates that the command was generated by the TN3270 server and not the SNA host application (which would send an X′F1′ instead). The use of X′02′ indicates to the TN3270 client that the command could not have been sent by a local channel non-SNA application as the WCC is unique to the TN3270 server. An X′0100′ can also only be generated by the TN3270 server. In this manner, the client is definitively made aware that the command originated from the TN3270 server. Upon receipt of the X′0102′ the TN3270 client knows that the X′0102′ must have come from the TN3270 server and the TN3270 client knows that the PS is completely built and is commanded to unlock the keyboard.  
         [0036]    In other embodiments, the server ( 350 ) receives a SIGNAL from the SNA application  340  demanding ownership of the PS ( 380 ). In response, the server generates (using the data stream command generation code ( 390 )) and transmits a command (represented as the instruction ( 302 )) indicating to the client ( 370 ) that the host application ( 340 ) now has ownership of the PS ( 380 ). Upon receipt of the command  302  (sent by the server in response to the SIGNAL), the keyboard is locked.  
         [0037]    [0037]FIG. 4 illustrates an exemplary flow process of one or more embodiments of the present invention. To update the PS ( 380 ), the PLU ( 310 ) sends an RU ( 402 ) via the SNA network ( 330 ) to the TN3270 server ( 350 ). The TN3270 server then converts the SNA data stream into the TN3270 data stream ( 404 ). Next, the TN3270 data stream is sent via the TN3270 network ( 360 ) to the TN3270 client ( 370 ), which updates ( 406 ) the PS ( 380 ) with the data, and may unlock the keyboard depending on the RU contents.  
         [0038]    After completing the update of the PS ( 432 ), the PLU ( 310 ) sends an EB ( 408 ) via the SNA network ( 330 ) to the TN3270 server ( 350 ). The TN3270 server then converts the SNA data stream into the TN3270 data stream ( 404 ), and generates an X′0102′ ( 410 ). Next, the TN3270 data stream with the X′0102′ is sent via the TN3270 network ( 360 ) to the TN3270 client ( 370 ), which unambiguously indicates to the TN3270 client ( 370 ) that the PS ( 380 ) is complete and may be modified, and that the keyboard should be unlocked. The command is unambiguous because it can only be generated by the TN3270 server ( 350 ).  
         [0039]    When the host application attempts to communicate with the SLU after the PS is complete, the host application ( 340 ) sends (via the PLU ( 310 )) a BID ( 414 ) via the SNA network ( 330 ) to the TN3270 server ( 350 ) to begin communication. The BID is automatically rejected by the TN3270 server ( 350 ).  
         [0040]    When the host application ( 340 ) sends a SIGNAL ( 418 ) via the SNA network ( 330 ) to the TN3270 server ( 350 ), it is demanding a communication. The TN3270 server ( 350 ) converts the 3270 data stream into a local channel non-SNA read modify command (X′06′). The host application, which typically generates an X′F6′ for read modify commands, could never generate an X′06′, thereby making the source of the command unambiguous to the client ( 370 ). The X′06′ is sent to the TN3270 client ( 370 ) via the TN network ( 360 ). Upon receipt of the X′06′, the TN3270 client locks the keyboard, stacks the keystrokes of the user, and sends the read modify data stream ( 424 ) inbound to the TN3270 server ( 350 ). The TN3270 server ( 350 ) then sends a CD ( 426 ) to the host application ( 340 ), allowing the PLU ( 310 ) to begin a communication.  
         [0041]    After the CD ( 426 ) is sent to the host application ( 340 ), the host application ( 340 ) may once again update the PS ( 380 ). To update the PS ( 380 ), the PLU ( 310 ) sends the RU ( 402 ) via the SNA network ( 330 ) to the TN3270 server ( 350 ). The TN3270 server then converts the SNA data stream into the TN3270 data stream ( 404 ). Next, the TN3270 data stream is sent via the TN3270 network ( 360 ) to the TN3270 client ( 370 ), which updates ( 406 ) the PS ( 380 ) with the data.  
         [0042]    If the PLU ( 310 ) sends a CD ( 428 ) via the SNA network ( 330 ) to the SLU, the TN3270 server ( 350 ) translates the CD into an X′0100′ ( 430 ). The X′0100′ is a write command that does not restore the keyboard. The TN3270 server ( 350 ) would send this via the TN3270 network ( 360 ) to the TN3270 client ( 370 ), where the TN3270 client ( 370 ) would recognize that the host application ( 340 ) has completed its modification ( 432 ) of the PS ( 380 ). At that point, the PS ( 380 ) could be modified, but the state of the keyboard will remain unchanged. If a write type command contained a keyboard restore since the last inbound operation, the keyboard will be unlocked. If a write type command did not contain a keyboard restore since the last inbound operation, the keyboard will be left locked.  
         [0043]    In one or more embodiments of the present invention, the invention could be implemented as a software upgrade to a TN3270 server and a TN3270 client.  
         [0044]    In various embodiments, there are numerous advantages achieved by implementing aspects of the present invention. One advantage is that no new traffic is generated on the TN3270 network. In addition, the problem of no explicit unlocking of the keyboard for applications migrated from 3270 architecture to TN3270 architecture is obviated. Further, network upgrades with features of the invention are not disruptive to the operation of the network. For example, an X′0102′ would be handled by an existing client (i.e., a client operating without the added intelligence of the data stream interpretation code ( 395 ) in FIG. 3) in the same manner that a X′F1C2′ would be handled, i.e., as a keyboard restore. However, the client is not aware whether the PS is complete. Further, an inventive client (i.e., a client with the added intelligence provided by the data stream interpretation code ( 395 )) would receive and handle a X′F1C2′ in the same manner that a X′F1C2′ would be handled by an existing (i.e., prior art client), i.e., as a keyboard restore.  
         [0045]    While the foregoing is directed to embodiments of the present invention, other and further embodiments of the invention may be devised without departing from the basic scope thereof, and the scope thereof is determined by the claims that follow.