JP7367312B2 - Program distribution device and program distribution method - Google Patents

Description

The present invention relates to a program distribution device and a program distribution method.

Conventionally, systems have been known that provide application programs with the same code to terminals with different platform types (see Patent Document 1, etc.).

In this system, differences in the platforms of each terminal are absorbed at the virtual machine layer.

Japanese Patent Application Publication No. 2001-51857

However, executing a program on a virtual machine imposes a load on interpreting intermediate language code, resulting in a decrease in execution speed and I/O access.

The present invention has been made in view of the above, and an object of the present invention is to provide a program distribution device and a program distribution method that can provide the same program to terminals with different execution environments without degrading the functions and performance of the terminals. Let's choose one.

In one embodiment of the program distribution device according to the present invention, a management unit that manages source codes using different programming languages sends a program to a program that can be executed in the execution environment of the terminal based on information on the language used by the terminal. a source code acquisition unit that identifies a used programming language and acquires the source code using the used programming language from the management unit; and when the used programming language is a compiled language, executes the source code in the execution environment; a converting unit that converts the source code into an executable format file when the programming language used is a script language, and the executable format file when the programming language used is the compiled language; a verification environment construction unit that constructs a verification environment equivalent to the execution environment of the terminal based on execution environment information of the terminal, and a verification environment construction unit that transmits the source code or the executable code on the verification environment. a verification unit that executes a format file and verifies the application program before distributing the application program, and the source code acquisition unit determines whether or not the source code is necessary to acquire, based on information included in architecture information. It is characterized in that the determination is made based on whether or not there is information about an application program that is not installed in the installed application information.

One aspect of the program distribution method according to the present invention is to identify a programming language that can be executed in the execution environment of the terminal based on language information of the terminal, and to distribute source code using different programming languages for one program. a step of obtaining the source code using the programming language used from a management unit that manages the programming language; and, if the programming language used is a compiled language, converting the source code into an executable format file that can be executed in the execution environment. a step of transmitting the source code if the programming language used is a scripting language or the executable format file if the programming language used is the compiled language to the terminal ; A step of constructing a verification environment equivalent to the execution environment of the terminal based on execution environment information, and executing the source code or the executable format file on the verification environment, and a step of verifying the program, and the step of transmitting the program to the terminal determines whether or not the source code should be acquired, and the step includes a step of verifying the program, and the step of transmitting the program to the terminal includes the step of verifying the necessity of acquiring the source code by checking whether the information of the application program that is not installed is included in the installed application information included in the architecture information. The feature is that the determination is made based on whether or not there was .

According to the present invention, it is possible to provide a program distribution device and a program distribution method that can provide the same program to terminals with different execution environments without degrading the functions and performance of the terminals.

FIG. 1 is an overall configuration diagram showing a program distribution system according to a first embodiment. FIG. 2 is a functional block diagram showing a program distribution server according to the first embodiment. FIG. 2 is a functional block diagram showing a terminal according to the first embodiment. FIG. 2 is an explanatory diagram showing architecture information of a terminal according to the first embodiment. 3 is a flowchart showing each process performed by the program distribution server according to the first embodiment. It is a flowchart which shows each process of the code conversion process in the program distribution server based on 1st Embodiment. FIG. 2 is a sequence diagram showing a data transaction between a program distribution server and a terminal according to the first embodiment. 1 is a block diagram showing a hardware configuration of a computer device for realizing a server according to a first embodiment. FIG. FIG. 2 is a functional block diagram showing a program distribution server according to a second embodiment. It is a flowchart which shows each process of the application verification process performed by the program distribution server based on 2nd Embodiment. It is a flowchart which shows each process of verification environment construction processing in a program distribution server concerning a 2nd embodiment. FIG. 7 is a schematic diagram showing the relationship between a target application and related applications in a second embodiment. It is a flowchart which shows each process of the verification process in the program distribution server concerning a 2nd embodiment. FIG. 7 is a schematic diagram showing normal and abnormal connections between the target application and related applications in the second embodiment.

Hereinafter, a program distribution device and a program distribution method according to the present embodiment will be described with reference to the drawings.

<Summary>
There are various execution environments (platforms) in which programs are executed on terminals. One of them is the programming language used in the execution environment (hereinafter referred to as the used programming language).

Among programming languages, high-level languages are broadly classified into "compiler languages" and "scripting languages" depending on their conversion format. A "compiler language" is a programming language in which source code is compiled in advance into an executable format on an execution environment, such as C, C++, or Java (registered trademark). A "script language" is a programming language that executes source code while interpreting it in an execution environment, and includes, for example, Python, Perl, PHP, Ruby, and JavaScript (registered trademark).

Among compiler languages, C, C++, and the like (hereinafter referred to as "C language, etc.") convert source code into an executable file (also simply referred to as "executable format") in advance. More specifically, the source code is compiled into an object file written in machine language or the like, and the object file and library are linked to generate an executable file.

The C language and the like have the advantage of being faster to execute on a terminal and having less load. However, compilation and linking depend on architecture such as the terminal's processor (CPU) and operating system (OS).

