JP7764957B2 - Generation device, generation method, and generation program - Google Patents

Description

The present invention relates to a generation device, a generation method, and a generation program.

Traditionally, communication devices in IP networks perform the control necessary to provide various services for each user, based on configuration information set for each user. In this case, a procedure called configuration input is carried out, in which the settings required for each user's contracted service are input into the communication device. Configuration input is sometimes performed by a server called a configuration input server. The communication device is, for example, an edge router (hereinafter referred to as "edge").

However, because necessary configuration additions and changes may occur even during operation, it is desirable for the application portion of the configuration input server to be easy to modify. In response to this, a configuration input server using Ansible, a configuration management tool for automatic configuration of servers, has been proposed (see, for example, Non-Patent Document 1).

Iwahashi et al., “User configuration input to easily modifiable edge routers using Ansible,” Proceedings of the 2021 IEICE General Conference, B-6-67, Mar. 2021.

However, conventional methods have the problem that it may not be possible to efficiently obtain data for issuing commands to a communication device.

For example, the code for executing command input is composed of the scenarios that need to be realized. Finalizing such code requires extensive network verification by experienced network designers. This can sometimes delay code development.

Furthermore, after network verification is complete, the development process shifts to software development of the code, which can lead to a sequential development schedule and put pressure on the overall development schedule. Furthermore, software developers can misinterpret the command instructions provided by experienced network designers, which can lead to bugs.

As such, it is difficult to efficiently develop code for command submission, which reduces the efficiency of the entire command submission process.

In order to solve the above-mentioned problems and achieve the objectives, the generating device is characterized by having a receiving unit that receives input of a first file that defines information for performing configuration input on a communication device that accommodates a user using the network, the information differing depending on the model of the communication device, and a synthesis unit that synthesizes the first file with a second file that defines information for performing configuration input on the communication device that is common to the model of the communication device.

According to the present invention, data for issuing commands to a communication device can be obtained efficiently.

FIG. 1 illustrates an example of the configuration of a management system according to the first embodiment. FIG. 2 is a diagram showing an example of a hierarchical structure for managing templates. FIG. 3 is a diagram showing an example of a hierarchical structure for managing templates. FIG. 4 is a diagram illustrating the command conversion unit. FIG. 5 illustrates an example of the configuration of a generating device according to the first embodiment. FIG. 6 is a diagram illustrating an example of the configuration of the command conversion unit according to the first embodiment. FIG. 7 is a diagram showing an example of an input file. FIG. 8 is a diagram illustrating an example of branch processing for each branch condition. FIG. 9 is a sequence diagram showing the flow of processing in the management system. FIG. 10 is a flowchart showing the flow of processing by the generation device. FIG. 11 is a flowchart showing the flow of processing by the command conversion unit. FIG. 12 illustrates an example of a computer that executes a generation program.

The following describes in detail embodiments of the generation device, generation method, and generation program according to the present application, with reference to the accompanying drawings. Note that the present invention is not limited to the embodiments described below.

In addition, the generation device, generation method, and generation program generate data for command conversion used in the management system. For this reason, the configuration of the management system will also be explained.

[Configuration of the first embodiment]
First, the configuration of a management system according to the first embodiment will be described with reference to FIG. 1. FIG. 1 is a diagram showing an example of the configuration of the management system according to the first embodiment. As shown in FIG. 1, the management system 1 includes a management device 10, an edge 20A, an edge 20B, and an edge 20C. The edges are examples of communication devices. Each edge accommodates users who use communication services. Company A, Company B, and Company C are examples of users. The communication devices may also be switches, routers, etc.

The management device 10 receives a configuration input request from the upper system 2. The configuration input request may also be referred to as an SO (service order).

The functions of the upper system 2 may be realized by an operator. In this case, the operator inputs the contents of a configuration input request into the management system 1. For example, inputting a configuration means making settings for a communication device that accommodates a user, such as when opening, changing, or canceling a service.

As shown in Figure 1, the management device 10 has a higher-level system support unit 11, a configuration input request management DB 12, a determination unit 13, a device control unit 14A, a device control unit 14B, and a device control unit 14C.

