How does Cassandra differ from Hadoop?

The primary difference between Cassandra and Hadoop is that Cassandra targets real-time/operational data, while Hadoop has been designed for batch-based analytic work.

There are many different technical differences between Cassandra and Hadoop, including Cassandra’s underlying data structure (based on Google’s Bigtable), its fault-tolerant, peer-to-peer architecture, multi-data center capabilities, tunable data consistency, all nodes being the same (no concept of a namenode, etc.) and much more.

How does Cassandra differ from HBase?

HBase is an open-source, column-oriented data store modeled after Google Bigtable, and is designed to offer Bigtable-like capabilities on top of data stored in Hadoop. However, while HBase shared the Bigtable design with Cassandra, its foundational architecture is much different.

A Cassandra cluster is much easier to setup and configure than a comparable HBase cluster. HBase’s reliance on the Hadoop namenode equates to there being a single point of failure in HBase, whereas with Cassandra, because all nodes are the same, there is no such issue.

In internal performance tests conducted at DataStax (using the Yahoo Cloud Serving Benchmark – YCSB), Cassandra offered literally 5X better performance in writes and 4X better performance on reads than HBase.

How does Cassandra differ from MongoDB?

MongoDB is a document-oriented database that is built upon a master-slave/sharding architecture. MongoDB is designed to store/manage collections of JSON-styled documents.

By contrast, Cassandra uses a peer-to-peer, write/read-anywhere styled architecture that is based on a combination of Google BigTable and Amazon Dynamo. This allows Cassandra to avoid the various complications and pitfalls of master/slave and sharding architectures. Moreover, Cassandra offers linear performance increases as new nodes are added to a cluster, scales to terabyte-petabyte data volumes, and has no single point of failure.

README.txt는 카산드라에 대한 개략적인 내용과 설치에 대한 내용이 들어 있습니다..
NEWS.txt는 카산드라가 버전업이 되면서, 바뀌는 내용을 개략적으로 기술한 파일입니다..

NOTICE.txt 파일에는 카산드라가 사용하고 있는 Dependency Library에 대한 내용을 포함하고 있습니다..
CHANGES.txt 파일에는 카산드라 버전이 업데이트 되면서, 새롭게 추가되거나 수정된 내용을 이슈트래킹 번호를 포함해서 보여주고 있습니다.. 따라서 자세한 내용은 CHANGES.txt 파일의 이슈트래킹 번호를 따라 들어가게 되면, 버전 업에 따른 좀 더 세부적인 내용을 살펴볼 수 있습니다.. 

sudo apt-get install libboost-dev libboost-test1.42-dev libboost-program-options1.42-dev libevent-dev automake libtool flex bison pkg-config g++

$ tar xvf thrift-0.6.1.tar.gz

$ cd thrift-0.6.1/
$ ./configure JAVAC=/usr/local/java --prefix=/usr/local/thrift
$ make
$ sudo make install

<property name="poolPingEnabled" value="true"/>
<property name="poolPingQuery" value="select 1 from dual"/>

Cassandra.Client는 org.apache.cassandra.thrift 패키지의 클래스이고, 결국, Client는 Cassandra의 Inner 클래스가 됩니다..그리고, 위 패키지는 Thrift라는 데이타 serialize/deserialize 라이브러리(Google Protocol Buffers랑 비슷)를 통해서 전송될 데이타를 만들고, 전송된 데이타를 처리하고 있겠죵.. Cassandra의 언어별 클라이언트 라이브러리는 http://wiki.apache.org/cassandra/ClientOptions 페이지에 자세히 기술이 되어 있습니다.. 클라이언트 라이브러리들은 보통 Cassandra 서버에 붙는 Connection에 대한 풀링을 제공하는데, Connection 풀링은 org.apache.cassandra.thrift 패키지의 Cassandra.Client를 풀링해서 구현 할 수 있습니다. 
아래 코드는 Cassandra.Client의 풀링을 통한 Cassandra 서버의 연결에 대한 풀링기능을 제공하고 있습니다..^^

* CassandraClientArrayFactory.java

* CassandraClientArrayFactoryTest.java 

ex) 인터페이스 이름
public String print(String x) throws Exception;

ex) mapper.xml
<select id="prints" statementType="CALLABLE" parameterType="String" resultType="String">
        .........................
</select>

1.Definition
2.History & Reference
3.Features
4.Data Model
5.Project Package
6.Performance
7.적용가능 부분
8.Q&A

Cassandra.pdf