Furthermore, among compiler languages, Java and the like differ from C, C++, and the like in that they are executed on a virtual machine. In Java and the like, source code is compiled to generate intermediate language code. The intermediate language file is interpreted and executed by a virtual machine running on the terminal.

There are two types of virtual machines: an interpreter type that executes intermediate language code while sequentially analyzing it, and a compiler type that compiles the intermediate language code into machine language and executes it when reading it, and a combination of the two can be used. There is also.

This type of high-level language has the advantage that intermediate language code can be shared between terminals with different execution environments because the virtual machine absorbs differences in terminal architecture. However, it is necessary to run a virtual machine on a terminal, and executing a program on a virtual machine places a load on the interpretation of intermediate language code, resulting in a decrease in execution speed and I/O access.

On the other hand, scripting languages are executed while being sequentially interpreted by an interpreter running on a terminal, so there is no need to convert the source code into another format in advance. Furthermore, since the interpreter absorbs differences in terminal architecture, there is an advantage that the source code can be shared between terminals with different execution environments. However, since the interpreter executes the source code while sequentially interpreting it, the execution speed is slow.

High-level languages such as those described above have advantages and disadvantages depending on their type. Conventionally, languages that use compilers and linkers for preliminary conversion, such as the C language, which has high execution speed, have often been used. However, as CPU speeds have increased, languages that use interpreters or virtual machines, such as script languages and Java, have come into use. The reason for this is that with scripting languages such as Java, programs can be added and executed by adding an interpreter or virtual machine through distribution via a network, even if an interpreter or virtual machine does not exist in the execution environment of the terminal. There are many things that can happen.

Against this background, it is desirable for a program distribution system that distributes programs in response to requests from terminals via a communication network such as the Internet to be able to provide the same program to terminals with different execution environments. However, there is no known program that can provide the same program to terminals with different execution environments without degrading the functions and performance of the terminals.

Furthermore, in the program distribution system, since the execution environments are different between the terminal and the server, there is a problem in that after the application is distributed to the terminal, it must be verified again.

Therefore, as a result of intensive study to solve the above problems, the inventors of the present invention prepared source codes using different programming languages for one program, and based on the language information of the terminal, the terminal executed By identifying the programming language used that can be executed in the environment and sending the program to the terminal in a format that can be executed in the execution environment of the terminal according to the programming language used, it contributes to not degrading the functionality and performance of the terminal. They discovered this and completed the present invention.

That is, the program distribution device according to the present embodiment allows a management unit that manages source codes using different programming languages to execute one program in the execution environment of the terminal based on the language information of the terminal. a source code acquisition unit that identifies a programming language to be used and acquires the source code using the programming language from the management unit; and if the programming language to be used is a compiled language, the source code is acquired in the execution environment; a conversion unit that converts the executable format file into an executable format file, the source code when the programming language used is a script language, and the executable format file when the programming language used is the compiled language; A transmitter that transmits data to a terminal.

That is, the program distribution method according to the present embodiment identifies a programming language that can be executed in the execution environment of the terminal based on the language information of the terminal, and distributes source code using different programming languages to one program. a step of obtaining the source code using the programming language used from a management unit that manages the code; and, if the programming language used is a compiled language, converting the source code into an executable format file that can be executed in the execution environment; and transmitting the source code, if the programming language used is a scripting language, or the executable format file, if the programming language used is the compiled language, to the terminal. It is characterized by

In addition, as a result of further study, the inventors constructed a verification environment equivalent to the terminal execution environment based on the terminal execution environment information, and created a verification environment that is equivalent to the terminal execution environment and runs the source code or executable file on the verification environment. By executing the program and verifying the program, we came up with the idea of distributing the program after verifying it in a verification environment equivalent to the execution environment before distribution.

The program distribution apparatus and program distribution method according to the present embodiment will be described in detail below with reference to FIGS. 1 to 14. In the following description, an application program will be exemplified as a program of the present invention, but the program is not particularly limited to this, and may be a system program.

<First embodiment>
(system)
FIG. 1 is an overall configuration diagram showing a program distribution system according to a first embodiment. The program distribution system 1 shown in FIG. 1 includes a program distribution server 11, a network 12, and a plurality of terminals 13a to 13n.

The program distribution server 11 is an information processing device that distributes application programs to the terminals 13a to 13n via the network 12.

The terminals 13a to 13n are information processing devices that execute application programs distributed from the program distribution server 11. The terminals 13a to 13n may be, for example, mobile terminals (mobile communication terminals) such as mobile phones, smartphones, and tablet terminals, or fixed communication terminals such as personal computers (PCs).

The network 12 includes various networks such as the Internet, a mobile network, a LAN (Local Area Network), and a WAN (Wide Area Network). Note that the network may be configured wirelessly, wired, or a combination thereof. For example, as the wireless communication method, Bluetooth (registered trademark), wireless LAN (for example, based on the IEEE802.11 standard), LTE (Long Term Evolution), or other wireless communication methods can be used.

(Program distribution server)
FIG. 2 is a functional block diagram showing the program distribution server 11 according to the first embodiment. As shown in FIG. 2, the program distribution server 11, which is an example of the program distribution device of the present invention, includes an architecture information acquisition section 101, a source code acquisition section 102, a code conversion section 103, and a distribution section 104. .