Here, the management device 10 may be realized by multiple computers or by a single computer. The configuration input request management DB 12, the determination unit 13, the device control unit 14A, the device control unit 14B, and the device control unit 14C may each be realized by a physical machine or a virtual machine.

First, the host system correspondence unit 11 receives a configuration entry request from the host system 2. The host system correspondence unit 11 registers the received configuration entry request in the configuration entry request management DB 12. As a result, the configuration entry request management DB 12 stores the contents of the configuration entry requests for multiple communication devices that accommodate users who use the network.

The determination unit 13 performs priority control of orders (configuration input requests) stored in the configuration input request management DB 12 and determines the physical location of the user.

Device control unit 14A, device control unit 14B, and device control unit 14C perform similar processing. Here, we will use device control unit 14A as an example.

The device control unit 14A has a common control unit 141A, an individual control unit 142A, and a command conversion unit 143A.

The common control unit 141A acquires a request for configuration input to a communication device that accommodates a user using the network. For example, the common control unit 141A acquires a request (order) for configuration input from the configuration input request management DB 12 and performs exclusive control on the acquired order.

Furthermore, the common control unit 141A acquires information about the edge to which the data is to be submitted. The information about the edge to which the data is to be submitted includes the model, version, and purpose of the edge, etc.

Furthermore, the common control unit 141A calls the corresponding individual control unit 142A based on the order's scenario information.

The individual control unit 142A identifies a set of variables required for the command to execute the configuration entry based on the content of the configuration entry request received by the common control unit 141A and the type of communication device, and transmits the identified set of variables to the common control unit 141A. The type of communication device is, for example, an edge model.

The individual control unit 142A writes the identified variable group to a variable file and sends the variable file to the common control unit 141A.

Here, the common control unit 141A instructs the command conversion unit 143 to create and execute a command using the variable file received from the individual control unit 142A as an argument.

The command conversion unit 143A obtains the set of variables identified by the individual control unit 142A from the common control unit 141A, creates a command based on the obtained set of variables, and executes the created command.

Here, the command conversion unit 143A stores templates for each type of communication device, version of the communication device, and purpose of the communication device, and creates commands based on the templates.

Figures 2 and 3 show an example of a hierarchical structure for managing templates. As shown in Figures 2 and 3, templates are managed for each model, version, and purpose of the communication device.

Figure 2 shows that there are templates for the model "Model A," version "1.0," and purpose "for normal users," corresponding to each of the "SO insertion scenario," "maintenance relocation scenario," and "fault relocation scenario."

Furthermore, the "SO Introduction Scenario" has a "PPPoE Service Setting Function" and an "IPv6 Service Setting Function" as function branches within the scenario. These function branches are set up because even within a scenario, whether or not a service is set up may change depending on each user's request, and the order of setting up may be taken into consideration depending on the device specifications.

On the other hand, Figure 3 shows a template with a model number of "Model A," a version number of "1.0," and a purpose number of "For corporate users." The template in Figure 2 and the template in Figure 3 share the same model number and version, but have different purposes.

The command conversion unit 143A also sends a log related to the execution of the command to the common control unit 141A. At this time, the common control unit 141A stores the results of the configuration entry in the configuration entry request management DB12 based on the log sent by the command conversion unit 143A.

As explained above, the command conversion unit (e.g., command conversion unit 143A, command conversion unit 143B) executes commands to communication devices such as edges depending on the scenario.

On the other hand, new communication devices that are the target of configuration input may be added. Furthermore, the model of the newly added communication device may differ from the model of the existing communication device. Furthermore, new scenarios for configuration input may be added for existing communication models.

Figure 4 is a diagram explaining the command conversion unit. In the example of Figure 4, it is assumed that a new edge 20B', which is the target of configuration input, has been added. However, the model of edge 20B' is different from the model of edge 20B.

In this case, it is desirable that command conversion data for executing commands targeting edge 20B' be quickly added to the command conversion unit 143B. The command conversion data includes a file containing the code for the command itself and a file containing the information necessary to execute the command.

The generation device of the embodiment generates command conversion data for executing commands during configuration input. The command conversion data generated by the generation device may be automatically added to the command conversion unit. Alternatively, the command conversion data generated by the generation device may be added to the command conversion unit by a software developer.

