<!doctype html>
<html lang="en" dir="ltr" class="mdx-wrapper mdx-page plugin-pages plugin-id-default" data-has-hydrated="false">
<head>
<meta charset="UTF-8">
<meta name="generator" content="Docusaurus v2.4.3">
<title data-rh="true">Developer Resources for Apache CloudStack | Apache CloudStack</title><meta data-rh="true" name="viewport" content="width=device-width,initial-scale=1"><meta data-rh="true" name="twitter:card" content="summary_large_image"><meta data-rh="true" property="og:url" content="https://cloudstack.apache.org/developers"><meta data-rh="true" name="docusaurus_locale" content="en"><meta data-rh="true" name="docusaurus_tag" content="default"><meta data-rh="true" name="docsearch:language" content="en"><meta data-rh="true" name="docsearch:docusaurus_tag" content="default"><meta data-rh="true" property="og:title" content="Developer Resources for Apache CloudStack | Apache CloudStack"><meta data-rh="true" name="description" content="Contributing as a Non-Committer"><meta data-rh="true" property="og:description" content="Contributing as a Non-Committer"><link data-rh="true" rel="icon" href="/img/favicon.ico"><link data-rh="true" rel="canonical" href="https://cloudstack.apache.org/developers"><link data-rh="true" rel="alternate" href="https://cloudstack.apache.org/developers" hreflang="en"><link data-rh="true" rel="alternate" href="https://cloudstack.apache.org/developers" hreflang="x-default"><link rel="alternate" type="application/rss+xml" href="/blog/rss.xml" title="Apache CloudStack RSS Feed">
<link rel="alternate" type="application/atom+xml" href="/blog/atom.xml" title="Apache CloudStack Atom Feed">






