WO2015045108A1

WO2015045108A1 - Client/server program generation device and client/server program generation program

Info

Publication number: WO2015045108A1
Application number: PCT/JP2013/076308
Authority: WO
Inventors: 隆史坂倉
Original assignee: 三菱電機株式会社
Priority date: 2013-09-27
Filing date: 2013-09-27
Publication date: 2015-04-02
Also published as: TW201512984A

Abstract

A client/server program generation device according to the present invention generates a server program by use of a stand-alone application program including a GUI program and a data processing program. In this case, the client/server program generation device analyzes the source program file for the data processing program and identifies, from among the plurality of functions included in the data processing program, external functions called by the GUI program. The client/server program generation device then adds, to the source program file for a server communication interface, calling codes, each of which calls an external function in the application program of the server program upon reception of an execution request message requesting that the external function be executed.

Description

Client server program generation device and client server program generation program

The present invention relates to a technique for generating a client server program using a stand-alone application program.

With the development of an IP (Internet Protocol) communication network, cloud computing services that provide computer resource provision services in various forms are rapidly spreading.
The cloud computing service includes a computer resource lending service or an application use service. The computer resource lending service is a service in which a service provider provides a data center composed of a cluster of computers at an appropriate place and lends the computer resource itself of the data center. The application use service is a service that can use a data center application.

Since the system is operated in the data center, the user can use all types of systems with a small initial investment.
In addition, since a plurality of users located in remote locations can collaborate and a plurality of replica data is stored, the data center can have disaster resistance.
In this way, the cloud computing service provides the user with convenience that cannot be enjoyed in the conventional form having an information system for each office.

However, in order to make a large-scale GUI (Graphical User Interface) application designed as a stand-alone type into a cloud computing service, in most cases, it is necessary to redesign and re-implement the GUI application.
In addition, since the data center is located at a remote location, it is necessary to design a GUI application by incorporating a communication delay into the response time from the data center.

Patent Document 1 discloses a method of analyzing a source code of an application that operates independently and generating a client server type program by dividing the source code into a client program part and a server program part.
However, in this method, the test performed on the original application that operates alone is invalidated, and it is necessary to further test the client server type program.

JP 2000-137600 A

The object of the present invention is to be able to generate a server program using a stand-alone application program.

The client server program generation device of the present invention
An application that analyzes a source program file of the data processing program of an application program including a user interface program and a data processing program, and identifies an external function called from the user interface program among a plurality of functions included in the data processing program A program analysis unit;
The server program comprising the server communication program and the application program, the source program file of the server communication program receives an execution request message for requesting execution of the external function, and is included in the application program of the server program A server communication program editing unit for adding a call code for calling an external function.

According to the present invention, a server program can be generated using a stand-alone application program.

3 is a relationship diagram among an application program 100, a server program 110, and a client program 120 according to Embodiment 1. FIG. 2 is a functional configuration diagram of a client server program generation device 200 according to Embodiment 1. FIG. 3 is a flowchart of a server program generation method according to the first embodiment. It is a figure which shows an example of the application file 300 in Embodiment 1. FIG. 6 is a diagram illustrating an example of a server communication interface file 400 according to Embodiment 1. FIG. 6 is a diagram illustrating an example of a server communication interface file 400 according to Embodiment 1. FIG. 3 is a diagram illustrating an example of a hardware configuration of a client server program generation device 200 according to Embodiment 1. FIG. FIG. 10 is a functional configuration diagram of a client server program generation device 200 according to Embodiment 2. 10 is a flowchart of a client server program generation method according to the second embodiment. 10 is a diagram illustrating an example of a client communication interface file 500 according to Embodiment 2. FIG. 10 is a diagram illustrating an example of a client communication interface file 500 according to Embodiment 2. FIG. FIG. 10 is a functional configuration diagram of a client server program generation device 200 according to Embodiment 3. 10 is a flowchart of a client server program generation method according to the third embodiment. FIG. 20 is a diagram showing an example of an API list 291 in the third embodiment. 15 is a flowchart of communication interface editing processing (S360) in the third embodiment. FIG. 10 is a configuration diagram of a client server system 600 in a fifth embodiment. FIG. 20 is a relationship diagram among an application program 100, a server program 110, and a client program 120 in a sixth embodiment. FIG. 38 is a diagram illustrating an example of message data conversion in the sixth embodiment. FIG. 20 is a diagram illustrating an example of a screen of a WEB browser 617 in the sixth embodiment. FIG. 20 is a diagram illustrating an example of a computer system 620 according to Embodiment 7. FIG. 20 is a diagram illustrating an example of a client server system 630 according to the eighth embodiment. FIG. 20 is a diagram illustrating an example of a computer system 640 according to a ninth embodiment.

Embodiment 1 FIG.
A mode in which a server program is generated using a stand-alone application program will be described.