The architecture information acquisition unit 101 performs a process (hereinafter referred to as “architecture information The computer is configured to perform a process of obtaining information on the computer. The architecture information is information regarding the design philosophy and structure of the computer that constitutes the terminal 13. Details of the architecture information will be described later.

The source code acquisition unit 102 acquires source code from the program management server 14 via the network 12.

The program management server 14 is an example of the management unit of the present invention, and stores source codes using different programming languages for one application program. More specifically, the program management server 14 includes a database in the storage 1003 (see FIG. 8) that stores source code and a plurality of records including the following items.
・Source code ID
・Application program ID
・Development language ID
・Source code file ・Information about compatible interpreter or virtual machine

The source code ID is identification information uniquely assigned to the source code. Further, the application program ID is identification information uniquely given to the application program. Further, the development language ID is identification information uniquely assigned to the programming language used in the source code. This identification information may be a serial number, a code consisting of a combination of alphanumeric characters, or a character string, and is not particularly limited.

A source code file is the body of source code for an application program. Instead of the source code file, a path indicating the storage location of the source code file may be stored.

Information about a compatible interpreter or virtual machine is used when the source code file uses a scripting language or a compiler language that uses a virtual machine, such as the name and version of the interpreter or the name of the virtual machine. and version, but are not particularly limited.

In response to a request from the program distribution server 11, the program management server 14 can refer to the database, search for a source code file, and transmit it to the program distribution server 11 using the application program ID and development language ID as keys. Additionally, if a source code file is searched and no matching file is found, a notification to that effect can be sent.

The code conversion unit 103 is an example of a conversion unit of the present invention, and is configured to perform a process of converting a source code file into an executable file (hereinafter referred to as “code conversion process”). Details of the code conversion process will be described later.

The distribution unit 104 is an example of the transmission unit of the present invention, and performs a process (hereinafter referred to as “distribution process”) of transmitting an executable file or a source code file to the terminal 13 via the network 12 (see FIG. 2). is configured to do the following:

(terminal)
FIG. 3 is a functional block diagram showing the terminal 13 according to the first embodiment. The terminals 13A, 13B, and 13C shown in FIGS. 3A to 3C are different in that their execution environments are different. First, the configuration common to terminals 13A, 13B, and 13C will be described with reference to FIG. 3A. In FIGS. 3B and 3C, the same components as the terminal 13A shown in FIG. 3A are given the same reference numerals, and the description thereof will be omitted.

As shown in FIG. 3A, the terminal 13A includes hardware (HW) 21 and an operating system (OS) 22 as an execution environment for executing application programs. Additionally, architecture information 23 is stored in the storage 1003 (see FIG. 8).

The terminal 13A shown in FIG. 3A has an execution environment in which the programming language is C language. An application program (hereinafter referred to as "C application") 24 using the C language is executable on the OS 22.

The terminal 13B shown in FIG. 3B includes an execution environment in which the programming language used is Python. An application program 25 using the Python language (hereinafter referred to as "Python application") can be executed by an interpreter (hereinafter referred to as "Python interpreter") 26 executed by the OS 22.

The terminal 13C shown in FIG. 3C is equipped with an execution environment in which the programming language used is Java. An application program (hereinafter referred to as "Java application") 27 using the Java language can be executed by a virtual machine (hereinafter referred to as "Java VM") 28 executed by the OS 22.

(Architecture information)
FIG. 4 is an explanatory diagram showing architecture information of the terminals 13A, 13B, and 13C according to the first embodiment.

As shown in FIG. 4, the architecture information includes installed application information and engineering information. The installed application information is an example of the execution environment information of the present invention, and is information regarding the application programs installed on the terminals 13A, 13B, and 13C. processing, input processing, output processing), and application program version information.

Further, the engineering information includes a development language which is an example of language information used in the present invention, interpreter information (name and version) which is an example of execution environment information of the present invention, compile conditions, and link conditions.

(Program distribution method)
Hereinafter, a program distribution method in the program distribution system 1 configured as described above will be explained. FIG. 5 is a flowchart showing each process performed by the program distribution server 11 according to the first embodiment.

As shown in FIG. 5, the architecture information acquisition unit 101 (see FIG. 2) transmits a connection request to the terminal 13 via the network 12 (S1).

Next, the architecture information acquisition unit 101 determines whether the architecture information could be received from the terminal 13 (S2). If the determination is No in S2, the process ends as an abnormality (S3). On the other hand, if the determination in S2 is Yes, the source code acquisition unit 102 (see FIG. 2) acquires the source code file from the program management server 14 (S4).

Specifically, the source code acquisition unit 102 transmits an acquisition request to the program management server 14. The acquisition request includes the development language ID corresponding to the development language included in the architecture information (see FIG. 4) sent from the terminal 13 in response to the connection request of S1, and the application program corresponding to the application program to be distributed. Contains ID. The program management server (see FIG. 2) searches the database using the development language ID and application program ID included in the acquisition request as keys, and sends the searched source code file to the source code acquisition unit 102.

