DETAILED ACTION
Notice of Pre-AIA or AIA Status
The present application, filed on or after March 16, 2013, is being examined under the first inventor to file provisions of the AIA .
Claims 1-5, 7-17 and 19 are pending in this office action.
Claims 6 and 18 is cancelled.
Claims 1, 3, 16 and 19 are amended.
Claim 20 is withdrawn from consideration due to restriction election.
Response to Arguments
Applicant's arguments filed 10/23/2025 have been fully considered but they are not persuasive.
Applicant’s argument:
However, while a container of Mathew runs on an operating system of a container computer system instance (see Matthew at paragraph [0033]), Matthew does not describe or suggest that “software resources on [a] variant of the build environment [provided at the second server node based on booting the second server node from a bootable image] run on a first operating system” that is different from “a second operating system,” on which the second server node runs, as claimed. In other words, while Mathew ’s containers may be scheduled to run by a scheduler service that is independent of the underlying operating system of the container instance (see id. at paragraph [0035]), the containers run on the operating system of the container instance where the container is provided and not “on a first operating system ... different from” a second operating system of the second server node, as claimed
Examiner response:
The issue in the argument is that, art of record fail to disclose different OS for respective nodes in order to build the software.
Mathew discloses, based on a bootable image , different build environment are disclosed in different container, where the containers each has a corresponding operating system:
[0033] “ When the container is run (or executed), the running program (i.e., the process) is isolated from other processes running in the same computer system instance. Thus, containers may each run on an operating system (e.g., using memory, CPU, and storage allocated by the operating system) of the container instance and execute in isolation from each other (e.g., each container may have an isolated view of the file system of the operating system).”;
Furthermore, Parees discloses that different nodes has different operating system and different build environment as disclosed in fig. 2: and [0037]-[0038]:
PNG
media_image1.png
657
906
media_image1.png
Greyscale
[0037]”In one implementation, each node 232a-c is implemented as a VM and has an operating system 234a-c that can execute applications 235a-c using the repository 233 that is resident on the node 232a”;
[0038] “n an implementation, one build container 250 may be used for multiple nodes of the PaaS system. In an alternative embodiment, respective build containers may run all nodes or on a subset of the nodes of the PaaS system.”;
Claim Rejections - 35 USC § 103
In the event the determination of the status of the application as subject to AIA 35 U.S.C. 102 and 103 (or as subject to pre-AIA 35 U.S.C. 102 and 103) is incorrect, any correction of the statutory basis (i.e., changing from AIA to pre-AIA ) for the rejection will not be considered a new ground of rejection if the prior art relied upon, and the rationale supporting the rejection, would be the same under either status.
The following is a quotation of 35 U.S.C. 103 which forms the basis for all obviousness rejections set forth in this Office action:
A patent for a claimed invention may not be obtained, notwithstanding that the claimed invention is not identically disclosed as set forth in section 102, if the differences between the claimed invention and the prior art are such that the claimed invention as a whole would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to which the claimed invention pertains. Patentability shall not be negated by the manner in which the invention was made.
Claims 1-5, 7-17 and 19 are rejected under 35 U.S.C. 103 as being unpatentable Mathew et al US20190187982A1 in view of Parees et al US20170249141A1.
As per claim 1, Mathew discloses a computer-implemented method, the method comprising:
receiving, from a first server node and at a second server node, instructions to boot the second server node :
[0021]”So, using the example of a software build task with two compiler versions, the software build management service sends a command to each of the containers to enter the “bootstrap” state, where each of the containers starts up, establishes network interfaces, establishes communications with other resources such as, for example, a source code repository, and performs other such startup procedures.
[0064] “In the example illustrated in FIG. 7, a container management service 702 may retrieve 704 a container image 722 from an image repository 706 in response to a software build management service as described above. A container image 722 is an image of a container that may be used to instantiate the container. A container image 722 contains the software and data needed to operate the container. So, for example, a container image 722 may contain an operating system for the container, drivers for the container to interface with the container instance, software that can be executed, data, and one or more scripts that, when executed, cause the container to perform actions associated with the task”;
.
to provide a variant of a build environment for executing a build process on a source code on the second server node :
[0051] “In the example illustrated in FIG. 4, the software build task description 402 has two build environments. The first build environment 406 (e.g., the “jdk8” environment) is the basis for a first container. The software build management service may provision 410 the container based on the first build environment 406 to generate the first provisioned container 412 that may then be instantiated 414 on the instance 416, as described above. Similarly, the second build environment 408 (e.g., the “jdk7” environment) is the basis for the second container.”
wherein the variant of the build environment includes software resources for executing the build process on the source code:
[0019]” In the example described above, the task is to build the software for the two different environments. Thus, one container can be instantiated for each build environment, with the software specified for each environment (i.e., one container would have one version of the compiler and another container would have the other version of the compiler).”
wherein the software resources on the variant of the build environment run on a first operating system, wherein the second server node runs on a second operating system different from the first operating system:
[0033] “ When the container is run (or executed), the running program (i.e., the process) is isolated from other processes running in the same computer system instance. Thus, containers may each run on an operating system (e.g., using memory, CPU, and storage allocated by the operating system) of the container instance and execute in isolation from each other (e.g., each container may have an isolated view of the file system of the operating system).”;
[0050]“the software build management service may next begin 314 the software builds for the containers by issuing build commands and monitoring 316 the build state for the software build task, as described herein.”;
wherein the first operating system for executing the software resources on the variant of the build environment on the second server node is provided from a bootable image instantiated at the first server node,
[0064] “A container image 722 is an image of a container that may be used to instantiate the container. A container image 722 contains the software and data needed to operate the container. So, for example, a container image 722 may contain an operating system for the container, drivers for the container to interface with the container instance, software that can be executed, data, and one or more scripts that, when executed, cause the container to perform actions associated with the task”;
and hardware resources for executing the build process on the source code at the variant of the build environment are provided by the second server node;
[0029]“The computing resources configured to process software build task descriptions and provide and manage container instances where the software build tasks and the associated containers can be executed may include virtual systems that are implemented on shared hardware hosted by, for example, a computing resource service provider”;
[0032] “ In some examples, a “container instance” (or, more simply, an “instance”) may refer to a computer system instance (virtual or non-virtual, such as a physical computer system running an operating system) that is configured to launch and run software containers. Thus, the container instance may be configured to run tasks in containers in accordance with the software build task description provided by the customer one or more container instances may comprise an isolated cluster or group of containers.”;
booting the second server node from the bootable image at the first server node to provide the variant of the build environment to execute the build process
[0021] So, using the example of a software build task with two compiler versions, the software build management service sends a command to each of the containers to enter the “bootstrap” state, where each of the containers starts up, establishes network interfaces, establishes communications with other resources such as, for example, a source code repository, and performs other such startup procedures.
[0050]”if the software build management service does not determine 312 that there are more environments to provision and instantiate containers for, the software build management service may next begin 314 the software builds for the containers by issuing build commands and monitoring 316 the build state for the software build task, as described herein.
executing, at the second server node, the build process on the source code within the build environment so that build artifacts as a result of the build process are only stored within the build environment as booted on the second server node:
[0060]“In an embodiment, the software build management service includes a final status of the software build such as, for example, failed, succeeded, timed out, or cancelled with the report. In another embodiment, the final status includes a location of the one or more build artifacts of the software build, as described above. When the agent receives the notification to finalize the build, the agent may do so by, for example, uploading 526 any build data and logs to a repository.’;
and responsive to determining that the build process is complete, deleting, at the second server node, the build environment on the second server node.
[0067] “The software build management service may then wait 812 for completion of the build state on each container (i.e., may wait for all to complete the operations associated with the build state), may report 814 the build progress as described above, and upon completion 816 of all build states, may finalize the build and, in some embodiments, terminate the containers by sending a terminate command to the containers”;
But not explicitly:
obtaining, at the second server node, the source code for executing the build process;
Parees discloses:
obtaining, at the second server node, the source code for executing the build process;
[0023] “The BC 150 includes user-provided source code for an application. The source code may be injected in a base image providing a structure and/or core functionality for the application (e.g., base framework used by the application) in order to assemble an application image instance (i.e., base image+source code) for running the application on the PaaS system.
Parees also discloses:
Different nodes each including different operating system :
[0037] “In one implementation, each node 232a-c is implemented as a VM and has an operating system 234a-c that can execute applications 235a-c using the repository 233 that is resident on the node 232a”;
and different build environment:
[0038] “n an implementation, one build container 250 may be used for multiple nodes of the PaaS system. In an alternative embodiment, respective build containers may run all nodes or on a subset of the nodes of the PaaS system.”;
Running in different operating system:
[0037]“In one implementation, each node 232a-c is implemented as a VM and has an operating system 234a-c that can execute applications 235a-c using the repository 233 that is resident on the node 232a…”
[0038] “A node 232a may include a build container 250 which includes modification logic 258”.
It would have obvious to one having ordinary skill in the art before the effective filling date of the claimed invention to combine the teachings of cited references. One of ordinary skill in the art before the effective filling date of the claimed invention would have been motivated to incorporate the teachings of Parees into teachings of Mathew to facilitate deployment of applications without the cost and complexity of buying and
managing the underlying hardware and software and provisioning hosting capabilities, providing the facilities to support the complete life cycle of building and delivering web applications and services entirely available from the Internet. Typically, these facilities operate as VMs running on top of a hypervisor in a host server.[Parees 0027].
As per claim 2, the rejection of claim 1 is incorporated and furthermore Mathew discloses:
wherein the second server node is maintained unaffected by the build artifacts generated within the build environment during the build process:
[0067] “The software build management service may then wait 812 for completion of the build state on each container (i.e., may wait for all to complete the operations associated with the build state), may report 814 the build progress as described above, and upon completion 816 of all build states, may finalize the build and, in some embodiments, terminate the containers by sending a terminate command to the containers”;
As per claim 3, the rejection of claim 1 is incorporated and furthermore Mathew discloses:
wherein the variant of the build environment is a first variant of the build environment, wherein the build process is a first build process, wherein the instructions to boot the second server node are first instructions
[0048] The software build management service may then select 306 the first build environment from the software build task description. For example, the first build environment can specify a compiler, a compiler version, a language, libraries to include in the software build, data, unit tests, integration tests, regression tests, or other such build environment parameters. The software build management service may then, based at least in part on the software build environment of the selected build environment (i.e., the first build environment), provision 308 a container for the build environment, as described above.
[0049] Once the container is provisioned to perform the software build for the environment, the software build management service may then instantiate 310 the container on the assigned instance and may next determine 312 whether there are more environments to provision and instantiate containers for.
[0050] “ the software build management service may next begin 314 the software builds for the containers by issuing build commands and monitoring 316 the build state for the software build task, as described herein.”;
and wherein the method further comprises:
[0049]”If the software build management service does determine 312 that there are more environments to provision and instantiate containers for, the software build management service may select 306 the next environment and provision 308 and instantiate 310 containers for that next build environment.
receiving, at the second server node from the first server node, second instructions to boot a second variant of the build environment at the second server node based on a disk image instantiated at the first server node, wherein the second variant of the build environment is for executing a second build process;
[0051]”FIG. 4 illustrates an example environment 400 where containers are provisioned for multi-container software builds using a software build management service, as described in connection with FIG. 1, and in accordance with an embodiment. In the example environment 400 illustrated in FIG. 4, a software build task description 402 is received and the software build task description is analyzed 404 by, for example, a software build management service as described herein. In the example illustrated in FIG. 4, the software build task description 402 has two build environments. The first build environment 406 (e.g., the “jdk8” environment) is the basis for a first container.”
wherein the disk image includes software resources for executing the second build process; obtaining source code for executing the second build process, booting the build environment from the second variant of to execute the second build process:
[0051]”The software build management service may provision 410 the container based on the first build environment 406 to generate the first provisioned container 412 that may then be instantiated 414 on the instance 416, as described above. Similarly, the second build environment 408 (e.g., the “jdk7” environment) is the basis for the second container”;
[0051]” Accordingly, the software build management service may next provision 418 the container based on the second build environment 408 to generate the second provisioned container 420 that may then be instantiated 422 on the instance 416, also as described above. It should be noted that while the example illustrated in FIG. 4 shows two build environments and two provisioned containers, any number of build environments and provisioned containers may be considered as within the scope of the present disclosure. It should also be noted that, while the example illustrated in FIG. 4 shows one container for each environment”;
executing the second build process within the second variant of the build environment;
[0054]” In an embodiment, the container build management service does not separately notify 504 the agent of the beginning of the build state and, instead, the agent (also referred to herein as a “build agent”) receives such notification using a different method. For example, the agent may monitor communications in and out of the instance and may determine, based on the command sent by the software build management service, that the build state has begun.”;
determining that the second build process is complete; and responsive to determining that the second build process is complete, deleting the second build environment such that a subsequent build process to the second build process is unaffected by build artifacts generated within the second build environment.
[0067] “The software build management service may then wait 812 for completion of the build state on each container (i.e., may wait for all to complete the operations associated with the build state), may report 814 the build progress as described above, and upon completion 816 of all build states, may finalize the build and, in some embodiments, terminate the containers by sending a terminate command to the containers”;
As per claim 4, the rejection of claim 1 is incorporated and furthermore Mathew discloses:
wherein the variant of the build environment is instantiated at the first server node from one of a plurality of build environments stored in a repository associated with the first server node:
[0064] “ In the example illustrated in FIG. 7, a container management service 702 may retrieve 704 a container image 722 from an image repository 706 in response to a software build management service as described above. A container image 722 is an image of a container that may be used to instantiate the container”;
As per claim 5, the rejection of claim 1 is incorporated and furthermore Mathew discloses:
wherein the first server node includes an application programming interface for receiving and processing requests in relation to execution of build processes over hardware resources provided by server nodes using instantiated variants of build environments at the first server node:
Fig. 2 and [0042] “ For example, the computing resource service provider 210 may provide a variety of services to users including, but not limited to, the user 202. The users may communicate with the computing resource service provider 210 via an interface such as a web services interface or any other type of interface. While the example environment illustrated in FIG. 2 shows a single connection or interface to the computing resource service provider 210, each of the services operating in an environment therein may have its own interface and, generally, subsets of the services may have corresponding interfaces in addition to or as an alternative to the single interface.
As per claim 7, the rejection of claim 1 is incorporated and furthermore Mathew discloses:
wherein the second server node comprises one of: a mobile device or a portable computing device:
[0068] “The environment includes an electronic client device 902, which can include any appropriate device operable to send and/or receive requests, messages, or information over an appropriate network 904 and, in some embodiments, convey information back to a user of the device. Examples of such client devices include personal computers, cell phones, handheld messaging devices, laptop computers, tablet computers, set-top boxes, personal data assistants, embedded computer systems, electronic book readers, and the like.”;
As per claim 8, the rejection of claim 1 is incorporated and furthermore Mathew discloses:
wherein receiving the instructions to boot the second server node comprises initiating a virtual environment configured to execute multiple build processes in parallel:
[0034] “The resource allocation for the containers may be specified in the software build task description 102. Multiple containers may run simultaneously on a single host computer or host container instance, and the resources of the host can be allocated efficiently between the containers using this system.’;
As per claim 9, the rejection of claim 8 is incorporated and furthermore Mathew discloses:
wherein the virtual environment comprises a hypervisor that supports a virtual machine for executing the build process corresponding to the source code:
[0074] “These devices also can include virtual devices such as virtual machines, hypervisors, and other virtual devices capable of communicating via a network”;
[0043]”In an example of a type of service operating within the environment of the computing resource service provider 210, a virtual computer system service may be a collection of computing resources configured to instantiate virtual machine instances on behalf of a customer such as the user 202.”;
As per claim 10, the rejection of claim 8 is incorporated and furthermore Mathew discloses:
wherein the virtual environment is configured to execute multiple build processes on the second server node:
[0061] “ An instance 602 may have three containers 604 instantiated on the instance with a build agent 606. The three containers 604 instantiated on the instance, which are associated with one or more environments, are used to build one or more versions of a software object according to a software build task description, as described herein”;
[0067] “Next, the software build management service may start 810 a software build on each container as described above by sending build commands to the containers”;
As per claim 11, the rejection of claim 1 is incorporated and furthermore Mathew discloses:
selecting the second server node from a pool of server nodes, wherein the second server node is compatible with the operating system and the software resources for starting the operating system and for executing the build process:
[0033]“Thus, containers may each run on an operating system (e.g., using memory, CPU, and storage allocated by the operating system) of the container instance and execute in isolation from each other (e.g., each container may have an isolated view of the file system of the operating system). Each of the containers may have its own namespace, and applications running within the containers are isolated by only having access to resources available within the container namespace.”;
[0049] “Once the container is provisioned to perform the software build for the environment, the software build management service may then instantiate 310 the container on the assigned instance and may next determine 312 whether there are more environments to provision and instantiate containers for.”;
As per claim 12, the rejection of claim 1 is incorporated and furthermore Mathew discloses:
executing one or more tests on a result of the build process:
[0048] “For example, the first build environment can specify a compiler, a compiler version, a language, libraries to include in the software build, data, unit tests, integration tests, regression tests, or other such build environment parameters.”;
[0055] “The agent may also monitor one or more resources associated with the container to determine 510 whether the build state has completed. The agent may also monitor a timer to determine 510 whether the build state has timed out (i.e., that a set time for the build state has been exceeded). This timeout constitutes a form of completion for the build state. That is, whether the build state succeeds, fails, times out, or is cancelled (for example, by a customer or by the software build management service), the agent can use this success, failure, timeout, or cancellation to determine 510 that the build state has completed.
As per claim 13, the rejection of claim 1 is incorporated and furthermore Mathew discloses:
in response to booting the second server node from the bootable image, downloading one or more resources for executing the build process, wherein downloading the one or more resources comprises: receiving configuration information identifying resources associated with the build process, the configuration information identifying one or more sources corresponding to the one or more resources; and downloading the one or more resources from the corresponding sources.:
[0048] “For example, the first build environment can specify a compiler, a compiler version, a language, libraries to include in the software build, data, unit tests, integration tests, regression tests, or other such build environment parameters. The software build management service may then, based at least in part on the software build environment of the selected build environment (i.e., the first build environment), provision 308 a container for the build environment, as described above. Using the example build environment “jdk8” illustrated and described above, the software build management service may provision 308 a container with libraries and a compiler that can be used to build the “HelloWorld.class” file from the “HelloWorld.java” file, for JDK8. Once the container is provisioned to perform the software build for the environment, the software build management service may then instantiate 310 the container on the assigned instance”;
As per claim 14, the rejection of claim 1 is incorporated and furthermore Mathew discloses:
in response to determining that the build process is complete, resetting the second server node such that the second server node is available to receive instructions to boot from a different variant of a build environment instantiated at the first server node.:
[0061] " The three containers 604 instantiated on the instance, which are associated with one or more environments, are used to build one or more versions of a software object according to a software build task description, as described herein. After those three containers 604 have completed their builds, two containers 610 may be instantiated on the instance 608 (which, in this example, is the same as the instance 602) with a build agent 612.";
[0067]" The software build management service may then wait 812 for completion of the build state on each container (i.e., may wait for all to complete the operations associated with the build state), may report 814 the build progress as described above, and upon completion 816 of all build states, may finalize the build and, in some embodiments, terminate the containers by sending a terminate command to the containers.
As per claim 15, the rejection of claim 14 is incorporated and furthermore Mathew discloses:
wherein resetting the second server node comprises deleting one or more software resources generated at the second server node during execution of the build process:
[0067]" The software build management service may then wait 812 for completion of the build state on each container (i.e., may wait for all to complete the operations associated with the build state), may report 814 the build progress as described above, and upon completion 816 of all build states, may finalize the build and, in some embodiments, terminate the containers by sending a terminate command to the containers”.
Claims 16, 17 are the system claims corresponding to method claims 1, 2, and rejected under the same rational set forth in connection with the rejection of claims 1, 2, above.
Claim 19 is the non-transitory, computer-readable medium claim corresponding to method claim 1 and rejected under the same rational set forth in connection with the rejection of claim 1 above.
Pertinent arts:
US20160147529A1:
providing the facilities to support the complete life cycle of building and delivering web application and service entirely available from the Internet.
US20160182315A1:
provide the requirements and preferences for the new or updated software build that is to be placed in the cloud computing environment.
Conclusion
THIS ACTION IS MADE FINAL. Applicant is reminded of the extension of time policy as set forth in 37 CFR 1.136(a).
A shortened statutory period for reply to this final action is set to expire THREE MONTHS from the mailing date of this action. In the event a first reply is filed within TWO MONTHS of the mailing date of this final action and the advisory action is not mailed until after the end of the THREE-MONTH shortened statutory period, then the shortened statutory period will expire on the date the advisory action is mailed, and any nonprovisional extension fee (37 CFR 1.17(a)) pursuant to 37 CFR 1.136(a) will be calculated from the mailing date of the advisory action. In no event, however, will the statutory period for reply expire later than SIX MONTHS from the mailing date of this final action.
Contact Information
Any inquiry concerning this communication or earlier communications from the examiner should be directed to BRAHIM BOURZIK whose telephone number is (571)270-7155. The examiner can normally be reached Monday-Friday (8-4:30).
Examiner interviews are available via telephone, in-person, and video conferencing using a USPTO supplied web-based collaboration tool. To schedule an interview, applicant is encouraged to use the USPTO Automated Interview Request (AIR) at http://www.uspto.gov/interviewpractice.
If attempts to reach the examiner by telephone are unsuccessful, the examiner’s supervisor, Wei Y Mui can be reached on 571-270-2738. The fax phone number for the organization where this application or proceeding is assigned is 571-273-8300.
Information regarding the status of published or unpublished applications may be obtained from Patent Center. Unpublished application information in Patent Center is available to registered users. To file and manage patent submissions in Patent Center, visit: https://patentcenter.uspto.gov. Visit https://www.uspto.gov/patents/apply/patent-center for more information about Patent Center and https://www.uspto.gov/patents/docx for information about filing in DOCX format. For additional questions, contact the Electronic Business Center (EBC) at 866-217-9197 (toll-free). If you would like assistance from a USPTO Customer Service Representative, call 800-786-9199 (IN USA OR CANADA) or 571-272-1000.
/BRAHIM BOURZIK/ Examiner, Art Unit 2191
/WEI Y MUI/ Supervisory Patent Examiner, Art Unit 2191