/**
 * The ConsistencyLevel is an enum that controls both read and write behavior based on <ReplicationFactor> in your
 * storage-conf.xml. The different consistency levels have different meanings, depending on if you're doing a write or read
 * operation. Note that if W + R > ReplicationFactor, where W is the number of nodes to block for on write, and R
 * the number to block for on reads, you will have strongly consistent behavior; that is, readers will always see the most
 * recent write. Of these, the most interesting is to do QUORUM reads and writes, which gives you consistency while still
 * allowing availability in the face of node failures up to half of <ReplicationFactor>. Of course if latency is more
 * important than consistency then you can use lower values for either or both.
 *
 * Write:
 *      ZERO    Ensure nothing. A write happens asynchronously in background
 *      ANY     Ensure that the write has been written once somewhere, including possibly being hinted in a non-target node.
 *      ONE     Ensure that the write has been written to at least 1 node's commit log and memory table before responding to the client.
 *      QUORUM  Ensure that the write has been written to <ReplicationFactor> / 2 + 1 nodes before responding to the client.
 *      ALL     Ensure that the write is written to <code>&lt;ReplicationFactor&gt;</code> nodes before responding to the client.
 *
 * Read:
 *      ZERO    Not supported, because it doesn't make sense.
 *      ANY     Not supported. You probably want ONE instead.
 *      ONE     Will return the record returned by the first node to respond. A consistency check is always done in a
 *              background thread to fix any consistency issues when ConsistencyLevel.ONE is used. This means subsequent
 *              calls will have correct data even if the initial read gets an older value. (This is called 'read repair'.)
 *      QUORUM  Will query all storage nodes and return the record with the most recent timestamp once it has at least a
 *              majority of replicas reported. Again, the remaining replicas will be checked in the background.
 *      ALL     Not yet supported, but we plan to eventually.
 */

INFO 10:00:53,760 Saved ClusterName found: Test Cluster
ERROR 10:00:53,760 ClusterName mismatch: Test Cluster != Cluster1

String y = new String(x.getBytes("iso-8859-1"));

Difference between Struts 1.0 and Struts 2.0

1.Servlet Dependency

Actions in Struts1 have dependencies on the servlet API since the HttpServletRequest and HttpServletResponse objects are passed to the execute method when an Action is invoked but in case of Struts 2.0, Actions are not container dependent because they are made simple POJOs. In Struts 2.0, the servlet contexts are represented as simple Maps which allows actions to be tested in isolation. Struts 2.0 Actions can access the original request and response, if required. However, other architectural elements reduce or eliminate the need to access the HttpServetRequest or HttpServletResponse directly.

2.Action classes

Programming the abstract classes instead of interfaces is one of design issues of struts 1.0 framework that has been resolved in the Struts 2.0 framework. Struts 1.0 Action classes needs to extend framework dependent abstract base class. But in case of Struts 2.0 Action class may or may not implement interfaces to enable optional and custom services. In case of Struts 2.0 , Actions are not container dependent because they are made simple POJOs. Struts 2.0 provides a base ActionSupport class to implement commonly used interfaces. Albeit, the Action interface is not required. Any POJO object with an execute signature can be used as an Struts 2.0 Action object.

3.Validation

Struts 1.0 and Struts 2.0 both supports the manual validation via a validate method. Struts 1.0 uses validate method on the ActionForm, or validates through an extension to the Commons Validator. However, Struts 2.0 supports manual validation via the validate method and the XWork Validation framework. The Xwork Validation Framework supports chaining validation into sub-properties using the validations defined for the properties class type and the validation context.

4.Threading Model

In Struts1, Action resources must be thread-safe or synchronized. So Actions are singletons and thread-safe, there should only be one instance of a class to handle all requests for that Action. The singleton strategy places restrictions on what can be done with Struts 1.0 Actions and requires extra care to develop. However in case of Struts 2.0, Action objects are instantiated for each request, so there are no thread-safety issues. (In practice, servlet containers generate many throw-away objects per request, and one more object does not impose a performance penalty or impact garbage collection.)

5.Testability

Testing Struts 1.0 applications are a bit complex. A major hurdle to test Struts 1.0 Actions is that the execute method because it exposes the Servlet API. A third-party extension, Struts TestCase, offers a set of mock object for Struts1. But the Struts 2.0 Actions can be tested by instantiating the Action, setting properties and invoking methods. Dependency Injection support also makes testing simpler. Actions in struts2 are simple POJOs and are framework independent, hence testability is quite easy in struts2.

6.Harvesting Input

Struts 1.0 uses an ActionForm object to capture input. And all ActionForms needs to extend a framework dependent base class. JavaBeans cannot be used as ActionForms, so the developers have to create redundant classes to capture input. However Struts 2.0 uses Action properties (as input properties independent of underlying framework) that eliminates the need for a second input object, hence reduces redundancy. Additionally in Struts 2.0, Action properties can be accessed from the web page via the taglibs. Struts 2.0 also supports the ActionForm pattern, as well as POJO form objects and POJO Actions. Even rich object types, including business or domain objects, can be used as input/output objects.