FIG. 1 is a relationship diagram among the application program 100, the server program 110, and the client program 120 in the first embodiment.
A relationship among the application program 100, the server program 110, and the client program 120 in the first embodiment will be described with reference to FIG.

The application program 100 is a stand-alone program generated on the assumption that it is executed by one information processing apparatus. That is, the application program 100 is a program executed by a stand-alone information processing apparatus that operates independently without depending on other computers.
The application program 100 includes a GUI (Graphical User Interface) operated by a user. Hereinafter, a program for processing the GUI is referred to as GUI 101. Of the programs included in the application program 100, programs other than the GUI 101 are called data processing programs.

The server program 110 is a program executed by the server device.
The server program 110 includes an application program 100 and a server communication interface 111. However, the library of the GUI 101 is invalidated so that the GUI 101 included in the application program 100 does not function.
A server communication interface 111 (an example of a server communication program) is a program that communicates with a client device via a network 199.

The client program 120 is a program executed by the client device.
The client program 120 includes a GUI 101 (or an equivalent program) and a client communication interface 121.
The client communication interface 121 (an example of a client communication program) is a program that communicates with the server device via the network 199. The client communication interface 121 calls the server program 110 by RPC (Remote Procedure Call).
A user of the client apparatus can operate the client apparatus using the GUI 101 with the same usability as a stand-alone information processing apparatus.

FIG. 2 is a functional configuration diagram of the client server program generation device 200 according to the first embodiment.
A functional configuration of the client server program generation device 200 according to the first embodiment will be described with reference to FIG.

The client server program generation device 200 is a computer that generates the server program 110 using the source program file of the application program 100.
The client server program generation device 200 includes an application program analysis unit 210, a server communication interface generation unit 220, a client server program generation unit 280, and a device storage unit 290.

The device storage unit 290 stores data used, generated or input / output by the client server program generation device 200.
For example, the device storage unit 290 stores the application file 300, the server communication interface file 400, and the server program 110.
The application file 300 is a source program file for each of a plurality of programs (including a data processing program and the GUI 101) included in the application program 100.
The server communication interface file 400 is a source program file for the server communication interface 111. The server communication interface file 400 includes source code necessary for communication with the client communication interface 121.
The source program file is a file including a program source code (source program).

The application program analysis unit 210 analyzes each application file 300 of a plurality of programs included in the application program 100 and identifies a function called from another program (for example, the GUI 101). A function corresponds to a method in an object-oriented program. Hereinafter, a function (or method) called from another program is referred to as an external function.
The server communication interface generation unit 220 (an example of a server communication program editing unit) receives source code (hereinafter referred to as an external function) included in the application program 100 of the server program 110 when an execution request message requesting execution of an external function is received. Are added to the server communication interface file 400.
The client server program generation unit 280 generates the server program 110 by compiling and linking the server communication interface file 400 and each application file 300.

FIG. 3 is a flowchart of the server program generation method according to the first embodiment.
A server program generation method according to Embodiment 1 will be described with reference to FIG.

In S110, the application program analysis unit 210 selects one unselected application file 300.
After S110, the process proceeds to S120.

In S120, the application program analysis unit 210 analyzes the application file 300 (including the header file used by the application file 300) selected in S110.
For example, the application program analysis unit 210 performs lexical analysis and syntax analysis on the application file 300.
After S120, the process proceeds to S130.

In S130, the application program analysis unit 210 determines whether or not the application file 300 includes an external function based on the analysis result obtained in S120. For example, a function (or method) having an “extern” declaration is an external function.
If the application file 300 includes an external function (YES), the process proceeds to S140.
If the application file 300 does not include an external function (NO), the process proceeds to S150.

FIG. 4 is a diagram illustrating an example of the application file 300 according to the first embodiment.
The application file 300 shown in FIG. 4 includes getname () in which an external declaration is made (see 302 in the figure). This getname () is an external function.
Returning to FIG. 3, the description will be continued from S140.

In S140, the server communication interface generation unit 220 adds a call code for calling an external function included in the application file 300 to the server communication interface file 400.
After S140, the process proceeds to S150.

5 and 6 are diagrams illustrating an example of the server communication interface file 400 according to the first embodiment.
An example of the server communication interface file 400 in the first embodiment will be described with reference to FIGS.

The server communication interface file 400 is a source file of the server communication interface 111 that communicates with the client communication interface 121.
The server communication interface generation unit 220 adds remote_getname () to the server communication interface file 400 (see 404 in FIG. 6). This remote_getname () is a wrap function for calling getname () included in the application file 300 (see FIG. 4). This wrap function is executed when an execution request message requesting execution of getname () is received. The name of the wrap function can be generated by adding a specific character string (remote_) to the name of the external function.
In the server communication interface file 400, a portion excluding remote_getname () (portion above the broken line in FIGS. 5 and 6) is a standard source code. A server communication interface file 400 in which a fixed source code is described is prepared in advance.
The standard part of the server communication interface file 400 includes source code that defines the listening port of the port number “2002” (see 401 in FIG. 5). This listening port is for communicating with the client communication interface 121.
Further, the fixed part of the server communication interface file 400 includes a main function of the server program 110 (see 402 in FIG. 5), and this main function includes a source code for calling a wrap function including a calling code. (See 403 in FIG. 6).
Returning to FIG. 3, the description will be continued from S150.

