FORM 2
THE PATENTS ACT, 1970 (39 of 1970) THE PATENTS RULES, 2003
COMPLETE SPECIFICATION
APPLICATIONS WITH SINGLE COMMAND
APPLICANT
380006, Gujarat, India; Nationality : India
The following specification particularly describes
the invention and the manner in which
it is to be performed

RESERVATION OF RIGHTS
[0001] A portion of the disclosure of this patent document contains
material, which is subject to intellectual property rights such as, but are not limited to, copyright, design, trademark, integrated circuit (IC) layout design, and/or trade dress protection, belonging to Jio Platforms Limited (JPL) or its affiliates (herein after referred as owner). The owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent files or records, but otherwise reserves all rights whatsoever. All rights to such intellectual property are fully reserved by the owner.
TECHNICAL FIELD
[0002] The present disclosure relates to a field of a wireless network, and
specifically to a system and a method for applying configuration changes to multiple applications with a single command.
DEFINITION
[0003] As used in the present disclosure, the following terms are generally
intended to have the meaning as set forth below, except to the extent that the context in which they are used to indicate otherwise.
[0004] The term ‘application IP’ as used herein, refers to an Internet
Protocol (IP) address assigned to an application instance running on a server or virtual machine. This IP address can be either an IPv4 or IPv6 address and is used to uniquely identify and communicate with the application over a network. The application IP serves as the destination for executing commands and receiving responses during the configuration process.
[0005] The term ‘API’ as used herein, refers to an Application
Programming Interface, a set of rules and protocols for building and interacting with software applications. The API defines the methods and data formats that

applications can use to communicate with each other, enabling applications to access the features or data of operating systems, libraries, or other services.
[0006] The term ‘HTTP REST API’ as used herein, refers to a specific
type of API that uses the Hypertext Transfer Protocol (HTTP) and follows the principles of Representational State Transfer (REST). The HTTP REST API allows for interaction with web services in a stateless, client-server, cacheable communications protocol. RESTful APIs typically use standard HTTP methods such as GET, POST, PUT, DELETE, and PATCH to perform operations on resources, which are represented in a structured format like JSON or XML.
BACKGROUND
[0007] The following description of related art is intended to provide
background information pertaining to the field of the disclosure. This section may include certain aspects of the art that may be related to various features of the present disclosure. However, it should be appreciated that this section be used only to enhance the understanding of the reader with respect to the present disclosure, and not as admissions of prior art.
[0008] In the field of server and application management, the process of
upgrading servers or applications typically includes several critical steps, such as backing up data, installing a new operating system, and restoring the data to its original location. These steps ensure that data integrity is maintained and upgraded system functions correctly without any data loss.
[0009] In conventional methods and systems, during multiple server
upgrades or application upgrades, a user has to login on each server or application individually, start a command line interpreter, and execute an individual command for each server or application. This process is highly manual and labour-intensive, especially in environments where there are a large number of servers or applications to be managed. For example, in a data center with hundreds of servers, an administrator may be needed to repeat the login and command

execution process hundreds of times, leading to significant time consumption and effort.
[0010] Conventional approach may increase the manual intervention
required to execute repetitive tasks for each application. As a result, there is a high probability of manual errors due to the repetitive nature of the work. For instance, the administrator may accidentally input incorrect commands or miss certain steps, leading to inconsistencies and potential failures in the upgrade process. These errors can result in application downtime, data loss, and increased troubleshooting time, all of which may have severe implications for business operations.
[0011] In a scenario where a company needs to upgrade its customer
relationship management (CRM) software across multiple servers. Using conventional methods, the IT team may need to login into each server, back up the existing data, install the new software version, and then restore the data. If the company has approximately fifty servers running the CRM software, this process would need to be repeated fifty times. The repetitive nature of this task not only increases the time required but also raises the likelihood of errors such as missed steps or incorrect commands.
[0012] Furthermore, in environments where multiple applications are
running on the same server, each application may require different upgrade commands. The administrator must keep track of these variations and ensure that the correct commands are executed for each application, adding to the complexity and potential for errors.
[0013] There is, therefore, a need in the art to improve the state of
upgrading multiple servers or applications using a single command by overcoming the deficiencies of the prior arts. The present disclosure described addresses these challenges by providing a method and system that allow for centralized command execution across multiple applications, reducing manual intervention, minimizing errors, and optimizing the overall upgrade process. This

automated approach streamlines the management of server and application upgrades, making it more efficient and reliable.
OBJECTS OF THE PRESENT DISCLOSURE
[0014] It is an object of the present disclosure to provide a system and a
method to apply configuration changes to multiple applications using a single command.
[0015] It is an object of the present disclosure to efficiently perform tasks
and retrieve information from multiple running instances of the application.
[0016] It is an object of the present disclosure to save user monitoring and
execution time, and manual intervention to execute repetitive tasks for each application.
[0017] It is an object of the present disclosure to eliminate the need for
multiple logins on each server to perform tasks, reducing manual effort, optimizing time, and facilitating application configuration changes without human errors.
[0018] It is an object of the present disclosure to display output of multiple
applications in one place which makes user to view easily and perform faster analysis.
SUMMARY
[0019] In an exemplary embodiment, a method for applying
configuration changes to a plurality of using a single command is described. The method includes reading, by an interface, a list of application Internet Protocol (IP) addresses from a configuration properties file. The method includes selecting, by a processing engine, an application IP from the list. The method includes executing, by the processing engine, an Application Programming Interface (API) command for the selected application IP. The method includes processing, by the