Figure 5 is a diagram showing an example configuration of a generation device according to the first embodiment. As shown in Figure 5, an input file is input to the generation device 30. The generation device 30 also outputs command conversion data. For example, the input file is created by a network designer. For example, the command conversion data is used by a software developer.

The reception unit 31 receives input of an input file that defines information for performing configuration input on communication devices that accommodate users who use the network, and which differs depending on the model of the communication device.

An input file is a file in which command definitions for each model are entered according to an input format. The reception unit 31 is an interface for accepting input of the input file.

The synthesis unit 32 synthesizes a common definition file, which defines information common to all communication device models and is used to perform configuration input for the communication device, with an input file.

The common definition file is stored in advance in the generation device 30. The input file is an example of a first file. The common definition file is an example of a second file.

Here, the configuration of the command conversion unit to which command conversion data has been added will be explained using Figure 6. Figure 6 is a diagram showing an example configuration of the command conversion unit of the first embodiment. Here, the explanation will be given using the command conversion unit 143B of the management system 1 as an example.

As shown in Figure 6, the command conversion unit 143B has a common processing unit 1431B, a model-specific processing unit 1431B_1, and a model-specific processing unit 1431B_2.

Model-specific processing unit 1431B_1 and model-specific processing unit 1431B_2 each correspond to a different model of communication device. For example, model-specific processing unit 1431B_1 is data for inputting the configuration of edge B. Also, model-specific processing unit 1431B_2 is data for inputting the configuration of edge B'. In this way, the command conversion unit has a hierarchical structure divided by model.

The model-specific processing unit 1431B_1 and the model-specific processing unit 1431B_2 are generated by the generation device 30.

Here, we will explain using the model-specific processing unit 1431B_1 as an example. The generation device 30 generates a scenario file and parameter file for the model-specific processing unit 1431B_1 based on the common definition file.

In addition, the generation device 30 generates a command file and an input result check file for the model-specific processing unit 1431B_1 based on the input file.

A scenario file is a file that abstractly describes the scenario to be executed. For example, the common control unit 141B issues instructions in a format such as "exe model/parameters address change scenario," which specifies the model, parameters, and scenario.

The model-specific processing unit 1431B_1 instructs the common processing unit 1431 to execute a task based on the scenario file and in accordance with instructions from the common control unit 141B. If the scenario includes multiple tasks, the model-specific processing unit 1431B_1 instructs execution for each task.

The model-specific processing unit 1431B_1 performs processing such as executing commands and checking the execution results according to the tasks executed by the common processing unit 1431B. The code of the command to be executed is written in the command file. In addition, the contents of the check of the execution results are written in the input result check file.

In addition, parameter files are fixed files for each model and are placed when the command is executed.

To realize the configuration of the command conversion unit 143B as shown in Figure 6, the input file is assumed to include a command file and an input result check file. Furthermore, the common definition file is assumed to include a file corresponding to the common processing unit 1431B, a scenario file, and a parameter file.

In other words, the reception unit 31 receives input of an input file that describes a set of commands that differ depending on the model of the communication device. The set of commands described in the input file that differ depending on the model of the communication device corresponds to a command file.

The command file can be said to be called when a task is executed by the common processing unit 1431B. Therefore, the command file can be said to contain the commands that are called when a task is executed.

The reception unit 31 also receives input of an input file that further describes the error detection process that occurs when a command is executed. The error detection process that occurs when a command is executed, described in the input file, corresponds to the submission result check file.

The format of the input file will be explained using Figure 7. As shown in Figure 7, the input file is a file in a format (e.g., table format, CSV format, XML format, etc.) consisting of item names and values.

The input file contains items such as "scenario," "command file name," "command," "variable," "response message," "loop processing," "branch processing," and "update of retained information."

The "Scenario" item stores information for identifying the scenario in which the command is executed, such as the name of the scenario and an ID for identifying the scenario.

The "Command file name" item stores the name of the command file in the command conversion section.

The "Command" item stores the command to be executed. The command is executed using information from the "Variables", "Response Message", "Loop Processing", and "Branch Processing" items described below.

The "Variables" item stores information indicating the variables used in the command. The "Response Message" item stores the response message when the command is executed successfully.