In S150, the application program analysis unit 210 determines whether there is an unselected application file 300 that has not been selected in S110.
If there is an unselected application file 300 (YES), the process returns to S110.
If there is no unselected application file 300 (NO), the process proceeds to S160.

In S160, the client server program generation unit 280 generates the server program 110 by compiling and linking the server communication interface file 400 and each application file 300.
At this time, the client server program generation unit 280 replaces main () (see 301 in FIG. 4) included in the application file 300 with another name. For example, the client server program generation unit 280 replaces main () with stub_main (). This is to prevent the name from overlapping with the main function (see 402 in FIG. 5) of the server communication interface file 400. That is, the contents of the application file 300 and the application program 100 are not altered.
After S160, the processing of the server program generation method ends.

FIG. 7 is a diagram illustrating an example of a hardware configuration of the client server program generation device 200 according to the first embodiment.
An example of the hardware configuration of the client server program generation device 200 according to Embodiment 1 will be described with reference to FIG. However, the hardware configuration of the client server program generation device 200 may be different from the configuration shown in FIG.

The client server program generation device 200 is a computer including an arithmetic device 901, an auxiliary storage device 902, a main storage device 903, a communication device 904, and an input / output device 905.
The arithmetic device 901, auxiliary storage device 902, main storage device 903, communication device 904, and input / output device 905 are connected to the bus 909.

The arithmetic device 901 is a CPU (Central Processing Unit) that executes a program.
The auxiliary storage device 902 is, for example, a ROM (Read Only Memory), a flash memory, or a hard disk device.
The main storage device 903 is, for example, a RAM (Random Access Memory).
The communication device 904 performs communication via the Internet, a LAN (local area network), a telephone line network, or other networks in a wired or wireless manner.
The input / output device 905 is, for example, a mouse, a keyboard, or a display device.

The program is normally stored in the auxiliary storage device 902, loaded into the main storage device 903, read into the arithmetic device 901, and executed by the arithmetic device 901.
For example, an operating system (OS) is stored in the auxiliary storage device 902. Further, a program for realizing the function described as “˜unit” is stored in the auxiliary storage device 902. The OS and the program that realizes the functions described as “˜units” are loaded into the main storage device 903 and executed by the arithmetic device 901. “˜part” can be read as “˜processing” and “˜process”.

“Determining”, “Determining”, “Extracting”, “Detecting”, “Settings”, “Registering”, “Selecting”, “Generating”, “To” Information, data, files, signal values or variable values indicating the results of processing such as “input”, “output of”, etc. are stored in the main storage device 903 or the auxiliary storage device 902. Further, other data used by the client server program generation device 200 is stored in the main storage device 903 or the auxiliary storage device 902.

According to the first embodiment, the server program 110 can be generated using the stand-alone type application program 100.
For example, a large-scale stand-alone GUI application exceeding 1 million lines can be used as a client-server type application program without modifying the source program. Thereby, a large-scale application program that is difficult to adapt to the cloud computing service can be adapted to the cloud computing service.

Embodiment 2. FIG.
A mode for generating the client program 120 in addition to the server program 110 will be described.
Hereinafter, items different from the first embodiment will be mainly described. Matters whose description is omitted are the same as those in the first embodiment.

FIG. 8 is a functional configuration diagram of the client server program generation device 200 according to the second embodiment.
A functional configuration of the client server program generation device 200 according to the second embodiment will be described with reference to FIG.

The client server program generation device 200 includes a client communication interface generation unit 230 (an example of a client communication program editing unit) in addition to the configuration described in the first embodiment (see FIG. 2).
In addition, the device storage unit 290 stores the client communication interface file 500.

The client communication interface file 500 is a source program file of the client communication interface 121. The client communication interface file 500 includes source code necessary for communication with the server communication interface 111.

The client communication interface generation unit 230 adds, to the client communication interface file 500, source code (hereinafter, referred to as an execution request code) that transmits an execution request message when the GUI 101 requests execution of an external function.
The client server program generation unit 280 generates the client program 120 by compiling and linking the client communication interface file 500 and the application file 300 of the GUI 101.

FIG. 9 is a flowchart of the client server program generation method according to the second embodiment.
A client server program generation method according to the second embodiment will be described with reference to FIG.

In S210, the application program analysis unit 210 selects an unselected application file 300. S210 is the same as S110 of the first embodiment (see FIG. 3).
After S210, the process proceeds to S220.

In S220, the application program analysis unit 210 analyzes the application file 300 selected in S210. S220 is the same as S120 of the first embodiment (see FIG. 3).
After S220, the process proceeds to S230.