Note that the source code acquisition unit 102 can determine whether it is necessary to acquire the source code file based on the installed application information included in the architecture information. Specifically, it can be determined that the source code file is to be acquired when there is an application program that has not been installed on the terminal 13 or when the version of the installed application program is old. Through such a determination, it is possible to decide whether or not the application program needs to be distributed.

Next, the code conversion unit 103 (see FIG. 2) executes code conversion processing to convert the acquired source code file into an appropriate format as necessary (S5).

(Code conversion process)
FIG. 6 is a flowchart showing each step of code conversion processing in the program distribution server 11 according to the first embodiment. As shown in FIG. 6, first, the code conversion unit 103 (see FIG. 2) determines the programming language used in the source code file (hereinafter referred to as "programming language used") based on the development language ID. , it is determined whether the language is C (S10).

If the determination in S10 is Yes, the code conversion unit 103 performs compile/link processing (S11). Details of the compile/link process will be described later. Next, the code conversion unit 103 determines whether the compile/link process was successfully completed (S12). If the determination is No in S12, the process ends as an abnormality (S13). If the determination is Yes in S12, a package for distribution is created from the executable file generated by the compile/link process (S14). Thereafter, the code conversion process is normally ended (S15).

On the other hand, if the determination in S10 is No, the code conversion unit 103 determines whether the programming language used is Python based on the development language ID (S16).

If the determination in S16 is Yes, the code conversion unit 103 performs a version check process of the Phthon interpreter (S17). Details of the version check process will be described later. Next, the code conversion unit 103 determines whether or not the version check process was successfully completed (S18). If the determination is No in S18, the process ends as an abnormality (S19). If the determination is Yes in S18, a package is created from the source code file (S14). Thereafter, the code conversion process is normally ended (S15).

On the other hand, if the determination in S16 is No, the code conversion unit 103 determines whether the programming language used is Java based on the development language ID (S20).

If the determination in S20 is Yes, the code conversion unit 103 performs bytecode conversion processing (S21). Details of the bytecode conversion process will be described later. Next, the code conversion unit 103 determines whether the bytecode conversion process was successfully completed (S22). If the determination is No in S22, the process ends as abnormal (S23). If the determination is Yes in S22, a package is created from the generated bytecode file (S14). Thereafter, the code conversion process is normally ended (S15). On the other hand, if the determination in S20 is No, the code conversion unit 103 terminates as an abnormality (S23).

Returning to FIG. 5, if the code conversion process (S5) is successfully completed, the distribution unit 104 distributes the package to the terminal 13 (see FIG. 2) (S6). Next, the distribution unit 104 receives the result of launching the distributed application program (OK or NG) from the terminal 13 that received the package, and determines whether the application launch was successful (S7). If the determination in S7 is Yes, the distribution unit 104 normally ends the process (S8). If the determination in S7 is No, the distribution unit 104 terminates the process as abnormal (S9).

(C language compilation/link processing)
Details of the compile/link process (S11) shown in FIG. 6 will be explained. The compile/link process (S11) is performed by the compiler and linker included in the code converter 103 (see FIG. 2). Compilers and linkers will be easily understood by those skilled in the art from their names.

Compilation by the compiler is performed according to the compilation conditions included in the engineering information of the architecture information. Compilation conditions include, for example, processor name, compiler software name, version, manufacturer name, and compile options, but are not particularly limited.

Further, linking by the linker is performed according to link conditions included in the engineering information of the architecture information. Link conditions include, for example, linker software name, version, manufacturer name, and link option, but are not particularly limited.

In S11, by using the compile conditions and link conditions in the engineering information of the architecture information acquired from the terminal 13A (see FIG. 3A), a binary code file (executable format file) in an executable format compatible with the terminal 13A is created. ) can be generated.

More specifically, the compiler refers to the compile conditions, prepares a compiler with a matching compiler software name, version, and manufacturer name, specifies the processor name and compile options, and executes compilation.

Also, for linking, refer to the linking conditions, prepare a linker with a matching linker software name and version, specify link options, and execute the link. Thereafter, in S14 of FIG. 6, the compiled and linked binary coded executable format file is packaged for distribution.

(Python version check process)
For programs (source code files) that run on a Python language interpreter, libraries and functions that can be used may be added or abolished depending on the version of the interpreter, so unless they match, the program will not be able to run on a terminal. Therefore, it is preferable to check whether the program written in the Python language in the database of the program management server 14 is a version that can be operated on the interpreter 26 installed in the terminal 13B (see FIG. 3B).

Therefore, in the Python version check process (S17), it is determined whether the interpreter name and interpreter version in the engineering information (see FIG. 4) match those of the source code file acquired by the source code acquisition unit 102 from the program management server 14. Check whether or not.

In the present embodiment, if they do not match (No in the determination in S18), the process ends as an abnormality (S19), but the present invention is not limited to this. For example, an interpreter compatible with the source code file acquired by the source code acquisition unit 102 may be packaged for distribution together with the source code file and distributed to the terminal 13B.

