<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width,initial-scale=1.0">
    <title>Apache Cassandra | Apache Cassandra Documentation</title>
    <link rel="stylesheet" href="../../assets/css/site.css">
    <link rel="schema.dcterms" href="https://purl.org/dc/terms/">
    <meta name="dcterms.subject" content="_">
    <meta name="dcterms.identifier" content="master">
    <meta name="generator" content="Antora 2.3.4">
    <link rel="icon" href="../../assets/img/favicon.ico" type="image/x-icon">
<script>
  const script = document.createElement("script");
  const domain = window.location.hostname;
  script.type = "text/javascript";
  script.src = "https://plausible.cassandra.apache.org/js/plausible.js";
  script.setAttribute("data-domain",domain);
  script.setAttribute("defer",'true');
  script.setAttribute("async",'true');
  document.getElementsByTagName("head")[0].appendChild(script);
</script>  </head>
  <body class="basic ">
      <div class="container mx-auto relative">
        <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.6.0/jquery.min.js"></script>
    <meta property="og:type" content="website" />
	<meta property="og:url" content="/" />
	<meta property="og:site_name" content="Apache Cassandra" />

<header id="top-nav">
    <div class="inner relative">
        <div class="header-social-icons text-right">
            <a href="https://twitter.com/cassandra?lang=en" target="_blank" styles="margin-left: 20px;"><img src="../../assets/img/twitter-icon-circle-white.svg" alt="twitter icon" width="24"></a>
            <a href="https://www.linkedin.com/company/apache-cassandra/"  target="_blank" styles="margin-left: 20px;"><img src="../../assets/img/LI-In-Bug.png" alt="linked-in icon" width="24"></a>
            <a href="https://www.youtube.com/c/PlanetCassandra" target="_blank" styles="margin-left: 20px;"><img src="../../assets/img/youtube-icon.png" alt="youtube icon" width="24"></a>
        </div>
        <div class="cf">
            <div class="logo left"><a href="/"><img src="../../assets/img/logo-white-r.png" alt="cassandra logo"></a></div>
            <div class="mobile-nav-icon right">
                <img class="toggle-icon" src="../../assets/img/hamburger-nav.svg">
            </div>
            <ul class="main-nav nav-links right flex flex-vert-center flex-space-between">
    <li>
        <a class="nav-link hide-mobile">Get Started</a>
        <ul class="sub-menu bg-white">
            <li class="pa-micro">
                <a href="/_/cassandra-basics.html">
                    <div class="sub-nav-icon">
                        <img src="../../assets/img/sub-menu-basics.png" alt="cassandra basics icon">
                    </div>
                    <div class="sub-nav-text teal py-small">
                        Cassandra Basics
                    </div>
                </a>
            </li>
            <li class="pa-micro">
                <a href="/_/quickstart.html">
                    <div class="sub-nav-icon">
                        <img src="../../assets/img/sub-menu-rocket.png" alt="cassandra basics icon">
                    </div>
                    <div class="sub-nav-text teal py-small">
                        Quickstart
                    </div>
                </a>
            </li>
            <li class="pa-micro">
                <a href="/_/ecosystem.html">
                    <div class="sub-nav-icon">
                        <img src="../../assets/img/sub-menu-ecosystem.png" alt="cassandra basics icon">
                    </div>
                    <div class="sub-nav-text teal py-small">
                        Ecosystem
                    </div>
                </a>
            </li>
        </ul>
    </li>
    <li><a class="nav-link" href="/doc/latest/">Documentation</a></li>
    <li>
        <a class="nav-link" href="/_/community.html">Community</a>
        <ul class="sub-menu bg-white">
            <li class="pa-micro">
                <a href="/_/community.html#code-of-conduct">
                    <div class="sub-nav-icon">
                        <img src="../../assets/img/sub-menu-welcome.png" alt="welcome icon">
                    </div>
                    <div class="sub-nav-text teal py-small">
                        Welcome
                    </div>
                </a>
            </li>
            <li class="pa-micro hide-mobile">
                <a href="/_/community.html#discussions">
                    <div class="sub-nav-icon">
                        <img src="../../assets/img/sub-menu-discussions.png" alt="discussions icon">
                    </div>
                    <div class="sub-nav-text teal py-small">
                        Discussions
                    </div>
                </a>
            </li>
            <li class="pa-micro hide-mobile">
                <a href="/_/community.html#project-governance">
                    <div class="sub-nav-icon">
                        <img src="../../assets/img/sub-menu-governance.png" alt="Governance icon">
                    </div>
                    <div class="sub-nav-text teal py-small">
                        Governance
                    </div>
                </a>
            </li>
            <li class="pa-micro hide-mobile">
                <a href="/_/community.html#how-to-contribute">
                    <div class="sub-nav-icon">
                        <img src="../../assets/img/sub-menu-contribute.png" alt="Contribute icon">
                    </div>
                    <div class="sub-nav-text teal py-small">
                        Contribute
                    </div>
                </a>
            </li>
            <li class="pa-micro hide-mobile">
                <a href="/_/community.html#meet-the-community">
                    <div class="sub-nav-icon">
                        <img src="../../assets/img/sub-menu-community.png" alt="Meet the Community icon">
                    </div>
                    <div class="sub-nav-text teal py-small">
                        Meet the Community
                    </div>
                </a>
            </li>
            <li class="pa-micro hide-mobile">
                <a href="/_/cassandra-catalyst-program.html">
                    <div class="sub-nav-icon">
                        <img src="../../assets/img/sub-menu-catalyst.png" alt="Catalyst icon">
                    </div>
                    <div class="sub-nav-text teal py-small">
                        Catalyst Program
                    </div>
                </a>
            </li>
            <li class="pa-micro hide-mobile">
                <a href="/_/events.html">
                    <div class="sub-nav-icon">
                        <img src="../../assets/img/sub-menu-events.png" alt="Events icon">
                    </div>
                    <div class="sub-nav-text teal py-small">
                        Events
                    </div>
                </a>
            </li>
        </ul>
    </li>
    <li>
        <a class="nav-link hide-mobile">Learn</a>
        <ul class="sub-menu bg-white">
            <li class="pa-micro">
                <a href="/_/Apache-Cassandra-5.0-Moving-Toward-an-AI-Driven-Future.html">
                    <div class="sub-nav-icon">
                        <img src="../../assets/img/sub-menu-basics.png" alt="Basics icon">
                    </div>
                    <div class="sub-nav-text teal py-small">
                        Cassandra 5.0
                    </div>
                </a>
            </li>
            <li class="pa-micro">
                <a href="/_/case-studies.html">
                    <div class="sub-nav-icon">
                        <img src="../../assets/img/sub-menu-case-study.png" alt="Case Studies icon">
                    </div>
                    <div class="sub-nav-text teal py-small">
                        Case Studies
                    </div>
                </a>
            </li>
            <li class="pa-micro">
                <a href="/_/resources.html">
                    <div class="sub-nav-icon">
                        <img src="../../assets/img/sub-menu-resources.png" alt="Resources icon">
                    </div>
                    <div class="sub-nav-text teal py-small">
                        Resources
                    </div>
                </a>
            </li>
            <li class="pa-micro">
                <a href="/_/blog.html">
                    <div class="sub-nav-icon">
                        <img src="../../assets/img/sub-menu-blog.png" alt="Blog icon">
                    </div>
                    <div class="sub-nav-text teal py-small">
                        Blog
                    </div>
                </a>
            </li>
        </ul>
    </li>
    <li><a class="nav-link btn btn--filled" href="/_/download.html">Download Now</a></li>
