1111111111111111 IIIIII IIIII 11111 1111111111 lllll 111111111111111 lllll 111111111111111 11111111
`US 20040268293Al
`
`(19) United States
`(12) Patent Application Publication
`Woodgeard
`
`(10) Pub. No.: US 2004/0268293 Al
`Dec. 30, 2004
`( 43) Pub. Date:
`
`(54) AUTOMATING THE LIFE CYCLE OF A
`DISTRIBUTED COMPUTING APPLICATION
`
`(76)
`
`Inventor: Larry A. Woodgeard, Lawrenceville,
`GA(US)
`
`Correspondence Address:
`THOMAS, KAYDEN, HORSTEMEYER &
`RISLEY, LLP/
`BELLSOUTH I.P. CORP
`100 GALLERIA PARKWAY
`SUITE 1750
`ATLANTA, GA 30339 (US)
`
`(21)
`
`Appl. No.:
`
`10/608,942
`
`(22)
`
`Filed:
`
`Jun.27,2003
`
`Publication Classification
`
`Int. CI.7 ....................................................... G06F 9/44
`(51)
`(52) U.S. Cl. .............................................................. 717/101
`
`(57)
`
`ABSTRACT
`
`A system for automating the life cycle of a software appli(cid:173)
`cation is provided. The software application utilizes com(cid:173)
`puting resources distributed over a network. A representative
`system includes creating logic operable to create a task list
`which describes how at least one stage in the application life
`cycle is to be performed, and processing logic responsive to
`the creating logic, operable to process the task list to perform
`at least one stage in the application life cycle. The processing
`logic is integrated with a development environment, and the
`development environment is used to develop the software
`application.
`
`402
`
`/
`
`STAGE DEVELOP
`DEPENDS ON
`dTASK LIST
`404A
`{ COMMANDS FOR BUILD TOOLS}
`
`403A
`
`STAGE DISTRIBUTE
`DEPENDS ON DEVELOP
`qTASKLIST
`404
`GRID-SVC-PROXY-INIT
`GRID-SVC-COPY <WHICH FILES>
`
`403B
`
`STAGE EXECUTE
`DEPENDS ON DISTRIBUTE
`<r(TASK LIST
`404C GRID-SVC-RUN <WHICH NODES>
`
`403C
`
`ST AGE COLLECT
`DEPENDS ON EXECUTE
`ro[ TASKLIST
`404
`GRID-SVC-STATUS
`GRID-SVC-COPY <WHICH FILES>
`
`403D
`
`406\ 1'._
`7/
`
`~
`
`(
`405A
`
`\______ 400
`
`I 401
`
`EVALUATE DEPENDENCIES
`-
`
`PERFORM
`EXECUTE
`:-----, TASK
`'Z7
`407
`
`-
`
`PERFORM
`COLLECT
`:-----, TASK
`'Z7
`408
`
`INVOKE SVC
`GRID_RUN
`
`INVOKE SVC
`GRID_STATUS
`
`INVOKE SVC
`GRID_COPY
`
`40 5B
`L,)
`
`e-
`
`40 5C
`
`e-v
`
`Netflix, Inc. - Ex. 1018, Page 000001
`IPR2022-00322 (Netflix, Inc. v. CA, Inc.)
`
`

`

`Patent Application Publication Dec. 30, 2004 Sheet 1 of 8
`
`US 2004/0268293 Al
`
`�
`■
`
`C)
`-LL
`
`§Iw 0
`
`0
`z 0
`0:::
`
`Cl..
`
`0::: w C")
`(9 0 �
`0
`z
`
`Cl)
`
`Cl.. 0 <( 01
`w 0�1>o
`Cl) �01w I!)
`
`er ..-
`w
`
`-o __J ..-
`
`0
`
`0 ..-
`
`)
`
`·►
`
`I"-0
`
`
`
`II-
`
`Cl..
`
`�I �
`
`er
`0
`� I-
`w
`<(
`z
`I-
`<(
`0
`
`c.o
`
`0
`
`..- :r:
`
`I-
`
`<(
`
`Cl..
`
`Q_
`
`Q_ 0 <(
`o::w("')
`C:01
`0 z
`(.') 0 �
`z ml
`-0 _J ..-u
`w 0
`�1>o
`
`I-
`w I!)
`
`Cf)
`
`c::r ..-
`w
`Cf)
`
`Cl..
`
`Cl.. 0
`0::: w C")
`(9 0 �
`
`z
`
`<( <(I
`� <iiw I!)
`
`-o _J ..-
`()
`
`Cf)
`w
`
`()�, >o 0::: ..-
`
`w
`Cl)
`
`00
`
`0 ..-I
`
`Cl..
`
`§I
`0 z 0
`
`w
`0
`
`er (9
`
`§ILU 0
`
`0
`z 0
`0::: (9
`
`Netflix, Inc. - Ex. 1018, Page 000002
`
`

`

`Patent Application Publication Dec. 30, 2004 Sheet 2 of 8
`
`US 2004/0268293 Al
`
`200
`
`201
`
`202
`
`203
`
`204
`
`205
`
`206
`
`207
`
`DEVELOP
`
`APPLICATION
`
`PACKAGE
`
`APPLICATION
`
`DISTRIBUTE
`
`APPLICATION
`
`INSTALL
`
`APPLICATION
`
`EXECUTE
`
`APPLICATION
`
`COLLECT
`
`RESULTS
`
`FROM
`
`EXECUTION
`
`UNINSTALL
`
`APPLICATION
`
`FIG. 2
`
`Netflix, Inc. - Ex. 1018, Page 000003
`
`

`

`Patent Application Publication Dec. 30, 2004 Sheet 3 of 8
`
`US 2004/0268293 Al
`
`201 \ DEVELOP
`
`APPLICATION
`
`202 � PACKAGE
`
`APPLICATION
`
`203
`
`DISTRIBUTE
`
`APPLICATION
`
`1"
`-v
`
`GRID-INFO-SEARCH
`
`�3 02
`
`GRID-PROXY-I NIT
`
`301
`
`303
`
`I\
`
`4
`30
`
`I
`
`l)
`
`305
`�
`303
`�
`
`204 �
`
`INSTALL
`
`APPLICATION
`
`◊
`
`GRID-COPY
`
`GRID-RUN
`
`205 \ EXECUTE
`
`APPLICATION
`
`206
`
`r
`COLLECT
`
`RESULTS
`
`FROM
`
`EXECUTION
`
`207 � UNINSTALL
`
`APPLICATION
`
`�-�-
`
`IL______
`
`GRID-RUN
`
`.l's
`V
`
`1"
`-v
`
`1'
`
`V
`
`GRID--STATUS
`
`GRID-COPY
`
`GRID-RUN
`
`FIG. 3 {Prior Art)
`
`Netflix, Inc. - Ex. 1018, Page 000004
`
`

`

`US 2004/0268293 Al
`
`Dec. 30, 2004 Sheet 4 of 8
`
`=
`
`.... 0
`....
`�
`. (')
`
`-...
`
`=
`
`Pub
`
`.... 0
`....
`�
`. (')
`
`-...
`
`= ....
`
`App
`
`.... �
`�
`""C
`
`\
`
`405C
`
`\
`
`\
`
`405B
`
`\
`
`COLLECT
`PERFORM
`
`TASK
`
`408
`
`(~
`V
`
`FIG. 4
`
`�400
`
`GRID_COPY
`INVOKE SVC
`
`GRID_STATUS
`INVOKE SVC
`
`GRID_RUN
`INVOKE SVC
`
`405A
`
`\
`
`4030
`
`GRID-SVC-COPY <WHICH FILES>
`GRID-SVC-STATUS
`TASK LIST
`DEPENDS ON EXECUTE
`STAGE COLLECT
`
`404
`
`404CL GRID-SVC-RUN <WHICH NODES>
`
`.-1 TASK LIST
`
`403C
`
`DEPENDS ON DISTRIBUTE
`STAGE EXECUTE
`
`I
`
`I
`
`EXECUTE
`PERFORM
`
`407
`TASK
`
`(~
`V
`
`406
`
`EVALUATE DEPENDENCIES
`
`403B
`404AL { COMMANDS FOR BUILD TOOLS}
`
`.--r-TASKLIST
`
`GRID-SVC-COPY <WHICH FILES>
`GRID-SVC-PROXY-INIT
`TASK LIST
`DEPENDS ON DEVELOP
`STAGE DISTRIBUTE
`
`404
`
`403A
`
`DEPENDS ON
`STAGE DEVELOP
`
`401
`
`402
`
`Netflix, Inc. - Ex. 1018, Page 000005
`
`

`

`-0
`00
`O'I
`N
`0
`
`0
`N
`'JJ.
`d
`
`0 �
`
`N �
`
`>�
`
`00
`....,
`
`0
`
`(Ji
`....
`
`'JJ. =-�
`
` �
`
`,i;;..
`0
`0
`�= N
`
`....
`
`.... (') �
`
` ri �
`....0 =
`
`��
`
`= C"'
`
`""C
`
`....
`
`-=
`>
`
`....0 =
`-= -....(') �
` � = ....
`
` ....
`""C�
`
`501
`
`�
`
`FIG. SA
`
`'v
`
`-
`
`-
`
`[>
`
`I
`
`I
`
`History
`
`I
`
`504
`
`r-----
`
`�
`
`</antcall>
`<param name="rsl" value="${basedir}/Prirre
`<antcall target="runGridTask">
`
`<target name="main" depends="stage Task">
`
`<target name="runGridTask">
`</target>
`
`<grid-run-task
`
`Wizards Iools Window Help
`
`-
`
`I
`
`-
`
`MyApplet
`
`r
`
`-
`
`FirstApplet
`Run Team
`
`-
`
`-
`
`gassUrl="${gass.server.url}"
`outputEnable="true"
`rsl="${rsl}"
`
`<antcall target="collectOutputTask"/>
`/>
`
`</target>
`
`:--...Source k_oesign l Doc l
`V
`-<JI I
`D
`.......... -
`
`�
`
`[>
`
`I
`
`I
`
`I I
`
`<l
`
`� start()
`� init()
`<f) MyApplet
`0 Applet
`� 0 MyApplet
`
`505
`
`503
`
`Rebuild
`Clean
`Make
`"'\
`507
`
`-
`
`Execute
`
`·········-
`
`. ....
`
`....
`
`Install
`
`~ Distribute
`-~Package
`
`� Build.xml
`0-® MyApplet
`
`A-D
`506
`
`502
`
`0-@ <Project Source>
`LJ] Applet.jpx
`File Edit Search View _Eroject
`
`-
`
`-
`
`-
`
`-
`
`gm[E]
`
`JAVA BUILDER
`
`Netflix, Inc. - Ex. 1018, Page 000006
`
`

`

`u
`
`0
`N
`rJ1
`
`> 1--'
`N �
`
`9
`
`00
`O'I
`N
`0
`
`0 �
`
`00
`
`O'I
`
`rJ1=-�
`
`0 ....,
` � ....
`
`-,::..
`0
`0
`�= N
`
`\ 501
`
`FIG. 5B
`
`11>
`
`-
`
`
`
`---'v
`
`ri �
`= ��
`� ........0
`O' .... (')
`= �
`....0
`� ....
`'0 -.... (')
`= ....
`
`
`
`
`
`�� ....�
`
`
`
`>'0
`
`u l
`
`� 504
`
`-
`
`� Execute
`�*-zlnstall
`\
`� xXl: Distribute
`A-D �
`� � Package
`6 .'- 50
`© Build.xml
`0-(t@ MyApplet
`0-@I <Project Source>
`[5] Applet.jpx
`File Edit Search View Project Run Team Wizards Tools Window Help
`
`r--,.Source k_Design k. Doc k_History I
`<JI I
`D
`
`I
`
`rt
`
`[grid-run-task] GRAM Job submission successful (rmc: near)
`Status : ACTIVE
`Job ID : https://astro.starlab.bls.com:41953/22345/1054062218/
`[grid-run-task] GRAM Job submission successful (rmc: astro)
`runGridTask:
`main:
`Buildfile: E:�bproject\Prime\build.xml
`<JI I
`
`11>
`
`I
`
`�
`
`50 5
`
`� start()
`� init()
`& MyApplet
`0 Applet
`(;) 0 MyApplet
`
`r
`
`50 3
`
`!::,. </target>
`
`-
`
`<target name="main" depends="stage Task"> D.-
`� FirstApplet f
`□�[Si
`
`I
`
`MyApplet
`
`I
`
`I
`
`I
`
`I
`
`I
`
`I
`
`</antcall>
`<param name="rsl" value::::"${basedir}/Prirre
`<antcall target="runGridTask">
`
`<target name="runGridTask">
`</target>
`
`Rebuild
`flean
`Make
`""\
`507
`
`I
`
`-
`
`(
`
`50 2
`
`I
`
`I
`
`I
`
`1
`
`I
`
`JAVA BUILDER
`
`<antcall target="collectOutputTask"/>
`/>
`gassUrl="${gass.server.url}"
`outputEnable="true"
`rsI="${rsl}"
`
`507
`<grid-run-task
`
`Netflix, Inc. - Ex. 1018, Page 000007
`
`

`

`Patent Application Publication Dec. 30, 2004 Sheet 7 of 8
`
`US 2004/0268293 Al
`
`§I
`
`I- z
`
`
`w-
`_j
`(.)
`
`0 0:: (9 (f)
`(.9 0:: ...-(f)
`
`w0 (.) "<:ti
`
`O::>O
`w
`
`■ (!)
`
`-u.
`
`�I
`
`Cf)
`....J
`
`0
`0
`0
`Ct'.'.
`
`0 f-a.. 0 0:: (.9
`1.4---
`
`--7
`
`I
`I
`I
`I
`I
`I
`I
`I
`I
`I
`I
`_....J
`
`-+---
`
`-
`
`gl
`
`(/)
`_j
`0
`t)
`0
`0
`Ct'.'.
`
`
`0 0:: (!)
`
`I- a..
`
`w 0
`
`IDI QO z ---
`0 a.. - [L 0:: <( (.9
`
`M
`0
`
`"°�
`
`I-
`
`c:o � CCI
`<(�<(I
`> _j ...-<(QO
`I-<( -
`0:: _j ---oOO
`
`-,oco
`
`I-
`
`0 0 co
`
`I-
`
`�, I-z
`w -_J
`
`u
`
`0 � (9 (f)
`O::>O
`
`w 0
`
`U -.:ti
`
`CJ� ...-
`w
`(/)
`
`Netflix, Inc. - Ex. 1018, Page 000008
`
`

`

`Patent Application Publication Dec. 30, 2004 Sheet 8 of 8
`
`US 2004/0268293 Al
`
`PROCESSOR
`701
`
`-
`
`- • • "
`
`MEMORY 702
`
`SYSTEM FOR AUTOMATING THE LIFE CYCLE
`OF A DISTRIBUTED COMPUTING
`APPLICATION 705
`
`'
`
`OPERATING SYSTEM
`706
`-
`
`'
`
`'
`LOCAL INTERFACE 704
`
`PERIPHERALS
`703
`-
`
`~ 700
`
`FIG. 7
`
`DEVELOP GRID NODE
`APPLICATION
`
`CREATE TASK LIST DESCRIBING
`LIFE CYCLE FOR GRID NODE
`APPLICATION
`
`PROCESS TASK LIST TO
`PERFORM STAGE(S) IN LIFE
`CYCLE
`
`801
`
`802
`
`803
`
`FIG. 8
`
`Netflix, Inc. - Ex. 1018, Page 000009
`
`

`

`US 2004/0268293 Al
`
`Dec. 30, 2004
`
`1
`
`AUTOMATING THE LIFE CYCLE OF A
`DISTRIBUTED COMPUTING APPLICATION
`
`FIELD OF THE INVENTION
`
`[0001] The present invention relates generally to distrib­
`uted computing software, and more particularly to tools used
`to develop and build distributed computing software.
`
`DESCRIPTION OF THE RELATED ART
`
`' ...
`
`[0002] For many years, scientists, academics and engi­
`neers have used computers to solve complex problems.
`Computers are used, in many different disciplines, for tasks
`such as modeling, simulation and forecasting. For example,
`the scientific community has used such networks to
`sequence genes, analyze astronomic data and analyze
`weather forecast data. Because these tasks are computation­
`ally complex and/or involve huge amounts of data, high­
`performance computers are generally used, and many inter­
`esting problems are not investigated because access to such
`high-performance computers is very limited.
`
`[0003] A relatively new approach to complex computing
`relies on the aggregate computing power of networks of
`computers instead of individual high-performance comput­
`ers. These networks are known as "computational grids", or
`simply "grids," while the computers on the grid are called
`"grid nodes." The infrastructure of these computational
`grids is designed to provide consistent, dependable, perva­
`sive and inexpensive access to computing resources, which
`in the aggregate provide high performance computing capa­
`bilities.
`
`[0004] To take advantage of computational grids, a com­
`puting task is decomposed so that it runs in parallel on
`multiple grid nodes. Some computing tasks are suited for
`data decomposition, where the same application executes on
`many grid nodes in parallel using different data. Others are
`suited for task decomposition, where different applications
`execute on many grid nodes in parallel using the same data.
`Other forms of decomposition are also possible, as well as
`a combination of multiple forms of decomposition.
`
`[0005] Grid computing began in the academic and scien­
`tific community. The tools first used to develop applications
`for the grid were therefore those familiar to academics and
`scientists, and were typically based on the Unix operating
`system and the C programming language. These software
`developers are comfortable with the "bare bones" develop­
`•
`ment environment provided by Unix, with features such as
`command line interpreters, shell scripts, etc.
`
`[0006] Grid computing is now beginning to spread to the
`business community. Software developers in the business
`community typically use a different set of tools and a
`different development environment. In order to make grid
`computing more accessible to the wider business commu­
`nity, there is a need for systems and methods that address
`these and/or other perceived shortcomings of the prior art.
`
`SUMMARY OF THE INVENTION
`
`[0007] One embodiment, among others, of the present
`invention provides systems and methods for automating the
`life cycle of a software application. The software application
`utilizes computing resources distributed over a network. A
`representative system includes creating logic operable to
`
`create a task list which describes how at least one stage in
`the application life cycle is to be performed, and processing
`logic responsive to the creating logic, operable to process the
`task list to perform at least one stage in the application life
`cycle. The processing logic is integrated with a development
`environment, and the development environment is used to
`develop the software application.
`
`[0008] One method, among others, includes: creating a
`task list which describes how at least one stage in the life
`cycle is to be performed, and processing the task list by a
`process engine to perform at least one stage in the life cycle.
`The process engine is integrated with a development envi­
`ronment, and the development environment is used to
`develop the software application.
`
`DESCRIPTION OF THE DRAWINGS
`
`[0009] FIG. 1 is a block diagram of a network of distrib­
`uted computing resources.
`
`[0010] FIG. 2 is a block diagram of the software life cycle
`of a grid node application from FIG. 1.
`
`[0011] FIG. 3 is a diagram showing how some prior art
`,
`performs stages in the software life cycle of FIG. 2, using
`one or more grid client programs.
`
`[0012] FIG. 4 is a block diagram illustrating one aspect of
`an embodiment of the system for automating the life cycle
`of a grid node application.
`
`[0013] FIG. SA is a diagram of one embodiment of a user
`interface for the system for automatiing the life cycle of a
`grid node application.
`
`[0014] FIG. 5B is a diagram of the user interface after the
`process engine of FIG. 4 has performed an execution stage.
`
`[0015] FIG. 6 is a block diagram of the software compo­
`nents that one embodiment of the process engine of FIG. 4
`uses to invoke grid services of FIG. 1.
`
`[0016] FIG. 7 illustrates an example of an embodiment of
`a grid node of FIG. 1.
`
`DETAILED DESCRIPTION
`
`[0017] FIG. 1 is a block diagram of a network of distrib­
`uted computing resources 100. The network 100 consists of
`one or more computing resources l0la-c in communication
`with each other through data network 102 ( connections to
`network not shown). As described above, this grid 100 can
`be used to perform computing tasks which are typically very
`complex and/or involve a very large amount of data. The
`term "computing resources" includes many different types
`of resources, not just computers. Other examples include
`storage resources, file systems, and databases. In order to
`simplify the explanation of the invention, the computing
`resources described herein will be computers, but the prin­
`ciples of this invention apply to all types of computing
`resources. The network will be referred to hereinafter as the
`grid 100, computing resources will be referred to as grid
`nodes lOla-d, and an application that runs on a grid node to
`perform a computing task ( or subtask, if the computing task
`has been decomposed) will be called a grid node application
`103.
`
`[0018] To execute a grid node application 103 on a grid
`node 101, nodes which can provide appropriate computing
`
`Netflix, Inc. - Ex. 1018, Page 000010
`
`

`

`US 2004/0268293 Al
`
`Dec. 30, 2004
`
`2
`
`resources must first be identified, and the grid node appli­
`cation 103 must be submitted to the identified node(s) as a
`job for execution. Rather than using a centralized resource
`manager and/or job submission manager, the grid 100 as it
`exists today uses a decentralized approach, where each grid
`node grid node 101 provides: grid services 104 which
`support resource discovery, job submission, and other func­
`tionality; and a grid client 105 which uses the grid services
`104 provided by other grid nodes 101. This can best be
`illustrated by an example.
`
`..
`
`In FIG. 1, grid node 101a submits a grid node
`[0019]
`application 103 for execution on grid node 101b and grid
`node 101c. This is accomplished by grid client 105a using
`•
`the grid services 104b provided by grid node 101b (shown
`by path 106) and using the grid services 104c provided by
`grid node 101c (shown by path 107). Grid node 101a also
`executes another grid node application 103, using its own
`computing resources, on behalf of grid node 101c. This is
`accomplished by grid client 105c using the grid services
`104a provided by grid node 101a (shown by path 108).
`
`In FIG. 1, grid client 105 is shown as a single
`[0020]
`entity which communicates with the single entity grid ser­
`vices 104. Since grid services 104 provides different types of
`services, in some embodiments grid services 104 may be
`implemented by multiple entities within grid node 101. For
`example, the resource discovery functions could be imple­
`mented by a grid resource service and the job submission
`functions could be implemented by a job submission ser­
`vice. Similarly, in some embodiments, the grid client 105
`may be implemented by separate grid client utility programs
`executing on grid node 101. For example, a Grid-Info­
`Search client program could communicate with grid services
`104 to access resource discovery services and a Grid-Run
`client program could communicate with grid services 104 to
`access job submission services.
`
`[0021] FIG. 2 is a block diagram of the software life cycle
`200 of a grid node application 103. The life cycle 200
`consists of multiple stages: development 201; packaging
`202; distribution 203; installation 204; execution 205; col­
`lection 206; and cleanup 207. In the development stage 201,
`the grid node application 103 is developed using application
`development tools, for example, an editor, a compiler and a
`Grid toolkit 601 (FIG. 6).
`
`In the packaging stage 202, the grid node applica­
`[0022]
`tion 103 is packaged, so that all files required to run the
`application are packaged together. For example, an applica­
`tion written in Java may require several different applets and
`classes in order to run, and these components can be
`aggregated into a single archive file. Packaging is often used
`because it simplifies transfer of the application to another
`system, but packaging stage 202 is not necessary.
`
`In the distribution stage 203, grid node application
`[0023]
`103 is distributed to the target nodes where it will run.
`Distribution stage 203 may involve the transfer of a single
`file (particularly if packaging is used) or it may involve
`transferring each required file individually. If a node requires
`additional installation after files are distributed, for example,
`setting up the run-time environment on the target nodes, then
`the installation stage 204 performs installation.
`
`the results from the execution of the grid node application
`103 on one or more target nodes are collected. At the
`uninstall stage 207, the grid node application 103 is unin­
`stalled, removing it from the target nodes.
`...
`[0025] FIG. 2 is intended as an illustration of a typical life
`cycle 200. However, some stages are optional, so that the life
`cycle 200 of a particular grid node application 103 may not
`have all stages shown in FIG. 2. For example, the packaging
`stage 202 and the installation stage are often 203 unneces­
`sary for a particular grid node application 103. It is also
`possible for the life cycle 200 of a particular grid node
`application 103 to contain additional stages not shown in
`FIG. 2.
`
`[0026] Life cycle 200 does not always progress from one
`stage to another in a strict sequence. Instead, it is common
`for a subset of stages in the life cycle 200 to be repeated. For
`example, while the grid node application 103 is still under
`development, the development stage 201 and packaging
`stage 202 may be repeated many times while the developer
`debugs the grid node application 103, while the remaining
`stages are not required because the developer executes the
`grid node application 103 locally rather than using the grid
`100. As another example, when development is complete,
`the stages of distribution, execution and collection may be
`repeated may times as the user runs the grid node application
`103 on several different sets of target nodes.
`
`[0027] FIG. 3 is a diagram showing how some prior art
`performs stages in life cycle 200 using one or more grid
`client programs. Typically, the development stage 201 and
`the packaging 202 are performed with standard application
`development tools (e.g. compiler, editor, compression util­
`ity, etc.) However, other stages are performed with one or
`more grid client programs which use various grid services
`104. (Alternatively, as explained above, a single grid client
`105, with access to all grid services 104, could be used
`instead).
`
`In the example shown in FIG. 3, stage 203 is the
`[0028]
`distribution stage. Grid-Proxy-Init 301 is a grid client 105
`which obtains authenticated access to the grid 100. Grid­
`Info-Search 302 is a grid client 105 which invokes a query
`on the meta-information grid service provided by grid
`services 104 to identify target nodes. Grid-Copy 303 is a grid
`client 105 which moves files between grid nodes 101. The
`files can be data files, executable files, or a package file
`containing a combination of these.
`
`Install stage 204 and Execute stage 205 both use
`[0029]
`Grid-Run 304 to execute a specific program on the target
`nodes. Typically, the install stage 204 will execute shell
`commands or utility programs in order to create directories,
`move files, uncompress files, etc. Execute stage 205
`executes the grid node application 103.
`
`[0030] Collect stage 204 is performed using Grid-Status
`305, which is a grid client 105 which checks the status of a
`grid node application 103 which was executed on a target
`node. Collect stage 204 also uses Grid-Copy 303 to copy
`output files produced by the execution of the grid node
`application 103 on the target nodes. Uninstall stage 207 is
`•
`performed using Grid-Run 304, typically executing shell
`commands and utilities to delete files from the target nodes
`and restore environment variables and paths.
`
`[0024] At the execution stage 205, grid node application
`103 executes on the target nodes. At the collection stage 206,
`
`[0031] As discussed above, in the prior art approach
`described by FIG. 3, a developer of a grid node application
`
`Netflix, Inc. - Ex. 1018, Page 000011
`
`

`

`US 2004/0268293 Al
`
`Dec. 30, 2004
`
`3
`
`�ne or more target nodes. The particular grid node applica­
`tion 103 and target nodes which are passed as parameters to
`gri� services 104 could be specified directly in input file 402,
`or m another file referenced by input file 402.
`[0037] At 408, process engine 401 decides to perform the
`task list associated with collect stage 206. The Grid-Check­
`Status task subsystem 405b checks the status of a grid node
`application 103 on one or more target nodes. The Grid-Copy
`task subsystem 405c copies files from one or more target
`nodes to the node which submitted the grid node application
`103 for execution. Processing by process engine 401 is then
`complete, as the last task in the collect stage 206 has been
`performed.
`In one embodiment, the process engine 401 verifies
`[0038]
`that pre-conditions are satisfied before performing a specific
`task in task list 404. Pre-conditions are specified at the task
`level, as parameters in input file 402. For example, if the
`distribution stage 203 includes a task which copies a file to
`� target grid node 101, preconditions for that task may
`mclude: the source file exists; the target grid node 101 exists,
`there is enough disk space on the target grid node 101, the
`user has permissions to copy the file and to create and write
`the file to the target, etc.
`[0039] Pre-conditions also allow process engine 401 to
`take into account the specific requirements of a particular
`grid node application 103 when performing a task. For
`example, a grid node application 103 may run only on an
`Intel® platform with a Linux® operating system, so a
`precondition for the Grid-Run task in this case verifies that
`the
`target grid node 101. In one embodiment, the process
`_
`engme 401 tests preconditions iteratively on all available
`grid nodes 101 within a organization. To determine whether
`or not pre-conditions are satisfied for a particular grid node
`101, process engine 401 uses grid services 104 to obtain
`meta-information about the resources available on grid node
`101, and compares this with the requirements of the grid
`node application 103.
`[0040] While pre-conditions are defined at the task level
`the �esolution of pre-conditions is handled at the stage level
`and Job level . That is, the section 403 of input file 402 which
`defines a stage also specifies how failure of a pre-condition
`is handled. For example, a pre-condition for the collection
`stage 206 (which collects the results produced by an
`executed job) would be that the submitted job has success­
`fully completed execution. If this pre-condition is not met,
`then the submitted job is aborted and/or resubmitted.
`[0041] FIG. SA is a diagram of one embodiment of a user
`interface for the system for automating the life cycle of a
`grid node application 400. In this embodiment, grid node
`application 103 is developed using an integrated develop­
`ment environment 501. Integrated development environ­
`�e�t - 501 typically includes: a compiler for translating
`mdividual source files into object code or into interpreted
`byte code; a linker for combining multiple object code
`modules into an executable program; and an editor for
`creating and modifying source files. Integrated development
`environment 501 may include other tools. The editor in the
`integrated development environment 501 may be used to
`edit task lists 404 contained in input file 402. Process engine
`401 is integrated into integrated development environment
`501, so that all stages in the life cycle 200 can be performed
`from within integrated development environment 501.
`
`103 performs some stages using standard software develop­
`ment tools and other stages using grid client programs 105.
`T�e developer may automate the stages to some degree by
`usmg one or more shell scripts which invoke grid client
`programs 105 and pass appropriate parameters to the pro­
`grams. While this level of automation is preferable to
`manually invoking grid client programs 105 from the com­
`ma�d line, a shell script interpreter is a general purpose tool
`which has no concept of stages in a life cycle, so that some
`degree of expertise in scripting is required to achieve the
`desired result of automating the life cycle of a grid node
`application 103.
`[0032] FIG. 4 is a block diagram illustrating one aspect of
`an embodiment of the system for automating the life cycle
`of a grid node application 400. Process engine 401 performs
`the tasks associated with one or more stages in life cycle 200
`of a particular grid node application 103. The life cycle 200
`scribed in input file 402, which is a text file. Each stage
`�s d
`m life cycle 200 corresponds to a section 403a-d in input file
`402. Each section 403a-d consists of a task list 404a-d
`of tasks to be performed for that stage. Sine�
`�hich is a list
`_
`mput file 402 is a text file, it may be created and edited using
`any text editor. Alternatively, input file 402 could be created
`and/or modified by a program.
`In one embodiment, process engine 401 does not
`[0033]
`perform the tasks itself, but relies on individual task sub­
`systems 405 to perform each type of task. In FIG. 4, three
`types of tasks are performed (Grid-Run, Grid-Status, Grid­
`Copy) and thus three task subsystems 405a-c are shown. In
`one embodiment, process engine 401 invokes appropriate
`grid client utility programs to perform tasks. For example,
`!he Grid-Run task subsystem 405a of process engine 401
`mvokes t�e grid client utility program Grid-Run (as dis­
`cussed with regard to FIG. 3). In another embodiment,
`process engine 401 uses a toolkit (see FIG. 6) to access grid
`services 104.
`Input file 402 may allow one stage to be specified
`[0034]
`s dependent on another stage. In FIG. 4, since an applica­
`tion
`cannot be distributed before it has been developed,
`_
`sect10n 403b of input file 402 indicates that the distribution
`stage 203 is dependent on the development stage 201. In one
`embodiment, a parameter indicates which stage(s) the pro­
`cess engine 401 is to perform, and if dependencies are
`present, then process engine 401 determines which, if any,
`other stages must be performed first.
`In FIG. 4, the process engine 401 is directed (at
`[0035]
`406) to perform the collect task 206. Section 403d of input
`file 402 represents the collection stage 206, and contains a
`task list 404d with two tasks: one to check the status of the
`submitted job; and another to transfer a file containing the
`results. Process engine 401 determines if grid node appli­
`cation 103 should be executed before results are collected.
`This determination could be made, for example, by checking
`for the presence of the output files generated on a target node
`when grid node application 103 executes. If the output files
`are not present, then the execution stage 205 should be
`performed before the collect stage 206. One skilled in the art
`wil� understand that process engine 401 could employ a
`vanety of methods to determine dependencies.
`] Proc�ss eng�ne 401 decides to perform (at 407) the
`[0036
`task list associated with execution stage 205. The Grid-Run
`task subsystem 405a executes a grid node application 103 on
`
`a_
`
`_e
`
`Netflix, Inc. - Ex. 1018, Page 000012
`
`_
`

`

`US 2004/0268293 Al
`
`Dec. 30, 2004
`
`4
`
`In this embodiment, the user int�rface for in�e­
`[0042]
`grated development environment 501 consists of one wm­
`dow which is split into several panes: the project pane 502;
`the structure pane 503; the content pane 504; and the
`message pane 505. The content pane 504 allows editing of
`source files. The structure pane 503 shows in a hierarchical
`form the structure of the file that is currently displayed in
`content pane 504. The message pane 505 displays messages
`which result from various operations such as building,
`compiling, debugging and testing.
`[0043] The life cycle stages described by input file 402 are
`displayed in project pane 502 as nodes 506a-d. In FIG. 5,
`node 506c ( corresponding to execution stage 205) is
`selected, a menu 507 of possible actions for that node is
`displayed, and the menu item Make is chosen. This action
`invokes process engine 401 and directs process engine 401
`to perform the execution stage 205 as described by input file
`402.
`[0044] FIG. 5B is a diagram of the user interface after
`process engine 401 has performed execution stage 205. The
`message pane 505 displays any status messages generated
`by the process engine 401.
`In one embodiment, the integrated development
`[0045]
`environment 501 is Borland }Builder®, the process engine
`401 is Apache Ant™, and the input file 402 is an XML build
`file. In this embodiment, stages correspond to Ant™ targets,
`and the tasks are implemented as Java classes which extend
`the base classes in Ant™.
`[0046] FIG. 6 is a block diagram of the software compo­
`nents that one embodiment of process engine 401 uses to
`invoke grid services 104. The software can be viewed as
`layered. Process engine 401 is developed using an appro­
`priate toolkit 601a, b. Toolkits 601a, b are language and
`framework-specific, for example, toolkit 601a is used to
`develop grid-aware applications in Java while toolkit 601b
`is used to develop grid-aware applications with Common
`Object Request Broker Architecture (COREA). In one
`embodiment, the toolkit is provided by the Globus Java
`Commodity Grid Kit (Java CoG).
`[0047] The Process engine 401 invokes grid services 104
`through whatever application programming interface (API)
`is provided by the toolkit. Grid client 105 presents an
`interface, API 602. Each toolkit 601 uses the GRID client
`API 602 to programmatically call grid client 105. Grid client
`105 uses GRID protocols 603 to communicate ( over data
`network 102) with the grid services 104 residing on another
`grid node 101.
`[0048] FIG. 7 illustrates an example of an embodiment of
`a grid node 101 of FIG. 1.
`
`[0049] Generally, in terms of hardware architecture, the
`grid node 101 is a general purpose computer including a
`processor 701, memory 702, and one or more input and/or
`output (1/0) devices or peripherals 703 that are communi­
`catively coupled via a local interface 704. The local interface
`704 can be, for example but not limited to, one or more buses
`or other wired or wireless connections, as is known in the
`art. The local interface 704 may have additional elements
`( omitted for simplicity), such as controllers, buffers, drivers,
`repeaters, and receivers, to enable communications. Further,
`the local interface 704 may include address, control, and/or
`
`data connections to enable appropriate communications
`among the aforementioned components.
`[0050] The peripherals 703 may include input devices, for
`example but not limited to, a keyboard, mouse, scanner,
`microphone, etc. Furthermore, the peripherals 703 may also
`includ