public void encodeClusterSchema(Element e, TransMeta transMeta) {
    JSONArray jsonArray = new JSONArray();
    for (int i = 0; i < transMeta.getClusterSchemas().size(); i++) {
      ClusterSchema clusterSchema = transMeta.getClusterSchemas().get(i);

      JSONObject jsonObject = new JSONObject();
      jsonObject.put("name", clusterSchema.getName());
      jsonObject.put("base_port", clusterSchema.getBasePort());
      jsonObject.put("sockets_buffer_size", clusterSchema.getSocketsBufferSize());

      jsonObject.put("sockets_flush_interval", clusterSchema.getSocketsFlushInterval());
      jsonObject.put("sockets_compressed", clusterSchema.isSocketsCompressed() ? "Y" : "N");
      jsonObject.put("dynamic", clusterSchema.isDynamic() ? "Y" : "N");

      JSONArray slaveservers = new JSONArray();
      for (int j = 0; j < clusterSchema.getSlaveServers().size(); j++) {
        SlaveServer slaveServer = clusterSchema.getSlaveServers().get(j);
        slaveservers.add(SlaveServerCodec.encode(slaveServer));
      }
      jsonObject.put("slaveservers", slaveservers);

      jsonArray.add(jsonObject);
    }
    e.setAttribute("clusterSchemas", jsonArray.toString());
  }
  private synchronized ObjectId insertCluster(ClusterSchema clusterSchema) throws KettleException {
    if (getClusterID(clusterSchema.getName()) != null) {
      // This cluster schema name is already in use. Throw an exception.
      throw new KettleObjectExistsException(
          "Failed to create object in repository. Object ["
              + clusterSchema.getName()
              + "] already exists.");
    }

    ObjectId id = repository.connectionDelegate.getNextClusterID();

    RowMetaAndData table = new RowMetaAndData();

    table.addValue(
        new ValueMeta(
            KettleDatabaseRepository.FIELD_CLUSTER_ID_CLUSTER, ValueMetaInterface.TYPE_INTEGER),
        id);
    table.addValue(
        new ValueMeta(KettleDatabaseRepository.FIELD_CLUSTER_NAME, ValueMetaInterface.TYPE_STRING),
        clusterSchema.getName());
    table.addValue(
        new ValueMeta(
            KettleDatabaseRepository.FIELD_CLUSTER_BASE_PORT, ValueMetaInterface.TYPE_STRING),
        clusterSchema.getBasePort());
    table.addValue(
        new ValueMeta(
            KettleDatabaseRepository.FIELD_CLUSTER_SOCKETS_BUFFER_SIZE,
            ValueMetaInterface.TYPE_STRING),
        clusterSchema.getSocketsBufferSize());
    table.addValue(
        new ValueMeta(
            KettleDatabaseRepository.FIELD_CLUSTER_SOCKETS_FLUSH_INTERVAL,
            ValueMetaInterface.TYPE_STRING),
        clusterSchema.getSocketsFlushInterval());
    table.addValue(
        new ValueMeta(
            KettleDatabaseRepository.FIELD_CLUSTER_SOCKETS_COMPRESSED,
            ValueMetaInterface.TYPE_BOOLEAN),
        Boolean.valueOf(clusterSchema.isSocketsCompressed()));
    table.addValue(
        new ValueMeta(
            KettleDatabaseRepository.FIELD_CLUSTER_DYNAMIC, ValueMetaInterface.TYPE_BOOLEAN),
        Boolean.valueOf(clusterSchema.isDynamic()));

    repository
        .connectionDelegate
        .getDatabase()
        .prepareInsert(table.getRowMeta(), KettleDatabaseRepository.TABLE_R_CLUSTER);
    repository.connectionDelegate.getDatabase().setValuesInsert(table);
    repository.connectionDelegate.getDatabase().insertRow();
    repository.connectionDelegate.getDatabase().closeInsert();

    return id;
  }
 protected boolean equals(ClusterSchema clusterSchema, ClusterSchema clusterSchema2) {
   if (!equals(clusterSchema.getName(), clusterSchema2.getName())) {
     return false;
   } else if (!equals(clusterSchema.getBasePort(), clusterSchema2.getBasePort())) {
     return false;
   } else if (!equals(
       clusterSchema.getSocketsBufferSize(), clusterSchema2.getSocketsBufferSize())) {
     return false;
   } else if (!equals(
       clusterSchema.getSocketsFlushInterval(), clusterSchema2.getSocketsFlushInterval())) {
     return false;
   } else if (!equals(clusterSchema.isSocketsCompressed(), clusterSchema2.isSocketsCompressed())) {
     return false;
   } else if (!equals(clusterSchema.isDynamic(), clusterSchema2.isDynamic())) {
     return false;
   } else if (!equals(clusterSchema.getSlaveServers(), clusterSchema2.getSlaveServers())) {
     return false;
   }
   return true;
 }
  public synchronized void updateCluster(ClusterSchema clusterSchema) throws KettleException {
    RowMetaAndData table = new RowMetaAndData();

    table.addValue(
        new ValueMeta(
            KettleDatabaseRepository.FIELD_CLUSTER_ID_CLUSTER, ValueMetaInterface.TYPE_INTEGER),
        clusterSchema.getObjectId());
    table.addValue(
        new ValueMeta(KettleDatabaseRepository.FIELD_CLUSTER_NAME, ValueMetaInterface.TYPE_STRING),
        clusterSchema.getName());
    table.addValue(
        new ValueMeta(
            KettleDatabaseRepository.FIELD_CLUSTER_BASE_PORT, ValueMetaInterface.TYPE_STRING),
        clusterSchema.getBasePort());
    table.addValue(
        new ValueMeta(
            KettleDatabaseRepository.FIELD_CLUSTER_SOCKETS_BUFFER_SIZE,
            ValueMetaInterface.TYPE_STRING),
        clusterSchema.getSocketsBufferSize());
    table.addValue(
        new ValueMeta(
            KettleDatabaseRepository.FIELD_CLUSTER_SOCKETS_FLUSH_INTERVAL,
            ValueMetaInterface.TYPE_STRING),
        clusterSchema.getSocketsFlushInterval());
    table.addValue(
        new ValueMeta(
            KettleDatabaseRepository.FIELD_CLUSTER_SOCKETS_COMPRESSED,
            ValueMetaInterface.TYPE_BOOLEAN),
        Boolean.valueOf(clusterSchema.isSocketsCompressed()));
    table.addValue(
        new ValueMeta(
            KettleDatabaseRepository.FIELD_CLUSTER_DYNAMIC, ValueMetaInterface.TYPE_BOOLEAN),
        Boolean.valueOf(clusterSchema.isDynamic()));

    repository.connectionDelegate.updateTableRow(
        KettleDatabaseRepository.TABLE_R_CLUSTER,
        KettleDatabaseRepository.FIELD_CLUSTER_ID_CLUSTER,
        table,
        clusterSchema.getObjectId());
  }