</ul>
        </div>
    </div>
</header>

        <div class="hero hero--home grad">
            <div class="eye"></div>
            <div id="home-content" class="text-center flex flex-center flex-column relative z2 ma-xlarge">
                <h1></h1>
            </div>
        </div>
        <div class="flex-center py-large arrow">
            <div class="inner inner--narrow">
                <div class="sect1">
<h2 id="ci-environments"><a class="anchor" href="#ci-environments"></a>CI Environments</h2>
<div class="sectionbody">
<div class="sect2">
<h3 id="about-ci-testing-and-apache-cassandra"><a class="anchor" href="#about-ci-testing-and-apache-cassandra"></a>About CI testing and Apache Cassandra</h3>
<div class="paragraph">
<p>Cassandra can be automatically tested using various test suites, that
are either implemented based on JUnit or the
<a href="https://github.com/apache/cassandra-dtest">dtest</a> scripts written in
Python. As outlined in <code>testing</code>, each kind of test suite addresses a
different way to test Cassandra. Eventually, all of the tests will be
executed together on the CI platform at
<a href="https://builds.apache.org">builds.apache.org</a>, running
<a href="http://jenkins-ci.org">Jenkins</a>.</p>
</div>
</div>
<div class="sect2">
<h3 id="setting-up-your-own-jenkins-server"><a class="anchor" href="#setting-up-your-own-jenkins-server"></a>Setting up your own Jenkins server</h3>
<div class="paragraph">
<p>Jenkins is an open source solution that can be installed on a large
number of platforms. Setting up a custom Jenkins instance for Cassandra
may be desirable for users who have hardware to spare, or organizations
that want to run Cassandra tests for custom patches before contribution.</p>
</div>
<div class="paragraph">
<p>Please refer to the Jenkins download and documentation pages for details
on how to get Jenkins running, possibly also including slave build
executor instances. The rest of the document will focus on how to setup
Cassandra jobs in your Jenkins environment.</p>
</div>
<div class="sect3">
<h4 id="required-plugins"><a class="anchor" href="#required-plugins"></a>Required plugins</h4>
<div class="paragraph">
<p>In addition, the following plugins need to be installed along with the standard
plugins (git, ant, ..).</p>
</div>
<div class="paragraph">
<p>You can install any missing plugins using the install manager.</p>
</div>
<div class="paragraph">
<p>Go to <code>Manage Jenkins &#8594; Manage Plugins &#8594; Available</code> and install the
following plugins and respective dependencies:</p>
</div>
<div class="ulist">
<ul>
<li>
<p>Job DSL</p>
</li>
<li>
<p>Javadoc Plugin</p>
</li>
<li>
<p>description setter plugin</p>
</li>
<li>
<p>Throttle Concurrent Builds Plug-in</p>
</li>
<li>
<p>Test stability history</p>
</li>
<li>
<p>Post Build Script</p>
</li>
</ul>
</div>
</div>
<div class="sect3">
<h4 id="setup-seed-job"><a class="anchor" href="#setup-seed-job"></a>Setup seed job</h4>
<div class="olist arabic">
<ol class="arabic">
<li>
<p>Config <code>New Item</code></p>
<div class="ulist">
<ul>
<li>
<p>Name it <code>Cassandra-Job-DSL</code></p>
</li>
<li>
<p>Select <code>Freestyle project</code></p>
</li>
</ul>
</div>
</li>
<li>
<p>Under <code>Source Code Management</code> select Git using the repository:
<code><a href="https://github.com/apache/cassandra-builds" class="bare">github.com/apache/cassandra-builds</a></code></p>
</li>
<li>
<p>Under <code>Build</code>, confirm <code>Add build step</code> &#8594; <code>Process Job DSLs</code> and enter
at <code>Look on Filesystem</code>: <code>jenkins-dsl/cassandra_job_dsl_seed.groovy</code></p>
</li>
</ol>
</div>
<div class="paragraph">
<p>Generated jobs will be created based on the Groovy script&#8217;s default
settings. You may want to override settings by checking
<code>This project is parameterized</code> and add <code>String Parameter</code> for on the
variables that can be found in the top of the script. This will allow
you to setup jobs for your own repository and branches (e.g. working
branches).</p>
</div>
<div class="olist arabic">
<ol class="arabic" start="4">
<li>
<p>When done, confirm "Save".</p>
</li>
</ol>
</div>
<div class="paragraph">
<p>You should now find a new entry with the given name in your project
list. However, building the project will still fail and abort with an
error message "Processing DSL script
cassandra_job_dsl_seed.groovy ERROR: script not yet approved for use".
Go to <code>Manage Jenkins</code> &#8594; <code>In-process Script Approval</code> to fix this issue.
Afterwards you should be able to run the script and have it generate
numerous new jobs based on the found branches and configured templates.</p>
</div>
<div class="paragraph">
<p>Jobs are triggered by either changes in Git or are scheduled to execute
periodically, e.g. on daily basis.
Jenkins will use any available executor with the label "cassandra", once the job
is to be run.
Please make sure to make any executors available by selecting
<code>Build Executor Status</code> &#8594; <code>Configure</code> &#8594; Add &#8220;cassandra&#8221; as label and
save.</p>
</div>
<div class="paragraph">
<p>Executors need to have "JDK 1.8 (latest)" installed. This is done under
<code>Manage Jenkins &#8594; Global Tool Configuration &#8594; JDK Installations…</code>.
Executors also need to have the <code>virtualenv</code> package installed on their
system.</p>
</div>
</div>
</div>
<div class="sect2">
<h3 id="circleci"><a class="anchor" href="#circleci"></a>CircleCI</h3>
<div class="paragraph">
<p>Cassandra ships with a default <a href="https://circleci.com">CircleCI</a>
configuration to enable running tests on your branches.
Go to the CircleCI website, click "Login" and log in with your github account.
Then give CircleCI permission to watch your repositories.</p>
</div>
<div class="paragraph">
<p>Once you have done that, you can optionally configure CircleCI to run
tests in parallel if you wish:</p>
</div>
<div class="olist arabic">
<ol class="arabic" start="1">
<li>
<p>Click <code>Projects</code> and select your github account, and then click the settings for your project.</p>
</li>
<li>
<p>Set the parallelism setting. If you leave the default value of 1
for Cassandra, only <code>ant eclipse-warnings</code> and <code>ant test</code> will be run.
If you change the value to 4, Circle CI also runs <code>ant long-test</code>,
<code>ant test-compression</code> and <code>ant stress-test</code>.</p>
</li>
</ol>
</div>
</div>
</div>
</div>
            </div>
        </div>
        <footer class="grad grad--two flex-center pb-xlarge">
    <div class="inner text-center z2 relative">
        <h2 class="white py-small">Get started with Cassandra, fast.</h2>
        <a id="footer-cta" href="/_/quickstart.html" class="btn btn--filled ma-medium">Quickstart Guide</a>
    </div>
    <div class="inner flex flex-distribute-items mt-xlarge z2 relative">
        <div class="col-2">
            <div id="footer-logo" class="logo logo--footer mb-medium"><img src="../../assets/img/logo-white-r.png" alt="Cassandra Logo"></div>
            <p>Apache Cassandra<img src="../../assets/img/registered.svg" alt="®" style="width:18px;"> powers mission-critical deployments with improved performance and unparalleled levels of scale in the cloud.</p>
            <div class="footer-social-icons">
                <a href="https://twitter.com/cassandra?lang=en" target="_blank"><img src="../../assets/img/twitter-icon-circle-white.svg" alt="twitter icon" width="24"></a>
                <a href="https://www.linkedin.com/company/apache-cassandra/" target="_blank"><img src="../../assets/img/LI-In-Bug.png" alt="linked-in icon" width="24"></a>
                 <a href="https://www.youtube.com/c/PlanetCassandra" target="_blank"><img src="../../assets/img/youtube-icon.png" alt="youtube icon" width="24"></a>
            </div>
        </div>
        <div class="col-2 flex flex-center">
            <ul class="columns-2">
                <li class="mb-small"><a href="/">Home</a></li>
                <li class="mb-small"><a href="/_/cassandra-basics.html">Cassandra Basics</a></li>
                <li class="mb-small"><a href="/_/quickstart.html">Quickstart</a></li>
                <li class="mb-small"><a href="/_/ecosystem.html">Ecosystem</a></li>
                <li class="mb-small"><a href="/doc/latest/">Documentation</a></li>
                <li class="mb-small"><a href="/_/community.html">Community</a></li>
                <li class="mb-small"><a href="/_/case-studies.html">Case Studies</a></li>
                <li class="mb-small"><a href="/_/resources.html">Resources</a></li>
                <li class="mb-small"><a href="/_/blog.html">Blog</a></li>
            </ul>
        </div>
    </div>
