<div class="wiki-content maincontent"><p>The following email templates are for use by the ActiveMQ PMC:&#160;</p><p><structured-macro ac:macro-id="5d00b44d-7927-4c01-8842-8a373f77d24b" ac:name="toc" ac:schema-version="1"></structured-macro></p><h1>Committer Discussion</h1><structured-macro ac:macro-id="d147b9c1-9d75-4d4f-b760-9945c192bed8" ac:name="panel" ac:schema-version="1"><rich-text-body><p>To:&#160;<a shape="rect" href="mailto:private@activemq.apache.org">private@activemq.apache.org<br clear="none"></a>Subject: [DISCUSS] Invite &lt;CANDIDATE&gt; to become an ActiveMQ committer</p><p>Considering &lt;CANDIDATE&gt;&#8217;s contributions to the ActiveMQ project...</p><p>&lt;INSERT EVIDENCE HERE&gt;</p><p>Based on this person's contributions above, I think we should invite &lt;CANDIDATE&gt; to become a committer.</p><p>Please remember that this is not a vote for this person to become a committer, at this point it is only a discussion.</p></rich-text-body></structured-macro><p>&#160;</p><h1>Committer Vote</h1><structured-macro ac:macro-id="ed4aaec6-1858-4603-b6b8-3cb0c1acea5d" ac:name="panel" ac:schema-version="1"><rich-text-body><p>To: <a shape="rect" href="mailto:private@activemq.apache.org">private@activemq.apache.org<br clear="none"></a>Subject: [VOTE] Invite &lt;CANDIDATE&gt; to become an ActiveMQ committer</p><p>After positive discussion about &lt;CANDIDATE&gt;&#8217;s contributions to the project, I would like to initiate a formal vote.</p><p>Considering &lt;INSERT EVIDENCE HERE&gt; as raised in the discussion thread...</p><p>This vote will follow the ASF process for committer votes and consensus approval (at least three binding +1 votes and no vetoes)The vote will be open for 72 hours.</p><p>[ ] +1 Accept &lt;CANDIDATE&gt; as a committer of Apache ActiveMQ<br clear="none">[ ] +0<br clear="none">[ ] -1 Do not accept at this time because...</p></rich-text-body></structured-macro><p>&#160;</p><h1>Committer Vote Result</h1><structured-macro ac:macro-id="c1d32f39-ad5d-40ca-9fa5-ea1d71f1e657" ac:name="panel" ac:schema-version="1"><rich-text-body><p>To: <a shape="rect" href="mailto:private@activemq.apache.org">private@activemq.apache.org<br clear="none"></a>Subject: [RESULT][VOTE] Invite &lt;CANDIDATE&gt; to become an ActiveMQ committer.</p><p>This vote has been open for &lt;X&gt; days and is now closed with the following results:</p><p>* Number of +1s<br clear="none">* Number of 0s<br clear="none">* Number of -1s</p><p>The vote &lt;passes|does not pass&gt;.</p></rich-text-body></structured-macro><p>&#160;</p><h1>Committer Invitation</h1><structured-macro ac:macro-id="8cc1f42d-1f40-47aa-b8bf-ef40e00aae70" ac:name="panel" ac:schema-version="1"><rich-text-body><p>To: &lt;INVITEE EMAIL&gt;<br clear="none">Cc: <a shape="rect" href="mailto:private@activemq.apache.org">private@activemq.apache.org<br clear="none"></a>Subject: Invitation to become Apache Active committer</p><p>Hello &lt;INVITEE&gt;,</p><p>The Apache ActiveMQ Project Management Committee (PMC) hereby invites you to become committer on the project. These privileges are offered on the understanding that you'll use them reasonably and with common sense. We like to work on trust rather than unnecessary constraints.</p><p>Being a committer enables you to more easily make changes without needing to go through the patch submission process. Although you will be granted commit access to project repositories, you will be expected to adhere to project best practices when committing. The following URL some good resources regarding expectations and processes:</p><p><a shape="rect" href="http://www.apache.org/dev/new-committers-guide.html">http://www.apache.org/dev/new-committers-guide.html</a></p><p>This is a personal invitation for you to accept or decline in private. Please reply to the <a shape="rect" href="mailto:private@activemq.apache.org">private@activemq.apache.org</a> address only.</p><p>If you accept the invitation, the next step is to register an Individual Contributor License Agreement (ICLA) with the Apache Software Foundation if you have not already. Details of the ICLA and the forma can be found at the following URL:</p><p><a shape="rect" href="http://www.apache.org/licenses/#clas">http://www.apache.org/licenses/#clas</a></p><p>The form provides instructions for its completion and submittal to the Secretary of the ASF.</p><p>When you submit the completed ICLA, please request to notify the Apache ActiveMQ project upon official receipt.Once your ICLA has been acknowledged by the Secretary, you will need to choose a unique ASF ID. You can check to see if your preferred id is already taken by browsing the following list of ASF committers:</p><p><a shape="rect" href="http://people.apache.org/committer-index.html">http://people.apache.org/committer-index.html</a></p><p>When your ICLA is recognized by the Secretary, you will receive a follow-up message with the next steps for establishing you as a committer.</p><p>We look forward to your response!</p></rich-text-body></structured-macro><structured-macro ac:macro-id="608ed2a9-144d-4f3c-8fa6-475c454ca983" ac:name="auimessage" ac:schema-version="1"><parameter ac:name="title">IMPORTANT</parameter><parameter ac:name="type">hint</parameter><rich-text-body><p>Once the prospective committer has accepted the invitation and the ICLA has been acknowledged (check the following URL to be sure it has been submitted: <a shape="rect" href="https://people.apache.org/unlistedclas.html">https://people.apache.org/unlistedclas.html</a>), locate the vote result thread permalink from the private@activemq list can be found using:&#160;<a shape="rect" class="external-link" href="https://mail-search.apache.org/">https://mail-search.apache.org/</a> or <a shape="rect" href="https://lists.apache.org/">https://lists.apache.org/</a> (authentication required).</p><p>Upon locating the permalink, use the account request form to request the new ASF user id:&#160;<a shape="rect" class="external-link" href="https://id.apache.org/acreq/pmc-chairs">https://id.apache.org/acreq/pmc-chairs</a>&#160; If the name isn't in the list be sure to click the link on the bottom right.</p></rich-text-body></structured-macro><h1>Committer Announcement</h1><structured-macro ac:macro-id="d5df4d47-f505-4d53-9535-1b4195f3da97" ac:name="panel" ac:schema-version="1"><rich-text-body><p>To: <a shape="rect" href="mailto:dev@activemq.apache.org">dev@activemq.apache.org</a><br clear="none">Subject: [ANNOUNCE] New Apache ActiveMQ Committer &lt;INVITEE&gt;</p><p>On behalf of the Apache ActiveMQ PMC, I am very pleased to announce that &lt;INVITEE&gt; has accepted an invitation to become a committer. We greatly appreciate all of &lt;INVITEE&gt;'s hard work and generous contributions to the project. We look forward to &lt;her/his&gt; continued involvement in the project.</p><p>Welcome &lt;INVITEE&gt; and congratulations!</p></rich-text-body></structured-macro><p>&#160;</p><h1>Commiter Onboarding</h1><structured-macro ac:macro-id="61bf0c7d-b9c9-4cff-8802-768617ae58f8" ac:name="panel" ac:schema-version="1"><rich-text-body><p>To: <a shape="rect" href="mailto:private@acctivemq.apache.org">private@acctivemq.apache.org</a>, &lt;NEW COMMITTER&gt;<br clear="none">Subject: [committer]: What to do now that you're a committer?</p><p>&lt;COMMITTER&gt;, the ASF Infrastructure has set up your user account as the '&lt;ASF USER ID&gt;'.</p><p>To learn more about how the ASF works, please visit the following URL and read the items in the 'Committers and Contributors' section:</p><p><a shape="rect" href="https://www.apache.org/dev/#committers">https://www.apache.org/dev/#committers</a></p><p>It is especially important to read through the New Committers Guide at the following URL:</p><p><a shape="rect" href="https://www.apache.org/dev/new-committers-guide.html">https://www.apache.org/dev/new-committers-guide.html</a></p><p>Please ensure that you subscribed to the Apache ActiveMQ Developers mailing list <a shape="rect" href="mailto:dev@activemq.apache.org">dev@activemq.apache.org</a>. We also recommend subscribing to the users@ and commits@ mailing lists at <a shape="rect" href="mailto:users@activemq.apache.org">users@activemq.apache.org</a> and <a shape="rect" href="mailto:commits@activemq.apache.org">commits@activemq.apache.org</a>. Please see the following page for more info about the mailing lists:</p><p><a shape="rect" href="http://activemq.apache.org/mailing-lists.html">http://activemq.apache.org/mailing-lists.html</a><br clear="none"> <br clear="none">To push commits, ensure that you use HTTPS or SSH in your git remotes, or if you've been pulling from a mirror like Github, you'll need to add a remote such as:</p><p><br clear="none"> $ git remote add apache <a shape="rect" href="https://git-wip-us.apache.org/repos/asf/activemq.git">https://git-wip-us.apache.org/repos/asf/activemq.git</a></p><p><br clear="none">If you have any questions please ask on the dev@activemq list.</p></rich-text-body></structured-macro><p>&#160;</p><h1>PMC&#160;Discussion</h1><structured-macro ac:macro-id="87b2b57b-6652-42e6-9b83-18f6dbaece4a" ac:name="panel" ac:schema-version="1"><rich-text-body><p>To:&#160;<a shape="rect" href="mailto:private@activemq.apache.org">private@activemq.apache.org<br clear="none"></a>Subject: [DISCUSS] Invite &lt;CANDIDATE&gt; to join ActiveMQ PMC</p><p>Considering &lt;CANDIDATE&gt;&#8217;s contributions to the ActiveMQ project as a committer...</p><p>&lt;INSERT EVIDENCE HERE&gt;</p><p>Based on this person's contributions above, I think we should invite &lt;CANDIDATE&gt; to become a committer.</p><p>Please remember that this is not a vote for this person to become a committer, at this point it is only a discussion.</p></rich-text-body></structured-macro><h1>PMC Vote</h1><structured-macro ac:macro-id="a221036b-3cf8-43c3-92ab-70329f703618" ac:name="panel" ac:schema-version="1"><rich-text-body><p>To: <a shape="rect" href="mailto:private@activemq.apache.org">private@activemq.apache.org</a><br clear="none">Subject: [VOTE] Invite <span>&lt;CANDIDATE&gt; </span>to join Apache ActiveMQ PMC</p><p>After positive discussion considering &lt;CANDIDATE&gt;&#8217;s contributions as a committer, I would like to initiate a formal vote.</p><p>&lt;INSERT EVIDENCE HERE&gt;</p><p>This vote will follow the ASF process for committer votes and consensus approval (at least three binding +1 votes and no vetoes)</p><p>The vote will be open for 72 hours.</p><p>[ ] +1 Accept &lt;CANDIDATE&gt; as a PMC member of Apache ActiveMQ<br clear="none">[ ] +0<br clear="none">[ ] -1 Do not accept at this time because...</p></rich-text-body></structured-macro><p>&#160;</p><h1>PMC Invite</h1><structured-macro ac:macro-id="0695afda-45b3-4f04-a588-97d64e1026ef" ac:name="panel" ac:schema-version="1"><rich-text-body><p>To: &lt;INVITEE EMAIL&gt;<br clear="none">Cc: <a shape="rect" href="mailto:private@activemq.apache.org">private@activemq.apache.org</a><br clear="none">Subject: Invitation to join the Apache ActiveMQ PMC</p><p>&lt;INVITEE&gt;,<br clear="none">In recognition of your continued contributions to the project, the Apache ActiveMQ PMC has voted to invite you to join the PMC. I am writing on behalf of the PMC to give you the opportunity to either accept or reject this invitation by replying to <a shape="rect" href="mailto:private@activemq.apache.org">private@activemq.apache.org</a>.</p><p>In making your decision, please see the following URL for more information on PMCs:</p><p><a shape="rect" href="https://www.apache.org/dev/pmc.html">https://www.apache.org/dev/pmc.html</a></p><p>If you have questions before making a decision, please let us know.</p></rich-text-body></structured-macro></div>