The "Loop Processing" item stores the details of the loop processing in the command. The "Branch Processing" item stores the details of the branch processing in the command.

In this way, the reception unit 31 accepts input of an input file containing variables used in commands called in the execution of a task (item "Variables"), a response message when the command is executed successfully (item "Response Message"), the contents of the repetitive processing (item "Repetitive Processing"), the contents of the branching processing (item "Branching Processing"), and information on parameters updated in the execution of the command (item "Update of Retained Information").

(Scenario: Address change)
The commands included in the scenario "Address Change" in Figure 7 are explained below. For example, the variables appear in the "{}" in the command "interface {} in {}" in the order they are specified. Since the variables are specified as "vlan_id_1, vlan_id_2", the first "{}" contains "vlan_id_1" and the second "{}" contains "vlan_id_2".

Also, "{{}}" in a command indicates a repetitive process. For example, the repetitive process of the command "ipv4 address {{}}" is "1_v4_addr_*(1-2)", and the variable to be repeatedly input is defined as "(number - number)" (for example, "(1-2)").

Also, if a command has a repeat section, a number indicating the order in which it appears is added to the beginning of the repeat process, such as "1_v4_addr_*(1-2)". In this case, the repeat processes for the two commands "ipv4 address{{}}" and "ipv6 nd suppress" have "1_" at the beginning, so these two commands make up the repeat section.

The results of executing the commands included in the scenario "Address Change" are as follows.
ipv6 address v6_addr_1
ipv6 address v6_addr_2
ipv4 address v4_addr_1
ipv6 nd suppress
ipv4 address v4_addr_2
ipv6 nd suppress

(Scenario: Policy Registration)
The commands included in the scenario "Policy Registration" in Fig. 7 include branch processing. The branch conditions and the contents of the branch processing are shown in Fig. 8. Fig. 8 is a diagram showing an example of branch processing for each branch condition. Note that "var" in Fig. 8 means a variable. Also, "vars" means a list of variables.

For example, if the repetition process is "1_" and the branching process is "(up_service_name) != None", this means that the "1_" part is repeated as many times as the number of variables stored as "up_service_name".

Also, the item "Update maintenance information" being "new g_edge_address = command_result" means that after the command is executed, the command result is stored in the variable "g_edge_address" and updated.

If the "Response Message" item is set to "* (don't care)", the input result will not be checked. On the other hand, if the "Response Message" item is set to a value other than "* (don't care)", such as "Success!", the input result will be checked. The "Response Message" item is used to create the input result check file.

[Processing of the First Embodiment]
9 is a sequence diagram showing the processing flow of the management system of the first embodiment. First, as shown in FIG. 9, the host system support unit 11 receives a configuration input request from the host system 2 (step S101). Next, the host system support unit 11 writes the received configuration input request into the configuration input request management DB 12 (step S102).

The determination unit 13 periodically attempts to acquire requests for which an expropriation location has not been determined from the configuration input request management DB 12 (steps S103 and S104). Here, if the determination unit 13 is able to acquire a request for which an expropriation location has not been determined (if there is a match), it determines the storage location (step S105).

The determination unit 13 writes the storage location in the configuration entry request management DB 12 (step S106). The common control unit 141A acquires a request whose storage location is a communication device under the device control unit 14A and performs exclusive control (step S108). The communication device under the device control unit 14A is, for example, edge 20A.

The common control unit 141A then calls the individual control unit 142A (step S109). The individual control unit 142A checks the status of the communication device (edge 20A) (step S110) and creates a variable file (step S111). The individual control unit 142A then sends the created variable file to the common control unit 141A (step S112).

The common control unit 141A requests the command conversion unit 143A to submit a command based on the variable file (step S113). The command conversion unit 143A selects a template based on the command submission request (step S114).

The command conversion unit 143A creates a command based on the selected command template (step S115). Then, the command conversion unit 143A executes the created command on the edge 20A and inputs the configuration (step S116).

Here, the command conversion unit 143A acquires the input log from the edge 20A (step S117) and sends the acquired input log to the common control unit 141A as the input result (step S118).

The common control unit 141A writes the input results to the configuration input request management DB 12 (step S119). The upper system correspondence unit 11 confirms the setting completion request in the configuration input request management DB 12 (step S120). The upper system correspondence unit 11 then notifies the upper system 2 that the setting is complete (step S121).