processing engine, the API command via the application IP. The method includes sending, by the processing engine, a response to the interface upon processing the API command.
[0020] In some embodiments, the method further includes determining if
the API command requires one or more inputs from a user, wherein upon determining the API command requires the one or more inputs, determining, by the processing engine, one of: if similar input is to be used for each applications, or if different input is to be used for each application.
[0021] In some embodiments, if similar input from the one or more inputs
is to be used for each of the applications, executing, by the processing engine, the API command with the similar input for the selected application IP; processing, by the processing engine and via the selected application IP, the API command; and sending, by the processing engine, a response to the interface upon processing the API command.
[0022] In some embodiments, wherein if different input from the one or
more inputs is to be used for each of the applications, prompting, by a user input module, the user to provide different input for each applications; executing, by the processing engine, the API command with the user provided different input for the selected application IP; processing, by the processing engine and via the selected application IP, the API command; and sending, by the processing engine, a response to the interface upon processing the API command.
[0023] In some embodiments, the method further includes iteratively
selecting an application IP from the list until each of the application IP is processed.
[0024] In some embodiments, the method further includes recording, by a
logging module, the response for a corresponding application IP.

[0025] In some embodiments, when API command requires the one or
more inputs from the user, the method includes prompting, by a user input module, the user to select an option to repeat the similar input for each application or provide different inputs for each application, wherein the user input prompt includes a default input option for each application.
[0026] In another exemplary embodiment, a system for applying
configuration changes to a plurality of applications using a single command is described. The system includes an interface configured to read a list of application Internet Protocol (IP) addresses from a configuration properties file. The system further includes a processing engine configured to select an application IP from the list, execute an Application Programming Interface (API) command for the selected application IP, process the API command by the selected application IP and send a response to the interface once the API command is processed.
[0027] In some embodiments, the processing module is configured to
determine if the API command requires one or more inputs from a user, wherein upon determining the API command requires the one or more inputs, the processing engine is further configured to determine one of: if similar input is to be used for each applications, or if different input is to be used for each application.
[0028] In some embodiments, if similar input from the one or more inputs
is to be used for each of the applications, the processing engine is configured to: execute the API command with the similar input for the selected application IP; process, via the selected application IP, the API command; and send a response to the interface upon processing the API command.
[0029] In some embodiments, if different input from the one or more
inputs is to be used for each of the applications, the processing engine is configured to: prompt, by a user input module, the user to provide different input for each applications; execute the API command with the user provided different input for the selected application IP; process via the selected application IP, the

API command; and send a response to the interface upon processing the API command.
[0030] In some embodiments, the system further includes iteratively
selecting an application IP from the list until each of the application IP is processed.
[0031] In some embodiments, the system further comprises a logging
module configured to record the response for a corresponding application IP.
[0032] In some embodiments, the configuration properties file is stored
locally or remotely accessible by the interface.
[0033] In some embodiments, the system further comprises a user input
module configured to prompt the user to select an option to repeat the similar input for each application or provide different inputs for each application, wherein the user input prompt includes a default input option for each application.
[0034] In another exemplary embodiment, a user equipment (UE)
communicatively coupled with a network, the coupling comprises steps of receiving, by the network, a connection request from the UE, sending, by the network, an acknowledgment of the connection request to the UE and transmitting a plurality of signals in response to the connection request, the plurality of signals is responsible to apply configuration changes to a plurality of applications using a single command in the network (106) performed by a method.
[0035] The foregoing general description of the illustrative embodiments
and the following detailed description thereof are merely exemplary aspects of the teachings of this disclosure and are not restrictive.
BRIEF DESCRIPTION OF THE DRAWINGS
[0036] In the figures, similar components and/or features may have the
same reference label. Further, various components of the same type may be

distinguished by following the reference label with a second label that distinguishes among the similar components. If only the first reference label is used in the specification, the description is applicable to any one of the similar components having the same first reference label irrespective of the second 5 reference label.
[0037] The diagrams are for illustration only, which thus is not a limitation
of the present disclosure, and wherein:
[0038] FIG. 1 illustrates an exemplary network architecture in which or
with which embodiments of the present disclosure may be implemented.
10 [0039] FIG. 2 illustrates an exemplary block diagram of a system for
applying configuration changes to a plurality of applications using a single command, in accordance with an embodiment of the present disclosure.
[0040] FIG. 3 illustrates an exemplary process flow for applying
configuration changes to the plurality of applications using the single command, 15 in accordance with an embodiment of the present disclosure.
[0041] FIG. 4 illustrates an exemplary architecture of the system, in
accordance with an embodiment of the present disclosure.
[0042] FIG. 5 illustrates a flowchart of a method for applying
configuration changes to the plurality of applications using the single command, 20 in accordance with an embodiment of the present disclosure
[0043] FIG. 6 illustrates an exemplary computer system in which or with
which embodiments of the present disclosure may be implemented.
LIST OF REFERENCES:
100 – Network architecture
25 102-1, 102-2…102-N: Users
9

104-1, 104-2…104-N: User equipment 106 – Network 108 – System 112 – Centralized server 5 200 – Block diagram 202 – Processor(s) 204 – Memory 206 – Interface(s) 208 – Processing engine 10 210 – Database
212– Command Line Interface 214 – Logging module 216 – User input module 218 – Other modules
15 600 – Computer System
610 – External Storage Device
620 – Bus
630 – Main Memory
640 – Read-Only Memory 20 650 – Mass Storage Device
660 – Communication Port(s)
670 – Processor

10

DETAILED DESCRIPTION
[0044] The following is a detailed description of embodiments of the
disclosure depicted in the accompanying drawings. The embodiments are in such detail as to clearly communicate the disclosure. However, the amount of detail 5 offered is not intended to limit the anticipated variations of embodiments; on the contrary, the intention is to cover all modifications, equivalents, and alternatives falling within the spirit and scope of the present disclosure as defined by the appended claims.
[0045] In the following description, for explanation, various specific
10 details are outlined in order to provide a thorough understanding of embodiments of the present disclosure. It will be apparent, however, that embodiments of the present disclosure may be practiced without these specific details. Several features described hereafter can each be used independently of one another or with any combination of other features. An individual feature may not address all of the 15 problems discussed above or might address only some of the problems discussed above. Some of the problems discussed above might not be fully addressed by any of the features described herein.
[0046] The ensuing description provides exemplary embodiments only and
is not intended to limit the scope, applicability, or configuration of the disclosure. 20 Rather, the ensuing description of the exemplary embodiments will provide those skilled in the art with an enabling description for implementing an exemplary embodiment. It should be understood that various changes may be made in the function and arrangement of elements without departing from the spirit and scope of the disclosure as set forth.
25 [0047] Specific details are given in the following description to provide a
thorough understanding of the embodiments. However, it will be understood by one of ordinary skill in the art that the embodiments may be practiced without these specific details. For example, circuits, systems, networks, processes, and other components may be shown as components in block diagram form in order
11