7.Expression Language

Struts 1.0 integrates with JSTL, so it uses the JSTL-EL. The struts1 EL has basic object graph traversal, but relatively weak collection and indexed property support. Struts 2.0 can also use JSTL, however it supports a more powerful and flexible expression language called "Object Graph Notation Language" (OGNL).

8.Binding values into views

In the view section, Struts1 uses the standard JSP mechanism to bind objects (processed from the model section) into the page context to access. However Struts 2.0 uses a "ValueStack" technology so that the taglibs can access values without coupling your view to the object type it is rendering. The ValueStack strategy allows the reuse of views across a range of types which may have the same property name but different property types.

9.Type Conversion

Usually, Struts 1.0 ActionForm properties are all Strings. Struts 1.0 uses Commons-Beanutils for type conversion. These type converters are per-class and not configurable per instance. However Struts 2.0 uses OGNL for type conversion. The framework includes converters for basic and common object types and primitives.

10.Control Of Action Execution

Struts 1.0 supports separate Request Processor (lifecycles) for each module, but all the Actions in a module must share the same lifecycle. However Struts 2.0 supports creating different lifecycles on a per Action basis via Interceptor Stacks. Custom stacks can be created and used with different Actions as needed.

• JVM에 1.5GB할당되었을 경우 : (2GB-1.5Gb-120MB)/(1MB) = ~380 threads
• JVM에 1.0GB할당되었을 경우 : (2GB-1.0Gb-120MB)/(1MB) = ~880 threads

• Tomcat의 경우 v6.0.14이상의 안정적 릴리즈 된것을 선택
• JDK1.4보다는 1.5, 1.6의 사용을 권고함
• -XXMaxPermSize 설정을 통해 perm 사이즈를 증가시킴
• JHat으로 메모리릭 원인을 찾고 JConsole, Lambda probe 등을 통해 메모리 모니터링을 함
• Application Server운영자는 Garbage Collection에 대한 이해가 있어야 함

3. Tomcat에서 설정 예시

• 힙메모리 정보를 출력 : -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:+PrintHeapAtGC

위 설정을 통해 출력되는 로그를 보고 New Generation의 eden 영역, Old Generation 영역, Permanent 영역을 확인하여 각 영역이 작으면 아래와 같은 설정으로 적당 사이즈를 확보해 줍니다.

• 도출된 설정 : -Xms256m -Xmx512m -XX:NewSize=256m -XX:MaxNewSize=256m -XX:MaxPermSize=128m -XX:SurvivorRatio=5
  -Xms : 최소 힙 싸이즈
  -Xmx : 최대 힙 싸이즈
  -XX:NewSize : New Generation의 최소 싸이즈
  -XX:MaxNewSize : New Generation의 최대 싸이즈
  -XX:MaxPermSize : Permanent Generation의 최대 싸이즈 가 되겠다.
  -XX:SurvivorRatio : 영역비율(New Generation)

결론적으로 적용할 설정은 아래와 같습니다.

• CATALINA_OPTS="-server -Xss256k -Xms256m -Xmx512m -XX:NewSize=256m -XX:MaxNewSize=256m -XX:MaxPermSize=128m -XX:SurvivorRatio=5 -XX:ReservedCodeCacheSize=128m -XX:+DisableExplicitGC -XX:+UseConcMarkSweepGC -Djava.net.preferIPv4Stack=true -Djava.awt.headless=true "

Open Soure는 100% 안정적이지 않기 때문에 가장 최신의 안정적인 버젼이 릴리즈되는지 항상 예의 주시하여 버전업에 게을러서는 안됩니다

위 내용은 http://www.mimul.com/pebble/default/2008/01/26/1201346400000.html 에서 발췌를 하였습니다.

Apache iBatis에서 다중의 데이타 베이스에 접속하는 방법에 대한 내용입니다.

1. database.properties

driver=oracle.jdbc.driver.OracleDriver
jdbc.url1=jdbc:oracle:thin:@mimuluserdb:1521:mimuluser
username1=mimuluser
password1=mimuluser

jdbc.url2=jdbc:oracle:thin:@pepsiuserdb:1521:pepsiuser
username2=pepsiuser
password2=pepsiuser

2. sqlmap1.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE sqlMapConfig
        PUBLIC "-//iBATIS.com//DTD SQL Map Config 2.0//EN"
        "http://www.ibatis.com/dtd/sql-map-config-2.dtd">
