Java tutorial
/* * 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.accumulo.fate.zookeeper; import java.util.Arrays; import java.util.List; import org.apache.accumulo.fate.zookeeper.ZooUtil.NodeExistsPolicy; import org.apache.accumulo.fate.zookeeper.ZooUtil.NodeMissingPolicy; import org.apache.accumulo.fate.zookeeper.ZooUtil.ZooKeeperConnectionInfo; import org.apache.zookeeper.CreateMode; import org.apache.zookeeper.KeeperException; import org.apache.zookeeper.KeeperException.Code; import org.apache.zookeeper.ZooKeeper; import org.apache.zookeeper.data.ACL; import org.apache.zookeeper.data.Stat; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class ZooReaderWriter extends ZooReader implements IZooReaderWriter { private static final Logger log = LoggerFactory.getLogger(ZooReaderWriter.class); private static ZooReaderWriter instance = null; private final String scheme; private final byte[] auth; private final ZooKeeperConnectionInfo info; @Override public ZooKeeper getZooKeeper() { return getSession(keepers, timeout, scheme, auth); } public ZooReaderWriter(String string, int timeInMillis, String scheme, byte[] auth) { super(string, timeInMillis); this.scheme = scheme; this.auth = Arrays.copyOf(auth, auth.length); this.info = new ZooKeeperConnectionInfo(string, timeInMillis, scheme, this.auth); } @Override public void recursiveDelete(String zPath, NodeMissingPolicy policy) throws KeeperException, InterruptedException { ZooUtil.recursiveDelete(info, zPath, policy); } @Override public boolean putPersistentData(String zPath, byte[] data, NodeExistsPolicy policy) throws KeeperException, InterruptedException { return ZooUtil.putPersistentData(info, zPath, data, policy); } @Override public boolean putPersistentData(String zPath, byte[] data, int version, NodeExistsPolicy policy, List<ACL> acls) throws KeeperException, InterruptedException { return ZooUtil.putPersistentData(info, zPath, data, version, policy, acls); } @Override public boolean putPrivatePersistentData(String zPath, byte[] data, NodeExistsPolicy policy) throws KeeperException, InterruptedException { return ZooUtil.putPrivatePersistentData(info, zPath, data, policy); } @Override public void putPersistentData(String zPath, byte[] data, int version, NodeExistsPolicy policy) throws KeeperException, InterruptedException { ZooUtil.putPersistentData(info, zPath, data, version, policy); } @Override public String putPersistentSequential(String zPath, byte[] data) throws KeeperException, InterruptedException { return ZooUtil.putPersistentSequential(info, zPath, data); } @Override public String putEphemeralData(String zPath, byte[] data) throws KeeperException, InterruptedException { return ZooUtil.putEphemeralData(info, zPath, data); } @Override public String putEphemeralSequential(String zPath, byte[] data) throws KeeperException, InterruptedException { return ZooUtil.putEphemeralSequential(info, zPath, data); } @Override public void recursiveCopyPersistent(String source, String destination, NodeExistsPolicy policy) throws KeeperException, InterruptedException { ZooUtil.recursiveCopyPersistent(info, source, destination, policy); } @Override public void delete(String path, int version) throws InterruptedException, KeeperException { final Retry retry = getRetryFactory().create(); while (true) { try { getZooKeeper().delete(path, version); return; } catch (KeeperException e) { final Code code = e.code(); if (code == Code.NONODE) { if (retry.hasRetried()) { // A retried delete could have deleted the node, assume that was the case log.debug("Delete saw no node on a retry. Assuming node was deleted"); return; } throw e; } else if (code == Code.CONNECTIONLOSS || code == Code.OPERATIONTIMEOUT || code == Code.SESSIONEXPIRED) { // retry if we have more attempts to do so retryOrThrow(retry, e); } else { throw e; } } retry.waitForNextAttempt(); } } @Override public byte[] mutate(String zPath, byte[] createValue, List<ACL> acl, Mutator mutator) throws Exception { if (createValue != null) { while (true) { final Retry retry = getRetryFactory().create(); try { getZooKeeper().create(zPath, createValue, acl, CreateMode.PERSISTENT); return createValue; } catch (KeeperException ex) { final Code code = ex.code(); if (code == Code.NODEEXISTS) { // expected break; } else if (code == Code.OPERATIONTIMEOUT || code == Code.CONNECTIONLOSS || code == Code.SESSIONEXPIRED) { retryOrThrow(retry, ex); } else { throw ex; } } retry.waitForNextAttempt(); } } do { final Retry retry = getRetryFactory().create(); Stat stat = new Stat(); byte[] data = getData(zPath, false, stat); data = mutator.mutate(data); if (data == null) return data; try { getZooKeeper().setData(zPath, data, stat.getVersion()); return data; } catch (KeeperException ex) { final Code code = ex.code(); if (code == Code.BADVERSION) { // Retry, but don't increment. This makes it backwards compatible with the infinite // loop that previously happened. I'm not sure if that's really desirable though. } else if (code == Code.OPERATIONTIMEOUT || code == Code.CONNECTIONLOSS || code == Code.SESSIONEXPIRED) { retryOrThrow(retry, ex); retry.waitForNextAttempt(); } else { throw ex; } } } while (true); } public static synchronized ZooReaderWriter getInstance(String zookeepers, int timeInMillis, String scheme, byte[] auth) { if (instance == null) instance = new ZooReaderWriter(zookeepers, timeInMillis, scheme, auth); return instance; } @Override public boolean isLockHeld(ZooUtil.LockID lockID) throws KeeperException, InterruptedException { return ZooUtil.isLockHeld(info, lockID); } @Override public void mkdirs(String path) throws KeeperException, InterruptedException { if (path.equals("")) return; if (!path.startsWith("/")) throw new IllegalArgumentException(path + "does not start with /"); if (exists(path)) return; String parent = path.substring(0, path.lastIndexOf("/")); mkdirs(parent); putPersistentData(path, new byte[] {}, NodeExistsPolicy.SKIP); } }