not to obscure the embodiments in unnecessary detail. In other instances, well-known circuits, processes, algorithms, structures, and techniques may be shown without unnecessary detail to avoid obscuring the embodiments.
[0048] Also, it is noted that individual embodiments may be described as a
5 process that is depicted as a flowchart, a flow diagram, a data flow diagram, a structure diagram, or a block diagram. Although a flowchart may describe the operations as a sequential process, many of the operations can be performed in parallel or concurrently. In addition, the order of the operations may be re¬arranged. A process is terminated when its operations are completed but could 10 have additional steps not included in a figure. A process may correspond to a method, a function, a procedure, a subroutine, a subprogram, etc. When a process corresponds to a function, its termination can correspond to a return of the function to the calling function or the main function.
[0049] The word “exemplary” and/or “demonstrative” is used herein to
15 mean serving as an example, instance, or illustration. For the avoidance of doubt, the subject matter disclosed herein is not limited by such examples. In addition, any aspect or design described herein as “exemplary” and/or “demonstrative” is not necessarily to be construed as preferred or advantageous over other aspects or designs, nor is it meant to preclude equivalent exemplary structures and 20 techniques known to those of ordinary skill in the art. Furthermore, to the extent that the terms “includes,” “has,” “contains,” and other similar words are used in either the detailed description or the claims, such terms are intended to be inclusive like the term “comprising” as an open transition word without precluding any additional or other elements.
25 [0050] Reference throughout this specification to “one embodiment” or
“an embodiment” or “an instance” or “one instance” means that a particular feature, structure, or characteristic described in connection with the embodiment is included in at least one embodiment of the present disclosure. Thus, the appearances of the phrases “in one embodiment” or “in an embodiment” in
12

various places throughout this specification are not necessarily all referring to the same embodiment. Furthermore, the particular features, structures, or characteristics may be combined in any suitable manner in one or more embodiments.
5 [0051] The terminology used herein is to describe particular embodiments
only and is not intended to be limiting the disclosure. As used herein, the singular forms “a”, “an”, and “the” are intended to include the plural forms as well, unless the context indicates otherwise. It will be further understood that the terms “comprises” and/or “comprising,” when used in this specification, specify the 10 presence of stated features, integers, steps, operations, elements, and/or components, but do not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and/or groups thereof. As used herein, the term “and/or” includes any combinations of one or more of the associated listed items.
15 [0052] The present disclosure describes a method and a system for
applying configuration changes to a plurality of applications using a single command. The plurality of applications may be multiple software applications or instances running on one or more servers or virtual machines. The multiple applications can vary in type, function, and platform, but are managed collectively
20 through the disclosed method. The plurality of applications is identified by their respective Internet Protocol (IP) addresses, which are listed in a configuration properties file. Examples of such applications may include, but is not limited to, web servers, database servers, application servers, microservices, email servers, file servers, and monitoring and logging tools.
25 [0053] The method involves reading a list of application IP addresses from
a configuration properties file via a command line interface. A processing module selects an application IP from the list, executes an API command for the selected application IP, processes the command by the application IP, and sends a response to the command line interface. The method allows for processing the API
13

command with either the same input or different input for each application based on user selection.
[0054] The present disclosure eliminates the need for multiple logins on
each server to perform tasks, thereby saving time and reducing manual effort. The 5 output is displayed in one place, making it easier and faster for users to analyze the results. Additionally, the present disclosure reduces the chances of human error during application configuration changes, enhancing reliability and efficiency.
[0055] The system for applying configuration changes includes an
10 interface (e.g., the command line interface) configured to read the list of application IP addresses from the configuration properties file. The configuration properties file can be stored locally or be remotely accessible, providing flexibility in deployment. The system further includes a processing module that manages the selection, execution, and response handling of API commands. The system also 15 includes a logging module to record responses and a user input module to prompt for user inputs when necessary.
[0056] The automation of configuration changes through the method and
system is time-saving and efficient. It streamlines the process, allowing for rapid deployment and consistent updates with minimal human intervention. The present 20 disclosure improves productivity but also ensures that application configurations are accurate and error-free.
[0057] The various embodiments of the present disclosure will be
explained in detail with reference to FIGS. 1 to 6.
[0058] FIG. 1 illustrates an exemplary network architecture (100) in which
25 or with which a system (108) for applying configuration changes to a plurality of applications is implemented, in accordance with embodiments of the present disclosure.
14

