<!doctype html>
<html lang="en" dir="ltr" class="docs-wrapper docs-doc-page docs-version-current plugin-docs plugin-id-default docs-doc-id-community/contributing">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width,initial-scale=1">
<meta name="generator" content="Docusaurus v2.0.0-beta.18">
<title data-rh="true">How To Contribute to Submarine | Apache Submarine</title><meta data-rh="true" name="twitter:card" content="summary_large_image"><meta data-rh="true" property="og:url" content="https://submarine.apache.org//docs/next/community/contributing"><meta data-rh="true" name="docusaurus_locale" content="en"><meta data-rh="true" name="docsearch:language" content="en"><meta data-rh="true" name="docusaurus_version" content="current"><meta data-rh="true" name="docusaurus_tag" content="docs-default-current"><meta data-rh="true" name="docsearch:version" content="current"><meta data-rh="true" name="docsearch:docusaurus_tag" content="docs-default-current"><meta data-rh="true" property="og:title" content="How To Contribute to Submarine | Apache Submarine"><meta data-rh="true" name="description" content="&lt;!--"><meta data-rh="true" property="og:description" content="&lt;!--"><link data-rh="true" rel="icon" href="/img/submarine.ico"><link data-rh="true" rel="canonical" href="https://submarine.apache.org//docs/next/community/contributing"><link data-rh="true" rel="alternate" href="https://submarine.apache.org//docs/next/community/contributing" hreflang="en"><link data-rh="true" rel="alternate" href="https://submarine.apache.org//zh-cn/docs/next/community/contributing" hreflang="zh-cn"><link data-rh="true" rel="alternate" href="https://submarine.apache.org//docs/next/community/contributing" hreflang="x-default"><link rel="stylesheet" href="/assets/css/styles.80258812.css">
<link rel="preload" href="/assets/js/runtime~main.89d436a2.js" as="script">
<link rel="preload" href="/assets/js/main.b3d57bf8.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=localStorage.getItem("theme")}catch(t){}return t}();t(null!==e?e:"light")}()</script><div id="__docusaurus">
<div role="region"><a href="#" class="skipToContent_ZgBM">Skip to main content</a></div><nav class="navbar navbar--fixed-top"><div class="navbar__inner"><div class="navbar__items"><button aria-label="Navigation bar toggle" class="navbar__toggle clean-btn" type="button" tabindex="0"><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/icons/128.png" alt="Apache Submarine Site Logo" class="themedImage_W2Cr themedImage--light_TfLj"><img src="/img/icons/128.png" alt="Apache Submarine Site Logo" class="themedImage_W2Cr themedImage--dark_oUvU"></div><b class="navbar__title">Apache Submarine</b></a><a class="navbar__item navbar__link navbar__link--active" href="/docs/next/gettingStarted/quickstart">Docs</a><a class="navbar__item navbar__link" href="/docs/next/api/environment">API</a><a class="navbar__item navbar__link" href="/docs/next/download">Download</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"><span><svg viewBox="0 0 24 24" width="20" height="20" aria-hidden="true" class="iconLanguage_dNtB"><path fill="currentColor" d="M12.87 15.07l-2.54-2.51.03-.03c1.74-1.94 2.98-4.17 3.71-6.53H17V4h-7V2H8v2H1v1.99h11.17C11.5 7.92 10.44 9.75 9 11.35 8.07 10.32 7.3 9.19 6.69 8h-2c.73 1.63 1.73 3.17 2.98 4.56l-5.09 5.02L4 19l5-5 3.11 3.11.76-2.04zM18.5 10h-2L12 22h2l1.12-3h4.75L21 22h2l-4.5-12zm-2.62 7l1.62-4.33L19.12 17h-3.24z"></path></svg><span>English</span></span></a><ul class="dropdown__menu"><li><a href="/docs/next/community/contributing" target="_self" rel="noopener noreferrer" class="dropdown__link dropdown__link--active">English</a></li><li><a href="/zh-cn/docs/next/community/contributing" target="_self" rel="noopener noreferrer" class="dropdown__link">中文</a></li></ul></div><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a class="navbar__link" aria-haspopup="true" aria-expanded="false" role="button" href="/docs/next/gettingStarted/quickstart">master 🏃</a><ul class="dropdown__menu"><li><a aria-current="page" class="dropdown__link dropdown__link--active" href="/docs/next/community/contributing">master 🏃</a></li><li><a class="dropdown__link" href="/docs/community/contributing">0.7.0</a></li><li><a class="dropdown__link" href="/docs/0.6.0/community/contributing">0.6.0</a></li><li><a class="dropdown__link" href="/versions">All versions</a></li></ul></div><a href="https://github.com/apache/submarine" target="_blank" rel="noopener noreferrer" class="navbar__item navbar__link">GitHub<svg width="13.5" height="13.5" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_I5OW"><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><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">Apache</a><ul class="dropdown__menu"><li><a href="https://www.apache.org/foundation/how-it-works.html" target="_blank" rel="noopener noreferrer" class="dropdown__link">Apache Software Foundation<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_I5OW"><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://www.apache.org/events/current-event" target="_blank" rel="noopener noreferrer" class="dropdown__link">Events<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_I5OW"><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://www.apache.org/licenses/" target="_blank" rel="noopener noreferrer" class="dropdown__link">Apache License<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_I5OW"><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://www.apache.org/foundation/thanks.html" target="_blank" rel="noopener noreferrer" class="dropdown__link">Thanks<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_I5OW"><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://www.apache.org/security/" target="_blank" rel="noopener noreferrer" class="dropdown__link">Security<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_I5OW"><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://www.apache.org/foundation/sponsorship.html" target="_blank" rel="noopener noreferrer" class="dropdown__link">Sponsorship<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_I5OW"><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="toggle_S7eR colorModeToggle_vKtC"><button class="clean-btn toggleButton_rCf9 toggleButtonDisabled_Pu9x" type="button" disabled="" title="Switch between dark and light mode (currently light mode)" aria-label="Switch between dark and light mode (currently light mode)"><svg viewBox="0 0 24 24" width="24" height="24" class="lightToggleIcon_v35p"><path fill="currentColor" d="M12,9c1.65,0,3,1.35,3,3s-1.35,3-3,3s-3-1.35-3-3S10.35,9,12,9 M12,7c-2.76,0-5,2.24-5,5s2.24,5,5,5s5-2.24,5-5 S14.76,7,12,7L12,7z M2,13l2,0c0.55,0,1-0.45,1-1s-0.45-1-1-1l-2,0c-0.55,0-1,0.45-1,1S1.45,13,2,13z M20,13l2,0c0.55,0,1-0.45,1-1 s-0.45-1-1-1l-2,0c-0.55,0-1,0.45-1,1S19.45,13,20,13z M11,2v2c0,0.55,0.45,1,1,1s1-0.45,1-1V2c0-0.55-0.45-1-1-1S11,1.45,11,2z M11,20v2c0,0.55,0.45,1,1,1s1-0.45,1-1v-2c0-0.55-0.45-1-1-1C11.45,19,11,19.45,11,20z M5.99,4.58c-0.39-0.39-1.03-0.39-1.41,0 c-0.39,0.39-0.39,1.03,0,1.41l1.06,1.06c0.39,0.39,1.03,0.39,1.41,0s0.39-1.03,0-1.41L5.99,4.58z M18.36,16.95 c-0.39-0.39-1.03-0.39-1.41,0c-0.39,0.39-0.39,1.03,0,1.41l1.06,1.06c0.39,0.39,1.03,0.39,1.41,0c0.39-0.39,0.39-1.03,0-1.41 L18.36,16.95z M19.42,5.99c0.39-0.39,0.39-1.03,0-1.41c-0.39-0.39-1.03-0.39-1.41,0l-1.06,1.06c-0.39,0.39-0.39,1.03,0,1.41 s1.03,0.39,1.41,0L19.42,5.99z M7.05,18.36c0.39-0.39,0.39-1.03,0-1.41c-0.39-0.39-1.03-0.39-1.41,0l-1.06,1.06 c-0.39,0.39-0.39,1.03,0,1.41s1.03,0.39,1.41,0L7.05,18.36z"></path></svg><svg viewBox="0 0 24 24" width="24" height="24" class="darkToggleIcon_nQuB"><path fill="currentColor" d="M9.37,5.51C9.19,6.15,9.1,6.82,9.1,7.5c0,4.08,3.32,7.4,7.4,7.4c0.68,0,1.35-0.09,1.99-0.27C17.45,17.19,14.93,19,12,19 c-3.86,0-7-3.14-7-7C5,9.07,6.81,6.55,9.37,5.51z M12,3c-4.97,0-9,4.03-9,9s4.03,9,9,9s9-4.03,9-9c0-0.46-0.04-0.92-0.1-1.36 c-0.98,1.37-2.58,2.26-4.4,2.26c-2.98,0-5.4-2.42-5.4-5.4c0-1.81,0.89-3.42,2.26-4.4C12.92,3.04,12.46,3,12,3L12,3z"></path></svg></button></div><div class="navbar__search"><span aria-label="expand searchbar" role="button" class="search-icon" tabindex="0"></span><input type="search" id="search_input_react" placeholder="Search" aria-label="Search" class="navbar__search-input search-bar"></div></div></div><div role="presentation" class="navbar-sidebar__backdrop"></div></nav><div class="main-wrapper"><div class="docPage_P2Lg"><button aria-label="Scroll back to top" class="clean-btn theme-back-to-top-button backToTopButton_RiI4" type="button"></button><aside class="theme-doc-sidebar-container docSidebarContainer_rKC_"><div class="sidebar_RiAD"><nav class="menu thin-scrollbar menu_izAj"><ul class="theme-doc-sidebar-menu menu__list"><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a class="menu__link menu__link--sublist menu__link--sublist-caret" aria-expanded="false" href="/docs/next/gettingStarted/quickstart">Getting Started</a></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a class="menu__link menu__link--sublist menu__link--sublist-caret" aria-expanded="false" href="/docs/next/userDocs/submarine-sdk/submarine-cli">User Docs</a></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a class="menu__link menu__link--sublist menu__link--sublist-caret" aria-expanded="false" href="/docs/next/devDocs/">Developer Docs</a></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item"><div class="menu__list-item-collapsible"><a class="menu__link menu__link--sublist menu__link--sublist-caret menu__link--active" aria-expanded="true" href="/docs/next/community/">Community</a></div><ul style="display:block;overflow:visible;height:auto" class="menu__list"><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class="menu__link" tabindex="0" href="/docs/next/community/">Apache Submarine Community</a></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class="menu__link" tabindex="0" href="/docs/next/community/Bylaws">Bylaws</a></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class="menu__link" tabindex="0" href="/docs/next/community/HowToCommit">Guide for Apache Submarine Committers</a></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class="menu__link menu__link--active" aria-current="page" tabindex="0" href="/docs/next/community/contributing">How To Contribute to Submarine</a></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class="menu__link" tabindex="0" href="/docs/next/community/HowToVoteCommitterOrPMC">How to vote a Committer or PMC</a></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class="menu__link" tabindex="0" href="/docs/next/community/HowToBecomeCommitter">How to become a Committer</a></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class="menu__link" tabindex="0" href="/docs/next/community/Resources">Resources</a></li></ul></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a class="menu__link menu__link--sublist menu__link--sublist-caret" aria-expanded="false" href="/docs/next/designDocs/architecture-and-requirements">Design Docs</a></div></li></ul></nav></div></aside><main class="docMainContainer_TCnq"><div class="container padding-top--md padding-bottom--lg"><div class="row"><div class="col docItemCol_DM6M"><div class="theme-doc-version-banner alert alert--warning margin-bottom--md" role="alert"><div>This is unreleased documentation for <!-- -->Apache Submarine<!-- --> <b>master 🏃</b> version.</div><div class="margin-top--md">For up-to-date documentation, see the <b><a href="/docs/community/contributing">latest version</a></b> (<!-- -->0.7.0<!-- -->).</div></div><div class="docItemContainer_vinB"><article><nav class="theme-doc-breadcrumbs breadcrumbsContainer_Xlws" aria-label="breadcrumbs"><ul class="breadcrumbs" itemscope="" itemtype="https://schema.org/BreadcrumbList"><li class="breadcrumbs__item"><a class="breadcrumbs__link" href="/">🏠</a></li><li itemscope="" itemprop="itemListElement" itemtype="https://schema.org/ListItem" class="breadcrumbs__item"><span class="breadcrumbs__link" itemprop="item name">Community</span><meta itemprop="position" content="1"></li><li itemscope="" itemprop="itemListElement" itemtype="https://schema.org/ListItem" class="breadcrumbs__item breadcrumbs__item--active"><span class="breadcrumbs__link" itemprop="item name">How To Contribute to Submarine</span><meta itemprop="position" content="2"></li></ul></nav><span class="theme-doc-version-badge badge badge--secondary">Version: master 🏃</span><div class="tocCollapsible_jdIR theme-doc-toc-mobile tocMobile_TmEX"><button type="button" class="clean-btn tocCollapsibleButton_Fzxq">On this page</button></div><div class="theme-doc-markdown markdown"><header><h1>How To Contribute to Submarine</h1></header><p>There are several ways to contribute to Submarine:</p><ol><li>Develop and Commit source code (This document will primarily focus on this.)</li><li>Report issues (You can report issues with both Github or Jira.)</li><li>Discuss/Answer questions on the mailing list</li><li>Share use cases</li></ol><h2 class="anchor anchorWithStickyNavbar_mojV" id="preface">Preface<a class="hash-link" href="#preface" title="Direct link to heading">​</a></h2><ul><li><strong>Apache Submarine</strong> is an <a href="https://github.com/apache/submarine/blob/master/LICENSE" target="_blank" rel="noopener noreferrer">Apache 2.0 License</a> Software. Contributing to Submarine means you agree to the Apache 2.0 License. </li><li>Please read <a href="http://www.apache.org/foundation/policies/conduct.html" target="_blank" rel="noopener noreferrer">Code of Conduct</a> carefully.</li><li>The document <a href="http://www.apache.org/foundation/how-it-works.html" target="_blank" rel="noopener noreferrer">How It Works</a> can help you understand Apache Software Foundation further.</li></ul><h2 class="anchor anchorWithStickyNavbar_mojV" id="build-submarine">Build Submarine<a class="hash-link" href="#build-submarine" title="Direct link to heading">​</a></h2><ul><li><a href="/docs/next/devDocs/BuildFromCode">Build From Code</a></li></ul><h2 class="anchor anchorWithStickyNavbar_mojV" id="creating-patches">Creating patches<a class="hash-link" href="#creating-patches" title="Direct link to heading">​</a></h2><p>Submarine follows <a href="https://github.com/sevntu-checkstyle/sevntu.checkstyle/wiki/Development-workflow-with-Git:-Fork,-Branching,-Commits,-and-Pull-Request" target="_blank" rel="noopener noreferrer">Fork &amp; Pull</a> model.</p><h3 class="anchor anchorWithStickyNavbar_mojV" id="step1-fork-apachesubmarine-github-repository-first-time">Step1: Fork apache/submarine github repository (first time)<a class="hash-link" href="#step1-fork-apachesubmarine-github-repository-first-time" title="Direct link to heading">​</a></h3><ul><li>Visit <a href="https://github.com/apache/submarine" target="_blank" rel="noopener noreferrer">https://github.com/apache/submarine</a></li><li>Click the <code>Fork</code> button to create a fork of the repository</li></ul><h3 class="anchor anchorWithStickyNavbar_mojV" id="step2-clone-the-submarine-to-your-local-machine">Step2: Clone the Submarine to your local machine<a class="hash-link" href="#step2-clone-the-submarine-to-your-local-machine" title="Direct link to heading">​</a></h3><div class="codeBlockContainer_I0IT language-sh theme-code-block"><div class="codeBlockContent_wNvx" style="color:#bfc7d5;background-color:#292d3e"><pre tabindex="0" class="prism-code language-sh codeBlock_jd64 thin-scrollbar"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#bfc7d5"><span class="token plain"># USERNAME – your Github user account name.</span><br></span><span class="token-line" style="color:#bfc7d5"><span class="token plain">git clone git@github.com:${USERNAME}/submarine.git</span><br></span><span class="token-line" style="color:#bfc7d5"><span class="token plain"># or: git clone https://github.com/${USERNAME}/submarine.git </span><br></span><span class="token-line" style="color:#bfc7d5"><span class="token plain"> </span><br></span><span class="token-line" style="color:#bfc7d5"><span class="token plain">cd submarine</span><br></span><span class="token-line" style="color:#bfc7d5"><span class="token plain"># set upstream </span><br></span><span class="token-line" style="color:#bfc7d5"><span class="token plain">git remote add upstream git@github.com:apache/submarine.git</span><br></span><span class="token-line" style="color:#bfc7d5"><span class="token plain"># or: git remote add upstream https://github.com/apache/submarine.git</span><br></span><span class="token-line" style="color:#bfc7d5"><span class="token plain" style="display:inline-block"></span><br></span><span class="token-line" style="color:#bfc7d5"><span class="token plain"># Don&#x27;t push to the upstream master.</span><br></span><span class="token-line" style="color:#bfc7d5"><span class="token plain">git remote set-url --push upstream no_push</span><br></span><span class="token-line" style="color:#bfc7d5"><span class="token plain" style="display:inline-block"></span><br></span><span class="token-line" style="color:#bfc7d5"><span class="token plain"># Check upstream/origin:</span><br></span><span class="token-line" style="color:#bfc7d5"><span class="token plain"># origin    git@github.com:${USERNAME}/submarine.git (fetch)</span><br></span><span class="token-line" style="color:#bfc7d5"><span class="token plain"># origin    git@github.com:${USERNAME}/submarine.git (push)</span><br></span><span class="token-line" style="color:#bfc7d5"><span class="token plain"># upstream  git@github.com:apache/submarine.git (fetch)</span><br></span><span class="token-line" style="color:#bfc7d5"><span class="token plain"># upstream  no_push (push)</span><br></span><span class="token-line" style="color:#bfc7d5"><span class="token plain">git remote -v</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" title="Copy" class="copyButton_eDfN clean-btn"><span class="copyButtonIcons_W9eQ" aria-hidden="true"><svg class="copyButtonIcon_XEyF" viewBox="0 0 24 24"><path 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 class="copyButtonSuccessIcon_i9w9" viewBox="0 0 24 24"><path d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div><h3 class="anchor anchorWithStickyNavbar_mojV" id="step3-create-a-new-jira-in-submarine-project">Step3: Create a new Jira in Submarine project<a class="hash-link" href="#step3-create-a-new-jira-in-submarine-project" title="Direct link to heading">​</a></h3><ul><li>New contributors need privilege to create JIRA issues. Please email <a href="mailto:kaihsun@apache.org" target="_blank" rel="noopener noreferrer">kaihsun@apache.org</a> with your Jira username. In addition, the email title should be &quot;<!-- -->[New Submarine Contributor]<!-- -->&quot;.</li><li>Check <a href="https://issues.apache.org/jira/projects/SUBMARINE/issues/SUBMARINE-748?filter=allopenissues" target="_blank" rel="noopener noreferrer">Jira issue tracker</a> for existing issues.</li><li>Create a new Jira issue in Submarine project. When the issue is created, a Jira number (eg. SUBMARINE-748) will be assigned to the issue automatically.
<img loading="lazy" alt="jira_number_example" src="/assets/images/jira_number_example-9d86e8dd3b72d9d9c2adddfbffc00a54.png" width="1920" height="914" class="img_E7b_"></li></ul><h3 class="anchor anchorWithStickyNavbar_mojV" id="step4-create-a-local-branch-for-your-contribution">Step4: Create a local branch for your contribution<a class="hash-link" href="#step4-create-a-local-branch-for-your-contribution" title="Direct link to heading">​</a></h3><div class="codeBlockContainer_I0IT language-sh theme-code-block"><div class="codeBlockContent_wNvx" style="color:#bfc7d5;background-color:#292d3e"><pre tabindex="0" class="prism-code language-sh codeBlock_jd64 thin-scrollbar"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#bfc7d5"><span class="token plain">cd submarine</span><br></span><span class="token-line" style="color:#bfc7d5"><span class="token plain" style="display:inline-block"></span><br></span><span class="token-line" style="color:#bfc7d5"><span class="token plain"># Make your local master up-to-date</span><br></span><span class="token-line" style="color:#bfc7d5"><span class="token plain">git checkout master</span><br></span><span class="token-line" style="color:#bfc7d5"><span class="token plain">git fetch upstream </span><br></span><span class="token-line" style="color:#bfc7d5"><span class="token plain">git rebase upstream/master</span><br></span><span class="token-line" style="color:#bfc7d5"><span class="token plain" style="display:inline-block"></span><br></span><span class="token-line" style="color:#bfc7d5"><span class="token plain"># Create a new branch fro issue SUBMARINE-${jira_number}</span><br></span><span class="token-line" style="color:#bfc7d5"><span class="token plain">git checkout -b SUBMARINE-${jira_number}</span><br></span><span class="token-line" style="color:#bfc7d5"><span class="token plain" style="display:inline-block"></span><br></span><span class="token-line" style="color:#bfc7d5"><span class="token plain"># Example: git checkout -b SUBMARINE-748 </span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" title="Copy" class="copyButton_eDfN clean-btn"><span class="copyButtonIcons_W9eQ" aria-hidden="true"><svg class="copyButtonIcon_XEyF" viewBox="0 0 24 24"><path 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 class="copyButtonSuccessIcon_i9w9" viewBox="0 0 24 24"><path d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div><h3 class="anchor anchorWithStickyNavbar_mojV" id="step5-develop--create-commits">Step5: Develop &amp; Create commits<a class="hash-link" href="#step5-develop--create-commits" title="Direct link to heading">​</a></h3><ul><li>You can edit the code on the <code>SUBMARINE-${jira_number}</code> branch. (Coding Style: <a href="#code-convention">Code Convention</a>)</li><li>Create commits</li></ul><div class="codeBlockContainer_I0IT language-sh theme-code-block"><div class="codeBlockContent_wNvx" style="color:#bfc7d5;background-color:#292d3e"><pre tabindex="0" class="prism-code language-sh codeBlock_jd64 thin-scrollbar"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#bfc7d5"><span class="token plain">git add ${edited files}</span><br></span><span class="token-line" style="color:#bfc7d5"><span class="token plain">git commit -m &quot;SUBMARINE-${jira_number}. ${Commit Message}&quot;</span><br></span><span class="token-line" style="color:#bfc7d5"><span class="token plain"># Example: git commit -m &quot;SUBMARINE-748. Update Contributing guide&quot; </span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" title="Copy" class="copyButton_eDfN clean-btn"><span class="copyButtonIcons_W9eQ" aria-hidden="true"><svg class="copyButtonIcon_XEyF" viewBox="0 0 24 24"><path 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 class="copyButtonSuccessIcon_i9w9" viewBox="0 0 24 24"><path d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div><h3 class="anchor anchorWithStickyNavbar_mojV" id="step6-syncing-your-local-branch-with-upstreammaster">Step6: Syncing your local branch with upstream/master<a class="hash-link" href="#step6-syncing-your-local-branch-with-upstreammaster" title="Direct link to heading">​</a></h3><div class="codeBlockContainer_I0IT language-sh theme-code-block"><div class="codeBlockContent_wNvx" style="color:#bfc7d5;background-color:#292d3e"><pre tabindex="0" class="prism-code language-sh codeBlock_jd64 thin-scrollbar"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#bfc7d5"><span class="token plain"># On SUBMARINE-${jira_number} branch</span><br></span><span class="token-line" style="color:#bfc7d5"><span class="token plain">git fetch upstream</span><br></span><span class="token-line" style="color:#bfc7d5"><span class="token plain">git rebase upstream/master</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" title="Copy" class="copyButton_eDfN clean-btn"><span class="copyButtonIcons_W9eQ" aria-hidden="true"><svg class="copyButtonIcon_XEyF" viewBox="0 0 24 24"><path 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 class="copyButtonSuccessIcon_i9w9" viewBox="0 0 24 24"><path d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div><ul><li>Please do not use <code>git pull</code> to synchronize your local branch. Because <code>git pull</code> does a merge to create merged commits, these will make commit history messy.</li></ul><h3 class="anchor anchorWithStickyNavbar_mojV" id="step7-push-your-local-branch-to-your-personal-fork">Step7: Push your local branch to your personal fork<a class="hash-link" href="#step7-push-your-local-branch-to-your-personal-fork" title="Direct link to heading">​</a></h3><div class="codeBlockContainer_I0IT language-sh theme-code-block"><div class="codeBlockContent_wNvx" style="color:#bfc7d5;background-color:#292d3e"><pre tabindex="0" class="prism-code language-sh codeBlock_jd64 thin-scrollbar"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#bfc7d5"><span class="token plain">git push origin SUBMARINE-${jira_number} </span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" title="Copy" class="copyButton_eDfN clean-btn"><span class="copyButtonIcons_W9eQ" aria-hidden="true"><svg class="copyButtonIcon_XEyF" viewBox="0 0 24 24"><path 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 class="copyButtonSuccessIcon_i9w9" viewBox="0 0 24 24"><path d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div><h3 class="anchor anchorWithStickyNavbar_mojV" id="step8-check-github-actions-status-of-your-personal-commit">Step8: Check GitHub Actions status of your personal commit<a class="hash-link" href="#step8-check-github-actions-status-of-your-personal-commit" title="Direct link to heading">​</a></h3><ul><li>Visit <code>https://github.com/${USERNAME}/submarine/actions</code></li><li>Please make sure your new commits can pass all workflows before creating a pull request.</li></ul><p><img loading="lazy" alt="check_ci_pass" src="/assets/images/check_ci_pass-9c6656dec7130470506c7420e55c7dd0.png" width="1898" height="577" class="img_E7b_"></p><h3 class="anchor anchorWithStickyNavbar_mojV" id="step9-create-a-pull-request-on-github-ui">Step9: Create a pull request on github UI<a class="hash-link" href="#step9-create-a-pull-request-on-github-ui" title="Direct link to heading">​</a></h3><ul><li>Visit your fork at <code>https://github.com/${USERNAME}/submarine.git</code></li><li>Click <code>Compare &amp; Pull Request</code> button to create pull request.
<img loading="lazy" alt="compare_pull_request_button" src="/assets/images/compare_pull_request_button-a5c8f7a7ebda5fad45d1d9e6ca8ed58a.png" width="2864" height="616" class="img_E7b_"></li></ul><h4 class="anchor anchorWithStickyNavbar_mojV" id="pull-request-template">Pull Request template<a class="hash-link" href="#pull-request-template" title="Direct link to heading">​</a></h4><ul><li><a href="https://github.com/apache/submarine/blob/bd7578cc28f8280f9170938d4469fcc965e24a89/.github/PULL_REQUEST_TEMPLATE" target="_blank" rel="noopener noreferrer">Pull request template</a></li><li>Filling the template thoroughly can improve the speed of the review process. Example: </li></ul><p><img loading="lazy" alt="pull_request_template_example" src="/assets/images/pull_request_template_example-5db7207e23fa54cca6de32325e8d7c67.png" width="2350" height="1408" class="img_E7b_"></p><h3 class="anchor anchorWithStickyNavbar_mojV" id="step10-check-github-actions-status-of-your-pull-request-in-apachesubmarine">Step10: Check GitHub Actions status of your pull request in apache/submarine<a class="hash-link" href="#step10-check-github-actions-status-of-your-pull-request-in-apachesubmarine" title="Direct link to heading">​</a></h3><ul><li>Visit <a href="https://github.com/apache/submarine/actions" target="_blank" rel="noopener noreferrer">https://github.com/apache/submarine/actions</a></li><li>Please make sure your pull request can pass all workflows. </li></ul><h3 class="anchor anchorWithStickyNavbar_mojV" id="step11-the-review-process">Step11: The Review Process<a class="hash-link" href="#step11-the-review-process" title="Direct link to heading">​</a></h3><ul><li>Anyone can be a reviewer and comment on the pull requests.</li><li>Reviewer can indicate that a patch looks suitable for merging with a comment such as: &quot;Looks good&quot;, &quot;LGTM&quot;, &quot;+1&quot;. (PS: LGTM = Looks Good To Me)</li><li>At least one indication of suitability (e.g. &quot;LGTM&quot;) from a committer is required to be merged. </li><li>A committer can then initiate lazy consensus (&quot;Merge if there is no more discussion&quot;) after which the code can be merged after a particular time (usually 24 hours) if there are no more reviews.</li><li>Contributors can ping reviewers (including committers) by commenting &#x27;Ready to review&#x27;.</li></ul><h3 class="anchor anchorWithStickyNavbar_mojV" id="step12-address-review-comments">Step12: Address review comments<a class="hash-link" href="#step12-address-review-comments" title="Direct link to heading">​</a></h3><ul><li>Push new commits to SUBMARINE-${jira_number} branch. The pull request will update automatically.</li><li>After you address all review comments, committers will merge the pull request.</li></ul><h3 class="anchor anchorWithStickyNavbar_mojV" id="code-convention">Code convention<a class="hash-link" href="#code-convention" title="Direct link to heading">​</a></h3><p>We are following Google Code style:</p><ul><li><a href="https://google.github.io/styleguide/javaguide.html" target="_blank" rel="noopener noreferrer">Java style</a></li><li><a href="https://google.github.io/styleguide/shell.xml" target="_blank" rel="noopener noreferrer">Shell style</a></li></ul><p>There are some plugins to format, lint your code in IDE (use <a href="hhttps://github.com/apache/submarine/blob/master/dev-support/maven-config/checkstyle.xml" target="_blank" rel="noopener noreferrer">dev-support/maven-config/checkstyle.xml</a> as rules)</p><ul><li><a href="https://plugins.jetbrains.com/plugin/1065" target="_blank" rel="noopener noreferrer">Checkstyle plugin for Intellij</a> (<a href="http://stackoverflow.com/questions/26955766/intellij-idea-checkstyle" target="_blank" rel="noopener noreferrer">Setting Guide</a>)</li><li><a href="http://eclipse-cs.sourceforge.net/#!/" target="_blank" rel="noopener noreferrer">Checkstyle plugin for Eclipse</a> (<a href="http://eclipse-cs.sourceforge.net/#!/project-setup" target="_blank" rel="noopener noreferrer">Setting Guide</a>)</li></ul></div><footer class="theme-doc-footer docusaurus-mt-lg"><div class="theme-doc-footer-edit-meta-row row"><div class="col"><a href="https://github.com/apache/submarine/edit/master/website/docs/community/contributing.md" target="_blank" rel="noreferrer noopener" class="theme-edit-this-page"><svg fill="currentColor" height="20" width="20" viewBox="0 0 40 40" class="iconEdit_dcUD" aria-hidden="true"><g><path d="m34.5 11.7l-3 3.1-6.3-6.3 3.1-3q0.5-0.5 1.2-0.5t1.1 0.5l3.9 3.9q0.5 0.4 0.5 1.1t-0.5 1.2z m-29.5 17.1l18.4-18.5 6.3 6.3-18.4 18.4h-6.3v-6.2z"></path></g></svg>Edit this page</a></div><div class="col lastUpdated_foO9"></div></div></footer></article><nav class="pagination-nav docusaurus-mt-lg" aria-label="Docs pages navigation"><div class="pagination-nav__item"><a class="pagination-nav__link" href="/docs/next/community/HowToCommit"><div class="pagination-nav__sublabel">Previous</div><div class="pagination-nav__label">Guide for Apache Submarine Committers</div></a></div><div class="pagination-nav__item pagination-nav__item--next"><a class="pagination-nav__link" href="/docs/next/community/HowToVoteCommitterOrPMC"><div class="pagination-nav__sublabel">Next</div><div class="pagination-nav__label">How to vote a Committer or PMC</div></a></div></nav></div></div><div class="col col--3"><div class="tableOfContents_cNA8 thin-scrollbar theme-doc-toc-desktop"><ul class="table-of-contents table-of-contents__left-border"><li><a href="#preface" class="table-of-contents__link toc-highlight">Preface</a></li><li><a href="#build-submarine" class="table-of-contents__link toc-highlight">Build Submarine</a></li><li><a href="#creating-patches" class="table-of-contents__link toc-highlight">Creating patches</a><ul><li><a href="#step1-fork-apachesubmarine-github-repository-first-time" class="table-of-contents__link toc-highlight">Step1: Fork apache/submarine github repository (first time)</a></li><li><a href="#step2-clone-the-submarine-to-your-local-machine" class="table-of-contents__link toc-highlight">Step2: Clone the Submarine to your local machine</a></li><li><a href="#step3-create-a-new-jira-in-submarine-project" class="table-of-contents__link toc-highlight">Step3: Create a new Jira in Submarine project</a></li><li><a href="#step4-create-a-local-branch-for-your-contribution" class="table-of-contents__link toc-highlight">Step4: Create a local branch for your contribution</a></li><li><a href="#step5-develop--create-commits" class="table-of-contents__link toc-highlight">Step5: Develop &amp; Create commits</a></li><li><a href="#step6-syncing-your-local-branch-with-upstreammaster" class="table-of-contents__link toc-highlight">Step6: Syncing your local branch with upstream/master</a></li><li><a href="#step7-push-your-local-branch-to-your-personal-fork" class="table-of-contents__link toc-highlight">Step7: Push your local branch to your personal fork</a></li><li><a href="#step8-check-github-actions-status-of-your-personal-commit" class="table-of-contents__link toc-highlight">Step8: Check GitHub Actions status of your personal commit</a></li><li><a href="#step9-create-a-pull-request-on-github-ui" class="table-of-contents__link toc-highlight">Step9: Create a pull request on github UI</a></li><li><a href="#step10-check-github-actions-status-of-your-pull-request-in-apachesubmarine" class="table-of-contents__link toc-highlight">Step10: Check GitHub Actions status of your pull request in apache/submarine</a></li><li><a href="#step11-the-review-process" class="table-of-contents__link toc-highlight">Step11: The Review Process</a></li><li><a href="#step12-address-review-comments" class="table-of-contents__link toc-highlight">Step12: Address review comments</a></li><li><a href="#code-convention" class="table-of-contents__link toc-highlight">Code convention</a></li></ul></li></ul></div></div></div></div></main></div></div><footer class="footer footer--dark"><div class="container container-fluid"><div class="row footer__links"><div class="col footer__col"><div class="footer__title">Docs</div><ul class="footer__items"><li class="footer__item"><a class="footer__link-item" href="/docs/gettingStarted/quickstart">Getting Started</a></li><li class="footer__item"><a class="footer__link-item" href="/docs/api/environment">API docs</a></li></ul></div><div class="col footer__col"><div class="footer__title">Community</div><ul class="footer__items"><li class="footer__item"><a href="https://stackoverflow.com/questions/tagged/apache-submarine" target="_blank" rel="noopener noreferrer" class="footer__link-item">Stack Overflow<svg width="13.5" height="13.5" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_I5OW"><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 class="footer__item"><a href="https://s.apache.org/slack-invite" target="_blank" rel="noopener noreferrer" class="footer__link-item">Slack<svg width="13.5" height="13.5" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_I5OW"><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="col footer__col"><div class="footer__title">More</div><ul class="footer__items"><li class="footer__item"><a href="https://medium.com/@apache.submarine" target="_blank" rel="noopener noreferrer" class="footer__link-item">Blog</a></li><li class="footer__item"><a href="https://github.com/apache/submarine" target="_blank" rel="noopener noreferrer" class="footer__link-item">GitHub<svg width="13.5" height="13.5" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_I5OW"><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><div class="footer__bottom text--center"><div class="margin-bottom--sm"><a href="https://www.apache.org/" target="_blank" rel="noopener noreferrer" class="footerLogoLink_gHmE"><img src="https://hadoop.apache.org/asf_logo_wide.png" alt="Apache Open Source Logo" class="themedImage_W2Cr themedImage--light_TfLj footer__logo"><img src="https://hadoop.apache.org/asf_logo_wide.png" alt="Apache Open Source Logo" class="themedImage_W2Cr themedImage--dark_oUvU footer__logo"></a></div><div class="footer__copyright">Apache Submarine, Submarine, Apache, the Apache feather logo, and the Apache Submarine project logo are
       either registered trademarks or trademarks of the Apache Software Foundation in the United States and other
        countries.<br> Copyright © 2023 Apache Submarine is Apache2 Licensed software.</div></div></div></footer></div>
<script src="/assets/js/runtime~main.89d436a2.js"></script>
<script src="/assets/js/main.b3d57bf8.js"></script>
</body>
</html>