Avoid layout updates after delete-pipeline-state

The delete-pipeline-state commend forces a layout update on every
scheduler, but that isn't strictly necessary.  While it may be helpful
for some issues, if it really is necessary, the operator can issue
a tenant reconfiguration after performing the delete-pipeline-state.

In most cases, where only the state information itself is causing a
problem, we can omit the layout updates and assume that the state reset
alone is sufficient.

To that end, this change removes the layout state changes from the
delete-pipeline-state command and instead simply empties and recreates
the pipeline state and change list objects.  This is very similar to
what happens in the pipeline manager _postConfig call, except in this
case, we have the tenant lock so we know we can write with imputinity,
and we know we are creating objects in ZK from scratch, so we use
direct create calls.

We set the pipeline state's layout uuid to None, which will cause the
first scheduler that comes across it to (assuming its internal layout
is up to date) perform a pipeline reset (which is almost a noop on an
empty pipeline) and update the pipeline state layout to the current
tenant layout state.

Change-Id: I1c503280b516ffa7bbe4cf456d9c900b500e16b0

1 files changed, 13 insertions, 24 deletions

diff --git a/zuul/cmd/client.py b/zuul/cmd/client.py
index 1a3738b85..62e51ac3f 100755
--- a/zuul/cmd/client.py
+++ b/zuul/cmd/client.py
@@ -30,16 +30,14 @@ import time
 import textwrap
 import requests
 import urllib.parse
-from uuid import uuid4
 
 import zuul.cmd
 from zuul.lib.config import get_default
-from zuul.model import SystemAttributes, PipelineState
+from zuul.model import SystemAttributes, PipelineState, PipelineChangeList
 from zuul.zk import ZooKeeperClient
 from zuul.lib.keystorage import KeyStorage
-from zuul.zk.locks import tenant_write_lock
+from zuul.zk.locks import tenant_read_lock, pipeline_lock
 from zuul.zk.zkobject import ZKContext
-from zuul.zk.layout import LayoutState, LayoutStateStore
 from zuul.zk.components import COMPONENT_REGISTRY
 
 
@@ -1029,27 +1027,18 @@ class Client(zuul.cmd.ZuulApp):
         safe_tenant = urllib.parse.quote_plus(args.tenant)
         safe_pipeline = urllib.parse.quote_plus(args.pipeline)
         COMPONENT_REGISTRY.create(zk_client)
-        with tenant_write_lock(zk_client, args.tenant) as lock:
+        self.log.info('get tenant')
+        with tenant_read_lock(zk_client, args.tenant):
             path = f'/zuul/tenant/{safe_tenant}/pipeline/{safe_pipeline}'
-            layout_uuid = None
-            zk_client.client.delete(path, recursive=True)
-            with ZKContext(zk_client, lock, None, self.log) as context:
-                ps = PipelineState.new(context, _path=path,
-                                       layout_uuid=layout_uuid)
-            ltime = ps._zstat.last_modified_transaction_id
-            # Force everyone to make a new layout for this tenant in
-            # order to rebuild the shared change queues.
-            layout_state = LayoutState(
-                tenant_name=args.tenant,
-                hostname='admin command',
-                last_reconfigured=int(time.time()),
-                last_reconfigure_event_ltime=ltime,
-                uuid=uuid4().hex,
-                branch_cache_min_ltimes={},
-                ltime=ltime,
-            )
-            tenant_layout_state = LayoutStateStore(zk_client, lambda: None)
-            tenant_layout_state[args.tenant] = layout_state
+            self.log.info('get pipe')
+            with pipeline_lock(
+                    zk_client, args.tenant, args.pipeline
+            ) as plock:
+                self.log.info('got locks')
+                zk_client.client.delete(path, recursive=True)
+                with ZKContext(zk_client, plock, None, self.log) as context:
+                    PipelineState.new(context, _path=path, layout_uuid=None)
+                    PipelineChangeList.new(context)
 
         sys.exit(0)