[0059] Referring to FIG. 1, the network architecture (100) includes one or
more computing devices or user equipments (104-1, 104-2…104-N) associated with one or more users (102-1, 102-2…102-N) in an environment. A person of ordinary skill in the art will understand that one or more users (102-1, 102-5 2…102-N) may be collectively referred to as the users (102). Similarly, a person of ordinary skill in the art will understand that one or more user equipments (104-1, 104-2…104-N) may be collectively referred to as the user equipment (104). A person of ordinary skill in the art will appreciate that the terms “computing device(s)” and “user equipment” may be used interchangeably throughout the 10 disclosure. Although three user equipments (104) are depicted in FIG. 1, however any number of the user equipments (104) may be included without departing from the scope of the ongoing description.
[0060] In an embodiment, the user equipment (104) includes smart devices
operating in a smart environment, for example, an Internet of Things (IoT)
15 system. In such an embodiment, the user equipment (104) may include, but is not limited to, smart phones, smart watches, smart sensors (e.g., mechanical, thermal, electrical, magnetic, etc.), networked appliances, networked peripheral devices, networked lighting system, communication devices, networked vehicle accessories, networked vehicular devices, smart accessories, tablets, smart
20 television (TV), computers, smart security system, smart home system, other devices for monitoring or interacting with or for the users (102) and/or entities, or any combination thereof. A person of ordinary skill in the art will appreciate that the user equipment (104) may include, but is not limited to, intelligent, multi-sensing, network-connected devices, that can integrate seamlessly with each other
25 and/or with a central server or a cloud-computing system or any other device that is network-connected.
[0061] In an embodiment, the user equipment (104) includes, but is not
limited to, a handheld wireless communication device (e.g., a mobile phone, a
smart phone, a phablet device, and so on), a wearable computer device(e.g., a
30 head-mounted display computer device, a head-mounted camera device, a
15

wristwatch computer device, and so on), a Global Positioning System (GPS) device, a laptop computer, a tablet computer, or another type of portable computer, a media playing device, a portable gaming system, and/or any other type of computer device with wireless communication capabilities, and the like. In 5 an embodiment, the user equipment (104) includes, but is not limited to, any electrical, electronic, electro-mechanical, or an equipment, or a combination of one or more of the above devices such as virtual reality (VR) devices, augmented reality (AR) devices, laptop, a general-purpose computer, desktop, personal digital assistant, tablet computer, mainframe computer, or any other computing
10 device, wherein the user equipment (104) may include one or more in-built or externally coupled accessories including, but not limited to, a visual aid device such as a camera, an audio aid, a microphone, a keyboard, and input devices for receiving input from the user (102), or the entity (110) such as touch pad, touch enabled screen, electronic pen, and the like. A person of ordinary skill in the art
15 will appreciate that the user equipment (104) may not be restricted to the mentioned devices and various other devices may be used.
[0062] Referring to FIG. 1, the user equipment (104) communicates with
the system (108) through a network (106). In other words, the user equipment (104) may be communicatively coupled with the network (106), the coupling
20 comprises steps of receiving, by the network (106), a connection request from the user equipment (104), sending, by the network (106), an acknowledgment of the connection request to the user equipment (104) and transmitting a plurality of signals in response to the connection request. The plurality of signals is responsible for communicating with the system (108) to apply configuration
25 changes to the plurality of applications using a single command in the network (106).
[0063] In an embodiment, the network (106) includes at least one of a
Fifth Generation (5G) network, 6G network, or the like. The network (106)
enables the user equipment (104) to communicate with other devices in the
30 network architecture (100) and/or with the system (108). The network (106)
16

includes a wireless card or some other transceiver connection to facilitate this communication. In another embodiment, the network (106) is implemented as, or include any of a variety of different communication technologies such as a wide area network (WAN), a local area network (LAN), a wireless network, a mobile 5 network, a Virtual Private Network (VPN), the Internet, the Public Switched Telephone Network (PSTN), or the like.
[0064] In another exemplary embodiment, the centralized server (112)
includes, by way of example but not limitation, one or more of: a stand-alone server, a server blade, a server rack, a bank of servers, a server farm, hardware 10 supporting a part of a cloud service or system, a home server, hardware running a virtualized server, one or more processors executing code to function as a server, one or more machines performing server-side functionality as described herein, at least a portion of any of the above, some combination thereof.
[0065] In an embodiment, the network (106) is further configured with the
15 centralized server (112) including a database, where all output is stored as part of the operational records. It can be retrieved whenever there is a need to reference this output in the future.
[0066] In an embodiment, the computing device (102) associated with one
or more users (102) may transmit the at least one captured data packet over a 20 point-to-point or point-to-multipoint communication channel or network (106) to the system (102).
[0067] In an embodiment, the computing device (102) may involve
collection, analysis, and sharing of data received from the system (108) via the communication network (106).
25 [0068] In an embodiment, the system (108) may be configured to apply
configuration changes to the plurality of applications using the single command. As will be described in greater detail in conjunction with FIG. 1 to FIG. 6, in order to apply configuration changes, the system (108) may initially read a list of
17

application IP addresses from a configuration properties file. Further, the system (108) may select an application IP from the list and execute an API command for the selected application IP. The system (108) may further process the API command via the application IP and send a response to the command line 5 interface upon processing the API command.
[0069] Although FIG. 1 shows exemplary components of the network
architecture (100), in other embodiments, the network architecture (100) may include fewer components, different components, differently arranged components, or additional functional components than depicted in FIG. 1. 10 Additionally, or alternatively, one or more components of the network architecture (100) may perform functions described as being performed by one or more other components of the network architecture (100).
[0070] FIG. 2 illustrates an exemplary block diagram (200) of the system
(108), in accordance with an embodiment of the present disclosure.
15 [0071] In an aspect, the system (108) may include one or more
processor(s) (202). The one or more processor(s) (202) may be implemented as one or more microprocessors, microcomputers, microcontrollers, edge or fog microcontrollers, digital signal processors, central processing units, logic circuitries, and/or any devices that process data based on operational instructions.
20 Among other capabilities, one or more processor(s) (202) may be configured to fetch and execute computer-readable instructions stored in a memory (204) of the system (108). The memory (204) may be configured to store one or more computer-readable instructions or routines in a non-transitory computer-readable storage medium, which may be fetched and executed to create or share data
25 packets over a network service. The memory (204) may comprise any non-transitory storage device including, for example, volatile memory such as Random-Access Memory (RAM), or non-volatile memory such as Erasable Programmable Read-Only Memory (EPROM), flash memory, and the like.
18

