Best practice for defining streams and flow targets
I need to know what is the best practice for defining streams and their flow targets.
Currently, we have the following componnents: event_model and event_model_app. Both are built into a single JAR file: event_model.jar and event_model_app.jar. event_model_app.jar depends upon event_model.jar being built and available.
We thought about having 2 streams: one for each component. Then, we thought we would add a 'staging' stream as the flow target of the event_model and event_model_app streams. We plan to do continuous or nightly builds on the code in the staging stream. Only once the code builds in the lower stream is it delivered to the staging stream.
We then plan to add a 'delivery' stream that is the flow target of the staging stream. We plan to only do builds on the delivery stream when needed. Only once the code builds in the staging stream and only at periodic intervals is it moved to the delivery stream.
So my question is: does this make sense? Is this the 'correct' way to define our streams? Is there an easier process that we should follow?
Currently, we have the following componnents: event_model and event_model_app. Both are built into a single JAR file: event_model.jar and event_model_app.jar. event_model_app.jar depends upon event_model.jar being built and available.
We thought about having 2 streams: one for each component. Then, we thought we would add a 'staging' stream as the flow target of the event_model and event_model_app streams. We plan to do continuous or nightly builds on the code in the staging stream. Only once the code builds in the lower stream is it delivered to the staging stream.
We then plan to add a 'delivery' stream that is the flow target of the staging stream. We plan to only do builds on the delivery stream when needed. Only once the code builds in the staging stream and only at periodic intervals is it moved to the delivery stream.
So my question is: does this make sense? Is this the 'correct' way to define our streams? Is there an easier process that we should follow?
One answer
I don't see a need a stream for each component ... just one stream for
each "promotion level". In the description of a given stream, you
should specify what are the requirements for that stream (i.e. what
conditions should be met before changes are delivered to that stream).
Ideally, you would actually enforce those conditions with pre-conditions
on the deliver operation on that stream.
From your description below, I didn't see the purpose of the lowest
level streams. The purpose of the staging stream is clear ... you do
your continuous builds off that stream.
I assume the "delivery stream" is the stream that contains the code that
you've actually delivered to either some customer or some other project.
You should make that explicit.
Cheers,
Geoff
kengreenlee wrote:
each "promotion level". In the description of a given stream, you
should specify what are the requirements for that stream (i.e. what
conditions should be met before changes are delivered to that stream).
Ideally, you would actually enforce those conditions with pre-conditions
on the deliver operation on that stream.
From your description below, I didn't see the purpose of the lowest
level streams. The purpose of the staging stream is clear ... you do
your continuous builds off that stream.
I assume the "delivery stream" is the stream that contains the code that
you've actually delivered to either some customer or some other project.
You should make that explicit.
Cheers,
Geoff
kengreenlee wrote:
I need to know what is the best practice for defining streams and
their flow targets.
Currently, we have the following componnents: event_model and
event_model_app. Both are built into a single JAR file:
event_model.jar and event_model_app.jar. event_model_app.jar depends
upon event_model.jar being built and available.
We thought about having 2 streams: one for each component. Then, we
thought we would add a 'staging' stream as the flow target of the
event_model and event_model_app streams. We plan to do continuous or
nightly builds on the code in the staging stream. Only once the code
builds in the lower stream is it delivered to the staging stream.
We then plan to add a 'delivery' stream that is the flow target of the
staging stream. We plan to only do builds on the delivery stream when
needed. Only once the code builds in the staging stream and only at
periodic intervals is it moved to the delivery stream.
So my question is: does this make sense? Is this the 'correct' way
to define our streams? Is there an easier process that we should
follow?