In S230, the application program analysis unit 210 determines whether or not the application file 300 includes an external function. S230 is the same as S130 of the first embodiment (see FIG. 3).
If the application file 300 includes an external function (YES), the process proceeds to S240.
If the application file 300 does not include an external function (NO), the process proceeds to S260.

In S <b> 240, the server communication interface generation unit 220 adds an external function call code to the server communication interface file 400. S240 is the same as S140 in the first embodiment (see FIG. 3).
After S240, the process proceeds to S250.

In S <b> 250, the client communication interface generation unit 230 adds an execution request code that transmits an execution request message when an external function execution is requested from the GUI 101 to the client communication interface file 500.
After S250, the process proceeds to S260.

10 and 11 are diagrams illustrating an example of the client communication interface file 500 according to the second embodiment.
An example of the client communication interface file 500 according to the second embodiment will be described with reference to FIGS.

The client communication interface file 500 is a source file of the client communication interface 121 that communicates with the server communication interface 111.
The client communication interface generation unit 230 adds getname () to the client communication interface file 500 (see 503 in FIG. 11). This getname () is a function including an execution request code (write) for transmitting an execution request message and a source code (read) for receiving an execution response message indicating the execution result.
In the client communication interface file 500, the part excluding getname () (the part above the broken line in FIGS. 10 and 11) is a standard source code. A client communication interface file 500 in which a fixed source code is described is prepared in advance.
The fixed part of the client communication interface file 500 includes createSession () and closeSession () (see 501 and 502 in FIG. 10). createSession () is a function that establishes a session with the server communication interface 111, and closeSession () is a function that releases the established session.
Returning to FIG. 9, the description will be continued from S260.

In S260, the application program analysis unit 210 determines whether there is an unselected application file 300 that has not been selected in S210.
If there is an unselected application file 300 (YES), the process returns to S210.
If there is no unselected application file 300 (NO), the process proceeds to S270.

In S270, the client server program generation unit 280 generates the server program 110 as in S160 (see FIG. 3) of the first embodiment.
Further, the client server program generation unit 280 generates the client program 120 by compiling and linking the client communication interface file 500 and the application file 300 of the GUI 101.
After S270, the processing of the client server program generation method ends.

According to the second embodiment, the server program 110 and the client program 120 can be generated using the stand-alone application program 100.

Embodiment 3 FIG.
A mode of generating a client server program that causes a server apparatus to execute only data processing when GUI processing and data processing are included in the external function will be described.
Hereinafter, items different from the first and second embodiments will be mainly described. Matters whose description is omitted are the same as in the first and second embodiments.

First, background art regarding the third embodiment will be described.
The application program 100 is a program having a GUI 101. Furthermore, the application program 100 is a program that operates only when a user operates a GUI object, unlike a simulation program or the like.

The main input means used by the user to operate the GUI are a keyboard and a mouse.
For example, the user inputs data into the GUI object using a keyboard. For example, the user operates the mouse to select a desired GUI object or select a pull-down menu.

Recent high-level programming languages provide GUI libraries. When the programming language is object-oriented, a GUI event handler is implemented by a base object (base class object). Then, the GUI library calls a GUI event handler defined in the base object, instead of being implemented so as to issue a system call to obtain an interrupt generated by the operation of the mouse or the keyboard and accompanying data. That is, the GUI library hides a mechanism for obtaining an interrupt generated by operating a mouse or a keyboard and accompanying data by issuing a system call from a programmer.

When an object-oriented high-level programming language is used, a GUI screen is configured by a lower GUI class that inherits the upper GUI class provided from the GUI library. When an event for a GUI component occurs, processing of the event handler of the inherited GUI class is defined (this redefinition is called an override).

For example, when a left click is performed on a menu object using a mouse, a menu implemented in an event handler called OnLeftClick () is displayed. Also, input data can be obtained from the menu that is in the selected state when the mouse button is released and the event OnRelease () occurs.

An application program with a GUI performs calculations based on data input by the user. For this reason, the contents of the event handler of the GUI library can be divided into GUI processing to be executed by the client program and data processing to be executed by the server program.

FIG. 12 is a functional configuration diagram of the client server program generation device 200 according to the third embodiment.
A functional configuration of the client server program generation device 200 according to Embodiment 3 will be described with reference to FIG.

The client server program generation device 200 includes an API analysis unit 211 (an example of an external function analysis unit) in addition to the configuration described in the second embodiment (see FIG. 8).
The API analysis unit 211 analyzes a source code of an API function that processes an API (Application Program Interface), and determines whether the API function includes user interface processing that uses the GUI 101 and data processing that does not use the GUI 101. To do. An API function is an example of an external function.

FIG. 13 is a flowchart of the client server program generation method according to the third embodiment.
A client server program generation method according to Embodiment 3 will be described with reference to FIG.