[0072] In an embodiment, the system (108) may include an interface(s)
(206). The interface(s) (206) may include a variety of interfaces, for example, interfaces for data input and output devices, referred to as I/O devices, storage devices, and the like. The interface(s) (206) may facilitate communication of the 5 system (108). The interface(s) (206) may also provide a communication pathway for one or more components of the system (108). Examples of such components include, but are not limited to, processing engine (208) and a database (210).
[0073] The processing engine (208) may be implemented as a combination
of hardware and programming (for example, programmable instructions) to
10 implement one or more functionalities of the processing engine (208). In examples described herein, such combinations of hardware and programming may be implemented in several different ways. For example, the programming for the processing engine (208) may be processor-executable instructions stored on a non-transitory machine-readable storage medium and the hardware for the
15 processing engine (208) may comprise a processing resource (for example, one or more processors), to execute such instructions. In the present examples, the machine-readable storage medium may store instructions that, when executed by the processing resource, implement the processing engine(s) (208). In such examples, the system (108) may comprise the machine-readable storage medium
20 storing the instructions and the processing resource to execute the instructions, or the machine-readable storage medium may be separate but accessible to the system (108) and the processing resource. In other examples, the processing engine (208) may be implemented by an electronic circuitry.
[0074] In an embodiment, the processing engine (208) may include several
25 modules or components, such as an interface (212) (e.g., a command line interface (212)), a logging module (214), a user input module (216), and other modules (218).
[0075] The command line interface (212) allows a user to input commands
and is configured to read a list of application IP addresses from a configuration
19

properties file. The configuration properties file may be a text file that stores configuration settings in a key-value pair format. The file may be designed to easily readable and editable by both humans and machines, ensuring flexibility in managing the configuration data. It may serve as a centralized repository for all 5 the necessary details required to manage the applications, including network settings, application-specific parameters, and user preferences.
[0076] The list of application IP addresses may include Internet Protocol
version 4 (IPv4) and Internet Protocol version 4 (IPv6) addresses, allowing for versatile application management across various network configurations. The
10 IPv4 are standard IP addresses used in most current networks. The IPv4 address is represented in dot-decimal notation, consisting of four decimal numbers, each ranging from 0 to 255, separated by dots (e.g., 192.168.1.1). Furthermore, the IPv6 are the newer IP addresses designed to replace IPv4 due to the limited number of IPv4 addresses. The IPv6 address is represented as eight groups of four
15 hexadecimal digits, each group separated by a colon (e.g., 2001:0db8:85a3:0000:0000:8a2e:0370:7334).
[0077] The command line interface (212) significantly reduces manual
effort by automating the process of reading and executing commands across multiple application instances. By reading a comma-separated list of IP addresses, 20 the command line interface (212) enables the system to handle a variety of network configurations efficiently. The automation is particularly useful in scenarios where multiple servers or applications require configuration updates simultaneously, eliminating the need for repeated manual logins and command executions.
25 [0078] The processing engine (208) may select an application IP from the
list provided in the configuration properties file. The list may be stored in a structured format, enabling efficient access and manipulation. The list may be represented as an array, a linked list, or any other suitable data structure that allows sequential or indexed access. In some embodiments, the application IP
20

may be selected based on certain conditions, such as, but not limited to, current status of the application, load, or availability of the application.
[0079] Once the application IP is selected, the processing engine (208)
may execute an API command. The API command may be an HTTP REST API 5 command. This API command is typically constructed based on predefined templates or dynamically generated parameters, depending on the specific configuration change or task to be performed. The API command includes essential components such as, but not limited to, setting HTTP method (specifies the type of action (e.g., GET, POST, PUT, DELETE)), endpoint URL (e.g., 10 specific endpoint of the application where the command is to be executed often including the application IP address and port), headers (such as, authentication tokens, content type, and custom headers required by the application), and request body (which contains the data or parameters needed for the command).
[0080] To further elaborate, the processing engine (208) may include an
15 API through which the API commands may be executed on the selected
application IP address. Upon receiving commands from the command line
interface (212), the processing engine (208) formulates the API commands and
sends them to the respective application via the API. The API processes these
commands within the applications and sends responses back to the command line
20 interface (212). Such automation allows for efficient configuration changes and
reduces the potential for human error. The API may handle various types of HTTP
REST API calls, making it adaptable to different application architectures and
ensuring seamless integration with existing systems. The role of the processing
engine (208) is to ensures that each application receives and processes the API
25 commands correctly and sends appropriate responses, which are then logged for
future reference.
[0081] The processing engine (208) may further process the API command
via the selected application IP. In particular, the application at the selected IP address may processes the request. The application may handle the command
21

according to its logic. This may involve updating configurations, retrieving data, executing scripts, or any other actions specified by the API command.
[0082] After processing the API command, the selected application IP
may generate the response. This response typically includes a status code (e.g., 5 200 OK, or 404 Not Found), headers, and a body with relevant data or confirmation messages. The processing engine (208) may receive this response and send the response to the command line interface (212) upon processing the API command, ensuring the results are available for user review.
[0083] The logging module (214) may record the response for the
10 respective application IP. The logging module (214) ensures that all actions and responses are logged, providing a comprehensive audit trail for future reference and troubleshooting. Logging the responses also facilitates easier and faster analysis of the output, enhancing the overall efficiency of system management. The logging module (214) may store logs locally or remotely, offering flexibility 15 in how logs are accessed and reviewed. By maintaining detailed logs of all interactions, the system ensures transparency and accountability, making it easier to identify and resolve issues that may arise during the configuration process.
[0084] In an embodiment, when the API command requires one or more
inputs from the user, the user input module (216) may prompt the user to select an
20 option to repeat the same input for each application or provide different inputs for each application. The same or different inputs may be configuration settings, values, or any other data necessary for the API commands to function. The user input module (220) may handle various types of inputs, including text, numerical values, and selections, providing a user-friendly interface for managing
25 configuration changes. By offering the option to repeat inputs or provide unique inputs for each application, the user input module (220) enhances the flexibility and usability of the system, ensuring that it may accommodate a wide range of user preferences and requirements. The user input module (220) includes a default input option for each application, which streamlines the process by reducing the
22