(Java language bytecode conversion process)
Programs that use bytecode (bytecode files or intermediate language files) that run on a Java language virtual machine (Java VM) may not match, as libraries and functions that can be used may be added or abolished depending on the version of the virtual machine. Otherwise, you will not be able to run programs on your terminal. Therefore, it is preferable to check whether the source code file written in the Java language in the database of the program management server 14 is a version that can run on the Java VM 28 installed in the terminal 13C (see FIG. 3C).

Therefore, in the bytecode conversion process (see S21), the virtual machine name and version in the engineering information (see FIG. 4) match those of the source code file acquired by the source code acquisition unit 102 from the program management server 14. Check whether or not.

In the present embodiment, if they do not match (determination in S22 is No), the process ends as abnormal (S23), but the present invention is not limited to this. For example, a virtual machine that matches the source code file acquired by the source code acquisition unit 102 may be packaged for distribution together with the source code file, and distributed to the terminal 13C.

When the version check is completed, the code conversion unit 103 compiles the source code file using the Java language and generates bytecode.

(Data transaction between program distribution server and terminal)
FIG. 7 is a sequence diagram showing a data transaction between the program distribution server 11 and the terminal 13 according to the first embodiment. As shown in FIG. 7, first, the architecture information acquisition unit 101 of the program distribution server 11 (see FIG. 2) transmits a "connection request" to the terminal 13 (S101). When the terminal 13 makes the application program acceptable, it returns a response "OK" to the program distribution server 11 (S102). Here, "acceptable" refers to a state in which communication is used only for program distribution and nothing else is communicated. For example, this includes a state in which an application unrelated to program distribution is not communicating on the terminal 13.

Next, the terminal 13 transmits "architecture information" stored in a storage unit (not shown) to the program distribution server 11 (S103). In response, upon completion of receiving the architecture information, the architecture information acquisition unit 101 of the program distribution server 11 transmits a response "OK" to the terminal 13 (S104). Furthermore, if the program distribution server 11 fails to receive the architecture information or receives an unknown response, it times out and abnormally terminates.

Next, the distribution unit 104 of the program distribution server 11 distributes the package to the terminal 13 (S105). When the terminal 13 receives the package and completes rewriting the program, it returns a response "OK" (S106). Rewriting a program means that the terminal 13 that has received the program reads the package, checks whether the program was correctly received using a check code, and records a new application in the storage unit (for example, ROM) of the device.

Next, the distribution unit 104 of the program distribution server 11 transmits "app launch" to the terminal 13 in order to launch the distributed application program (S107). If the terminal 13 has successfully started the application program, it returns a response of "OK" (S108).

The data transaction between the program distribution server 11 and the terminal 13 described with reference to FIG. 7 is only an example, and the order etc. can be changed as appropriate.

(Server configuration)
Next, with reference to FIG. 8, the hardware configuration of a computer device for realizing servers (hereinafter simply referred to as "servers") such as the program distribution server 11 (see FIG. 2) and the program management server 14. I will explain about it. FIG. 8 is a block diagram showing the hardware configuration of a computer device for realizing the server according to the first embodiment.

FIG. 2 used to explain the first embodiment shows functional unit blocks. These functional blocks (components) are realized by any combination of hardware and/or software. Further, the means for realizing each functional block is not particularly limited. That is, each functional block may be realized by one physically coupled device, or may be realized by two or more physically separated devices connected by wire or wirelessly. good.

For example, the server in the first embodiment may function as a computer that implements each step of the program distribution method of the present invention. The server 1000 shown in FIG. 8 may be physically configured as a computer device including a processor 1001, a memory 1002, a storage 1003, a communication device 1004, an input device 1005, an output device 1006, a bus 1008, and the like.

In addition, in the following description, the word "apparatus" can be read as a circuit, a device, a unit, etc. The hardware configuration of the server 1000 and the like may be configured to include one or more of the devices shown in the figure, or may be configured to not include some of the devices.

For example, although only one processor 1001 is shown, there may be multiple processors. Also, the processing may be performed on one processor, or the processing may be performed on one or more processors simultaneously, sequentially, or in some other manner.

Each function in the program distribution server 11, program management server 14, etc. is performed by loading predetermined software (programs) onto hardware such as the processor 1001 and memory 1002, so that the processor 1001 performs calculations and the communication device 1004 performs communication. This is realized by controlling reading and/or writing of data in the memory 1002 and storage 1003.

The processor 1001, for example, operates an operating system to control the entire computer. The processor 1001 may be configured with a central processing unit (CPU) that includes interfaces with peripheral devices, a control device, an arithmetic device, registers, and the like. Note that each unit such as the above-mentioned architecture information acquisition unit 101, source code acquisition unit 102, code conversion unit 103, and distribution unit 104 may be implemented by the processor 1001. Processor 1001 may be implemented with one or more chips.

Further, the processor 1001 reads programs (program codes), software modules, and data from the storage 1003 and/or the communication device 1004 to the memory 1002, and executes various processes in accordance with these. As the program, a program that causes a computer to execute at least part of the operations described in the above embodiments is used. For example, the architecture information acquisition unit 101, the source code acquisition unit 102, the code conversion unit 103, and the distribution unit 104 may be realized by a control program that is stored in the memory 1002 and runs on the processor 1001, and other functional blocks may also be realized in the same way.

