anchor.diff:  -----------------------
   // TEST[continued]
   
  -When creating our index, we have to consider a few important configurations
  -that tie our index and our policy together correctly. We need to make sure
  -that our index name matches our index template pattern of "datastream-*",
  -which it does. We are using the <<ilm-rollover-action, Rollover Action>> in our policy, which
  -requires that our index name ends with a number. In our case, we used
  -`000001`. This is important so that Rollover can increment this number when
  -naming the new index created from rolling over.
  -
  -Our index creation request leverages its template to apply our settings,
  -but we must also configure our rollover alias: "datastream". To do this,
  -we take advantage of <<aliases-write-index,write indices>>. This is a way
  -to define an alias to be used for both reading and writing, with only one
  -index being the index that is being written to at a time. Rollover swaps
  -the write index to be the new index created from rollover, and sets the
  -alias to be read-only for the source index.
  +When the rollover conditions are met, the `rollover` action:
  +
  +* Creates a new index called `datastream-000002`. 
  +This matches the `datastream-*` pattern, so the settings from `datastream_template` are applied to the new index.
  +* Designates the new index as the write index and makes the bootstrap index read-only.
  +
  +This process repeats each time rollover conditions are met. 
  +You can search across all of the indices managed by the `datastream_policy` with the `datastream` alias. 
  +Write operations are routed to the current write index. 
  +
  +For more information about write indices and rollover, see the <<rollover-index-api-desc, rollover API>>.
   
   [float]
   [[ilm-gs-check-progress]]
   === Checking progress
   
  -Now that we have an index managed by our policy, how do we tell what is going
  -on? Which phase are we in? Is something broken? This section will go over a
  -few APIs and their responses to help us inspect our indices with respect
  -to {ilm-init}.
  -
  -With the help of the <<ilm-explain-lifecycle,Explain API>>, we can know
  -things like which phase we're in and when we entered that phase. The API
  -will also provide further info if errors occurred, or if we are blocked on
  -certain checks within actions.
  +To get status information for managed indices, you use the {ilm-init} explain API. 
  +This lets you find out things like:
  +
  +* What phase an index is in and when it entered that phase.
  +* The current action and what step is being performed.
  +* If any errors have occurred or progress is blocked.
  +
  +For example, the following request gets information about the `datastream` indices: 
   
   [source,console]
   --------------------------------------------------
  
positive.code:   "indices": {
      "datastream-000001": {
        "index": "datastream-000001",
        "managed": true,                           <1>
        "policy": "datastream_policy",             <2>
        "lifecycle_date_millis": 1538475653281,
        "age": "30s",                              <3>
        "phase": "hot",                            <4>
        "phase_time_millis": 1538475653317,
        "action": "rollover",                      <5>
        "action_time_millis": 1538475653317,
        "step": "attempt-rollover",                <6>
        "step_time_millis": 1538475653317,
        "phase_execution": {
          "policy": "datastream_policy",
          "phase_definition": {                    <7>
            "min_age": "0ms",
            "actions": {
              "rollover": {
  
negative.code: -----------------------
  // TEST[continued]
  
  <1> Apply the template to a new index if its name starts with `datastream-`. 
  <2> The name of the lifecycle policy to apply to each new index.
  <3> The name of the alias used to reference these indices. 
  Required for policies that use the rollover action.
  
  //////////////////////////
  
  [source,console]
  