[Carbon-commits] [Carbon] svn commit r114229 - in branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2: . src src/main src/main/java src/main/java/org src/main/java/org/wso2 src/main/java/org/wso2/carbon src/main/java/org/wso2/carbon/cassandra src/main/java/org/wso2/carbon/cassandra/server src/main/java/org/wso2/carbon/cassandra/server/cache src/main/java/org/wso2/carbon/cassandra/server/internal src/main/resources src/main/resources/org src/main/resources/org/wso2 src/main/resources/org/wso2/carbon src/main/resources/org/wso2/carbon/cassandra src/main/resources/org/wso2/carbon/cassandra/server src/main/resources/org/wso2/carbon/cassandra/server/deployment src/test src/test/resources
deep at wso2.com
deep at wso2.com
Mon Oct 17 08:35:26 EDT 2011
Author: deep
Date: Mon Oct 17 05:35:26 2011
New Revision: 114229
URL: http://wso2.org/svn/browse/wso2?view=rev&revision=114229
Log:
cassandra server 3.2.2
Added:
branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/
branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/pom.xml
branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/
branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/
branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/
branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/
branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/wso2/
branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/wso2/carbon/
branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/wso2/carbon/cassandra/
branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/wso2/carbon/cassandra/server/
branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/wso2/carbon/cassandra/server/CarbonCassandraAuthenticator.java
branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/wso2/carbon/cassandra/server/CarbonCassandraAuthority.java
branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/wso2/carbon/cassandra/server/CassandraServerComponentManager.java
branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/wso2/carbon/cassandra/server/CassandraServerController.java
branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/wso2/carbon/cassandra/server/CassandraServerException.java
branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/wso2/carbon/cassandra/server/cache/
branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/wso2/carbon/cassandra/server/cache/UserAccessKeyCache.java
branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/wso2/carbon/cassandra/server/internal/
branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/wso2/carbon/cassandra/server/internal/CassandraServerDSComponent.java
branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/resources/
branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/resources/org/
branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/resources/org/wso2/
branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/resources/org/wso2/carbon/
branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/resources/org/wso2/carbon/cassandra/
branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/resources/org/wso2/carbon/cassandra/server/
branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/resources/org/wso2/carbon/cassandra/server/deployment/
branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/resources/org/wso2/carbon/cassandra/server/deployment/cassandra_default.yaml
branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/test/
branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/test/resources/
Added: branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/pom.xml
URL: http://wso2.org/svn/browse/wso2/branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/pom.xml?pathrev=114229
==============================================================================
--- (empty file)
+++ branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/pom.xml Mon Oct 17 05:35:26 2011
@@ -0,0 +1,96 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ ~ Copyright (c) 2009-2010, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
+ ~
+ ~ Licensed 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.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+ <parent>
+ <groupId>org.wso2.carbon</groupId>
+ <artifactId>cassandra</artifactId>
+ <version>3.2.0</version>
+ <relativePath>../../pom.xml</relativePath>
+ </parent>
+ <version>3.2.2</version>
+ <modelVersion>4.0.0</modelVersion>
+ <artifactId>org.wso2.carbon.cassandra.server</artifactId>
+ <packaging>bundle</packaging>
+ <name>WSO2 Carbon - Cassandra Server</name>
+ <url>http://wso2.org</url>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.felix</groupId>
+ <artifactId>maven-scr-plugin</artifactId>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.felix</groupId>
+ <artifactId>maven-bundle-plugin</artifactId>
+ <version>1.4.0</version>
+ <extensions>true</extensions>
+ <configuration>
+ <instructions>
+ <Bundle-SymbolicName>${pom.artifactId}</Bundle-SymbolicName>
+ <Bundle-Name>${pom.artifactId}</Bundle-Name>
+ <Private-Package>org.wso2.carbon.cassandra.server.internal</Private-Package>
+ <Export-Package>
+ org.wso2.carbon.cassandra.server.*,
+ </Export-Package>
+ <Import-Package>
+ !org.wso2.carbon.cassandra.server.*,
+ org.apache.axiom.*; version="${axiom.osgi.version.range}",
+ !org.wso2.carbon.cassandra.server.deployment,
+ *;resolution:=optional,
+ </Import-Package>
+ <DynamicImport-Package>*</DynamicImport-Package>
+ </instructions>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+ <dependencies>
+ <dependency>
+ <groupId>org.wso2.carbon</groupId>
+ <artifactId>org.wso2.carbon.core</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.wso2.carbon</groupId>
+ <artifactId>org.wso2.carbon.caching.core</artifactId>
+ <version>3.2.2</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.cassandra</groupId>
+ <artifactId>apache-cassandra</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.wso2.carbon</groupId>
+ <artifactId>org.wso2.carbon.user.api</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.wso2.carbon</groupId>
+ <artifactId>org.wso2.carbon.logging</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>libthrift</groupId>
+ <artifactId>libthrift</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.wso2.carbon</groupId>
+ <artifactId>org.wso2.carbon.identity.authentication</artifactId>
+ </dependency>
+ </dependencies>
+
+</project>
Added: branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/wso2/carbon/cassandra/server/CarbonCassandraAuthenticator.java
URL: http://wso2.org/svn/browse/wso2/branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/wso2/carbon/cassandra/server/CarbonCassandraAuthenticator.java?pathrev=114229
==============================================================================
--- (empty file)
+++ branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/wso2/carbon/cassandra/server/CarbonCassandraAuthenticator.java Mon Oct 17 05:35:26 2011
@@ -0,0 +1,138 @@
+/*
+ * 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.wso2.carbon.cassandra.server;
+
+import org.apache.cassandra.auth.AuthenticatedUser;
+import org.apache.cassandra.auth.IAuthenticator;
+import org.apache.cassandra.config.ConfigurationException;
+import org.apache.cassandra.thrift.AuthenticationException;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.wso2.carbon.caching.core.CacheEntry;
+import org.wso2.carbon.caching.core.StringCacheEntry;
+import org.wso2.carbon.caching.core.StringCacheKey;
+import org.wso2.carbon.cassandra.server.cache.UserAccessKeyCache;
+import org.wso2.carbon.identity.authentication.AuthenticationService;
+
+import java.util.Collections;
+import java.util.Map;
+
+/**
+ * Carbon's authentication based implementation for the Cassandra's <coe>IAuthenticator</code>
+ * This can be used in both a MT environment and a normal Carbon plugin. For the former case, a user have to provide
+ * his or her name in the form of name at domainname (e.g foo at bar.com)
+ * TODO
+ */
+public class CarbonCassandraAuthenticator implements IAuthenticator {
+
+ private static final Log log = LogFactory.getLog(CarbonCassandraAuthenticator.class);
+
+ public static final String USERNAME_KEY = "username";
+ public static final String PASSWORD_KEY = "password";
+ private AuthenticationService authenticationService;
+ private static final UserAccessKeyCache cache = UserAccessKeyCache.getInstance();
+
+ /**
+ * @return null as a user must call login().
+ */
+ public AuthenticatedUser defaultUser() {
+ return null; // A user must log-in to the Cassandra
+ }
+
+ public static void addToCache(String username, String accessKey) {
+ cache.addToCache(new StringCacheKey(username), new StringCacheEntry(accessKey));
+
+ }
+ /**
+ * Validate the user's credentials and Call the Authentication plugin for checking permission for log-in to the
+ * Cassandra.
+ *
+ * @param credentials a user's credentials
+ * @return <code>AuthenticatedUser<code> representing a successful authentication
+ * @throws AuthenticationException if the authentication is failed
+ */
+ public AuthenticatedUser authenticate(Map<? extends CharSequence, ? extends CharSequence> credentials) throws AuthenticationException {
+
+ String domainName = null;
+
+ CharSequence user = credentials.get(USERNAME_KEY);
+ if (null == user) {
+ logAndAuthenticationException("Authentication request was missing the required " +
+ "key '" + USERNAME_KEY + "'");
+ }
+ assert user != null;
+
+ String userName = user.toString();
+ if (userName.indexOf("@") > 0) {
+ domainName = userName.substring(userName.indexOf("@") + 1);
+ if (domainName == null || domainName.trim().equals("")) {
+ logAndAuthenticationException("Authentication request was missing the domain name of the user in" +
+ " the key " + USERNAME_KEY);
+ }
+ }
+
+ CharSequence pass = credentials.get(PASSWORD_KEY);
+ if (null == pass) {
+ logAndAuthenticationException("Authentication request was missing the required" +
+ " key '" + PASSWORD_KEY + "'");
+ }
+ assert pass != null;
+
+ String password = pass.toString();
+
+ if (authenticationService.authenticate(userName, password)) {
+ AuthenticatedUser authenticatedUser = new AuthenticatedUser(userName,
+ Collections.<String>emptySet(), domainName);
+ return authenticatedUser;
+ } else if (isAuthenticated(userName, password)) {
+ AuthenticatedUser authenticatedUser = new AuthenticatedUser(userName,
+ Collections.<String>emptySet(), domainName);
+ return authenticatedUser;
+ }
+
+ return null; //
+ }
+
+ private void logAndAuthenticationException(String msg) throws AuthenticationException {
+ log.error(msg);
+ throw new AuthenticationException(msg);
+ }
+
+ private boolean isAuthenticated(String username, String keyAccess) {
+
+ CacheEntry cacheEntry = cache.getValueFromCache(new StringCacheKey(username));
+ String value=null;
+ if(cacheEntry != null){
+ value = ((StringCacheEntry)cacheEntry).getStringValue();
+ }else {
+ log.error("The key is not present in the cache...");
+ }
+ if (keyAccess != null && keyAccess.equals(value)) {
+ return true;
+ }
+ return false;
+ }
+
+ public void validateConfiguration() throws ConfigurationException {
+ CassandraServerComponentManager manager = CassandraServerComponentManager.getInstance();
+ authenticationService = manager.getAuthenticationService();
+ }
+
+
+}
Added: branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/wso2/carbon/cassandra/server/CarbonCassandraAuthority.java
URL: http://wso2.org/svn/browse/wso2/branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/wso2/carbon/cassandra/server/CarbonCassandraAuthority.java?pathrev=114229
==============================================================================
--- (empty file)
+++ branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/wso2/carbon/cassandra/server/CarbonCassandraAuthority.java Mon Oct 17 05:35:26 2011
@@ -0,0 +1,210 @@
+/*
+ * 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.wso2.carbon.cassandra.server;
+
+import org.apache.cassandra.auth.*;
+import org.apache.cassandra.config.ConfigurationException;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.wso2.carbon.user.api.AuthorizationManager;
+import org.wso2.carbon.user.api.UserRealm;
+import org.wso2.carbon.user.api.UserStoreException;
+import org.wso2.carbon.user.api.UserStoreManager;
+import org.wso2.carbon.user.core.util.UserCoreUtil;
+
+import java.util.EnumSet;
+import java.util.List;
+
+/**
+ * Carbon's authorization based implementation for the Cassandra's <coe>IAuthority</code>
+ * Resources are mapped to a URL and make the authorization for it
+ *
+ * @see org.apache.cassandra.auth.IAuthority
+ */
+public class CarbonCassandraAuthority implements IAuthority {
+
+ private static final Log log = LogFactory.getLog(CarbonCassandraAuthority.class);
+ //TODO use constants from user manager
+ private static final String ACTION_WRITE = "write";
+ private static final String ACTION_READ = "read";
+
+ /**
+ * Authorize the given user for performing actions on the given resource
+ *
+ * @param authenticatedUser <code>AuthenticatedUser</code> instance
+ * @param resource Cassandra's resource such as cf, keyspace
+ * @param action The action is going to be performed by the user
+ * @return A set of <code>Permission</code> the given user allowed for the given resource
+ * @see #authorize(org.apache.cassandra.auth.AuthenticatedUser, java.util.List, org.apache.cassandra.auth.Action)
+ */
+ public EnumSet<Permission> authorize(AuthenticatedUser authenticatedUser, List<Object> resource, Action action) {
+
+ if (resource.size() < 2 || !Resources.ROOT.equals(resource.get(0)) || !Resources.KEYSPACES.equals(resource.get(1))) {
+ return Permission.NONE;
+ }
+
+ String resourcePath = "/" + Resources.ROOT + "/" + Resources.KEYSPACES;
+
+ if (resource.size() == 2) {
+ //nothing
+ } else if (resource.size() == 3) {
+ String keyspace = (String) resource.get(2);
+ resourcePath += "/" + keyspace;
+ } else if (resource.size() == 4) {
+ String keyspace = (String) resource.get(2);
+ String columnFamily = (String) resource.get(3);
+ resourcePath += "/" + keyspace + "/" + columnFamily;
+ } else {
+ String msg = "Do not currently descend any lower in the hierarchy than the column family";
+ log.error(msg);
+ throw new UnsupportedOperationException(msg);
+ }
+
+ try {
+ //TODO - get the realm for a special user that can be used to authorize other users - security team - already talked but need to implement
+ UserRealm userRealm =
+ CassandraServerComponentManager.getInstance().getRealmForTenant(authenticatedUser.domainName);
+ UserStoreManager userStoreManager = userRealm.getUserStoreManager();
+ AuthorizationManager authorizationManager = userRealm.getAuthorizationManager();
+
+ String tenantLessUsername = UserCoreUtil.getTenantLessUsername(authenticatedUser.username);
+
+ switch (action) {
+ case ADD: {
+ return authorizeForAdd(userStoreManager, authorizationManager, tenantLessUsername, resourcePath);
+ }
+ case UPDATE: {
+ return authorizeForWrite(authorizationManager, tenantLessUsername, resourcePath);
+ }
+ case READ: {
+ return authorizeForRead(authorizationManager, tenantLessUsername, resourcePath);
+ }
+ case DELETE: {
+ return authorizeForWrite(authorizationManager, tenantLessUsername, resourcePath);
+ }
+ case ALL: {
+ return authorizeForWrite(authorizationManager, tenantLessUsername, resourcePath); //TODO check read if need
+ }
+ default: {
+ log.error("Undefined action for resource" + resourcePath);
+ return Permission.NONE;
+ }
+ }
+ } catch (UserStoreException e) {
+ log.error("Error during authorizing a user for a resource" + resourcePath, e);
+ return Permission.NONE;
+ }
+ }
+
+ /**
+ * Helper method to check the write operation on a resource for the current user
+ *
+ * @param authorizationManager <code>AuthorizationManager</code>
+ * @param tenantLessUsername username
+ * @param resourcePath resource
+ * @return a set of <code>Permission</code>
+ */
+ private EnumSet<Permission> authorizeForWrite(AuthorizationManager authorizationManager,
+ String tenantLessUsername,
+ String resourcePath) {
+ try {
+ EnumSet<Permission> authorized = EnumSet.noneOf(Permission.class);
+ boolean isAuthorized = authorizationManager.isUserAuthorized(tenantLessUsername,
+ resourcePath,
+ ACTION_WRITE);
+ if (isAuthorized) {
+ authorized.add(Permission.WRITE);
+ return authorized;
+ }
+ } catch (UserStoreException e) {
+ log.error("Authorization failure for user " + tenantLessUsername +
+ " for performing write on resource" + resourcePath);
+ }
+
+ return Permission.NONE;
+ }
+
+ /**
+ * Helper method to check the read operation on a resource for the current user
+ *
+ * @param authorizationManager <code>AuthorizationManager</code>
+ * @param tenantLessUsername username
+ * @param resourcePath resource
+ * @return a set of <code>Permission</code>
+ */
+ private EnumSet<Permission> authorizeForRead(AuthorizationManager authorizationManager,
+ String tenantLessUsername,
+ String resourcePath) {
+ try {
+ EnumSet<Permission> authorized = EnumSet.noneOf(Permission.class);
+ boolean isAuthorized = authorizationManager.isUserAuthorized(tenantLessUsername,
+ resourcePath,
+ ACTION_READ);
+
+ if (isAuthorized) {
+ authorized.add(Permission.READ);
+ return authorized;
+ }
+ } catch (UserStoreException e) {
+ log.error("Authorization failure for user " + tenantLessUsername +
+ " for performing read on resource" + resourcePath);
+ }
+ return Permission.NONE;
+ }
+
+ /**
+ * Helper method to authorize a user when adding a resorce. Here we create a role with the user's name
+ * TODO This should be done at the user manager level.
+ *
+ * @param userStoreManager <code>UserStoreManager</code>
+ * @param authorizationManager <code>AuthorizationManager</code>
+ * @param tenantLessUsername user name
+ * @param resourcePath resource
+ * @return a set of <code>Permission</code>
+ */
+ private EnumSet<Permission> authorizeForAdd(UserStoreManager userStoreManager,
+ AuthorizationManager authorizationManager,
+ String tenantLessUsername,
+ String resourcePath) {
+ try {
+ if(authorizationManager.isUserAuthorized(tenantLessUsername,resourcePath,ACTION_READ) && authorizationManager.isUserAuthorized(tenantLessUsername,resourcePath,ACTION_WRITE)){
+ return Permission.ALL;
+ }
+// if (userStoreManager.isExistingRole(tenantLessUsername)) {
+// authorizationManager.authorizeRole(tenantLessUsername, resourcePath, ACTION_WRITE);
+// authorizationManager.authorizeRole(tenantLessUsername, resourcePath, ACTION_READ);
+// } else {
+// // TODO this code should be done by user manager component
+// org.wso2.carbon.user.api.Permission[] permissions = new org.wso2.carbon.user.api.Permission[2];
+// permissions[0] = new org.wso2.carbon.user.api.Permission(resourcePath, ACTION_WRITE);
+// permissions[1] = new org.wso2.carbon.user.api.Permission(resourcePath, ACTION_READ);
+//
+// userStoreManager.addRole(tenantLessUsername, new String[]{tenantLessUsername}, permissions);
+// }
+ } catch (UserStoreException e) {
+ log.error("Authorization failure for user " + tenantLessUsername +
+ " for performing add resource" + resourcePath);
+ return Permission.NONE;
+ }
+ return Permission.NONE;
+ }
+
+ public void validateConfiguration() throws ConfigurationException {
+ }
+}
Added: branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/wso2/carbon/cassandra/server/CassandraServerComponentManager.java
URL: http://wso2.org/svn/browse/wso2/branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/wso2/carbon/cassandra/server/CassandraServerComponentManager.java?pathrev=114229
==============================================================================
--- (empty file)
+++ branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/wso2/carbon/cassandra/server/CassandraServerComponentManager.java Mon Oct 17 05:35:26 2011
@@ -0,0 +1,99 @@
+/*
+ * 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.
+ */
+/**
+ * Keeps the services required by this component
+ */
+package org.wso2.carbon.cassandra.server;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.wso2.carbon.identity.authentication.AuthenticationService;
+import org.wso2.carbon.user.api.UserRealm;
+import org.wso2.carbon.user.api.UserStoreException;
+import org.wso2.carbon.user.core.service.RealmService;
+
+/**
+ * Keep and manage the services required for operation of this component
+ */
+public class CassandraServerComponentManager {
+
+ private static Log log = LogFactory.getLog(CassandraServerComponentManager.class);
+
+ private static CassandraServerComponentManager ourInstance = new CassandraServerComponentManager();
+
+ private RealmService realmService;
+
+ private AuthenticationService authenticationService;
+
+ private boolean initialized = false;
+
+ public static CassandraServerComponentManager getInstance() {
+ return ourInstance;
+ }
+
+ private CassandraServerComponentManager() {
+ }
+
+ /**
+ * Initialize by giving required services
+ *
+ * @param realmService realm
+ * @param authenticationService authentication service
+ */
+ public void init(RealmService realmService,
+ AuthenticationService authenticationService) {
+ this.realmService = realmService;
+ this.authenticationService = authenticationService;
+ this.initialized = true;
+ }
+
+ public boolean isInitialized() {
+ return initialized;
+ }
+
+ private void assertInitialized() {
+ if (!initialized) {
+ throw new CassandraServerException("Cassandra server Component has not been initialized", log);
+ }
+ }
+
+ public AuthenticationService getAuthenticationService() {
+ assertInitialized();
+ return authenticationService;
+ }
+
+ public UserRealm getRealmForTenant(String domainName) {
+ assertInitialized();
+ try {
+ int tenantID = realmService.getTenantManager().getTenantId(domainName);
+ return realmService.getTenantUserRealm(tenantID);
+ } catch (UserStoreException e) {
+ throw new CassandraServerException("Error accessing the UserRealm for super tenant : " + e, log);
+ }
+ }
+
+ /**
+ * Cleanup resources
+ */
+ public void destroy() {
+ realmService = null;
+ authenticationService = null;
+ initialized = false;
+ }
+}
Added: branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/wso2/carbon/cassandra/server/CassandraServerController.java
URL: http://wso2.org/svn/browse/wso2/branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/wso2/carbon/cassandra/server/CassandraServerController.java?pathrev=114229
==============================================================================
--- (empty file)
+++ branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/wso2/carbon/cassandra/server/CassandraServerController.java Mon Oct 17 05:35:26 2011
@@ -0,0 +1,68 @@
+/*
+ * 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.wso2.carbon.cassandra.server;
+
+import org.apache.cassandra.thrift.CassandraDaemon;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+/**
+ * Control the Cassandra Daemon : TODO review this approach
+ */
+public class CassandraServerController {
+
+ private static Log log = LogFactory.getLog(CassandraServerController.class);
+
+ private final CassandraDaemon cassandraSever;
+ private Thread thread;
+
+ public CassandraServerController() {
+ cassandraSever = new CassandraDaemon();
+ }
+
+ /**
+ * Starts the Cassandra daemon
+ */
+ public void start() {
+ thread = new Thread(new Runnable() {
+ public void run() {
+ if (log.isDebugEnabled()) {
+ log.debug("Activating the Cassandra Server");
+ }
+ cassandraSever.activate();
+ log.info("Cassandra Server Controller Thread was destroyed successfully");
+ }
+ }, "CassandraServerController");
+ thread.start();
+ }
+
+ /**
+ * Stops the Cassandra daemon
+ */
+ public void shutdown() {
+ if (log.isDebugEnabled()) {
+ log.debug("Deactivating the Cassandra Server");
+ }
+ cassandraSever.deactivate();
+ try {
+ thread.join();
+ } catch (InterruptedException ignored) {
+ }
+ }
+}
Added: branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/wso2/carbon/cassandra/server/CassandraServerException.java
URL: http://wso2.org/svn/browse/wso2/branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/wso2/carbon/cassandra/server/CassandraServerException.java?pathrev=114229
==============================================================================
--- (empty file)
+++ branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/wso2/carbon/cassandra/server/CassandraServerException.java Mon Oct 17 05:35:26 2011
@@ -0,0 +1,51 @@
+/*
+ * 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.wso2.carbon.cassandra.server;
+
+import org.apache.commons.logging.Log;
+
+/**
+ * Represents errors at the back-end of the Cassandra
+ */
+
+public class CassandraServerException extends RuntimeException {
+
+ /**
+ * Logs the given message and create a RuntimeException object
+ *
+ * @param msg Error Message
+ * @param log Logger who need to consume message
+ */
+ public CassandraServerException(String msg, Log log) {
+ super(msg);
+ log.error(msg);
+ }
+
+ /**
+ * Logs the given message and the root error and create a RuntimeException object
+ *
+ * @param msg Error Message
+ * @param throwable Root Error
+ * @param log Logger who need to consume message
+ */
+ public CassandraServerException(String msg, Throwable throwable, Log log) {
+ super(msg, throwable);
+ log.error(msg, throwable);
+ }
+}
Added: branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/wso2/carbon/cassandra/server/cache/UserAccessKeyCache.java
URL: http://wso2.org/svn/browse/wso2/branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/wso2/carbon/cassandra/server/cache/UserAccessKeyCache.java?pathrev=114229
==============================================================================
--- (empty file)
+++ branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/wso2/carbon/cassandra/server/cache/UserAccessKeyCache.java Mon Oct 17 05:35:26 2011
@@ -0,0 +1,22 @@
+package org.wso2.carbon.cassandra.server.cache;
+
+import org.wso2.carbon.caching.core.BaseCache;
+
+public class UserAccessKeyCache extends BaseCache {
+
+ public final static String CASSANDRA_ACCESS_KEY_CACHE = "CASSANDRA_ACCESS_KEY_CACHE";
+
+ private static UserAccessKeyCache accessKeyCache = null;
+
+ private UserAccessKeyCache() {
+ super(CASSANDRA_ACCESS_KEY_CACHE);
+ }
+
+ public synchronized static UserAccessKeyCache getInstance() {
+ if (accessKeyCache == null) {
+ accessKeyCache = new UserAccessKeyCache();
+ }
+ return accessKeyCache;
+ }
+
+}
Added: branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/wso2/carbon/cassandra/server/internal/CassandraServerDSComponent.java
URL: http://wso2.org/svn/browse/wso2/branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/wso2/carbon/cassandra/server/internal/CassandraServerDSComponent.java?pathrev=114229
==============================================================================
--- (empty file)
+++ branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/java/org/wso2/carbon/cassandra/server/internal/CassandraServerDSComponent.java Mon Oct 17 05:35:26 2011
@@ -0,0 +1,190 @@
+/*
+ * 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.wso2.carbon.cassandra.server.internal;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.osgi.service.component.ComponentContext;
+import org.wso2.carbon.cassandra.server.CassandraServerComponentManager;
+import org.wso2.carbon.cassandra.server.CassandraServerController;
+import org.wso2.carbon.identity.authentication.AuthenticationService;
+import org.wso2.carbon.user.core.service.RealmService;
+import org.wso2.carbon.utils.ServerConstants;
+ import org.wso2.carbon.base.ServerConfiguration;
+
+import java.io.File;
+
+/**
+ * @scr.component name="org.wso2.carbon.cassandra.server.component" immediate="true"
+ * @scr.reference name="user.realmservice.default" interface="org.wso2.carbon.user.core.service.RealmService"
+ * cardinality="1..1" policy="dynamic" bind="setRealmService" unbind="unsetRealmService"
+ * @scr.reference name="org.wso2.carbon.identity.authentication.internal.AuthenticationServiceComponent"
+ * interface="org.wso2.carbon.identity.authentication.AuthenticationService"
+ * cardinality="1..1" policy="dynamic" bind="setAuthenticationService" unbind="unsetAuthenticationService"
+ */
+
+public class CassandraServerDSComponent {
+
+ private static Log log = LogFactory.getLog(CassandraServerDSComponent.class);
+
+ private static final String CASSANDRA_SERVER_CONF = File.separator + "repository" + File.separator + "conf"
+ + File.separator + "advanced" + File.separator + "cassandra.yaml";
+ private static final String DEFAULT_CONF = File.separator + "org" + File.separator + "wso2" + File.separator
+ + "carbon" + File.separator + "cassandra" + File.separator + "server" + File.separator + "deployment"
+ + File.separator + "cassandra_default.yaml";
+ /**
+ * WSO2 Carbon Port for carbon.xml
+ */
+ private static int CARBON_DEFAULT_PORT_OFFSET = 0;
+ private static String CARBON_CONFIG_CASSANDRA_RPC_PORT = "Ports.EmbeddedCassandra.RPCPort";
+ private static String CARBON_CONFIG_CASSANDRA_STORAGE_PORT = "Ports.EmbeddedCassandra.StoragePort";
+ private static String CARBON_CONFIG_PORT_OFFSET = "Ports.Offset";
+
+
+ private CassandraServerController cassandraServerController;
+ private RealmService realmService;
+ private AuthenticationService authenticationService;
+
+ protected void activate(ComponentContext componentContext) {
+
+ if (log.isDebugEnabled()) {
+ log.debug("Starting the Cassandra Server component");
+ }
+
+ CassandraServerComponentManager.getInstance().init(realmService, authenticationService);
+
+ // initialize and start the Cassandra server
+ String cassandraConfLocation = DEFAULT_CONF;
+ if (isConfigurationExists()) {
+ cassandraConfLocation = "file:" + System.getProperty(ServerConstants.CARBON_HOME) + CASSANDRA_SERVER_CONF;
+ }
+ System.setProperty("cassandra.config", cassandraConfLocation);
+ System.setProperty("cassandra-foreground", "yes");
+ //set Cassnadra ports form carbon.xml
+
+ int rpcPort = 0;
+ String carbonCassandraRPCPort = readRPCPortFromCarbonConfig();
+ int carbonPortOffset = readPortOffset();
+
+ if(!carbonCassandraRPCPort.isEmpty()){
+ try {
+ rpcPort = Integer.parseInt(carbonCassandraRPCPort) + carbonPortOffset;
+ if( rpcPort > 0 && rpcPort< 65535){
+ System.setProperty("cassandra.rpcport", Integer.toString(rpcPort));
+ }
+ } catch (NumberFormatException e) {
+ log.debug("Error Reading Cassandra RPC Port");
+ }
+ }
+
+ int storagePort = 0;
+ String carbonCassandraStoragePort = readStoragePortFromCarbonConfig();
+
+ if(!carbonCassandraStoragePort.isEmpty()){
+ try {
+ storagePort = Integer.parseInt(carbonCassandraStoragePort) + carbonPortOffset;
+ if( storagePort > 0 && storagePort< 65535){
+ System.setProperty("cassandra.storageport", Integer.toString(storagePort));
+ }
+ } catch (NumberFormatException e) {
+ log.debug("Error Reading Cassandra RPC Port");
+ }
+ }
+
+
+ cassandraServerController = new CassandraServerController();
+ cassandraServerController.start();
+ }
+
+ protected void deactivate(ComponentContext componentContext) {
+
+ if (log.isDebugEnabled()) {
+ log.debug("Stopping the Cassandra Server component");
+ }
+ // stop and destroy the Cassandra server
+ if (cassandraServerController != null) {
+ cassandraServerController.shutdown();
+ }
+ CassandraServerComponentManager.getInstance().destroy();
+ }
+
+ protected void setRealmService(RealmService realmService) {
+ this.realmService = realmService;
+ }
+
+ protected void unsetRealmService(RealmService realmService) {
+ this.realmService = null;
+ }
+
+ protected void setAuthenticationService(AuthenticationService authenticationService) {
+ this.authenticationService = authenticationService;
+ }
+
+ protected void unsetAuthenticationService(AuthenticationService authenticationService) {
+ this.authenticationService = null;
+ }
+
+ /**
+ * Checks the existence of the cassandra conf
+ *
+ * @return true if it is there in advanced directory
+ */
+ private boolean isConfigurationExists() {
+ String carbonHome = System.getProperty(ServerConstants.CARBON_HOME);
+ String path = carbonHome + CASSANDRA_SERVER_CONF;
+ if (!new File(path).exists()) {
+ log.info("There is no " + CASSANDRA_SERVER_CONF + ". Using the default configuration");
+ return false;
+ } else {
+ return true;
+ }
+ }
+
+ /**
+ * Read port from carbon.xml
+ *
+ * @return
+ */
+ private String readRPCPortFromCarbonConfig() {
+ ServerConfiguration carbonConfig = ServerConfiguration.getInstance();
+ String port = carbonConfig.getFirstProperty(CARBON_CONFIG_CASSANDRA_RPC_PORT);
+
+ return ((port != null) ? port.trim() : "");
+ }
+
+ private String readStoragePortFromCarbonConfig() {
+ ServerConfiguration carbonConfig = ServerConfiguration.getInstance();
+ String port = carbonConfig.getFirstProperty(CARBON_CONFIG_CASSANDRA_STORAGE_PORT);
+
+ return ((port != null) ? port.trim() : "");
+ }
+
+ private int readPortOffset() {
+ ServerConfiguration carbonConfig = ServerConfiguration.getInstance();
+ String portOffset = carbonConfig.getFirstProperty(CARBON_CONFIG_PORT_OFFSET);
+
+ try {
+ return ((portOffset != null) ? Integer.parseInt(portOffset.trim()) : CARBON_DEFAULT_PORT_OFFSET);
+ } catch (NumberFormatException e) {
+ return CARBON_DEFAULT_PORT_OFFSET;
+ }
+ }
+
+
+}
Added: branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/resources/org/wso2/carbon/cassandra/server/deployment/cassandra_default.yaml
URL: http://wso2.org/svn/browse/wso2/branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/resources/org/wso2/carbon/cassandra/server/deployment/cassandra_default.yaml?pathrev=114229
==============================================================================
--- (empty file)
+++ branches/carbon/3.2.0/components/cassandra/org.wso2.carbon.cassandra.server/3.2.2/src/main/resources/org/wso2/carbon/cassandra/server/deployment/cassandra_default.yaml Mon Oct 17 05:35:26 2011
@@ -0,0 +1,455 @@
+# Cassandra storage config YAML
+
+# NOTE:
+# See http://wiki.apache.org/cassandra/StorageConfiguration for
+# full explanations of configuration directives
+# /NOTE
+
+# The name of the cluster. This is mainly used to prevent machines in
+# one logical cluster from joining another.
+cluster_name: 'ClusterOne'
+
+# You should always specify InitialToken when setting up a production
+# cluster for the first time, and often when adding capacity later.
+# The principle is that each node should be given an equal slice of
+# the token ring; see http://wiki.apache.org/cassandra/Operations
+# for more details.
+#
+# If blank, Cassandra will request a token bisecting the range of
+# the heaviest-loaded existing node. If there is no load information
+# available, such as is the case with a new cluster, it will pick
+# a random token, which will lead to hot spots.
+initial_token:
+
+# Set to true to make new [non-seed] nodes automatically migrate data
+# to themselves from the pre-existing nodes in the cluster. Defaults
+# to false because you can only bootstrap N machines at a time from
+# an existing cluster of N, so if you are bringing up a cluster of
+# 10 machines with 3 seeds you would have to do it in stages. Leaving
+# this off for the initial start simplifies that.
+auto_bootstrap: false
+
+# See http://wiki.apache.org/cassandra/HintedHandoff
+hinted_handoff_enabled: true
+
+# authentication backend, implementing IAuthenticator; used to identify users
+authenticator: org.wso2.carbon.cassandra.server.CarbonCassandraAuthenticator
+
+# authorization backend, implementing IAuthority; used to limit access/provide permissions
+authority: org.wso2.carbon.cassandra.server.CarbonCassandraAuthority
+
+# The partitioner is responsible for distributing rows (by key) across
+# nodes in the cluster. Any IPartitioner may be used, including your
+# own as long as it is on the classpath. Out of the box, Cassandra
+# provides org.apache.cassandra.dht.RandomPartitioner
+# org.apache.cassandra.dht.ByteOrderedPartitioner,
+# org.apache.cassandra.dht.OrderPreservingPartitioner (deprecated),
+# and org.apache.cassandra.dht.CollatingOrderPreservingPartitioner
+# (deprecated).
+#
+# - RandomPartitioner distributes rows across the cluster evenly by md5.
+# When in doubt, this is the best option.
+# - ByteOrderedPartitioner orders rows lexically by key bytes. BOP allows
+# scanning rows in key order, but the ordering can generate hot spots
+# for sequential insertion workloads.
+# - OrderPreservingPartitioner is an obsolete form of BOP, that stores
+# - keys in a less-efficient format and only works with keys that are
+# UTF8-encoded Strings.
+# - CollatingOPP colates according to EN,US rules rather than lexical byte
+# ordering. Use this as an example if you need custom collation.
+#
+# See http://wiki.apache.org/cassandra/Operations for more on
+# partitioners and token selection.
+partitioner: org.apache.cassandra.dht.RandomPartitioner
+
+# directories where Cassandra should store data on disk.
+data_file_directories:
+ - ./repository/database/cassandra/data
+
+# commit log
+commitlog_directory: ./repository/database/cassandra/commitlog
+
+# saved caches
+saved_caches_directory: ./repository/database/cassandra/saved_caches
+
+# Size to allow commitlog to grow to before creating a new segment
+commitlog_rotation_threshold_in_mb: 128
+
+# commitlog_sync may be either "periodic" or "batch."
+# When in batch mode, Cassandra won't ack writes until the commit log
+# has been fsynced to disk. It will wait up to
+# CommitLogSyncBatchWindowInMS milliseconds for other writes, before
+# performing the sync.
+commitlog_sync: periodic
+
+# the other option is "timed," where writes may be acked immediately
+# and the CommitLog is simply synced every commitlog_sync_period_in_ms
+# milliseconds.
+commitlog_sync_period_in_ms: 10000
+
+# Addresses of hosts that are deemed contact points.
+# Cassandra nodes use this list of hosts to find each other and learn
+# the topology of the ring. You must change this if you are running
+# multiple nodes!
+seeds:
+ - 127.0.0.1
+
+# Access mode. mmapped i/o is substantially faster, but only practical on
+# a 64bit machine (which notably does not include EC2 "small" instances)
+# or relatively small datasets. "auto", the safe choice, will enable
+# mmapping on a 64bit JVM. Other values are "mmap", "mmap_index_only"
+# (which may allow you to get part of the benefits of mmap on a 32bit
+# machine by mmapping only index files) and "standard".
+# (The buffer size settings that follow only apply to standard,
+# non-mmapped i/o.)
+disk_access_mode: auto
+
+# Unlike most systems, in Cassandra writes are faster than reads, so
+# you can afford more of those in parallel. A good rule of thumb is 2
+# concurrent reads per processor core. Increase ConcurrentWrites to
+# the number of clients writing at once if you enable CommitLogSync +
+# CommitLogSyncDelay. -->
+concurrent_reads: 8
+concurrent_writes: 32
+
+# This sets the amount of memtable flush writer threads. These will
+# be blocked by disk io, and each one will hold a memtable in memory
+# while blocked. If you have a large heap and many data directories,
+# you can increase this value for better flush performance.
+# By default this will be set to the amount of data directories defined.
+#memtable_flush_writers: 1
+
+# Buffer size to use when performing contiguous column slices.
+# Increase this to the size of the column slices you typically perform
+sliced_buffer_size_in_kb: 64
+
+# TCP port, for commands and data
+storage_port: 7000
+
+# Address to bind to and tell other Cassandra nodes to connect to. You
+# _must_ change this if you want multiple nodes to be able to
+# communicate!
+#
+# Leaving it blank leaves it up to InetAddress.getLocalHost(). This
+# will always do the Right Thing *if* the node is properly configured
+# (hostname, name resolution, etc), and the Right Thing is to use the
+# address associated with the hostname (it might not be).
+#
+# Setting this to 0.0.0.0 is always wrong.
+listen_address: localhost
+
+# The address to bind the Thrift RPC service to -- clients connect
+# here. Unlike ListenAddress above, you *can* specify 0.0.0.0 here if
+# you want Thrift to listen on all interfaces.
+#
+# Leaving this blank has the same effect it does for ListenAddress,
+# (i.e. it will be based on the configured hostname of the node).
+rpc_address: localhost
+# port for Thrift to listen for clients on
+rpc_port: 9160
+
+# enable or disable keepalive on rpc connections
+rpc_keepalive: true
+
+# uncomment to set socket buffer sizes on rpc connections
+# rpc_send_buff_size_in_bytes:
+# rpc_recv_buff_size_in_bytes:
+
+# Frame size for thrift (maximum field length).
+# 0 disables TFramedTransport in favor of TSocket. This option
+# is deprecated; we strongly recommend using Framed mode.
+thrift_framed_transport_size_in_mb: 15
+
+# The max length of a thrift message, including all fields and
+# internal thrift overhead.
+thrift_max_message_length_in_mb: 16
+
+# Whether or not to take a snapshot before each compaction. Be
+# careful using this option, since Cassandra won't clean up the
+# snapshots for you. Mostly useful if you're paranoid when there
+# is a data format change.
+snapshot_before_compaction: false
+
+# change this to increase the compaction thread's priority. In java, 1 is the
+# lowest priority and that is our default.
+# compaction_thread_priority: 1
+
+# The threshold size in megabytes the binary memtable must grow to,
+# before it's submitted for flushing to disk.
+binary_memtable_throughput_in_mb: 256
+
+# Add column indexes to a row after its contents reach this size.
+# Increase if your column values are large, or if you have a very large
+# number of columns. The competing causes are, Cassandra has to
+# deserialize this much of the row to read a single column, so you want
+# it to be small - at least if you do many partial-row reads - but all
+# the index data is read for each access, so you don't want to generate
+# that wastefully either.
+column_index_size_in_kb: 64
+
+# Size limit for rows being compacted in memory. Larger rows will spill
+# over to disk and use a slower two-pass compaction process. A message
+# will be logged specifying the row key.
+in_memory_compaction_limit_in_mb: 64
+
+# Time to wait for a reply from other nodes before failing the command
+rpc_timeout_in_ms: 10000
+
+# phi value that must be reached for a host to be marked down.
+# most users should never need to adjust this.
+# phi_convict_threshold: 8
+
+# endpoint_snitch -- Set this to a class that implements
+# IEndpointSnitch, which will let Cassandra know enough
+# about your network topology to route requests efficiently.
+# Out of the box, Cassandra provides
+# - org.apache.cassandra.locator.SimpleSnitch:
+# Treats Strategy order as proximity. This improves cache locality
+# when disabling read repair, which can further improve throughput.
+# - org.apache.cassandra.locator.RackInferringSnitch:
+# Proximity is determined by rack and data center, which are
+# assumed to correspond to the 3rd and 2nd octet of each node's
+# IP address, respectively
+# org.apache.cassandra.locator.PropertyFileSnitch:
+# - Proximity is determined by rack and data center, which are
+# explicitly configured in cassandra-topology.properties.
+endpoint_snitch: org.apache.cassandra.locator.SimpleSnitch
+
+# dynamic_snitch -- This boolean controls whether the above snitch is
+# wrapped with a dynamic snitch, which will monitor read latencies
+# and avoid reading from hosts that have slowed (due to compaction,
+# for instance)
+dynamic_snitch: true
+# controls how often to perform the more expensive part of host score
+# calculation
+dynamic_snitch_update_interval_in_ms: 100
+# controls how often to reset all host scores, allowing a bad host to
+# possibly recover
+dynamic_snitch_reset_interval_in_ms: 600000
+# if set greater than zero and read_repair_chance is < 1.0, this will allow
+# 'pinning' of replicas to hosts in order to increase cache capacity.
+# The badness threshold will control how much worse the pinned host has to be
+# before the dynamic snitch will prefer other replicas over it. This is
+# expressed as a double which represents a percentage. Thus, a value of
+# 0.2 means Cassandra would continue to prefer the static snitch values
+# until the pinned host was 20% worse than the fastest.
+dynamic_snitch_badness_threshold: 0.0
+
+# request_scheduler -- Set this to a class that implements
+# RequestScheduler, which will schedule incoming client requests
+# according to the specific policy. This is useful for multi-tenancy
+# with a single Cassandra cluster.
+# NOTE: This is specifically for requests from the client and does
+# not affect inter node communication.
+# org.apache.cassandra.scheduler.NoScheduler - No scheduling takes place
+# org.apache.cassandra.scheduler.RoundRobinScheduler - Round robin of
+# client requests to a node with a separate queue for each
+# request_scheduler_id. The scheduler is further customized by
+# request_scheduler_options as described below.
+request_scheduler: org.apache.cassandra.scheduler.NoScheduler
+
+# Scheduler Options vary based on the type of scheduler
+# NoScheduler - Has no options
+# RoundRobin
+# - throttle_limit -- The throttle_limit is the number of in-flight
+# requests per client. Requests beyond
+# that limit are queued up until
+# running requests can complete.
+# The value of 80 here is twice the number of
+# concurrent_reads + concurrent_writes.
+# - default_weight -- default_weight is optional and allows for
+# overriding the default which is 1.
+# - weights -- Weights are optional and will default to 1 or the
+# overridden default_weight. The weight translates into how
+# many requests are handled during each turn of the
+# RoundRobin, based on the scheduler id.
+#
+# request_scheduler_options:
+# throttle_limit: 80
+# default_weight: 5
+# weights:
+# Keyspace1: 1
+# Keyspace2: 5
+
+# request_scheduler_id -- An identifer based on which to perform
+# the request scheduling. Currently the only valid option is keyspace.
+# request_scheduler_id: keyspace
+
+# The Index Interval determines how large the sampling of row keys
+# is for a given SSTable. The larger the sampling, the more effective
+# the index is at the cost of space.
+index_interval: 128
+
+# Keyspaces have ColumnFamilies. (Usually 1 KS per application.)
+# ColumnFamilies have Rows. (Dozens of CFs per KS.)
+# Rows contain Columns. (Many per CF.)
+# Columns contain name:value:timestamp. (Many per Row.)
+#
+# A KS is most similar to a schema, and a CF is most similar to a relational table.
+#
+# Keyspaces, ColumnFamilies, and Columns may carry additional
+# metadata that change their behavior. These are as follows:
+#
+# Keyspace required parameters:
+# - name: name of the keyspace; "system" is
+# reserved for Cassandra Internals.
+# - replica_placement_strategy: the class that determines how replicas
+# are distributed among nodes. Contains both the class as well as
+# configuration information. Must extend AbstractReplicationStrategy.
+# Out of the box, Cassandra provides
+# * org.apache.cassandra.locator.SimpleStrategy
+# * org.apache.cassandra.locator.NetworkTopologyStrategy
+# * org.apache.cassandra.locator.OldNetworkTopologyStrategy
+#
+# SimpleStrategy merely places the first
+# replica at the node whose token is closest to the key (as determined
+# by the Partitioner), and additional replicas on subsequent nodes
+# along the ring in increasing Token order.
+#
+# With NetworkTopologyStrategy,
+# for each datacenter, you can specify how many replicas you want
+# on a per-keyspace basis. Replicas are placed on different racks
+# within each DC, if possible. This strategy also requires rack aware
+# snitch, such as RackInferringSnitch or PropertyFileSnitch.
+# An example:
+# - name: Keyspace1
+# replica_placement_strategy: org.apache.cassandra.locator.NetworkTopologyStrategy
+# strategy_options:
+# DC1 : 3
+# DC2 : 2
+# DC3 : 1
+#
+# OldNetworkToplogyStrategy [formerly RackAwareStrategy]
+# places one replica in each of two datacenters, and the third on a
+# different rack in in the first. Additional datacenters are not
+# guaranteed to get a replica. Additional replicas after three are placed
+# in ring order after the third without regard to rack or datacenter.
+# - replication_factor: Number of replicas of each row
+# Keyspace optional paramaters:
+# - strategy_options: Additional information for the replication strategy.
+# - column_families:
+# ColumnFamily required parameters:
+# - name: name of the ColumnFamily. Must not contain the character "-".
+# - compare_with: tells Cassandra how to sort the columns for slicing
+# operations. The default is BytesType, which is a straightforward
+# lexical comparison of the bytes in each column. Other options are
+# AsciiType, UTF8Type, LexicalUUIDType, TimeUUIDType, LongType,
+# and IntegerType (a generic variable-length integer type).
+# You can also specify the fully-qualified class name to a class of
+# your choice extending org.apache.cassandra.db.marshal.AbstractType.
+#
+# ColumnFamily optional parameters:
+# - keys_cached: specifies the number of keys per sstable whose
+# locations we keep in memory in "mostly LRU" order. (JUST the key
+# locations, NOT any column values.) Specify a fraction (value less
+# than 1) or an absolute number of keys to cache. Defaults to 200000
+# keys.
+# - rows_cached: specifies the number of rows whose entire contents we
+# cache in memory. Do not use this on ColumnFamilies with large rows,
+# or ColumnFamilies with high write:read ratios. Specify a fraction
+# (value less than 1) or an absolute number of rows to cache.
+# Defaults to 0. (i.e. row caching is off by default)
+# - comment: used to attach additional human-readable information about
+# the column family to its definition.
+# - read_repair_chance: specifies the probability with which read
+# repairs should be invoked on non-quorum reads. must be between 0
+# and 1. defaults to 1.0 (always read repair).
+# - gc_grace_seconds: specifies the time to wait before garbage
+# collecting tombstones (deletion markers). defaults to 864000 (10
+# days). See http://wiki.apache.org/cassandra/DistributedDeletes
+# - default_validation_class: specifies a validator class to use for
+# validating all the column values in the CF.
+# NOTE:
+# min_ must be less than max_compaction_threshold!
+# - min_compaction_threshold: the minimum number of SSTables needed
+# to start a minor compaction. increasing this will cause minor
+# compactions to start less frequently and be more intensive. setting
+# this to 0 disables minor compactions. defaults to 4.
+# - max_compaction_threshold: the maximum number of SSTables allowed
+# before a minor compaction is forced. decreasing this will cause
+# minor compactions to start more frequently and be less intensive.
+# setting this to 0 disables minor compactions. defaults to 32.
+# /NOTE
+# - row_cache_save_period_in_seconds: number of seconds between saving
+# row caches. The row caches can be saved periodically and if one
+# exists on startup it will be loaded.
+# - key_cache_save_period_in_seconds: number of seconds between saving
+# key caches. The key caches can be saved periodically and if one
+# exists on startup it will be loaded.
+# - memtable_flush_after_mins: The maximum time to leave a dirty table
+# unflushed. This should be large enough that it won't cause a flush
+# storm of all memtables during periods of inactivity.
+# - memtable_throughput_in_mb: The maximum size of the memtable before
+# it is flushed. If undefined, 1/8 * heapsize will be used.
+# - memtable_operations_in_millions: Number of operations in millions
+# before the memtable is flushed. If undefined, throughput / 64 * 0.3
+# will be used.
+# - column_metadata:
+# Column required parameters:
+# - name: binds a validator (and optionally an indexer) to columns
+# with this name in any row of the enclosing column family.
+# - validator: like cf.compare_with, an AbstractType that checks
+# that the value of the column is well-defined.
+# Column optional parameters:
+# NOTE:
+# index_name cannot be set if index_type is not also set!
+# - index_name: User-friendly name for the index.
+# - index_type: The type of index to be created. Currently only
+# KEYS is supported.
+# /NOTE
+#
+# NOTE:
+# this keyspace definition is for demonstration purposes only.
+# Cassandra will not load these definitions during startup. See
+# http://wiki.apache.org/cassandra/FAQ#no_keyspaces for an explanation.
+# /NOTE
+keyspaces:
+ - name: Keyspace1
+ replica_placement_strategy: org.apache.cassandra.locator.SimpleStrategy
+ replication_factor: 1
+ column_families:
+ - name: Standard1
+ compare_with: BytesType
+ keys_cached: 10000
+ rows_cached: 1000
+ row_cache_save_period_in_seconds: 0
+ key_cache_save_period_in_seconds: 3600
+ memtable_flush_after_mins: 59
+ memtable_throughput_in_mb: 255
+ memtable_operations_in_millions: 0.29
+
+ - name: Standard2
+ compare_with: UTF8Type
+ read_repair_chance: 0.1
+ keys_cached: 100
+ gc_grace_seconds: 0
+ min_compaction_threshold: 5
+ max_compaction_threshold: 31
+
+ - name: StandardByUUID1
+ compare_with: TimeUUIDType
+
+ - name: Super1
+ column_type: Super
+ compare_with: BytesType
+ compare_subcolumns_with: BytesType
+
+ - name: Super2
+ column_type: Super
+ compare_subcolumns_with: UTF8Type
+ rows_cached: 10000
+ keys_cached: 50
+ comment: 'A column family with supercolumns, whose column and subcolumn names are UTF8 strings'
+
+ - name: Super3
+ column_type: Super
+ compare_with: LongType
+ comment: 'A column family with supercolumns, whose column names are Longs (8 bytes)'
+
+ - name: Indexed1
+ default_validation_class: LongType
+ column_metadata:
+ - name: birthdate
+ validator_class: LongType
+ index_name: birthdate_idx
+ index_type: KEYS
More information about the Carbon-commits
mailing list