The memory 1002 is a computer-readable recording medium, and includes at least one of ROM (Read Only Memory), EPROM (Erasable Programmable ROM), EEPROM (Electrical EPROM), RAM (Random Access Memory), and other suitable storage media. It may be composed of one. Memory 1002 may be called a register, cache, main memory, or the like. The memory 1002 can store executable programs (program codes), software modules, and the like to implement the program distribution method according to an embodiment of the present invention.

The storage 1003 is a computer-readable recording medium, such as a flexible disk, a floppy (registered trademark) disk, a magneto-optical disk (for example, a compact disk (CD-ROM), etc.), a digital versatile disk, removable disk, hard disk drive, smart card, flash memory device (e.g., card, stick, key drive), magnetic stripe, database, server, or other suitable storage medium. It may be composed of. Storage 1003 may also be called an auxiliary storage device.

The communication device 1004 is hardware (transmission/reception device) for communicating between computers via a wired and/or wireless network, and is also referred to as, for example, a network device, network controller, network card, communication module, or the like.

The input device 1005 is an input device (eg, keyboard, mouse, etc.) that accepts input from the outside. The output device 1006 is an output device (eg, a display, a speaker, etc.) that performs output to the outside. Note that the input device 1005 and the output device 1006 may have an integrated configuration (for example, a touch panel). The server 1000 does not need to include the input device 1005 and the output device 1006.

Furthermore, each device such as the processor 1001 and the memory 1002 is connected by a bus 1008 for communicating information. Bus 1008 may be configured as a single bus or may be configured as different buses between devices.

The server 1000 also includes hardware such as a microprocessor, a digital signal processor (DSP), an application specific integrated circuit (ASIC), a programmable logic device (PLD), and a field programmable gate array (FPGA). A part or all of each functional block may be realized by the hardware. For example, processor 1001 may be implemented with at least one of these hardware.

Note that the terminal 13 (see FIG. 2) can also be realized by a computer device having the above-described hardware configuration.

As explained above, according to the first embodiment, source code files using different programming languages are prepared for one application program in the program management server 14 (see FIG. 2), and the program distribution server 11 acquires a source code file based on the development language (language information used) included in the architecture information acquired from the terminal 13, converts it into an executable file to match the development language, or The code file is delivered to the terminal 13 as it is. This brings about the effect that the same program can be provided to terminals with different execution environments without degrading the functionality and performance of the terminal 13.

<Second embodiment>
A program distribution system including verification processing according to the second embodiment will be described with reference to FIGS. 9 to 14. In the following description, points that are different from the first embodiment will be explained, and descriptions of the same points will be omitted. Further, the same reference numerals used in FIGS. 1 to 8 refer to the same structures or steps, and the explanation thereof will be omitted.

In the program distribution system 1 according to the first embodiment, as shown in FIG. 7, after distributing an application program from the program distribution server 11 to the terminal 13 (see FIG. 2), the application program is started on the terminal 13, and then Upon receiving the response "OK" indicating that the application was successful, the application program is being verified. Therefore, when verifying the application program on the terminal 13, if there is an event where the application program cannot be started due to interference with other application programs installed on the terminal 13 and running, the program distribution server 11 side It can be detected as an abnormal termination. However, there is a concern that verifying the application program on the terminal 13 may cause inconveniences such as causing the terminal 13 to stop abnormally or requiring restarting.

Therefore, in the second embodiment, before distributing the application program, an evaluation environment equivalent to the execution environment of the terminal 13 is constructed in the program distribution server, and the application program is verified.

<Application verification process>
FIG. 9 is a functional block diagram showing a program distribution server according to the second embodiment. As shown in FIG. 9, the program distribution server 201 further includes a verification environment construction section 202 and a verification section 203.

FIG. 10 is a flowchart showing each step of the application verification process performed by the program distribution server 201 according to the second embodiment. The program distribution server 201 (see FIG. 9) performs the same processing as the program distribution server 11 according to the first embodiment described with reference to FIGS. 5 to 7. However, before distributing the package (see S6 in FIG. 5), the application program is verified in a verification environment (hereinafter referred to as "application verification processing") based on the architecture information of the terminal 13. They differ in some respects.

(Verification environment construction process)
As shown in FIG. 10, first, the verification environment construction unit 202 executes verification environment construction processing (S61). In the verification environment construction process (S61), a verification environment that is an execution environment equivalent to the terminal 13 (see FIG. 9) is virtually constructed on the program distribution server 201 based on the architecture information.

FIG. 11 is a flowchart showing each step of the verification environment construction process in the program distribution server 201 according to the second embodiment. As shown in FIG. 11, among the terminals 13 (see FIG. 9), the architecture information obtained in advance for the terminal to be evaluated (hereinafter referred to as the target terminal) is analyzed (S81), and the It is determined whether a verification environment equivalent to the terminal can be constructed (S82).

The determination method in S82 is not particularly limited, but if the environment indicated in the architecture information of the target terminal cannot be constructed, it can be determined that the environment cannot be constructed, and if not, it can be determined that the environment can be constructed. Specifically, examples include, but are not limited to, cases in which recompilation cannot be performed because the compiler license has expired, and cases in which there are differences in versions of development languages (e.g., differences in versions of Java and Python). .

