Example #1
0
  public List<String> getChildren(String path) throws KeeperException, InterruptedException {
    RetryCounter retryCounter = retryCounterFactory.create();
    while (true) {
      try {
        return zk.getChildren(path, true);
      } catch (KeeperException e) {
        switch (e.code()) {
          case CONNECTIONLOSS:
          case OPERATIONTIMEOUT:
            LOG.warn("Possibly transient ZooKeeper exception: " + e);
            if (!retryCounter.shouldRetry()) {
              LOG.error(
                  "ZooKeeper getChildren failed after "
                      + retryCounter.getMaxRetries()
                      + " retries");
              throw e;
            }
            break;

          default:
            throw e;
        }
      }
      retryCounter.sleepUntilNextRetry();
      retryCounter.useRetry();
    }
  }
    @Override
    public void run() {
      if (isSynchronizedWithZooKeeper.get() || !zkClient.isConnected() || !started.get()) {

        return;
      }
      if (checkVersion.getAndSet(false)) {
        try {
          synchronized (lastStatusVersionMonitor) {
            final Stat stat = zkClient.getZookeeper().exists(path, null);
            if (stat != null
                && zkClient.getZookeeper().getSessionId() == stat.getEphemeralOwner()) {
              zkClient.getZookeeper().delete(path, lastStatusVersion);
            }
          }
        } catch (InterruptedException e) {
          LOG.info("Interrupted");
          checkVersion.set(true);
        } catch (KeeperException e) {
          LOG.info("exception " + e.getMessage());
          checkVersion.set(true);
        }
      }
      LOG.info(
          "We are out-of-sync, have a zookeeper connection, and are started, trying reclaim: "
              + path
              + this);
      tryClaim();
    }