<sqlMapConfig>
    <properties resource="com/mimul/dwr/app/
               resource/database.properties"/>
    <settings
            cacheModelsEnabled="true"
            enhancementEnabled="true"
            lazyLoadingEnabled="true"
            maxRequests="40"
            maxSessions="20"
            maxTransactions="5"
            useStatementNamespaces="false"
            />
    <transactionManager type="JDBC">
        <dataSource type="DBCP">
            <property name="driverClassName" value="${driver}"/>
            <property name="url" value="${jdbc.url1}"/>
            <property name="username" value="${username1}"/>
            <property name="password" value="${password1}"/>

            <!-- OPTIONAL PROPERTIES BELOW -->
            <property name="initialSize" value="5"/>
            <property name="maxActive" value="30"/>
            <property name="maxIdle" value="20"/>
            <property name="maxWait" value="60000"/>
            <property name="poolPreparedStatements" value="true"/>
            <property name="validationQuery" value="select 0 from dual"/>
            <property name="testOnBorrow" value="true"/>
            <property name="maximumActiveConnections" value="10"/>
            <property name="maximumIdleConnections" value="5"/>
            <property name="maximumWait" value="60000"/>
            <property name="logAbandoned" value="false"/>
            <property name="removeAbandoned" value="false"/>
            <property name="removeAbandonedTimeout" value="50000"/>
        </dataSource>
    </transactionManager>
    <sqlMap resource="com/mimul/dwr/app/sql/Mimul.xml"/>
</sqlMapConfig>

3. sqlmap2.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE sqlMapConfig
        PUBLIC "-//iBATIS.com//DTD SQL Map Config 2.0//EN"
        "http://www.ibatis.com/dtd/sql-map-config-2.dtd">
<sqlMapConfig>
    <properties resource="com/mimul/dwr/app/resource/database.properties"/>
    <settings
            cacheModelsEnabled="true"
            enhancementEnabled="true"
            lazyLoadingEnabled="true"
            maxRequests="40"
            maxSessions="20"
            maxTransactions="5"
            useStatementNamespaces="false"
            />
    <transactionManager type="JDBC">
        <dataSource type="DBCP">
            <property name="driverClassName" value="${driver}"/>
            <property name="url" value="${jdbc.url2}"/>
            <property name="username" value="${username2}"/>
            <property name="password" value="${password2}"/>

            <!-- OPTIONAL PROPERTIES BELOW -->
            <property name="initialSize" value="5"/>
            <property name="maxActive" value="30"/>
            <property name="maxIdle" value="20"/>
            <property name="maxWait" value="60000"/>
            <property name="poolPreparedStatements" value="true"/>
            <property name="validationQuery" value="select 0 from dual"/>
            <property name="testOnBorrow" value="true"/>
            <property name="maximumActiveConnections" value="10"/>
            <property name="maximumIdleConnections" value="5"/>
            <property name="maximumWait" value="60000"/>
            <property name="logAbandoned" value="false"/>
            <property name="removeAbandoned" value="false"/>
            <property name="removeAbandonedTimeout" value="50000"/>
        </dataSource>
    </transactionManager>
    <sqlMap resource="com/mimul/dwr/app/sql/Pepsi.xml"/>
</sqlMapConfig>

4. SqlCondig.java

import java.io.File;
import java.io.Reader;

import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;
import com.jaeminara.common.log.LogPool;

public class SqlConfig {
    private static SqlMapClient sqlMap1 = null;
    private static SqlMapClient sqlMap2 = null;
    private static SqlConfig instance_ = null;
   
    private SqlConfig() throws Exception {
        Reader reader = null;
        String resource = null;
        try {
            if (sqlMap == null) {
                resource = "sqlmap1.xml";
              reader = Resources.getResourceAsReader(resource);
              sqlMap1 = SqlMapClientBuilder.buildSqlMapClient(reader);
                resource = "sqlmap2.xml";
              reader = Resources.getResourceAsReader(resource);
              sqlMap2 = SqlMapClientBuilder.buildSqlMapClient(reader);
              reader.close();
            }
        } catch (Exception e) {
            System.out.println(e);
            throw e;
        } finally {
            if (reader != null)
                reader.close();
            reader = null;
            rsc = null;
        }
    }
   
    public static SqlConfig instance() {
        try {
            if (instance_ == null) {
                synchronized (SqlConfig.class) {
                    if (instance_ == null)
                        instance_ = new SqlConfig();
                }
            }
        } catch (Exception e) {
            System.out.println(e);
        }
        return instance_;
    }

    /**
     * Return SqlMapClient for SDP schema
     *
     * @return
     */
    public static SqlMapClient getSqlMap1Instance() {
        return sqlMap1;
    }

    /**
     * Return SqlMapClient for SDP schema
     *
     * @return
     */
    public static SqlMapClient getSqlMap2Instance() {
        return sqlMap2;
    }
}