need for repetitive manual inputs. In many scenarios, the configuration changes (e.g., a timeout setting, or a security policy across several web servers) required for the plurality of applications may be identical or follow a common pattern. In such scenarios, the default input option allows the user to predefined standard 5 inputs that may be applied across multiple applications without having to manually enter the same data repeatedly.
[0085] The database (210) may include data that is either stored or
generated as a result of functionalities implemented by any of the components of the processor(s) (202) or the processing engine (208) or the system (108). The
10 database (210) ensures that all configuration changes and responses are stored securely, enabling efficient data retrieval and management. The database (210) can be implemented using various database management systems, including structured query language SQL and NoSQL databases, depending on the specific requirements of the system. By securely storing all configuration data and
15 responses, the database (210) provides a reliable repository for managing application configurations and tracking changes over time.
[0086] The other modules (218) in the processing engine (208) may
perform additional tasks to support the operation and management of the network functions. These could include modules for monitoring performance, managing 20 resources, handling security protocols, and ensuring compliance with regulatory standards.
[0087] Although FIG. 2 shows an exemplary block diagram (200) of the
system (108), in other embodiments, the system (108) may include fewer components, different components, differently arranged components, or additional 25 functional components than depicted in FIG. 2. Additionally, or alternatively, one or more components of the system (108) may perform functions described as being performed by one or more other components of the system (108).
[0088] FIG. 3 illustrates an exemplary process flow (300) for applying
configuration changes to multiple applications using a single command, in
23

accordance with an embodiment of the present disclosure. The single command may refer to an ability to initiate configuration changes across the plurality of applications with one unified command input. Instead of manually executing separate commands for each application, a single command may be processed the 5 processing engine to sequentially handle each application IP from the list. This single command execution may reduce manual intervention, minimizes the risk of human error, and significantly optimizes the time required for configuration management.
[0089] The process begins at step (302), where the command line interface
10 (CLI) reads a list of application IP addresses from a configuration properties file.
This list may include both IPv4 and IPv6 addresses, allowing for versatile
application management across various network configurations. The configuration
properties file contains the necessary IP addresses of the applications that may
undergo configuration changes. The configuration changes may include, but is not
15 limited to, updating the timeout settings for application requests, enabling, or
disabling certain security protocols like TLS/SSL, adjusting a memory or CPU
resources allocated to the application, changing the logging level, enabling, or
disabling specific features within the application, and updating network-related
settings such as IP addresses, port numbers, or firewall rules. By centralizing the
20 list in the configuration file, the system may manage multiple application
instances efficiently.
[0090] At step (304), the process may select an application IP from the
list. This selection process continues iteratively until all application IPs in the list have been processed. This ensures that each application instance receives the 25 necessary configuration changes without manual intervention.
[0091] The process flow then moves to step (306) to determine if the
command requires user input. This step is crucial as some commands may necessitate user interaction for parameter values or specific inputs that vary across applications.
24

[0092] When no user input is required, at step (308), the application
processes the command and sends the response back to the CLI. The CLI then prints the response with the respective application IP, at step (310). This step ensures that all responses are logged and associated with their respective 5 application IPs, allowing for easy tracking and analysis.
[0093] For commands requiring user input, the process reaches step (312),
where the user decides whether to apply the same input or provide different inputs for each applications. Same input refers to using identical parameters or values for all applications when executing the API commands. This ensures uniform 10 configuration changes across all targeted applications. Examples of same input may include, but is not limited to, same timeout value for all applications, same logging level applied to all applications, and same security settings for all applications.
[0094] On the other hand, different input refer to using unique parameters
15 or values for each application when executing the API commands. This allows for customized configuration changes tailored to each application's specific needs. Examples of different input may include, but is not limited to, different timeout values for different applications, different logging levels for different applications, enabling a feature in one application but disabling it in another, and different 20 database connection strings for different applications.
[0095] If the user opts for the same input for all applications, the process
proceeds to step (314). Here, the application processes the command with the same input and sends the response back to the CLI, which then prints the response with the respective application IP at step (320).
25 [0096] If different inputs are required for each application, the process
moves to step (316). Here, the system prompts the user to provide unique inputs for each application. Each input is then processed by the respective application at step (318), which sends the response back to the CLI. The CLI prints the response with the respective application IP, similar to the previous steps.
25

[0097] Once an application IP has been processed (at steps 310, 320, or
318), the process loops back to step (304) to select next application IP from the list. This iterative loop continues until all application IPs have been processed, ensuring comprehensive configuration changes across all specified applications.
5 [0098] Additionally, the process includes retrying the command execution
for application IP that failed to respond by the processing engine (208). This ensures that all applications are correctly configured, even if initial attempts fail.
[0099] The process allows a specified waiting time for processing the next
available IPs to be configurable by the user. This flexibility enhances the 10 efficiency of the method by accommodating different network speeds and application response times.
[00100] FIG. 4 illustrates an exemplary architecture (400) of the system
(108), in accordance with an embodiment of the present disclosure. The exemplary architecture (400) represents a command line interpreter (402) (also 15 refer to as the command line interface 212) that is configured to manage multiple application processes (e.g., application process 1, application process 2, application process 3, application process 4, and application process 5).
[00101] The command line interpreter (402) is responsible for reading the
list of application IP addresses from a configuration properties file and executing 20 commands across multiple application instances. A command or configuration change is input into the command line interpreter (402), which is then prepared to be distributed to the respective application processes.
[00102] For example, the command line interpreter (402) sends the
command to the application process 1 (404). The application process 1 (404) 25 executes the command and sends the output back to the command line interpreter (402).
26