In S310, the application program analysis unit 210 selects an unselected application file 300. S310 is the same as S110 of the first embodiment (see FIG. 3).
After S310, the process proceeds to S320.

In S320, the application program analysis unit 210 analyzes the application file 300 selected in S310. S320 is the same as S120 of the first embodiment (see FIG. 3).
After S320, the process proceeds to S330.

In S330, the application program analysis unit 210 determines whether or not the application file 300 includes a call code for calling an API function, based on the analysis result in S320.
For example, the application program analysis unit 210 determines whether or not the application file 300 includes an API function using an API list 291 (see FIG. 14) indicating the function name of the API function.
FIG. 14 is a diagram illustrating an example of the API list 291 according to the third embodiment.
An API list 291 in FIG. 14 shows the function names of the API functions of the GUI library class. The API list 291 may be a hash list in which function names of API functions are arranged using hash values. When the API list 291 is a hash list, the function name of the API function can be searched at high speed.
If the application file 300 includes an API function call code (YES), the process proceeds to S340.
If the application file 300 does not include the API function call code (NO), the process proceeds to S370.

In S340, the server communication interface generation unit 220 adds the API function source code (an example of the execution code) to the server communication interface file 400 instead of the external function call code (see the first embodiment).
The API function source code is stored in the device storage unit 290 in advance.
After S340, the process proceeds to S350.

In S350, the client communication interface generation unit 230 adds an execution request code for requesting execution of the API function instead of the external function to the client communication interface file 500.
After S350, the process proceeds to S360.

In S360, the server communication interface generation unit 220 edits the server communication interface file 400, and the client communication interface generation unit 230 edits the client communication interface file 500.
Details of the communication interface editing process (S360) will be described later.
After S360, the process proceeds to S370.

In S370, the application program analysis unit 210 determines whether there is an unselected application file 300 that has not been selected in S310.
If there is an unselected application file 300 (YES), the process returns to S310.
If there is no unselected application file 300 (NO), the process proceeds to S380.

In S380, the client server program generation unit 280 generates the server program 110 and the client program 120, as in S270 (see FIG. 9) of the second embodiment.
After S380, the processing of the client server program generation method ends.

FIG. 15 is a flowchart of the communication interface editing process (S360) in the third embodiment.
The communication interface editing process (S360) in the third embodiment will be described with reference to FIG.

In S361, the API analysis unit 211 analyzes the source code of the API function specified in S330 (see FIG. 13). For example, the API analysis unit 211 performs lexical analysis and syntax analysis on the API function source code.
Hereinafter, the API function specified in S330 is referred to as a specific API.
After S361, the process proceeds to S362.

In S362, the API analysis unit 211 determines whether or not the specific API includes an API function call code based on the analysis result of S361. The determination method is the same as S330 (see FIG. 13).
If the specific API includes an API function call code (YES), the process proceeds to S363.
When the specific API does not include the API function call code (NO), the communication interface editing process (S360) ends.

In S363, the API analysis unit 211 determines whether the API function called by the call code included in the specific API is a GUI event handler (an example of user interface processing) based on the analysis result in S361. For example, the API analysis unit 211 determines whether the API function is a GUI event handler by using a GUI event handler list indicating the name of the GUI event handler. In this case, the GUI event handler list is stored in advance in the device storage unit 290.
If the API function is a GUI event handler, the process proceeds to S364.
If the API function is not a GUI event handler, the communication interface editing process (S360) ends.

In S364, the server communication interface generation unit 220 adds a callback function to the source code of the specific API added to the server communication interface file 400 in S340 (see FIG. 13).
The callback function (an example of a user interface request code) is a function that transmits an execution request message (an example of a user interface request message) for requesting execution of a GUI event handler to a client device.
For example, the server communication interface generation unit 220 adds a callback function before or after the calling code that calls the GUI event handler.
In addition, the server communication interface generation unit 220 invalidates the function of the GUI event handler by editing a library that functions as a GUI event handler among a plurality of libraries (binary codes) used by the server program 110. .
After S364, the process proceeds to S365.

In S <b> 365, the client communication interface generation unit 230 adds a call code that calls an event handler of the GUI 101 to the client communication interface file 500. Thereby, the client program 120 can execute the event handler of the GUI 101 in response to a request from the callback function of the server program 110.
Further, the client communication interface generation unit 230 adds an execution response code that responds to the execution result of the event handler of the GUI 101 to the client communication interface file 500.
After S365, the communication interface editing process (S360) ends.

Embodiment 4 FIG.
A mode for generating the client program 120 including the acceleration logic will be described.
Hereinafter, items different from the first to third embodiments will be mainly described. Matters whose description is omitted are the same as at least one of the first to third embodiments.

The configuration of the client server program generation device 200 is the same as that of the second embodiment (see FIG. 8) or the third embodiment (see FIG. 12).

However, in addition to the process described in the second embodiment (S250 in FIG. 9) or the process described in the third embodiment (S350 in FIG. 13 and S365 in FIG. 15), the client communication interface generation unit 230 performs the following processing: Execute the process.