Figure 10 is a flowchart showing the processing flow of the generation device. As shown in Figure 10, first, the generation device 30 accepts input of an input file (step S201).

Next, the generating device 30 combines the input file and the common definition file (step S202). The generating device 30 then outputs the command conversion data obtained by the combination (step S203).

The command conversion data generated by the generation device 30 is used by the command conversion unit of the management system 1. Figure 11 is a flowchart showing the processing flow of the command conversion unit.

Here, we will use the command conversion unit 143B as an example. As shown in Figure 11, first, the command conversion unit 143B starts executing the scenario specified by the common control unit 141B (step S301).

Next, the command conversion unit 143B executes the tasks described in the scenario (step S302). The correspondence between the scenario and the tasks is indicated in the scenario file generated from the common definition file.

Next, the command conversion unit 143B executes the command according to the command file (step S303). The command conversion unit 143B also checks the execution result of the command according to the input result check file (step S304). The command file and input result check file are generated from the input file.

Then, the command conversion unit 143B updates the parameters in the parameter file as necessary (step S305).

[Effects of the First Embodiment]
As described above, the generating device 30 has a receiving unit 31 and a combining unit 32. The receiving unit 31 receives input of an input file that defines information for executing configuration input for communication devices that accommodate users who use the network, and that differs depending on the model of the communication device. The combining unit 32 combines the input file with a common definition file that defines information common to all communication device models, and that is information for executing configuration input for the communication device.

The generation device 30 automatically obtains data to add to the command conversion unit, thereby efficiently obtaining data for inputting commands to the communication device.

The receiving unit 31 also receives input of an input file that describes a set of commands that differ depending on the model of the communication device. The combining unit 32 combines the input file with a common definition file that defines the process for calling the commands included in the set of commands.

The reception unit 31 also receives input of an input file that describes commands to be called when executing a task.

In addition, the synthesis unit 32 synthesizes a common definition file containing information identifying tasks corresponding to the specified scenario with the input file.

The receiving unit 31 also receives input of an input file that further describes error detection processing when the command is executed.

In this way, the generation device 30 divides the functional deployment of the command conversion unit into model-dependent functional units (parts derived from the input file) and parts commonly used within the model (parts derived from the common definition file), thereby precisely separating the difference information for each model.

The reception unit 31 also accepts input of an input file containing information on variables used in commands called during task execution, response messages when the commands are executed successfully, the contents of repetitive processing, the contents of branching processing, and parameters that are updated during command execution.

In this way, by formatting command files for each model and presenting a method that allows for repetitive processing and branching conditions to be described, it is possible to clarify a framework that can be automatically generated based on data entered into the format.

[System configuration, etc.]
Furthermore, the components of each device shown in the figure are conceptual functional units and do not necessarily have to be physically configured as shown. In other words, the specific form of distribution and integration of each device is not limited to that shown, and all or part of the devices can be functionally or physically distributed or integrated in any unit depending on various loads, usage conditions, etc. Furthermore, all or any part of the processing functions performed by each device can be realized by a CPU and a program analyzed and executed by the CPU, or can be realized as hardware using wired logic.

Furthermore, among the processes described in this embodiment, all or part of the processes described as being performed automatically can be performed manually, or all or part of the processes described as being performed manually can be performed automatically using known methods. In addition, the information, including the processing procedures, control procedures, specific names, various data, and parameters shown in the above documents and drawings, can be changed as desired unless otherwise specified.

[program]
In one embodiment, the generating device 30 can be implemented by installing a generating program that executes the above-described generating process as package software or online software on a desired computer. For example, by executing the above-described generating program on an information processing device, the information processing device can function as the generating device 30. The information processing device referred to here includes desktop and notebook personal computers. Other information processing devices also include mobile communication terminals such as smartphones, mobile phones, and PHS (Personal Handyphone Systems), as well as slate terminals such as PDAs (Personal Digital Assistants).

Figure 12 is a diagram showing an example of a computer that executes a generation program. The computer 1000 has, for example, memory 1010 and a CPU 1020. The computer 1000 also has a hard disk drive interface 1030, a disk drive interface 1040, a serial port interface 1050, a video adapter 1060, and a network interface 1070. Each of these components is connected by a bus 1080.