[00103] Similarly, the command line interpreter (402) sends a command to
the application process 2 (404). The application process 2 (404) executes the command and sends the output back to the command line interpreter (402).
[00104] Further, the command line interpreter (402) sends a command to
5 the application process 3 (406). The application process 3 (406) executes the command and sends the output back to the command line interpreter (402).
[00105] Further, the command line interpreter (402) sends a command to
the application process 4 (408). The application process 4 (408) executes the command and sends the output back to the command line interpreter (402).
10 [00106] Additionally, the command line interpreter (402) sends a command
to the application process 5 (410). The application process 5 (410) executes the command and sends the output back to the command line interpreter (402).
[00107] The command line interpreter (402) collects these outputs into a
centralized output component (414), which holds responses from all the 15 application processes. The collected outputs are then made available for logging with respect to each application IP. The outputs are consolidated to provide a comprehensive view of the results, enabling easier and faster analysis.
[00108] The system renders efficient and automated configuration changes
across multiple applications, reducing the need for manual intervention and 20 minimizing the risk of human error. Each application processes the command independently, and the command line interpreter (402) collects and logs the responses for future reference and troubleshooting. This approach enhances the overall efficiency and reliability of the management process.
[00109] FIG. 5 illustrates an exemplary flowchart (500) implementing a
25 method for applying configuration changes to multiple applications using a single
command, in accordance with an embodiment of the present disclosure. The
configuration changes may include, but is not limited to, parameter adjustments,
27

security settings, resource allocations, logging levels, feature toggles, network configurations, database connections, service endpoints, user access controls, or environment variables.
[00110] At step (502), the method (500) includes reading, by an interface, a
5 list of application IP addresses from a configuration properties file. The interface may be a command line interface (212) that may allow a user to input commands. This list may include both IPv4 and IPv6 addresses, allowing for versatile application management across various network configurations.
[00111] At step (504), the method (500) includes selecting, by a processing
10 engine, an application IP from the list. This selection process continues until all application IPs are processed. In other words, the method (500) includes iteratively selecting the application IP from the list until each of the application IP is processed
[00112] At step (506), the method (500) includes executing, by the
15 processing engine, an API command for the selected application IP.
[00113] At step (508), the method (500) includes processing, by the
processing engine, the API command via the selected application IP. In some embodiments, the method (500) includes determining if the API command requires one or more inputs from a user. Upon determining the API command 20 requires the one or more inputs, the method (500) includes determining, by the processing engine (208), one of: if similar input is to be used for each applications, or if different input is to be used for each application.
[00114] In some embodiments, if similar input from the one or more inputs
is to be used for each of the applications, the method (500) includes executing, by 25 the processing engine (208), the API command with the similar input for the selected application IP; processing, by the processing engine (208) and via the selected application IP, the API command; and sending, by the processing engine (208), a response to the interface (212) upon processing the API command.
28

[00115] In some embodiments, if different input from the one or more
inputs is to be used for each of the applications, the method (500) includes prompting, by a user input module (220), the user to provide different input for each applications; executing, by the processing engine (208), the API command 5 with the user provided different input for the selected application IP; processing, by the processing engine (208) and via the selected application IP, the API command; and sending, by the processing engine (208), a response to the interface (212) upon processing the API command.
[00116] At step (510), the method (500) includes and sending, by the
10 processing engine, a response to the interface. The response may include a status code (e.g., 200 OK, 404 Not Found), headers, and a body containing relevant data or confirmation messages. The response may also include error messages, warnings, or detailed output data depending on the nature of the API command executed. The response is used to verify the successful execution of the command 15 and to gather necessary information for further processing or logging.
[00117] In some embodiments, the method (500) includes recording, by a
logging module (214), the response for a corresponding application IP.
[00118] The method described ensures efficient and automated
configuration changes across multiple applications, reducing the need for manual 20 intervention and minimizing the risk of human error. Each application processes the command independently, and the command line interface collects and logs the responses for future reference and troubleshooting.
[00119] FIG. 6 illustrates an exemplary computer system (600) in which or
with which embodiments of the present disclosure may be implemented. As 25 shown in FIG. 6, the computer system (600) may include an external storage device (610), a bus (620), a main memory (630), a read only memory (640), a mass storage device (650), a communication port (660), and a processor (670). A person skilled in the art will appreciate that the computer system (500) may include more than one processor (670) and communication ports (660). Processor
29

(670) may include various modules associated with embodiments of the present disclosure.
[00120] In an embodiment, the communication port (660) may be any of an
RS-232 port for use with a modem-based dialup connection, a 10/100 Ethernet 5 port, a Gigabit or 10 Gigabit port using copper or fiber, a serial port, a parallel port, or other existing or future ports. The communication port (660) may be chosen depending on a network, such a Local Area Network (LAN), Wide Area Network (WAN), or any network to which the computer system (500) connects.
[00121] In an embodiment, the memory (630) may be Random Access
10 Memory (RAM), or any other dynamic storage device commonly known in the art. Read-only memory (640) may be any static storage device(s) e.g., but not limited to, a Programmable Read Only Memory (PROM) chips for storing static information e.g., start-up or Basic Input/Output System (BIOS) instructions for the processor (670).
15 [00122] In an embodiment, the mass storage (650) may be any current or
future mass storage solution, which may be used to store information and/or instructions. Exemplary mass storage solutions include, but are not limited to, Parallel Advanced Technology Attachment (PATA) or Serial Advanced Technology Attachment (SATA) hard disk drives or solid-state drives (internal or
20 external, e.g., having Universal Serial Bus (USB) and/or Firewire interfaces), one or more optical discs, Redundant Array of Independent Disks (RAID) storage, e.g., an array of disks (e.g., SATA arrays).
[00123] In an embodiment, the bus (620) communicatively couples the
processor(s) (670) with the other memory, storage, and communication blocks. 25 The bus (620) may be, e.g., a Peripheral Component Interconnect (PCI)/PCI Extended (PCI-X) bus, Small Computer System Interface (SCSI), Universal Serial Bus (USB) or the like, for connecting expansion cards, drives and other subsystems as well as other buses, such a front side bus (FSB), which connects the processor (670) to the computer system (500).
30