</footer>
<div class="lower-footer bg-white pa-medium">
    <div class="flex flex-row flex-vert-center">
        <div class="pr-medium"><img src="../../assets/img//feather-small.png" alt="ASF" width="20"></div>
        <div class="pr-medium"><a href="http://www.apache.org/" target="_blank">Foundation</a></div>
        <div class="pr-medium"><a href="https://www.apache.org/events/current-event.html" target="_blank">Events</a></div>
        <div class="pr-medium"><a href="https://www.apache.org/licenses/" target="_blank">License</a></div>
        <div class="pr-medium"><a href="https://www.apache.org/foundation/thanks" target="_blank">Thanks</a></div>
        <div class="pr-medium"><a href="https://www.apache.org/security" target="_blank">Security</a></div>
        <div class="pr-medium"><a href="https://privacy.apache.org/policies/privacy-policy-public.html" target="_blank">Privacy</a></div>
        <div class="pr-medium"><a href="https://www.apache.org/foundation/sponsorship" target="_blank">Sponsorship</a></div>
    </div>
    <p class="my-medium">© 2009-<script>document.write(new Date().getFullYear())</script> <a href="https://apache.org" target="_blank">The Apache Software Foundation</a> under the terms of the Apache License 2.0.  Apache, the Apache feather logo, Apache Cassandra, Cassandra, and the Cassandra logo, are either registered trademarks or trademarks of The Apache Software Foundation.</p>