The memory 1010 includes a ROM (Read Only Memory) 1011 and a RAM 1012. The ROM 1011 stores a boot program such as a BIOS (Basic Input Output System). The hard disk drive interface 1030 is connected to a hard disk drive 1090. The disk drive interface 1040 is connected to a disk drive 1100. A removable storage medium such as a magnetic disk or optical disk is inserted into the disk drive 1100. The serial port interface 1050 is connected to a mouse 1110 and a keyboard 1120, for example. The video adapter 1060 is connected to a display 1130, for example.

The hard disk drive 1090 stores, for example, an OS 1091, an application program 1092, a program module 1093, and program data 1094. That is, the program that defines each process of the generation device 30 is implemented as a program module 1093 in which computer-executable code is written. The program module 1093 is stored, for example, on the hard disk drive 1090. For example, a program module 1093 for executing processes similar to the functional configuration of the generation device 30 is stored on the hard disk drive 1090. Note that the hard disk drive 1090 may be replaced by an SSD.

In addition, the setting data used in the processing of the above-described embodiment is stored as program data 1094, for example, in memory 1010 or hard disk drive 1090. Then, the CPU 1020 reads the program module 1093 or program data 1094 stored in memory 1010 or hard disk drive 1090 into RAM 1012 as needed, and executes the processing of the above-described embodiment.

The program module 1093 and program data 1094 may not necessarily be stored on the hard disk drive 1090, but may also be stored on a removable storage medium, for example, and read by the CPU 1020 via the disk drive 1100, etc. Alternatively, the program module 1093 and program data 1094 may be stored on another computer connected via a network (such as a LAN (Local Area Network) or WAN (Wide Area Network)). The program module 1093 and program data 1094 may then be read by the CPU 1020 from the other computer via the network interface 1070.

DESCRIPTION OF SYMBOLS 1 Management system 2 Upper system 10 Management device 11 Upper system correspondence unit 12 Configuration input request management DB
13 Determination unit 20A, 20B, 20B', 20C Edge 30 Generation device 31 Reception unit 32 Synthesis unit 14A, 14B, 14C Device control unit 141A, 141B, 141C Common control unit 142A, 142B, 142C Individual control unit 143A, 143B Command conversion unit 143C Edge control device 1431B Common processing unit 1431B_1, 1431B_2 Model-specific processing unit

Claims (7)

a receiving unit that receives input of a first file that defines information for executing configuration input for a communication device that accommodates a user who uses a network, the information differing depending on the model , version, and use of the communication device;
a synthesizing unit that synthesizes the first file with a second file that defines information for executing configuration input for the communication device, the second file defining information common to the model , version, and use of the communication device;
A generating device comprising: the receiving unit receives input of the first file in which a group of commands that differ depending on the model , version, and purpose of the communication device are described;
The generating device according to claim 1 , wherein the combining unit combines the second file, in which a process for calling a command included in the command group is defined, with the first file. the receiving unit receives input of the first file in which a command to be called in the execution of a task is written;
The generating device according to claim 1 , wherein the combining unit combines the second file containing information for identifying a task corresponding to a specified scenario with the first file. The generation device described in claim 3, characterized in that the reception unit receives input of the first file, which further describes error detection processing during command execution. The generation device according to claim 3, characterized in that the reception unit receives input of the first file containing information on variables used in commands called in task execution, response messages when commands are executed successfully, details of repetitive processing, details of branching processing, and parameters updated in command execution. A generation method performed by a generation device, comprising:
a receiving step of receiving an input of a first file defining information for executing configuration input for a communication device accommodating a user who uses a network, the information differing depending on the model , version, and use of the communication device;
a combining step of combining the first file with a second file that defines information for executing configuration input to the communication device and that is common to the model , version, and use of the communication device;
A generating method comprising: a receiving step of receiving an input of a first file that defines information for executing configuration input for a communication device that accommodates a user who uses a network, the information differing depending on the model , version, and use of the communication device;
a combining step of combining the first file with a second file that defines information for executing configuration input for the communication device and that is common to the model , version, and use of the communication device;
A generating program that causes a computer to execute the above.