The client communication interface generation unit 230 adds the number measurement code, the number calculation code, the conditional branch code, and the data synchronization code to the client communication interface file 500.
In addition, the client communication interface generation unit 230 adds the external function to the client communication interface file 500.

The number measurement code is source code for measuring the number of execution requests for which the execution request code has been executed.

The number calculation code is a source code for calculating the number of times per unit time that the execution request code is executed based on the number calculation code measured by the number measurement code.

The conditional branch code compares the number of times per unit time calculated by the number calculation code with the execution request frequency threshold. The execution request frequency threshold is a predetermined value.
When the number of times per unit time is greater than the execution request count threshold, the conditional branch code transmits a data request message requesting data used by the external function to the server communication interface 111, and the data used by the external function is transmitted to the server communication interface. The received data is stored in the memory of the client device, and an external function is executed using the data stored in the memory.
If the number of times per unit time is less than the number of execution requests, the conditional branch code executes the execution request code.
When the number of times per unit time is the same as the execution request frequency threshold, the conditional branch code executes the same processing as in any of the above cases. That is, the conditional branch code executes either the external function or the execution request code.

The data synchronization code is a source for transmitting data stored in the memory of the client device to the server device at a specific timing in order to synchronize the data stored in the client device and the data stored in the server device. Code. For example, the specific timing is when the GUI 101 of the client apparatus ends or when the external function is executed a predetermined number of times of synchronization.

According to the fourth embodiment, the client device can cache the data stored in the server device, execute the external function using the cached data, and reduce the RPC that requests the server device to execute the external function. .

Embodiment 5 FIG.
In each embodiment, the server communication interface 111 and the client communication interface 121 may be programs that perform communication using HTTP (HyperText Transfer Protocol).

FIG. 16 is a diagram illustrating an example of the client server system 600 according to the fifth embodiment.
A client server system 600 illustrated in FIG. 16 includes a client device 601, a firewall 602 on the client device 601 side, a server device 604, and a firewall 603 on the server device 604 side.
The RPC mechanism in the client server system 600 does not exclude HTTP or an HTTP derivation procedure (Websocket or the like) as its communication means. Therefore, even if multiple firewalls (602, 603) are interposed, the RPC mechanism is not affected.

Embodiment 6 FIG.
A mode in which a WEB browser is used as a client program will be described.
Hereinafter, items different from the first embodiment will be mainly described. Matters whose description is omitted are the same as those in the first embodiment.

FIG. 17 is a relationship diagram among the application program 100, the server program 110, and the client program 120 in the sixth embodiment.
A relationship among the application program 100, the server program 110, and the client program 120 in the sixth embodiment will be described with reference to FIG.

Unlike the first embodiment, the client program 120 is configured by a WEB browser. That is, the WEB browser functions as the client program 120.
The server communication interface 111 of the server program 110 includes a data conversion function 112 (an example of a data format conversion code).
The data conversion function 112 converts the data format of the message received from the client program 120 from the client data format to the server data format, and converts the data format of the message transmitted to the client program 120 from the server data format to the client data format. Here, the client data format is a data format used by the client program 120, and the server data format is a data format used by the server program 110.
For example, the data conversion function 112 converts the data format of the execution request message that requests execution of the external function from the client data format to the server data format. The data conversion function 112 converts the data format of the execution response message that returns the execution result of the external function from the server data format to the client data format.

FIG. 18 is a diagram illustrating an example of message data conversion in the sixth embodiment.
A message 611 illustrated in FIG. 18 is an example of a message communicated between the client program 120 and the server program 110, and the message 616 is obtained by converting the message 611 into a JSON (Java Script Object Notification) format. “JavaScript” is a registered trademark.
The message header 612 indicates whether or not the message 611 is divided and the data size of the message 611. The integer 613 indicates “4” in the int format. The binary data size 614 indicates the data size of the binary data 615. Show.
Mutual data conversion between the message 611 and the message 616 is performed immediately after the server communication interface 111 receives the message 611 and immediately before the server communication interface 111 transmits the message 611.

The configuration of the client server program generation device 200 is the same as that of the first embodiment (see FIG. 2).
However, the server communication interface file 400 includes the data conversion function 112, the received message conversion code, and the transmission message conversion code as a part of the standard source code.
The received message conversion code is source code for calling the data conversion function 112 after receiving a message from the client program 120 and before executing the call code for the external function.
The transmission message conversion code is source code for calling the data conversion function 112 after executing the external function call code and before transmitting the message to the client program 120.

The server program generation method is the same as that in the first embodiment (see FIG. 3).