</div>
<div id="fade" class="hidden"></div>
<div id="modal" class="hidden">
  <div id="close-modal" class="cursor-pointer"><svg viewBox="0 0 24 24" width="24" height="24" stroke="currentColor" stroke-width="2" fill="none" stroke-linecap="round" stroke-linejoin="round" class="css-i6dzq1"><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></svg></div>
  <div id="mod-content" class="vid-mod-content resp-container"></div>
</div>
<script>
jQuery(function(){
    var windowW = $(window).width();
    $(document)
    .on('click','.mobile-nav-icon',function(){
        $('.main-nav').fadeIn();
    })
    .on('click','.main-nav',function(){
        if(windowW <= 1000){
            $(this).fadeOut();
        }
    })
    .on('click','#version-toggle',function(){
      $(this).toggleClass('active');
      $(this).next().fadeToggle();
    })
    .on('click','#mobile-docs-nav-burger', function(){
      $(this).toggleClass('active');
      $('.docs-nav').toggleClass('active');
    });
    var url = window.location.pathname;
    var isQuickstart = url.includes('quickstart.html');
    if(isQuickstart){
      var footerCTA = document.getElementById('footer-cta');
      footerCTA.innerHTML = 'Get latest updates';
      footerCTA.setAttribute('href', '/_/blog.html');
    }
});
</script>
      </div>
  </body>
<script>
jQuery(function(){
    jQuery(document)
    .on('click','.cassandra-cloud h3',function(){
        var el = jQuery(this);
        el.toggleClass('active');
        el.next().slideToggle();
    })
    .on('click','.image-expand img', function(){
      $(this).clone().appendTo('#mod-content');
      $('#fade,#modal,#close-modal').fadeIn();
      $('body,html').addClass('no-scroll');
    })
    .on('click','#fade,#close-modal', function(){
      $('#fade,#modal,#close-modal').fadeOut();
      $('body,html').removeClass('no-scroll');
      $('#mod-content').html('');
    });
});
</script>
</html>