[00124] Optionally, operator and administrative interfaces, e.g., a display,
keyboard, joystick, and a cursor control device, may also be coupled to the bus (620) to support direct operator interaction with the computer system (500). Other operator and administrative interfaces may be provided through network 5 connections connected through the communication port (660). Components described above are meant only to exemplify various possibilities. In no way should the aforementioned exemplary computer system (500) limit the scope of the present disclosure.
[00125] The present disclosure provides a technical advancement related to
10 the field of application configuration management. This advancement addresses
the limitations of existing solutions by enabling the application of configuration
changes to multiple applications using a single command. The disclosure involves
a method for centralized command execution across the plurality of application IP
addresses, which offers significant improvements in efficiency, accuracy, and
15 time optimization. By implementing the command line interface that reads IP
addresses from a configuration file, and the processing engine that selects an
application IP, executes an API command, processes the command, and sends a
response back to the command line interface, the present disclosure enhances the
management of application configurations, resulting in reduced manual effort, and
20 human error.
[00126] While the foregoing describes various embodiments of the present
disclosure, other and further embodiments of the present disclosure may be devised without departing from the basic scope thereof. The scope of the present disclosure is determined by the claims that follow. The present disclosure is not 25 limited to the described embodiments, versions, or examples, which are included to enable a person having ordinary skill in the art to make and use the present disclosure when combined with information and knowledge available to the person having ordinary skill in the art.
ADVANTAGES OF THE PRESENT DISCLOSURE
31

[00127] The present disclosure provides a system and a method to apply
configuration changes to multiple applications using the single command.
[00128] The present disclosure efficiently performs tasks and retrieve
information from multiple running instances of the applications.
5 [00129] The present disclosure saves user monitoring and execution time,
and manual intervention to execute repetitive tasks for each application.
[00130] The present disclosure displays output of multiple applications in
one place which makes user to view easily and perform faster analysis.
[00131] The present disclosure avoids multiple logins on each server to
10 perform the tasks.
[00132] The present disclosure performs application configuration changes
easily without the human errors.
32

We Claim:
1. A method (500) for applying configuration changes to a plurality of
applications using a single command, the method (500) comprising:
reading (502), by an interface (212), a list of application Internet Protocol (IP) addresses from a configuration properties file;
selecting (504), by a processing engine (208), an application IP from the list;
executing (506), by the processing engine (208), an Application Programming Interface (API) command for the selected application IP;
processing (508), by the processing engine (208), the API command via the selected application IP; and
sending (510), by the processing engine (208), a response to the interface (212) upon processing the API command.
2. The method (500) as claimed in claim 1, further comprising determining if the
API command requires one or more inputs from a user, wherein upon determining
the API command requires the one or more inputs,
determining, by the processing engine (208), one of:
if similar input is to be used for each application, or if different input is to be used for each application.
3. The method (500) as claimed in claim 2, wherein if similar input from the one
or more inputs is to be used for each of the applications,
executing, by the processing engine (208), the API command with the similar input for the selected application IP;
processing, by the processing engine (208) and via the selected application IP, the API command; and

sending, by the processing engine (208), a response to the interface (212) upon processing the API command.
4. The method (500) as claimed in claim 2, wherein if different input from the one
or more inputs is to be used for each of the applications,
prompting, by a user input module (220), the user to provide different input for each application;
executing, by the processing engine (208), the API command with the user provided different input for the selected application IP;
processing, by the processing engine (208) and via the selected application IP, the API command; and
sending, by the processing engine (208), a response to the interface (212) upon processing the API command.
5. The method (500) as claimed in claim 1, further comprising iteratively selecting the application IP from the list until each of the application IP is processed.
6. The method (500) as claimed in claim 1, further comprising recording, by a logging module (214), the response for a corresponding application IP.
7. The method (500) as claimed in claim 1, wherein when the API command requires the one or more inputs from the user, prompting, by the user input module (216), the user to select an option to repeat the similar input for each application or provide the different input for each application, and wherein the user prompt comprises a default input option for each of the application.
8. A system (108) for applying configuration changes to a plurality of applications using a single command, the system (108) comprising:
an interface (212) configured to read a list of application Internet Protocol (IP) addresses from a configuration properties file; a processing engine (208) configured to:

select an application IP from the list;
execute an Application Programming Interface (API) command for the selected application IP;
process the API command by the selected application IP; and
send a response to the interface (212) once the API command is processed.
9. The system (108) as claimed in claim 8, wherein the processing engine (208) is
configured to determine if the API command requires one or more inputs from a
user, wherein upon determining the API command requires the one or more
inputs,
the processing engine (208) is further configured to determine one of: if similar input is to be used for each application, or if different input is to be used for each application.
10. The system (108) as claimed in claim 9, wherein if similar input from the one
or more inputs is to be used for each of the applications, the processing engine
(208) is configured to:
execute the API command with the similar input for the selected application IP;
process, via the selected application IP, the API command; and
send a response to the interface (212) upon processing the API command.
11. The system (108) as claimed in claim 9, wherein if different input from the
one or more inputs is to be used for each of the applications, the processing engine
(208) is configured to:
prompt, by a user input module (220), the user to provide different input for each applications;
execute the API command with the user provided different input for the selected application IP;
process, via the selected application IP, the API command; and

send a response to the interface (212) upon processing the API command.
12. The system (108) as claimed in claim 8, wherein the processing engine (208) is configured to iteratively select the application IP from the list until each of the application IP is processed.
13. The system (108) as claimed in claim 8, further comprising a logging module (214) configured to record the response for a corresponding application IP.
14. The system (108) as claimed in claim 8, wherein the configuration properties file is stored locally or remotely accessible by the interface (212).
15. The system (108) as claimed in claim 8, further comprising a user input module (216) configured to prompt the user to select an option to repeat the similar input for each application or provide different input for each application, wherein the user input prompt comprises a default input option for each application.
16. A user equipment (UE) (104) communicatively coupled with a network (106), the coupling comprises steps of:
receiving, by the network (106), a connection request from the UE (104);
sending, by the network (106), an acknowledgment of the connection request to the UE (104); and
transmitting a plurality of signals in response to the connection request, wherein the plurality of signals is responsible to apply configuration changes to a plurality of applications using a single command in the network (106) performed by a method (500) as claimed in claim 1.