Example #3
0
File: Tools.java Project: goby/oce
  public static String obtainUpgradingLock(ZooKeeper zk, String name) {
    String created = null;
    try {
      if (null == name) {
        created =
            zk.create("/upgrading_lock", new byte[] {}, Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
      } else {
        created =
            zk.create(
                "/" + name + "/upgrading_lock",
                new byte[] {},
                Ids.OPEN_ACL_UNSAFE,
                CreateMode.EPHEMERAL);
      }
    } catch (KeeperException e) {
      e.printStackTrace();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }

    if (created == null) {
      System.out.println("Failed to obtain upgrading lock.");
      return null;
    }
    return created;
  }
Example #4
0
  /**
   * Place the host:port advertisement for the Monitor's Log4j listener in ZooKeeper
   *
   * @param conf configuration for the instance
   * @param instanceId instanceId for the instance
   * @param hostAddress Address that monitor process is bound to
   */
  public static void startLogListener(
      AccumuloConfiguration conf, String instanceId, String hostAddress) {
    try {
      SocketServer server = new SocketServer(conf.getPort(Property.MONITOR_LOG4J_PORT));

      // getLocalPort will return the actual ephemeral port used when '0' was provided.
      String logForwardingAddr = hostAddress + ":" + server.getLocalPort();

      log.debug("Setting monitor log4j log-forwarding address to: " + logForwardingAddr);

      final String path = ZooUtil.getRoot(instanceId) + Constants.ZMONITOR_LOG4J_ADDR;
      final ZooReaderWriter zoo = ZooReaderWriter.getInstance();

      // Delete before we try to re-create in case the previous session hasn't yet expired
      try {
        zoo.delete(path, -1);
      } catch (KeeperException e) {
        // We don't care if the node is already gone
        if (!KeeperException.Code.NONODE.equals(e.code())) {
          throw e;
        }
      }

      zoo.putEphemeralData(path, logForwardingAddr.getBytes(UTF_8));

      new Daemon(server).start();
    } catch (Throwable t) {
      log.info("Unable to start/advertise Log4j listener for log-forwarding to monitor", t);
    }
  }
  @Override
  public void initializeSecurity(TCredentials credentials, String principal, byte[] token)
      throws AccumuloSecurityException {
    try {
      // remove old settings from zookeeper first, if any
      IZooReaderWriter zoo = ZooReaderWriter.getInstance();
      synchronized (zooCache) {
        zooCache.clear();
        if (zoo.exists(ZKUserPath)) {
          zoo.recursiveDelete(ZKUserPath, NodeMissingPolicy.SKIP);
          log.info("Removed " + ZKUserPath + "/" + " from zookeeper");
        }

        // prep parent node of users with root username
        zoo.putPersistentData(ZKUserPath, principal.getBytes(UTF_8), NodeExistsPolicy.FAIL);

        constructUser(principal, ZKSecurityTool.createPass(token));
      }
    } catch (KeeperException e) {
      log.error("{}", e.getMessage(), e);
      throw new RuntimeException(e);
    } catch (InterruptedException e) {
      log.error("{}", e.getMessage(), e);
      throw new RuntimeException(e);
    } catch (AccumuloException e) {
      log.error("{}", e.getMessage(), e);
      throw new RuntimeException(e);
    }
  }
Example #6
0
  /**
   * Removes the lock or associated znode if you no longer require the lock. this also removes your
   * request in the queue for locking in case you do not already hold the lock.
   *
   * @throws RuntimeException throws a runtime exception if it cannot connect to zookeeper.
   */
  public synchronized void unlock() throws RuntimeException {

    if (!isClosed() && id != null) {
      // we don't need to retry this operation in the case of failure
      // as ZK will remove ephemeral files and we don't wanna hang
      // this process when closing if we cannot reconnect to ZK
      try {

        ZooKeeperOperation zopdel =
            new ZooKeeperOperation() {
              public boolean execute() throws KeeperException, InterruptedException {
                zookeeper.delete(id, -1);
                return Boolean.TRUE;
              }
            };
        zopdel.execute();
      } catch (InterruptedException e) {
        LOG.warn("Caught: " + e, e);
        // set that we have been interrupted.
        Thread.currentThread().interrupt();
      } catch (KeeperException.NoNodeException e) {
        // do nothing
      } catch (KeeperException e) {
        LOG.warn("Caught: " + e, e);
        throw (RuntimeException) new RuntimeException(e.getMessage()).initCause(e);
      } finally {
        if (callback != null) {
          callback.lockReleased();
        }
        id = null;
      }
    }
  }
 @Override
 public void changePassword(String principal, AuthenticationToken token)
     throws AccumuloSecurityException {
   if (!(token instanceof PasswordToken))
     throw new AccumuloSecurityException(principal, SecurityErrorCode.INVALID_TOKEN);
   PasswordToken pt = (PasswordToken) token;
   if (userExists(principal)) {
     try {
       synchronized (zooCache) {
         zooCache.clear(ZKUserPath + "/" + principal);
         ZooReaderWriter.getInstance()
             .putPrivatePersistentData(
                 ZKUserPath + "/" + principal,
                 ZKSecurityTool.createPass(pt.getPassword()),
                 NodeExistsPolicy.OVERWRITE);
       }
     } catch (KeeperException e) {
       log.error("{}", e.getMessage(), e);
       throw new AccumuloSecurityException(principal, SecurityErrorCode.CONNECTION_ERROR, e);
     } catch (InterruptedException e) {
       log.error("{}", e.getMessage(), e);
       throw new RuntimeException(e);
     } catch (AccumuloException e) {
       log.error("{}", e.getMessage(), e);
       throw new AccumuloSecurityException(principal, SecurityErrorCode.DEFAULT_SECURITY_ERROR, e);
     }
   } else
     throw new AccumuloSecurityException(
         principal, SecurityErrorCode.USER_DOESNT_EXIST); // user doesn't exist
 }
Example #8
0
 /**
  * Utility - return true if the given exception is retry-able
  *
  * @param exception exception to check
  * @return true/false
  */
 public static boolean isRetryException(Throwable exception) {
   if (exception instanceof KeeperException) {
     KeeperException keeperException = (KeeperException) exception;
     return shouldRetry(keeperException.code().intValue());
   }
   return false;
 }
  private String createSequential(String path, byte[] data, List<ACL> acl, CreateMode createMode)
      throws KeeperException, InterruptedException {
    RetryCounter retryCounter = retryCounterFactory.create();
    boolean first = true;
    String newPath = path + this.identifier;
    while (true) {
      try {
        if (!first) {
          // Check if we succeeded on a previous attempt
          String previousResult = findPreviousSequentialNode(newPath);
          if (previousResult != null) {
            return previousResult;
          }
        }
        first = false;
        return zk.create(newPath, data, acl, createMode);
      } catch (KeeperException e) {
        switch (e.code()) {
          case CONNECTIONLOSS:
          case SESSIONEXPIRED:
          case OPERATIONTIMEOUT:
            retryOrThrow(retryCounter, e, "create");
            break;

          default:
            throw e;
        }
      }
      retryCounter.sleepUntilNextRetry();
      retryCounter.useRetry();
    }
  }
Example #10
0
  /**
   * Creates the serialized value of the object and stores this in ZooKeeper under the path. It
   * updates the lastStatusVersion. It does not set a watcher for the path.
   */
  private void updateCoordinateData() throws CoordinateMissingException, CloudnameException {
    if (!started.get()) {
      throw new IllegalStateException("Not started.");
    }

    if (!zkClient.isConnected()) {
      throw new CloudnameException("No proper connection with zookeeper.");
    }

    synchronized (lastStatusVersionMonitor) {
      try {
        Stat stat =
            zkClient
                .getZookeeper()
                .setData(
                    path,
                    zkCoordinateData.snapshot().serialize().getBytes(Util.CHARSET_NAME),
                    lastStatusVersion);
        LOG.fine("Updated coordinate, latest version is " + stat.getVersion());
        lastStatusVersion = stat.getVersion();
      } catch (KeeperException.NoNodeException e) {
        throw new CoordinateMissingException("Coordinate does not exist " + path);
      } catch (KeeperException e) {
        throw new CloudnameException(
            "ZooKeeper errror in updateCoordinateData: " + e.getMessage(), e);
      } catch (UnsupportedEncodingException e) {
        throw new CloudnameException(e);
      } catch (InterruptedException e) {
        throw new CloudnameException(e);
      } catch (IOException e) {
        throw new CloudnameException(e);
      }
    }
  }
Example #11
0
  public byte[] getData(String path, Watcher watcher, Stat stat)
      throws KeeperException, InterruptedException {
    RetryCounter retryCounter = retryCounterFactory.create();
    while (true) {
      try {
        // 120227 by DaeJin Choi - What about Metadata of data ( ex: Magic
        // number and so on )
        return zk.getData(path, watcher, stat);
      } catch (KeeperException e) {
        switch (e.code()) {
          case CONNECTIONLOSS:
          case OPERATIONTIMEOUT:
            LOG.warn("Possibly transient ZooKeeper exception: " + e);
            if (!retryCounter.shouldRetry()) {
              LOG.error(
                  "ZooKeeper getData failed after " + retryCounter.getMaxRetries() + " retries");
              throw e;
            }
            break;

          default:
            throw e;
        }
      }
      retryCounter.sleepUntilNextRetry();
      retryCounter.useRetry();
    }
  }
Example #12
0
  /**
   * Barrier constructor
   *
   * @param address
   * @param root
   * @param size
   */
  Barrier(String address, String root, int size) {
    super(address);
    this.input = input;
    this.size = size;

    // Create barrier node
    if (zk != null) {
      try {
        Stat s = zk.exists(root, false);
        if (s == null) {
          zk.create(input, new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        }
      } catch (KeeperException e) {
        System.out.println("Keeper exception when instantiating queue: " + e.toString());
      } catch (InterruptedException e) {
        System.out.println("Interrupted exception");
      }
    }

    // My node name
    try {
      name = new String(InetAddress.getLocalHost().getCanonicalHostName().toString());
    } catch (UnknownHostException e) {
      System.out.println(e.toString());
    }
  }
Example #13
0
  public String createEphemeralSequential(final String path, final byte[] data) throws Exception {
    RetryCounter retryCounter = retryCounterFactory.create();
    while (true) {
      try {
        return zk.create(path, data, Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
      } catch (KeeperException e) {
        switch (e.code()) {
          case CONNECTIONLOSS:
          case OPERATIONTIMEOUT:
            LOG.warn("Possibly transient ZooKeeper exception: " + e);
            if (!retryCounter.shouldRetry()) {
              LOG.error(
                  "ZooKeeper create failed after " + retryCounter.getMaxRetries() + " retries");
              throw e;
            }
            break;

          default:
            throw e;
        }
      }
      retryCounter.sleepUntilNextRetry();
      retryCounter.useRetry();
    }
  }
Example #14
0
  /**
   * Lista os {@link DataNode}s conectados no momento ao ClusterService.
   *
   * @return datanodes
   * @throws KeeperException
   * @throws InterruptedException
   * @throws IOException
   */
  public static List<NodeStatus> getDatanodesConnected() {
    List<NodeStatus> datanodes = new ArrayList<NodeStatus>();
    try {
      List<String> nodesIds = zk.getChildren(ZkConf.DATANODES_PATH, true);
      LOG.info("Cluster com " + nodesIds.size() + " datanode(s) ativo(s) no momento.");

      for (String hostName : nodesIds) {
        String path = ZkConf.DATANODES_PATH + "/" + hostName;
        byte[] bytes = zk.getData(path, true, null);
        NodeStatus node = (NodeStatus) Serializer.toObject(bytes);
        datanodes.add(node);
      }

    } catch (ClassNotFoundException e) {
      LOG.error(e.getMessage(), e);
    } catch (KeeperException e) {
      LOG.error(e.getMessage(), e);
    } catch (InterruptedException e) {
      LOG.error(e.getMessage(), e);
    } catch (IOException e) {
      LOG.error(e.getMessage(), e);
    }

    return datanodes;
  }
Example #15
0
  public void createPersistent(final String path, final byte[] data)
      throws KeeperException, InterruptedException {
    RetryCounter retryCounter = retryCounterFactory.create();
    while (true) {
      try {
        zk.create(path, data, Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        return;
      } catch (KeeperException e) {
        switch (e.code()) {
          case CONNECTIONLOSS:
          case OPERATIONTIMEOUT:
            LOG.warn("Possibly transient ZooKeeper exception: " + e);
            if (!retryCounter.shouldRetry()) {
              LOG.error(
                  "ZooKeeper create failed after " + retryCounter.getMaxRetries() + " retries");
              throw e;
            }
            break;

          default:
            throw e;
        }
      }
      retryCounter.sleepUntilNextRetry();
      retryCounter.useRetry();
    }
  }
  @Test
  public void testStormZkRoot() {
    String stormRoot = "/storm-zk-root";

    List<String> children = null;

    try {
      children = zkClient.get().getChildren(stormRoot, null);
    } catch (KeeperException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (TimeoutException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }

    for (String string : children) {
      System.out.println(string);
    }
  }
  public void displayConfig() {
    try {
      String value = store.read(ConfigUpdater.CONFIG, this);

      System.out.printf("取出值 %s from %s\n", ConfigUpdater.CONFIG, value);
    } catch (KeeperException e) {
      e.printStackTrace();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }
Example #18
0
 void setWatcher() {
   try {
     Stat s = zk.exists("/root", true);
     if (s != null) {
       zk.getData("/root", false, s);
     }
   } catch (KeeperException e) {
     e.printStackTrace();
   } catch (InterruptedException e) {
     e.printStackTrace();
   }
 }
 /** {@inheritDoc} */
 @Override
 public boolean remove(Object o) {
   try {
     return this.removeUnsynchronized(o);
   } catch (InterruptedException e) {
     throw new RuntimeException(e.getClass().getSimpleName() + " caught", e);
   } catch (KeeperException e) {
     throw new RuntimeException(e.getClass().getSimpleName() + " caught", e);
   } catch (IOException e) {
     throw new RuntimeException(e.getClass().getSimpleName() + " caught", e);
   }
 }
Example #20
0
  public static synchronized void managerDatanodesCreated(String hostName, NodeStatus nodeLocal) {
    try {

      if (nodeLocal.getNodesResponding().contains(hostName)) {
        String path = ZkConf.DATANODES_PATH + "/" + HOSTNAME;
        nodeLocal.getNodesResponding().remove(nodeLocal.getNodesResponding().indexOf(hostName));
        zk.setData(path, Serializer.fromObject(nodeLocal), -1);
      }

      if (HOSTNAME.equals(hostName)) {
        loadDada();

        if (managerDatanodesResponding.containsKey(hostName)) {
          managerDatanodesResponding.remove(hostName);
          zk.setData(
              ZkConf.MANAGER_NODES_RESPONDING,
              Serializer.fromObject((Serializable) managerDatanodesResponding),
              -1);
        }

        if (datanodesDesconnected.contains(hostName)) {
          datanodesDesconnected.remove(hostName);

          if (historicSendDatanodesDesconnected.containsKey(hostName)) {
            historicSendDatanodesDesconnected.remove(hostName);
          }

          zk.setData(
              ZkConf.DATANODES_DESCONNECTED,
              Serializer.fromObject((Serializable) datanodesDesconnected),
              -1);
          zk.setData(
              ZkConf.HISTORIC_SEND,
              Serializer.fromObject((Serializable) historicSendDatanodesDesconnected),
              -1);
        }

        if (datanodesConnected.size() > 1) {
          new SupportReplyText().checkRepliesText(datanodesReplyReceive);
          new SupportReplyImage().checkRepliesImage(datanodesReplyReceive);
        }

        clear();
      }
    } catch (KeeperException e) {
      LOG.error(e.getMessage(), e);
    } catch (InterruptedException e) {
      LOG.error(e.getMessage(), e);
    } catch (IOException e) {
      LOG.error(e.getMessage(), e);
    }
  }
Example #21
0
 @Result(success = "/WEB-INF/pages/group/viewAdd.jsp", fail = "/WEB-INF/pages/group/viewAdd.jsp")
 @Override
 public String add(HttpServletRequest req, HttpServletResponse resp) {
   String groupname = param(req, "groupname");
   groupname = groupname.toUpperCase();
   Group model = new Group();
   model.setGroupname(groupname);
   setAttr(req, MODEL, model);
   if (StringUtils.isBlank(groupname)) {
     setAttr(req, TIP_NAME_KEY, "请输入分组名");
     return FAIL;
   }
   // 屏蔽原始节点名[zookeeper][serverCluster]
   if (StringUtils.equals(groupname, ZOOKEEPER_KEY.toUpperCase())
       || StringUtils.equals(groupname, SERVER_CLUSTER_KEY.toUpperCase())) {
     setAttr(req, TIP_NAME_KEY, "对不起,不能创建内置分组名");
     model.setGroupname("");
     return FAIL;
   }
   // 业务
   if (model.isExist(groupname)) {
     setAttr(req, TIP_NAME_KEY, "对不起,分组名[" + groupname + "]已被使用,请换个分组名后重试!");
     model.setGroupname("");
     return FAIL;
   }
   // 添加组服务zookeeper节点
   ZooKeeper zk = (ZooKeeper) context.getAttribute(ZOOKEEPER_KEY);
   Stat groupExist;
   try {
     String groupNode = "/" + groupname;
     groupExist = zk.exists(groupNode, new AutoDataWatcher(zk));
     if (groupExist == null) {
       log.debug("创建分组节点:" + groupNode);
       zk.create(groupNode, new byte[] {}, Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
     } else {
       log.debug("已存在分组节点" + groupNode + ",不能创建...");
     }
   } catch (KeeperException e) {
     e.printStackTrace();
   } catch (InterruptedException e) {
     e.printStackTrace();
   }
   // 保存到数据库
   if (model.save() > 0) {
     setAttr(req, TIP_NAME_KEY, "恭喜您,成功添加新分组: [" + groupname + "]");
     model.setGroupname("");
     return SUCCESS;
   } else {
     setAttr(req, TIP_NAME_KEY, "系统故障,请稍候重试");
     return FAIL;
   }
 }
Example #22
0
 SelfWatch(String address) {
   try {
     zk = new ZooKeeper(address, 600000, this); // 在创建ZooKeeper时第三个参数负责设置该类的默认构造函数
     zk.create("/root", new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
   } catch (IOException e) {
     e.printStackTrace();
     zk = null;
   } catch (KeeperException e) {
     e.printStackTrace();
   } catch (InterruptedException e) {
     e.printStackTrace();
   }
 }
  protected KeeperException.Code createFromByte(String path, byte[] data, CreateMode mode) {

    try {
      zooKeeper.create(path, data, acl, mode);

    } catch (KeeperException e) {
      return e.code();
    } catch (Exception e) {
      return KeeperException.Code.SYSTEMERROR;
    }

    return KeeperException.Code.OK;
  }
Example #24
0
 public static boolean createIfNotExists(
     ZooKeeperConnection zooKeeper, String path, byte[] value, CreateMode createMode)
     throws KeeperException, InterruptedException {
   if (zooKeeper.exists(path, false) == null) {
     try {
       zooKeeper.create(path, value, ZooDefs.Ids.OPEN_ACL_UNSAFE, createMode);
     } catch (KeeperException e) {
       if (e.code() != KeeperException.Code.NODEEXISTS) throw e;
       return false;
     }
     return true;
   }
   return false;
 }
  /**
   * {@inheritDoc} NB: Nulls cannot be represented by this collection. Attempting to add one will
   * cause an {@link IllegalArgumentException} to be thrown.
   */
  @Override
  public boolean add(T o) {
    if (o == null) throw new IllegalArgumentException("nulls not allowed");

    try {
      return this.addUnsynchronized(o);
    } catch (KeeperException e) {
      throw new RuntimeException(e.getClass().getSimpleName() + " caught", e);
    } catch (InterruptedException e) {
      throw new RuntimeException(e.getClass().getSimpleName() + " caught", e);
    } catch (IOException e) {
      throw new RuntimeException(e.getClass().getSimpleName() + " caught", e);
    }
  }
  /** {@inheritDoc} */
  @Override
  public void clear() {
    synchronized (this.elements) {
      try {
        for (String s : this.keeper.getChildren(this.znode, this.watcher))
          this.keeper.delete(this.znode + '/' + s, -1);

        this.synchronize();
      } catch (KeeperException e) {
        throw new RuntimeException(e.getClass().getSimpleName() + " caught", e);
      } catch (InterruptedException e) {
        throw new RuntimeException(e.getClass().getSimpleName() + " caught", e);
      }
    }
  }
 public boolean deletePath(String path, ZookeeperConnection zkConn) throws IOException {
   if (zkConn != null) {
     try {
       zkConn.createZookeeper().delete(path, -1);
       zkConn.close();
     } catch (InterruptedException e) {
       e.printStackTrace();
       return false;
     } catch (KeeperException e) {
       e.printStackTrace();
       return false;
     }
   }
   return true;
 }
Example #28
0
 private List<ReplicationPeer> listValidReplicationPeers() {
   Map<String, ReplicationPeerConfig> peers = listPeerConfigs();
   if (peers == null || peers.size() <= 0) {
     return null;
   }
   List<ReplicationPeer> validPeers = new ArrayList<ReplicationPeer>(peers.size());
   for (Entry<String, ReplicationPeerConfig> peerEntry : peers.entrySet()) {
     String peerId = peerEntry.getKey();
     String clusterKey = peerEntry.getValue().getClusterKey();
     Configuration peerConf = new Configuration(this.connection.getConfiguration());
     Stat s = null;
     try {
       ZKUtil.applyClusterKeyToConf(peerConf, clusterKey);
       Pair<ReplicationPeerConfig, Configuration> pair = this.replicationPeers.getPeerConf(peerId);
       ReplicationPeer peer = new ReplicationPeerZKImpl(peerConf, peerId, pair.getFirst());
       s =
           zkw.getRecoverableZooKeeper()
               .exists(peerConf.get(HConstants.ZOOKEEPER_ZNODE_PARENT), null);
       if (null == s) {
         LOG.info(peerId + ' ' + clusterKey + " is invalid now.");
         continue;
       }
       validPeers.add(peer);
     } catch (ReplicationException e) {
       LOG.warn(
           "Failed to get valid replication peers. "
               + "Error connecting to peer cluster with peerId="
               + peerId);
       LOG.debug("Failure details to get valid replication peers.", e);
       continue;
     } catch (KeeperException e) {
       LOG.warn(
           "Failed to get valid replication peers. KeeperException code=" + e.code().intValue());
       LOG.debug("Failure details to get valid replication peers.", e);
       continue;
     } catch (InterruptedException e) {
       LOG.warn("Failed to get valid replication peers due to InterruptedException.");
       LOG.debug("Failure details to get valid replication peers.", e);
       Thread.currentThread().interrupt();
       continue;
     } catch (IOException e) {
       LOG.warn("Failed to get valid replication peers due to IOException.");
       LOG.debug("Failure details to get valid replication peers.", e);
       continue;
     }
   }
   return validPeers;
 }
Example #29
0
 /**
  * Constructor
  *
  * @param connectString
  * @param root
  */
 FIFOQueue(String connectString, String root) throws IOException {
   super(connectString);
   this.root = root;
   if (zk != null) {
     try {
       Stat s = zk.exists(root, false);
       if (s == null) {
         zk.create(root, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
       }
     } catch (KeeperException e) {
       System.out.println("NO:" + e.getMessage());
     } catch (InterruptedException e) {
       System.out.println("NO:" + e.getMessage());
     }
   }
 }
Example #30
0
  private void enode_test_1() throws IOException, InterruptedException, KeeperException {
    checkRoot();
    String parentName = testDirOnZK;
    String nodeName = parentName + "/enode_abc";
    ZooKeeper zk = new ZooKeeper(hostPort, 10000, this);

    Stat stat = zk.exists(parentName, false);
    if (stat == null) {
      try {
        zk.create(parentName, null, Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
      } catch (KeeperException ke) {
        fail("Creating node " + parentName + ke.getMessage());
      }
    }

    try {
      zk.create(nodeName, null, Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
    } catch (KeeperException ke) {
      int code = ke.getCode();
      boolean valid = code == KeeperException.Code.NodeExists;
      if (!valid) {
        fail("Unexpected exception code for createin: " + ke.getMessage());
      }
    }

    stat = zk.exists(nodeName, false);
    if (stat == null) {
      fail("node " + nodeName + " should exist");
    }
    System.out.println("Closing client with sessionid: 0x" + Long.toHexString(zk.getSessionId()));
    zk.close();
    zk = new ZooKeeper(hostPort, 10000, this);

    for (int i = 0; i < 10; i++) {
      System.out.println("i = " + i);
      stat = zk.exists(nodeName, false);
      if (stat != null) {
        System.out.println("node " + nodeName + " should not exist after reconnection close");
      } else {
        System.out.println("node " + nodeName + " is gone after reconnection close!");
        break;
      }
      Thread.sleep(5000);
    }
    deleteZKDir(zk, nodeName);
    zk.close();
  }