The server communication interface 111 may include an object generation function (an example of object generation code) and an object selection code as a part of the standard source code.
The object selection code is source code that selects a GUI object to be displayed on the screen of the WEB browser based on the content of the message transmitted from the WEB browser of the client device, calls the object generation function by specifying the selected GUI object. .
The object generation function generates data of a specified GUI object. Pull-down menus, buttons, dialogs, canvases, and trees are examples of GUI objects. The GUI object is also referred to as a GUI component.
The data of the GUI object is transmitted to the client device as a part of the message, and the GUI object is displayed by the WEB browser.

FIG. 19 is a diagram illustrating an example of a screen of the WEB browser 617 according to the sixth embodiment.
A WEB browser 617 shown in FIG. 19 includes a parts list 618 and a screen design unit 619. The screen design unit 619 displays a design screen including a button 619A, a tree 619B, and a canvas 619C.
For example, the screen designer selects a component (GUI object) from the component list 618 and designs the screen by dragging and dropping the selected component onto the screen design unit 619. The screen designer designs screen transitions.

According to the sixth embodiment, a WEB browser (including a script that operates on the WEB browser) can be used as the client program 120. That is, the user can access the server program 110 from a generally distributed WEB browser. For example, a user can design a screen by accessing the server program 110 from a WEB browser.

Embodiment 7 FIG.
A form of a computer system to which the sixth embodiment is applied will be described.

FIG. 20 is a diagram illustrating an example of a computer system 620 according to the seventh embodiment.
An example of a computer system 620 according to Embodiment 7 will be described with reference to FIG.

The user connects the client program 120 to the server program 110 adapted to the cloud computing service, accesses the server program 110, and creates data on the cloud.
The client program 120 writes data to the data control device 621 and reads data from the data control device 621 using a WEB browser whose restrictions are released on the assumption that there is an authentication means.

Embodiment 8 FIG.
A mode in which the server program performs multicast communication with a plurality of client programs will be described.
Hereinafter, items different from the first to third embodiments will be mainly described. Matters whose description is omitted are the same as at least one of the first to third embodiments.

The configuration of the client server program generation device 200 is the same as that of any one of the first to third embodiments (see FIGS. 2, 8, and 12).
The client server program generation method is the same as in any one of the first to third embodiments (see FIGS. 3, 9, and 13).

However, the server communication interface generation unit 220 adds the multicast transmission code to the client communication interface file 500.
The multicast transmission code is source code for multicasting an execution response message to a plurality of client devices including the client device that has transmitted the execution request message. The execution response message is a message indicating the execution result of the external function requested by the execution request message.
Multicast may be read as broadcast.

FIG. 21 is a diagram illustrating an example of the client server system 630 according to the eighth embodiment.
An example of the client server system 630 according to the eighth embodiment will be described with reference to FIG.

Here, it is assumed that the client device 635 has issued an RPC for changing data.
The server device 631 returns a message as a synchronous RPC to the client device 635, but multicasts the contents of the data change to the client devices 632 to 634, the client device 636, and the client device 637 using session information managed by itself.
The listening thread of the client program 120 receives the message asynchronously and reflects the data change on the display.

Embodiment 9 FIG.
A form of a computer system to which any one of the first to eighth embodiments is applied will be described.

FIG. 22 is a diagram illustrating an example of a computer system 640 according to the ninth embodiment.
An example of a computer system 640 according to Embodiment 9 will be described with reference to FIG.

When the client device 647 is authenticated by the authentication server 641 across the firewall 646, an authentication ticket is given.
The client device 647 designates a desired service among the services provided by the server devices (641 to 645) in the URL, and accesses the service activation server 648 using the authentication ticket. Thereby, the server program of the server device that provides a desired service is executed.

Here, it is assumed that the client device 647 specifies the URL of the engineering server 643 and passes the authentication ticket to the service activation server 648.
The service activation server 648 inquires ticket information to the authentication server 641 and authenticates the access of the client device 647.
If the authentication ticket of the client device 647 matches the authentication ticket given from the authentication server 851, the service activation server 648 activates the server program of the engineering server 643.

Each server program of the asset server 642, the engineering server 643, the equipment management server 644, and the production management server 645 is one computer although it is desirable that the server programs operate in accordance with the use scene of the system. It is a program that has been closed and used.
By making these server programs into client servers as described in the respective embodiments, extremely high convenience can be given to users of the system.

Each embodiment is an example of a form of the client server program generation device 200.
That is, the client server program generation device 200 may not have a part of the function or configuration described in each embodiment. Further, the client server program generation device 200 may have a function or configuration not described in each embodiment. Furthermore, some or all of the embodiments may be combined as long as no contradiction occurs.

The processing procedures described using the flowcharts and the like in each embodiment are an example of a processing procedure of a method according to each embodiment and an example of a processing procedure of a program (for example, a client server program generation program) according to each embodiment. It is.
That is, the processing procedure of the method according to each embodiment and the processing procedure of the program according to each embodiment may be realized by a processing procedure partially different from the processing procedure described in each embodiment.