If the determination is No in S82, the process ends as abnormal (S83). If the determination is Yes in S82, a verification environment is constructed (S84). Specifically, the verification environment can be constructed as follows.

The verification environment can be constructed using virtualization technology (container-based virtualization technology, etc.) and an automated environment using batch processing. Based on the architecture information of the target terminal, the CPU architecture (x86, ARM, etc.), OS (Debian, Ubuntu, CentOS, etc.), development language (Java, Python, etc.) stored in the program distribution server 201, etc. The system acquires images for building a virtual environment, and automatically builds a verification environment similar to the target terminal based on each image.

After constructing the verification environment, it is determined whether the construction has been completed (S85). If the determination in S85 is No, the process ends as abnormal (S86). On the other hand, if the determination in S85 is Yes, the process advances to S62 shown in FIG.

In S62, the verification unit 203 determines whether the related application (described as “related application” in FIG. 10) can be obtained from the program management server 14.

(Related applications)
When the application program to be distributed (hereinafter referred to as the target application) is part of an application group made up of multiple applications, the related application refers to other application programs that make up the same application group.

FIG. 12 is a schematic diagram showing the relationship between the target application and related applications in the second embodiment. In FIG. 12, "processing application" is described as "processing application" and "analysis application" is described as "analysis application." Specifically, as shown in FIG. 12, it is assumed that a target terminal has a "processing application" that processes certain data (processed data) and an "analysis application" that analyzes it. Furthermore, it is assumed that the "processing application" and the "analysis application" share a data format. Since the "analysis application" executes analysis processing of processed data based on the shared data format, there is a dependency with the "processing application". Further, after transmitting the processed data to the "analysis application", the "processing application" receives a reception completion response from the "analysis application".

In this way, among the two applications that have a dependent relationship, one is defined as the target application and the other as the related application.

The determination in S62 is made by, for example, searching the database of the program management server 14 for the source code file of the related application using the installed application information, which is an example of the execution environment information of the present invention, in the architecture information of the target terminal. This can be done depending on whether or not a search result is obtained.

If the determination is No in S62, the process ends as an abnormality (S63). If the determination is Yes in S62, the source code acquisition unit 102 (see FIG. 9) acquires the source code file of the related application from the program management server 14 (S64).

Next, the code conversion unit 103 (see FIG. 9) performs code conversion processing on the source code file of the related application, as in the first embodiment (S65). Thereafter, it is determined whether the code conversion process has ended normally (S66).

If the determination is No in S66, the process ends as abnormal (S67). If the determination is Yes in S66, the verification unit 203 (see FIG. 9) deploys the related application to the verification environment (S68). Deployment here means placing the related application in an executable state on the verification environment.

(Verification process)
Next, the verification unit 203 performs verification processing (S69). FIG. 13 is a flowchart showing each step of the verification process in the program distribution server 201 according to the second embodiment. As shown in FIG. 13, first, the verification unit 203 (see FIG. 9) performs unit verification of the target application (S91).

Specifically, the unit verification checks the compatibility (CPU architecture, OS, development language, etc.) of the target application alone with the terminal to be distributed. More specifically, the target application is executed and log analysis of the execution results is performed in the same execution environment (CPU architecture, OS, development language, etc.) as the target terminal constructed in the verification environment construction process. If this output log matches a normal value predefined in the program distribution server 201, it is determined that the response is normal. In addition, in the case of an abnormality, the error code is output and compared with the error code table predefined in the program distribution server 201 to determine the cause of the nonconformity (CPU architecture, OS, development language, etc.) before distribution. It is possible to check. This makes it possible to confirm that the target application to be distributed can be executed in an environment equivalent to the execution environment of the target terminal.

Next, it is determined whether the result of the unit verification of the target application is normal (S92). If the determination in S92 is No, it is abnormal, an error is output, and the process ends (S93). If the determination in S92 is Yes, it is normal and the next connection verification (S94) is performed.

(Connection verification)
In connection verification (S94), the target application and related applications are connected and verification between the applications is performed.

As described above, there is a dependency between the target application and related applications. In connection verification, if there is an abnormality, such as a mismatch, in the dependent item, it is determined to be abnormal.

Specifically, this includes differences in protocols or settings in connection/communication between applications.

FIG. 14 is a schematic diagram showing normal and abnormal connections between the target application and related applications in the second embodiment. A specific example will be described with reference to FIG. 14, assuming that the target application is a "processing application" and the related application is an "analysis application." When communicating between applications, it is necessary to use the same communication protocol and to mutually recognize communication settings (eg, port numbers, etc.) between the applications. Additionally, an error (NG) will occur during verification if the data format does not conform to the data format shared by the "processing application" and the "analysis application". As shown in Figure 14, the determination made when verifying the connection between the "processing application" and the "analysis application" is, for example, whether the communication protocols (HTTP and MQTT) match or do not match, and the data formats (text, JSON) match or do not match. It can be done based on