<script src="scripts/bootstrap.bundle.min.js" async></script><link rel="stylesheet" href="/assets/css/styles.e12efb83.css">
<link rel="preload" href="/assets/js/runtime~main.d78c67af.js" as="script">
<link rel="preload" href="/assets/js/main.8e0276ef.js" as="script">
</head>
<body class="navigation-with-keyboard">
<script>!function(){function t(t){document.documentElement.setAttribute("data-theme",t)}var e=function(){var t=null;try{t=new URLSearchParams(window.location.search).get("docusaurus-theme")}catch(t){}return t}()||function(){var t=null;try{t=localStorage.getItem("theme")}catch(t){}return t}();t(null!==e?e:"light")}()</script><div id="__docusaurus">
<div role="region" aria-label="Skip to main content"><a class="skipToContent_fXgn" href="#__docusaurus_skipToContent_fallback">Skip to main content</a></div><nav aria-label="Main" class="navbar navbar--fixed-top"><div class="navbar__inner"><div class="navbar__items"><button aria-label="Toggle navigation bar" aria-expanded="false" class="navbar__toggle clean-btn" type="button"><svg width="30" height="30" viewBox="0 0 30 30" aria-hidden="true"><path stroke="currentColor" stroke-linecap="round" stroke-miterlimit="10" stroke-width="2" d="M4 7h22M4 15h22M4 23h22"></path></svg></button><a class="navbar__brand" href="/"><div class="navbar__logo"><img src="/img/navlogo.png" alt="apache-cloudstack" class="themedImage_ToTc themedImage--light_HNdA"><img src="/img/navlogo.png" alt="apache-cloudstack" class="themedImage_ToTc themedImage--dark_i4oU"></div><b class="navbar__title text--truncate"></b></a></div><div class="navbar__items navbar__items--right"><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">About</a><ul class="dropdown__menu"><li><a class="dropdown__link" href="/about">About</a></li><li><a class="dropdown__link" href="/history">History</a></li><li><a class="dropdown__link" href="/features">Features</a></li><li><a class="dropdown__link" href="/who">Who We Are</a></li><li><a class="dropdown__link" href="/bylaws">Community Bylaws</a></li><li><a class="dropdown__link" href="/trademark-guidelines">Trademark Guidelines</a></li><li><a class="dropdown__link" href="/security">Security</a></li></ul></div><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">Community</a><ul class="dropdown__menu"><li><a class="dropdown__link" href="/contribute">Get Involved</a></li><li><a class="dropdown__link" href="/developers">Developer Resources</a></li><li><a class="dropdown__link" href="/mailing-lists">Join Mailing Lists</a></li><li><a href="https://github.com/apache/cloudstack/issues" target="_blank" rel="noopener noreferrer" class="dropdown__link">Issues Tracker<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a href="https://join.slack.com/t/apachecloudstack/shared_invite/zt-1u8qwbivp-u16HRI~LWioLmF1G2D3Iyg" target="_blank" rel="noopener noreferrer" class="dropdown__link">Community Slack<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a class="dropdown__link" href="/events">Events and Meetups</a></li><li><a href="https://www.cloudstackcollab.org/" target="_blank" rel="noopener noreferrer" class="dropdown__link">Collab Conference<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li></ul></div><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">Use Cases</a><ul class="dropdown__menu"><li><a class="dropdown__link" href="/cloud-builders">Cloud Builders</a></li><li><a class="dropdown__link" href="/kubernetes">Kubernetes</a></li><li><a class="dropdown__link" href="/integrations">Integrations</a></li></ul></div><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">Users</a><ul class="dropdown__menu"><li><a class="dropdown__link" href="/users">Known Users</a></li><li><a class="dropdown__link" href="/blog/tags/case-studies">Case Studies</a></li><li><a href="https://docs.google.com/forms/d/e/1FAIpQLScPHIRetdt-pxPT62IesXMoQUmhQ8ATGKcYZa507mB9uwzn-Q/viewform" target="_blank" rel="noopener noreferrer" class="dropdown__link">Take Survey<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li></ul></div><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">Documentation</a><ul class="dropdown__menu"><li><a href="https://docs.cloudstack.apache.org" target="_blank" rel="noopener noreferrer" class="dropdown__link">CloudStack Documentation<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/Home" target="_blank" rel="noopener noreferrer" class="dropdown__link">Project Wiki<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/CloudStack+Books" target="_blank" rel="noopener noreferrer" class="dropdown__link">CloudStack Books<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a class="dropdown__link" href="/api/">API Documentation</a></li></ul></div><a class="navbar__item navbar__link" href="/downloads">Download</a><a class="navbar__item navbar__link" href="/blog">Blog</a><a href="https://github.com/apache/cloudstack" target="_blank" rel="noopener noreferrer" class="navbar__item navbar__link header-github-link" aria-label="GitHub repository"></a><div class="searchBox_ZlJk"><div class="navbar__search searchBarContainer_NW3z"><input placeholder="Search" aria-label="Search" class="navbar__search-input"><div class="loadingRing_RJI3 searchBarLoadingRing_YnHq"><div></div><div></div><div></div><div></div></div><div class="searchHintContainer_Pkmr"><kbd class="searchHint_iIMx">ctrl</kbd><kbd class="searchHint_iIMx">K</kbd></div></div></div><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">ASF</a><ul class="dropdown__menu"><li><a href="https://www.apache.org/" target="_blank" rel="noopener noreferrer" class="dropdown__link">Foundation</a></li><li><a href="https://www.apache.org/licenses/" target="_blank" rel="noopener noreferrer" class="dropdown__link">License</a></li><li><a href="https://www.apache.org/events/current-event" target="_blank" rel="noopener noreferrer" class="dropdown__link">Events</a></li><li><a href="https://www.apache.org/security/" target="_blank" rel="noopener noreferrer" class="dropdown__link">Security</a></li><li><a href="https://www.apache.org/foundation/sponsorship.html" target="_blank" rel="noopener noreferrer" class="dropdown__link">Sponsorship</a></li><li><a href="https://www.apache.org/foundation/policies/privacy.html" target="_blank" rel="noopener noreferrer" class="dropdown__link">Privacy</a></li><li><a href="https://www.apache.org/foundation/thanks.html" target="_blank" rel="noopener noreferrer" class="dropdown__link">Thanks</a></li></ul></div></div></div><div role="presentation" class="navbar-sidebar__backdrop"></div></nav><div id="__docusaurus_skipToContent_fallback" class="main-wrapper mainWrapper_z2l0"><main class="container container--fluid margin-vert--lg"><div class="row mdxPageWrapper_j9I6"><div class="col col--8"><article><h1>CloudStack Developer Resources</h1><h2 class="anchor anchorWithStickyNavbar_LWe7" id="contributing-as-a-non-committer">Contributing as a Non-Committer<a href="#contributing-as-a-non-committer" class="hash-link" aria-label="Direct link to Contributing as a Non-Committer" title="Direct link to Contributing as a Non-Committer">​</a></h2><p>If you&#x27;re a committer on an Apache project, it means that you can commit
directly to the project&#x27;s repository. For instance, with Apache CloudStack
committers are allowed to directly push commits into the git repository.</p><p>Non-committers, however, have to submit patches for review. Apache CloudStack
accepts <a href="https://github.com/apache/cloudstack" target="_blank" rel="noopener noreferrer">GitHub</a> pull requests. If you are new to Git and GitHub,
check these two links:</p><ul><li><a href="https://try.github.io/levels/1/challenges/1" target="_blank" rel="noopener noreferrer">GitHub in 15 minutes</a></li><li><a href="https://help.github.com/articles/creating-a-pull-request/" target="_blank" rel="noopener noreferrer">Creating GitHub Pull Request</a></li></ul><p>The Apache CloudStack repository is on <a href="https://github.com/apache/cloudstack" target="_blank" rel="noopener noreferrer">GitHub</a> that is
kept in sync with the canonical Git repo maintained by the Apache Software
Foundation. Submitting GitHub pull requests is the easiest way to get your
contribution upstream.</p><p>For detailed instructions see the link below: <a href="https://github.com/apache/cloudstack/blob/main/CONTRIBUTING.md" target="_blank" rel="noopener noreferrer">CloudStack GitHub Contribution Guidelines</a>.</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="submitting-a-patch">Submitting a patch<a href="#submitting-a-patch" class="hash-link" aria-label="Direct link to Submitting a patch" title="Direct link to Submitting a patch">​</a></h3><p>While we encourage you to submit your contribution through GitHub pull requests,
you can also attach a patch in a GitHub issue/ticket. For the purpose of these
instructions, we&#x27;ll assume that you already have a system with <a href="http://git-scm.com/" target="_blank" rel="noopener noreferrer">Git</a> and have found a bug to fix
or have a feature that you&#x27;d like to submit, and you&#x27;re willing to contribute
that code or documentation under the <a href="http://www.apache.org/licenses/LICENSE-2.0.html" target="_blank" rel="noopener noreferrer">Apache
License 2.0</a>.</p><p>Further, if you&#x27;re fixing a bug we&#x27;ll assume that you&#x27;ve either filed a bug
report (where you will attach your patch) or are submitting a fix for a known
bug. If you find a bug and would like to fix it, that&#x27;s awesome! Please be sure
to file the bug too, though.</p><p>If you want to add a feature, you should bring it up for discussion on the <a href="mailto:dev@cloudstack.apache.org" target="_blank" rel="noopener noreferrer"><a href="mailto:dev@cloudstack.apache.org" target="_blank" rel="noopener noreferrer">dev@cloudstack.apache.org</a></a> mailing
list before implementing it. This ensures that it meshes with the plans that
other contributors have for Apache CloudStack, and that you&#x27;re not doing
redundant work. Other developers may also have ideas for the feature or
suggestions that will help you land the feature without having to re-do the
work. More information about our mailing lists can be found <a href="/mailing-lists">here</a>.</p><p>In short, communication is a vital part of making a contribution to an Apache
project.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="getting-started">Getting Started<a href="#getting-started" class="hash-link" aria-label="Direct link to Getting Started" title="Direct link to Getting Started">​</a></h2><h3 class="anchor anchorWithStickyNavbar_LWe7" id="fork-the-code">Fork the code<a href="#fork-the-code" class="hash-link" aria-label="Direct link to Fork the code" title="Direct link to Fork the code">​</a></h3><p>In your browser, navigate to: <a href="https://github.com/apache/cloudstack" target="_blank" rel="noopener noreferrer"><a href="https://github.com/apache/cloudstack" target="_blank" rel="noopener noreferrer">https://github.com/apache/cloudstack</a></a>.</p><p>Fork the repository by clicking on the &#x27;Fork&#x27; button on the top right hand side.
The fork will happen and you will be taken to your own
fork of the repository. Copy the Git repository URL by clicking on the clipboard
next to the URL on the right hand side of the page under &#x27;<b>HTTPS</b> clone
URL&#x27;.</p><p>You will paste this URL when doing the following <code>git clone</code> command.</p><p>On your computer, follow these steps to setup a local repository for working on ACS:</p><div class="codeBlockContainer_Ckt0 theme-code-block" style="--prism-color:#393A34;--prism-background-color:#f6f8fa"><div class="codeBlockContent_biex"><pre tabindex="0" class="prism-code language-text codeBlock_bY9V thin-scrollbar"><code class="codeBlockLines_e6Vv"><span class="token-line" style="color:#393A34"><span class="token plain">$ git clone https://github.com/YOUR_ACCOUNT/cloudstack.git</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">$ cd cloudstack</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">$ git remote add upstream https://github.com/apache/cloudstack.git</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">$ git checkout main</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">$ git fetch upstream</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">$ git rebase upstream/main</span><br></span></code></pre><div class="buttonGroup__atx"><button type="button" aria-label="Copy code to clipboard" title="Copy" class="clean-btn"><span class="copyButtonIcons_eSgA" aria-hidden="true"><svg viewBox="0 0 24 24" class="copyButtonIcon_y97N"><path fill="currentColor" d="M19,21H8V7H19M19,5H8A2,2 0 0,0 6,7V21A2,2 0 0,0 8,23H19A2,2 0 0,0 21,21V7A2,2 0 0,0 19,5M16,1H4A2,2 0 0,0 2,3V17H4V3H16V1Z"></path></svg><svg viewBox="0 0 24 24" class="copyButtonSuccessIcon_LjdS"><path fill="currentColor" d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div></div><h3 class="anchor anchorWithStickyNavbar_LWe7" id="making-changes">Making Changes<a href="#making-changes" class="hash-link" aria-label="Direct link to Making Changes" title="Direct link to Making Changes">​</a></h3><p>It is important that you create a new branch to make changes on and that you do
not change the <code>main</code> branch (other than to rebase in changes from</p><code>upstream/main</code>).  In this example I will assume you will be making your changes to a branch called <code>feature_x</code>. This<code>feature_x</code> branch will be created on your local repository and will be pushed to your forked repository on GitHub. Once this branch is on your fork you will create a Pull Request for the changes to be added to the ACS project.<p>It is best practice to create a new branch each time you want to contribute
to the project and only track the changes for that pull request in this
branch.</p><div class="codeBlockContainer_Ckt0 theme-code-block" style="--prism-color:#393A34;--prism-background-color:#f6f8fa"><div class="codeBlockContent_biex"><pre tabindex="0" class="prism-code language-text codeBlock_bY9V thin-scrollbar"><code class="codeBlockLines_e6Vv"><span class="token-line" style="color:#393A34"><span class="token plain">$ git checkout -b feature_x</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">   (make your changes)</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">$ git status</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">$ git add .</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">$ git commit -a -m &quot;descriptive commit message for your changes&quot;</span><br></span></code></pre><div class="buttonGroup__atx"><button type="button" aria-label="Copy code to clipboard" title="Copy" class="clean-btn"><span class="copyButtonIcons_eSgA" aria-hidden="true"><svg viewBox="0 0 24 24" class="copyButtonIcon_y97N"><path fill="currentColor" d="M19,21H8V7H19M19,5H8A2,2 0 0,0 6,7V21A2,2 0 0,0 8,23H19A2,2 0 0,0 21,21V7A2,2 0 0,0 19,5M16,1H4A2,2 0 0,0 2,3V17H4V3H16V1Z"></path></svg><svg viewBox="0 0 24 24" class="copyButtonSuccessIcon_LjdS"><path fill="currentColor" d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div></div><blockquote>The <code>-b</code> specifies that you want to create a new branch called <code>feature_x</code>.  You only specify <code>-b</code> the first time you checkout because you are creating a new branch.  Once the <code>feature_x</code>branch exists, you can later switch to it with only <code>git checkout feature_x</code>.</blockquote><h3 class="anchor anchorWithStickyNavbar_LWe7" id="rebase-feature_x-to-include-updates-from-upstreammain">Rebase <code>feature_x</code> to include updates from <code>upstream/main</code><a href="#rebase-feature_x-to-include-updates-from-upstreammain" class="hash-link" aria-label="Direct link to rebase-feature_x-to-include-updates-from-upstreammain" title="Direct link to rebase-feature_x-to-include-updates-from-upstreammain">​</a></h3><p>It is important that you maintain an up-to-date <code>main</code> branch in
your local repository.  This is done by rebasing in the code
changes from <code>upstream/main</code> (the official ACS project repository)
into your local repository.  You will want to do this before you start
working on a feature as well as right before you submit your changes as a pull
request. We recommend you do this process periodically while you work to make
sure you are working off the most recent project code.</p><p>This process will do the following:</p><ul><li>Checkout your local <code>main</code> branch;</li><li>Synchronize your local <code>main</code> branch with the <code>upstream/main</code> so you have all the latest changes from the project;</li><li>Rebase the latest project code into your <code>feature_x</code> branch so it is up-to-date with the upstream code.</li></ul><div class="codeBlockContainer_Ckt0 theme-code-block" style="--prism-color:#393A34;--prism-background-color:#f6f8fa"><div class="codeBlockContent_biex"><pre tabindex="0" class="prism-code language-text codeBlock_bY9V thin-scrollbar"><code class="codeBlockLines_e6Vv"><span class="token-line" style="color:#393A34"><span class="token plain">$ git checkout main</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">$ git fetch upstream</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">$ git rebase upstream/main</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">$ git checkout feature_x</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">$ git rebase main</span><br></span></code></pre><div class="buttonGroup__atx"><button type="button" aria-label="Copy code to clipboard" title="Copy" class="clean-btn"><span class="copyButtonIcons_eSgA" aria-hidden="true"><svg viewBox="0 0 24 24" class="copyButtonIcon_y97N"><path fill="currentColor" d="M19,21H8V7H19M19,5H8A2,2 0 0,0 6,7V21A2,2 0 0,0 8,23H19A2,2 0 0,0 21,21V7A2,2 0 0,0 19,5M16,1H4A2,2 0 0,0 2,3V17H4V3H16V1Z"></path></svg><svg viewBox="0 0 24 24" class="copyButtonSuccessIcon_LjdS"><path fill="currentColor" d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div></div><blockquote>Now your <code>feature_x</code> branch is up-to-date with all the code in <code>upstream/main</code>.</blockquote><h3 class="anchor anchorWithStickyNavbar_LWe7" id="make-a-github-pull-request-to-contribute-your-changes">Make a GitHub pull request to contribute your changes<a href="#make-a-github-pull-request-to-contribute-your-changes" class="hash-link" aria-label="Direct link to Make a GitHub pull request to contribute your changes" title="Direct link to Make a GitHub pull request to contribute your changes">​</a></h3><p>When you are happy with your changes and you are ready to contribute them, you will create a Pull Request on GitHub to do so. This is done by pushing your local changes to your forked repository (default remote name is <code>origin</code>) and then initiating a pull request on GitHub.</p><p>Please include JIRA ID or GitHub ID, detailed information about the bug/feature, what all tests are executed, how the reviewer can test this feature etc. In case of UI PRs, a screenshot is preferred.</p><blockquote><b>IMPORTANT:</b>Make sure you have rebased your<code>feature_x</code> branch to include the latest code from<code>upstream/main</code> <b>before</b>you do this.</blockquote><div class="codeBlockContainer_Ckt0 theme-code-block" style="--prism-color:#393A34;--prism-background-color:#f6f8fa"><div class="codeBlockContent_biex"><pre tabindex="0" class="prism-code language-text codeBlock_bY9V thin-scrollbar"><code class="codeBlockLines_e6Vv"><span class="token-line" style="color:#393A34"><span class="token plain">$ git push origin main</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">$ git push origin feature_x</span><br></span></code></pre><div class="buttonGroup__atx"><button type="button" aria-label="Copy code to clipboard" title="Copy" class="clean-btn"><span class="copyButtonIcons_eSgA" aria-hidden="true"><svg viewBox="0 0 24 24" class="copyButtonIcon_y97N"><path fill="currentColor" d="M19,21H8V7H19M19,5H8A2,2 0 0,0 6,7V21A2,2 0 0,0 8,23H19A2,2 0 0,0 21,21V7A2,2 0 0,0 19,5M16,1H4A2,2 0 0,0 2,3V17H4V3H16V1Z"></path></svg><svg viewBox="0 0 24 24" class="copyButtonSuccessIcon_LjdS"><path fill="currentColor" d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div></div><p>Now that the <code>feature_x</code> branch has been pushed to your GitHub repository, you can initiate the pull request.</p><p>To initiate the pull request, do the following:</p><ul><li>In your browser, navigate to your forked repository: <b><a href="https://github.com/YOUR_ACCOUNT/cloudstack" target="_blank" rel="noopener noreferrer">https://github.com/YOUR_ACCOUNT/cloudstack</a></b>;</li><li>Click the new button called &#x27;<b>Compare &amp; pull request</b>&#x27; that showed up just above the main area in your forked repository;</li><li>Validate the pull request will be into the upstream <code>main</code> and will be from your <code>feature_x</code> branch;</li><li>Enter a detailed description of the work you have done and then click &#x27;<b>Send pull request</b>&#x27;.</li></ul><p>If you are requested to make modifications to your proposed changes, make the changes locally on your <code>feature_x</code> branch, re-push the <code>feature_x</code> branch to your fork. The existing pull request should automatically pick up the change and update accordingly.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="cleaning-up-after-a-successful-pull-request">Cleaning up after a successful pull request<a href="#cleaning-up-after-a-successful-pull-request" class="hash-link" aria-label="Direct link to Cleaning up after a successful pull request" title="Direct link to Cleaning up after a successful pull request">​</a></h4><p>Once the <code>feature_x</code> branch has been committed into the<code>upstream/main</code> branch, your local <code>feature_x</code> branch and the <code>origin/feature_x</code> branch are no longer needed. If you want to make additional changes, restart the process with a new branch.</p><blockquote><b>IMPORTANT:</b>Make sure that your changes are in<code>upstream/main</code>before you delete your <code>feature_x</code>and <code>origin/feature_x</code> branches!</blockquote><p>You can delete these deprecated branches with the following:</p><div class="codeBlockContainer_Ckt0 theme-code-block" style="--prism-color:#393A34;--prism-background-color:#f6f8fa"><div class="codeBlockContent_biex"><pre tabindex="0" class="prism-code language-text codeBlock_bY9V thin-scrollbar"><code class="codeBlockLines_e6Vv"><span class="token-line" style="color:#393A34"><span class="token plain">$ git checkout main</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">$ git branch -D feature_x</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">$ git push origin :feature_x</span><br></span></code></pre><div class="buttonGroup__atx"><button type="button" aria-label="Copy code to clipboard" title="Copy" class="clean-btn"><span class="copyButtonIcons_eSgA" aria-hidden="true"><svg viewBox="0 0 24 24" class="copyButtonIcon_y97N"><path fill="currentColor" d="M19,21H8V7H19M19,5H8A2,2 0 0,0 6,7V21A2,2 0 0,0 8,23H19A2,2 0 0,0 21,21V7A2,2 0 0,0 19,5M16,1H4A2,2 0 0,0 2,3V17H4V3H16V1Z"></path></svg><svg viewBox="0 0 24 24" class="copyButtonSuccessIcon_LjdS"><path fill="currentColor" d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div></div><h3 class="anchor anchorWithStickyNavbar_LWe7" id="further-reading">Further Reading<a href="#further-reading" class="hash-link" aria-label="Direct link to Further Reading" title="Direct link to Further Reading">​</a></h3><p>You might want to peruse the <a href="http://www.apache.org/foundation/getinvolved.html" target="_blank" rel="noopener noreferrer">Get Involved</a> page on Apache.org. Please, respect the original style of the CloudStack code, and ensure that you&#x27;re using spaces rather than tabs, and your code have Unix line endings (LF) rather than Windows-type line endings (CRLF).</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="resources">Resources<a href="#resources" class="hash-link" aria-label="Direct link to Resources" title="Direct link to Resources">​</a></h2><ul><li><a href="https://github.com/apache/cloudstack/" target="_blank" rel="noopener noreferrer">Public repository (on github)</a></li><li><a href="https://github.com/apache/cloudstack/blob/main/CONTRIBUTING.md" target="_blank" rel="noopener noreferrer">Contribution Guidelines</a></li><li><a href="https://builds.apache.org/view/A-D/view/Cloudstack/" target="_blank" rel="noopener noreferrer">ASF Jenkins</a></li><li><a href="http://jenkins.buildacloud.org/" target="_blank" rel="noopener noreferrer">CloudStack Jenkins</a></li><li><a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/Development+101" target="_blank" rel="noopener noreferrer">CloudStack Development 101</a></li><li><a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/Setting+up+CloudStack+Development+Environment" target="_blank" rel="noopener noreferrer">Setting up a Dev Environment</a></li><li><a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/Coding+conventions" target="_blank" rel="noopener noreferrer">Code Conventions</a></li><li><a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/Testing" target="_blank" rel="noopener noreferrer">Testing CloudStack</a></li><li><a href="https://issues.apache.org/jira/browse/CLOUDSTACK" target="_blank" rel="noopener noreferrer">Obsolete Jira issue tracker</a></li><li><a href="https://github.com/shapeblue/hackerbook" target="_blank" rel="noopener noreferrer">Hackerbook - opensource CloudStack Developer training course</a></li><li><a href="https://github.com/shapeblue/mbx" target="_blank" rel="noopener noreferrer">mbx - build and run appliance based CloudStack env for development and QA</a></li></ul><h3 class="anchor anchorWithStickyNavbar_LWe7" id="cloudstack-git-repositories">CloudStack Git Repositories<a href="#cloudstack-git-repositories" class="hash-link" aria-label="Direct link to CloudStack Git Repositories" title="Direct link to CloudStack Git Repositories">​</a></h3><p>The git repositories are hosted on Apache infrastructure, and can be found here:</p><ul><li><a href="https://github.com/apache/cloudstack" target="_blank" rel="noopener noreferrer">https://github.com/apache/cloudstack</a></li><li><a href="https://github.com/apache/cloudstack-cloudmonkey" target="_blank" rel="noopener noreferrer">https://github.com/apache/cloudstack-cloudmonkey</a></li><li><a href="https://github.com/apache/cloudstack-go" target="_blank" rel="noopener noreferrer">https://github.com/apache/cloudstack-go</a></li><li><a href="https://github.com/apache/cloudstack-terraform-provider" target="_blank" rel="noopener noreferrer">https://github.com/apache/cloudstack-terraform-provider</a></li><li><a href="https://github.com/apache/cloudstack-kubernetes-provider" target="_blank" rel="noopener noreferrer">https://github.com/apache/cloudstack-kubernetes-provider</a></li><li><a href="https://github.com/apache/cloudstack-ec2stack" target="_blank" rel="noopener noreferrer">https://github.com/apache/cloudstack-ec2stack</a></li><li><a href="https://github.com/apache/cloudstack-documentation" target="_blank" rel="noopener noreferrer">https://github.com/apache/cloudstack-documentation</a></li><li><a href="https://github.com/apache/cloudstack-www" target="_blank" rel="noopener noreferrer">https://github.com/apache/cloudstack-www</a></li></ul><p>To get the most recent source for Apache CloudStack, use:</p><div class="codeBlockContainer_Ckt0 theme-code-block" style="--prism-color:#393A34;--prism-background-color:#f6f8fa"><div class="codeBlockContent_biex"><pre tabindex="0" class="prism-code language-text codeBlock_bY9V thin-scrollbar"><code class="codeBlockLines_e6Vv"><span class="token-line" style="color:#393A34"><span class="token plain">git clone https://github.com/apache/cloudstack.git</span><br></span></code></pre><div class="buttonGroup__atx"><button type="button" aria-label="Copy code to clipboard" title="Copy" class="clean-btn"><span class="copyButtonIcons_eSgA" aria-hidden="true"><svg viewBox="0 0 24 24" class="copyButtonIcon_y97N"><path fill="currentColor" d="M19,21H8V7H19M19,5H8A2,2 0 0,0 6,7V21A2,2 0 0,0 8,23H19A2,2 0 0,0 21,21V7A2,2 0 0,0 19,5M16,1H4A2,2 0 0,0 2,3V17H4V3H16V1Z"></path></svg><svg viewBox="0 0 24 24" class="copyButtonSuccessIcon_LjdS"><path fill="currentColor" d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div></div><p>Similarly, clone the cloudstack-cloudmonkey repository or the other repositories
to get access to the most recent source of all CloudStack subprojects.</p><p>For projects related to Apache CloudStack but not under ASF governance, see the <a href="https://github.com/cloudstack-extras" target="_blank" rel="noopener noreferrer">CloudStack-extras repositories on GitHub</a>.</p></article></div><div class="col col--2"><div class="tableOfContents_bqdL thin-scrollbar"><ul class="table-of-contents table-of-contents__left-border"><li><a href="#contributing-as-a-non-committer" class="table-of-contents__link toc-highlight">Contributing as a Non-Committer</a><ul><li><a href="#submitting-a-patch" class="table-of-contents__link toc-highlight">Submitting a patch</a></li></ul></li><li><a href="#getting-started" class="table-of-contents__link toc-highlight">Getting Started</a><ul><li><a href="#fork-the-code" class="table-of-contents__link toc-highlight">Fork the code</a></li><li><a href="#making-changes" class="table-of-contents__link toc-highlight">Making Changes</a></li><li><a href="#rebase-feature_x-to-include-updates-from-upstreammain" class="table-of-contents__link toc-highlight">Rebase <code>feature_x</code> to include updates from <code>upstream/main</code></a></li><li><a href="#make-a-github-pull-request-to-contribute-your-changes" class="table-of-contents__link toc-highlight">Make a GitHub pull request to contribute your changes</a></li><li><a href="#further-reading" class="table-of-contents__link toc-highlight">Further Reading</a></li></ul></li><li><a href="#resources" class="table-of-contents__link toc-highlight">Resources</a><ul><li><a href="#cloudstack-git-repositories" class="table-of-contents__link toc-highlight">CloudStack Git Repositories</a></li></ul></li></ul></div></div></div></main></div><footer class="footer footer--dark"><div class="container container-fluid"><div class="footer__bottom text--center"><div class="margin-bottom--sm"><a href="https://cloudstack.apache.org/" rel="noopener noreferrer" class="footerLogoLink_BH7S"><img src="/img/ACS_logo_slogan.svg" alt="Apache CloudStack logo" class="themedImage_ToTc themedImage--light_HNdA footer__logo"><img src="/img/ACS_logo_slogan.svg" alt="Apache CloudStack logo" class="themedImage_ToTc themedImage--dark_i4oU footer__logo"></a></div><div class="footer__copyright">
            <div class="social">
                <a href="mailto:dev-subscribe@cloudstack.apache.org">
		  <img src="/img/mail_mini_icon.svg" alt="">
		</a>
                <a href="https://join.slack.com/t/apachecloudstack/shared_invite/zt-2aegc22z7-tPCxpptfcebTBtd59qcZSQ">
		  <img src="/img/slack_mini_icon.svg" alt="">
		</a>
                <a href="https://github.com/apache/cloudstack">
		  <img src="/img/git_mini_icon.svg" alt="">
		</a>
                <a href="https://twitter.com/CloudStack">
		  <img src="/img/twitter_X_mini_icon.svg" alt="">
		</a>
                <a href="https://www.youtube.com/@ApacheCloudStack">
		  <img src="/img/youtube_mini_icon.svg" alt="">
		</a>
                <a href="https://www.linkedin.com/company/apachecloudstack/posts/">
		  <img src="/img/linkedin_icon.svg" alt="">
		</a>
            </div>
            <div class="footer-bottom">Copyright © 2023 The Apache
Software Foundation, Licensed under the Apache License, Version 2.0.
“Apache”, “CloudStack”, “Apache CloudStack”, the Apache CloudStack logo,
 the Apache CloudStack Cloud Monkey logo and the Apache feather logos
are registered trademarks or trademarks of The Apache Software
Foundation.
            <p class="footer-blue"><a href="/trademark-guidelines">Apache CloudStack Trademark Usage</a> - <a href="/bylaws">Apache CloudStack Community ByLaws</a> - <a href="https://github.com/apache/cloudstack-www">Website Source Code</a></p></div>
            </div>
          <br>
          </div></div></footer></div>
<script src="/assets/js/runtime~main.d78c67af.js"></script>
<script src="/assets/js/main.8e0276ef.js"></script>
</body>
</html>