100 application program, 101 GUI, 110 server program, 111 server communication interface, 112 data conversion function, 120 client program, 121 client communication interface, 199 network, 200 client server program generator, 210 application program analysis unit, 211 API analysis unit , 220 Server communication interface generation unit, 230 Client communication interface generation unit, 280 Client server program generation unit, 290 Device storage unit, 291 API list, 300 Application file, 400 Server communication interface file, 500 Client communication interface file, 60 Client server system, 601 client device, 602 firewall, 603 firewall, 604 server device, 611 message, 612 message header, 613 integer, 614 binary data size, 615 binary data, 616 message, 617 WEB browser, 618 component list, 619 screen Design department, 619A button, 619B tree, 619C canvas, 620 computer system, 621 data control device, 630 client server system, 631 server device, 632, 633, 634, 635, 636, 637 client device, 640 computer system, 641 authentication Server, 642 asset server, 643 engineering server Bar, 644 device management server, 645 production management server, 646 firewall 647 client device 648 service activation server 901 computing device 902 an auxiliary storage device, 903 main storage, 904 communication device, 905 input device, 909 a bus.

Claims

An application that analyzes a source program file of the data processing program of an application program including a user interface program and a data processing program, and identifies an external function called from the user interface program among a plurality of functions included in the data processing program A program analysis unit;
The server program comprising the server communication program and the application program, the source program file of the server communication program receives an execution request message for requesting execution of the external function, and is included in the application program of the server program A client server program generation device comprising: a server communication program editing unit for adding a call code for calling an external function.
An execution request code for transmitting the execution request message to the source program file of the client communication program of a client program comprising a client communication program and the user interface program when the user interface program requests execution of the external function The client server program generation apparatus according to claim 1, further comprising a client communication program editing unit for adding the client communication program.
The client communication program editing unit is configured to execute the execution request code based on the number measurement code for measuring the number of execution requests for which the execution request code has been executed and the number of execution requests measured by the number measurement code. Number of times calculation code for calculating the number of times per unit time, and the number of times per unit time calculated by the number of times calculation code when the number of times per unit time is greater than an execution request number of times threshold 3. The client server program generation device according to claim 2, wherein conditional branching code for executing is added to a source program file of the client communication program.
2. The client server program generation device according to claim 1, wherein the server communication program is a program for performing communication using HTTP (HyperText Transfer Protocol).
The source program of the server communication program includes a data format conversion code for converting a data format of the execution request message from a client data format used by a client program to a server data format used by the server program. Item 4. The client server program generation device according to Item 1.
The client program is a WEB browser;
6. The client server program generation apparatus according to claim 5, wherein the source program of the server communication program includes an object generation code for generating a GUI (Graphical User Interface) object to be displayed on the screen of the WEB browser.
The server communication program editing unit adds a multicast code for transmitting the execution result of the external function to a plurality of client devices including a client device that has requested execution of the external function to a source program file of the server communication program. The client server program generation device according to claim 1, wherein:
An application that analyzes a source program file of the data processing program of an application program including a user interface program and a data processing program, and identifies an external function called from the user interface program among a plurality of functions included in the data processing program A program analysis unit;
An external function analysis unit that determines whether or not the external function identified by the application program analysis unit includes a user interface process that uses a user interface and a data process that does not use the user interface;
When the external function analysis unit determines that the user interface process and the data process are included in the external function, a source program file of the server communication program of a server program comprising a server communication program and the application program And a server communication program editing unit for adding an execution code for executing the data processing when an execution request message for requesting execution of the external function is received.
When the external function analysis unit determines that the external interface includes the user interface process and the data process, the server communication program editing unit sends a user interface request message requesting execution of the user interface process. 9. The client server program generation device according to claim 8, wherein a user interface request code to be transmitted is added to a source program file of the server communication program.
A client communication program editing unit for adding a call code for calling the user interface program when receiving the user interface request message to a source program file of the client communication program of a client program comprising a client communication program and the user interface program 10. The client server program generation device according to claim 9, further comprising:
An application that analyzes a source program file of the data processing program of an application program including a user interface program and a data processing program, and identifies an external function called from the user interface program among a plurality of functions included in the data processing program Program analysis processing,
The server program comprising the server communication program and the application program, the source program file of the server communication program receives an execution request message for requesting execution of the external function, and is included in the application program of the server program A client server program generation program for causing a computer to execute a server communication program generation process for adding a call code for calling an external function.
An application that analyzes a source program file of the data processing program of an application program including a user interface program and a data processing program, and identifies an external function called from the user interface program among a plurality of functions included in the data processing program Program analysis processing,
An external function analysis process for determining whether or not the external function specified by the application program analysis process includes a user interface process using a user interface and a data process not using the user interface;
When it is determined by the external function analysis process that the external interface includes the user interface process and the data process, a source program file of the server communication program of a server program comprising a server communication program and the application program A client server program generation program for causing a computer to execute a server communication program editing process for adding an execution code for executing the data processing when an execution request message requesting execution of the external function is received.