/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.solr.handler;
import java.lang.invoke.MethodHandles;
import org.apache.solr.common.cloud.SolrZkClient;
import org.apache.solr.core.SolrCore;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* <p>
* Manage the life-cycle state of the CDCR process. It is responsible of synchronising the state
* through Zookeeper. The state of the CDCR process is stored in the zk node defined by {@link #getZnodePath()}.
* </p>
* <p>
* It takes care of notifying the {@link CdcrReplicatorManager} in case
* of a process state change.
* </p>
*/
class CdcrProcessStateManager extends CdcrStateManager {
private CdcrParams.ProcessState state = DEFAULT_STATE;
private ProcessStateWatcher wrappedWatcher;
private Watcher watcher;
private SolrCore core;
/**
* The default state must be STOPPED. See comments in
* {@link #setState(org.apache.solr.handler.CdcrParams.ProcessState)}.
*/
static CdcrParams.ProcessState DEFAULT_STATE = CdcrParams.ProcessState.STOPPED;
private static final Logger log = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
CdcrProcessStateManager(final SolrCore core) {
this.core = core;
// Ensure that the status znode exists
this.createStateNode();
// Register the watcher at startup
try {
SolrZkClient zkClient = core.getCoreContainer().getZkController().getZkClient();
watcher = this.initWatcher(zkClient);
this.setState(CdcrParams.ProcessState.get(zkClient.getData(this.getZnodePath(), watcher, null, true)));
} catch (KeeperException | InterruptedException e) {
log.warn("Failed fetching initial state", e);
}
}
/**
* SolrZkClient does not guarantee that a watch object will only be triggered once for a given notification
* if we does not wrap the watcher - see SOLR-6621.
*/
private Watcher initWatcher(SolrZkClient zkClient) {
wrappedWatcher = new ProcessStateWatcher();
return zkClient.wrapWatcher(wrappedWatcher);
}
private String getZnodeBase() {
return "/collections/" + core.getCoreDescriptor().getCloudDescriptor().getCollectionName() + "/cdcr/state";
}
private String getZnodePath() {
return getZnodeBase() + "/process";
}
void setState(CdcrParams.ProcessState state) {
if (this.state != state) {
this.state = state;
this.callback(); // notify the observers of a state change
}
}
CdcrParams.ProcessState getState() {
return state;
}
/**
* Synchronise the state to Zookeeper. This method must be called only by the handler receiving the
* action.
*/
void synchronize() {
SolrZkClient zkClient = core.getCoreContainer().getZkController().getZkClient();
try {
zkClient.setData(this.getZnodePath(), this.getState().getBytes(), true);
// check if nobody changed it in the meantime, and set a new watcher
this.setState(CdcrParams.ProcessState.get(zkClient.getData(this.getZnodePath(), watcher, null, true)));
} catch (KeeperException | InterruptedException e) {
log.warn("Failed synchronising new state", e);
}
}
private void createStateNode() {
SolrZkClient zkClient = core.getCoreContainer().getZkController().getZkClient();
try {
if (!zkClient.exists(this.getZnodePath(), true)) {
if (!zkClient.exists(this.getZnodeBase(), true)) { // Should be a no-op if the node exists
zkClient.makePath(this.getZnodeBase(), null, CreateMode.PERSISTENT, null, false, true);
}
zkClient.create(this.getZnodePath(), DEFAULT_STATE.getBytes(), CreateMode.PERSISTENT, true);
log.info("Created znode {}", this.getZnodePath());
}
} catch (KeeperException.NodeExistsException ne) {
// Someone got in first and created the node.
} catch (KeeperException | InterruptedException e) {
log.warn("Failed to create CDCR process state node", e);
}
}
void shutdown() {
if (wrappedWatcher != null) {
wrappedWatcher.cancel(); // cancel the watcher to avoid spurious warn messages during shutdown
}
}
private class ProcessStateWatcher implements Watcher {
private boolean isCancelled = false;
/**
* Cancel the watcher to avoid spurious warn messages during shutdown.
*/
void cancel() {
isCancelled = true;
}
@Override
public void process(WatchedEvent event) {
if (isCancelled) return; // if the watcher is cancelled, do nothing.
String collectionName = core.getCoreDescriptor().getCloudDescriptor().getCollectionName();
String shard = core.getCoreDescriptor().getCloudDescriptor().getShardId();
log.info("The CDCR process state has changed: {} @ {}:{}", event, collectionName, shard);
// session events are not change events, and do not remove the watcher
if (Event.EventType.None.equals(event.getType())) {
return;
}
SolrZkClient zkClient = core.getCoreContainer().getZkController().getZkClient();
try {
CdcrParams.ProcessState state = CdcrParams.ProcessState.get(zkClient.getData(CdcrProcessStateManager.this.getZnodePath(), watcher, null, true));
log.info("Received new CDCR process state from watcher: {} @ {}:{}", state, collectionName, shard);
CdcrProcessStateManager.this.setState(state);
} catch (KeeperException | InterruptedException e) {
log.warn("Failed synchronising new state @ " + collectionName + ":" + shard, e);
}
}
}
}