Next, it is determined whether the connection verification result is normal or not (S95). If the determination in S95 is No, it is abnormal, an error is output, and the process ends (S96). If the determination in S95 is Yes, it is normal, the verification process ends, and the process proceeds to S70 in FIG. 10.

In S70, it is determined whether the result of the verification process is normal. If the determination in S70 is No, it is determined that there is an abnormality and the process ends (S71). If the determination in S70 is Yes, it is normal, the application verification process is ended, and the package is distributed to the target terminal (S6 in FIG. 5).

In this embodiment, verification by starting an application program on the target terminal is not necessary, but may be performed.

As explained above, according to the second embodiment, in addition to the same effects as the first embodiment, execution of the target terminal is performed based on the execution environment information (for example, installed application information) of the target terminal. A verification environment equivalent to the environment is constructed, the source code or executable file is executed on the verification environment, and the program is verified. This allows the program distribution server 201 to manage, verify, and distribute application programs used in target terminals, and to develop and deploy application programs appropriately in a short period of time. In addition, it is possible to deliver application programs that are compatible with the execution environment of the target terminal after being verified in a verification environment that is equivalent to the execution environment, down to the binary level, before distribution, making it possible to provide high-quality application programs. This has the effect that the target terminal can execute the application program without degrading the application execution time or function.

Note that the present invention is not limited to the above embodiments, and can be implemented with various modifications. In the embodiments described above, the sizes, shapes, functions, etc. of the constituent elements illustrated in the accompanying drawings are not limited to these, and can be changed as appropriate within the scope of achieving the effects of the present invention. Other changes can be made as appropriate without departing from the scope of the invention.

For example, in the first and second embodiments described above, application programs (packages) are distributed based on requests from the program distribution servers 11 and 201 (see FIGS. 2 and 9); It may be performed by

Further, in the first and second embodiments described above, the source code files are managed by the database of the program management server 14, but the program distribution servers 11 and 201 (see FIGS. 2 and 9) manage the database, for example. In preparation for the storage 1003 (see FIG. 8), source code files may be managed in the same manner as the program management server 14. That is, the management unit of the present invention may be included in the program distribution servers 11 and 201 (see FIGS. 2 and 9).

Furthermore, in the second embodiment described above, the source code acquisition unit (see FIGS. 2 and 9) performs a version check of the source code file after acquiring the source code file. Beforehand, information regarding a compatible interpreter or virtual machine may be obtained from the program management server 14 and a version check may be performed.

INDUSTRIAL APPLICABILITY The present invention has the effect that the same program can be provided to terminals with different execution environments without degrading the functions and performance of the terminals, and is suitable for application to, for example, a system for distributing and verifying application programs. .

1 Program distribution system 11, 201 Program distribution server (program distribution device)
12 Network 13 (13a to 13c, 13n, 13A to 13C) Terminal 14 Program management server (management department)
23 Architecture information 26 Interpreter 28 Java VM (virtual machine)
101 Architecture information acquisition unit 102 Source code acquisition unit (acquisition unit)
103 Code conversion section (conversion section)
104 Distribution section (transmission section)
202 Verification environment construction unit 203 Verification unit 1000 Server 1001 Processor 1002 Memory 1003 Storage 1004 Communication device 1005 Input device 1006 Output device 1008 Bus

Claims (4)

A management unit that manages source codes using different programming languages for one program identifies a programming language that can be executed in the execution environment of the terminal based on the language information of the terminal, and selects the programming language that can be executed in the execution environment of the terminal. a source code acquisition unit that acquires the used source code from the management unit;
If the programming language used is a compiled language, a conversion unit that converts the source code into an executable file that can be executed in the execution environment;
a transmitter that transmits the source code when the programming language used is a script language, and the executable format file when the programming language used is the compiled language, to the terminal;
a verification environment construction unit that constructs a verification environment equivalent to the execution environment of the terminal based on execution environment information of the terminal;
a verification unit that executes the source code or the executable file on the verification environment and verifies the program before distributing the application program;
Equipped with
The source code acquisition unit determines whether or not it is necessary to acquire the source code based on whether installed application information included in architecture information includes information about an application program that is not installed. Program distribution device. The conversion unit includes a compiler and a linker,
2. The program distribution apparatus according to claim 1, wherein a binary code file is generated as the executable file from the source code based on compiling conditions and linking conditions of the terminal. 3. The program distribution according to claim 1, wherein the conversion unit generates an intermediate language file executable by a virtual machine on the terminal as the executable format file from the source code. Device. Based on the language information of the terminal, a programming language that can be executed in the execution environment of the terminal is specified, and a management unit that manages source codes using different programming languages uses the programming language for one program. a step of obtaining the source code,
If the programming language used is a compiled language, converting the source code into an executable file that can be executed in the execution environment;
transmitting the source code if the programming language used is a scripting language, or the executable file if the programming language used is the compiled language, to the terminal;
building a verification environment equivalent to the execution environment of the terminal based on the execution environment information of the terminal;
executing the source code or the executable file on the verification environment and verifying the program before distributing the application program;
Equipped with
The step of transmitting to the terminal determines whether or not the source code needs to be acquired based on whether or not there is information about an application program that is not installed in the installed application information included in the architecture information. program delivery method.

Images