<!doctype html>
<html lang="en" dir="ltr" class="blog-wrapper blog-post-page plugin-blog plugin-id-default" data-has-hydrated="false">
<head>
<meta charset="UTF-8">
<meta name="generator" content="Docusaurus v2.4.3">
<title data-rh="true">Apache CloudStack Weekly News - 14 January 2013 | 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/blog/apache_cloudstack_weekly_news_14"><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="Apache CloudStack Weekly News - 14 January 2013 | Apache CloudStack"><meta data-rh="true" name="description" content="Each week, we&#x27;ll summarize the most important issues and developments in the Apache CloudStack (incubating) community. This week, the vote on accepting Marvin tests, Apache CloudStack bylaws, issues with features for 4.1.0, and upcoming events."><meta data-rh="true" property="og:description" content="Each week, we&#x27;ll summarize the most important issues and developments in the Apache CloudStack (incubating) community. This week, the vote on accepting Marvin tests, Apache CloudStack bylaws, issues with features for 4.1.0, and upcoming events."><meta data-rh="true" property="og:type" content="article"><meta data-rh="true" property="article:published_time" content="2013-01-14T00:00:00.000Z"><link data-rh="true" rel="icon" href="/img/favicon.ico"><link data-rh="true" rel="canonical" href="https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_14"><link data-rh="true" rel="alternate" href="https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_14" hreflang="en"><link data-rh="true" rel="alternate" href="https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_14" 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/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"><div class="container margin-vert--lg blog-container"><div class="row"><aside class="col col--3"><nav class="sidebar thin-scrollbar"><div class="sidebarItemTitle margin-bottom--md">CloudStack Blog</div><ul class="sidebarItemList clean-list"><li class="sidebarItem"><a class="sidebarItemLink" href="/blog">All Posts</a></li><li class="sidebarItem"><a class="sidebarItemLink" href="/blog/tags/news">News</a></li><li class="sidebarItem"><a class="sidebarItemLink" href="/blog/tags/announcement">Announcements</a></li><li class="sidebarItem"><a class="sidebarItemLink" href="/blog/tags/roundup">Past Events</a></li><li class="sidebarItem"><a class="sidebarItemLink" href="/blog/tags/case-studies">Case Studies &amp; Integrations</a></li><li class="sidebarItem"><a class="sidebarItemLink" href="/blog/tags/community">Meet the Community</a></li></ul></nav></aside><main class="col col--7" itemscope="" itemtype="http://schema.org/Blog"><article itemprop="blogPost" itemscope="" itemtype="http://schema.org/BlogPosting"><meta itemprop="description" content="Each week, we&#x27;ll summarize the most important issues and developments in the Apache CloudStack (incubating) community. This week, the vote on accepting Marvin tests, Apache CloudStack bylaws, issues with features for 4.1.0, and upcoming events."><header><h1 class="title_f1Hy" itemprop="headline">Apache CloudStack Weekly News - 14 January 2013</h1><div class="container_mt6G margin-vert--md"><time datetime="2013-01-14T00:00:00.000Z" itemprop="datePublished">January 14, 2013</time></div></header><div id="__blog-post-container" class="markdown" itemprop="articleBody"><p>Each week, we&#x27;ll summarize the most important issues and developments in the Apache CloudStack (incubating) community. This week, the vote on accepting Marvin tests, Apache CloudStack bylaws, issues with features for 4.1.0, and upcoming events.</p><h3><a name="ApacheCloudStackWeeklyNews-14January2013-MajorDiscussionsandIssues"></a>Major Discussions and Issues</h3><ul><li>Project Bylaws were <a href="http://markmail.org/thread/ma3g6hdgegu76g44" target="_blank" rel="nofollow" class="external-link">discussed previously</a> and after a substantial discussion on cloudstack-dev have <a href="http://markmail.org/thread/2q5b2y7oahgobqfg" target="_blank" rel="nofollow" class="external-link">passed</a>. The bylaws are intended to go into effect once Apache CloudStack graduates from the Apache Incubator. (Note that a vote on graduation is not currently pending.)</li><li>Discussion about whether CloudStack should make a concerted effort to <a href="http://markmail.org/thread/moyctvlxmgrrorb5" target="_blank" rel="nofollow" class="external-link">get into Linux distros</a>.</li><li>There are some <a href="http://markmail.org/thread/nu4f6tphsnsv7ls6" target="_blank" rel="nofollow" class="external-link">concerns about where development is happening</a> for major features being targeted for CloudStack 4.1.0. A number of features have been developed outside of the community, and may need to go through IP clearance to be accepted into master for 4.1.0.</li><li>Discussion on how CloudMonkey should be released, whether it makes sense to <a href="http://markmail.org/thread/moyctvlxmgrrorb5" target="_blank" rel="nofollow" class="external-link">release CloudMonkey out-of-band via pypi or stick with major releases</a>.</li><li>Reminder to developers to <a href="http://markmail.org/thread/pb3bmv44m6vwro4w" target="_blank" rel="nofollow" class="external-link">update status, risk, and issues in Jira items</a>.</li><li>Vote to accept Marvin automated tests from Citrix <a href="http://markmail.org/thread/cqkim6v5nk73tur7" target="_blank" rel="nofollow" class="external-link">started on January 9th</a> the vote <a href="http://markmail.org/thread/vxwtwnhapmf7inw7" target="_blank" rel="nofollow" class="external-link">passed</a> and now will begin going through IP clearance.</li><li><a href="http://markmail.org/thread/jhkqwujf23zegn5d" target="_blank" rel="nofollow" class="external-link">Minutes from QA Scrum on 8 January 2013</a>.</li><li><a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/CloudStack+Meeting+9+January+2013+Minutes" target="_blank" rel="nofollow" class="external-link">Minutes from CloudStack IRC Meeting 9 January 2013</a> and the <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/CloudStack+Meeting+9+January+2013+Log" target="_blank" rel="nofollow" class="external-link">full log</a>.</li></ul><h3><a name="ApacheCloudStackWeeklyNews-14January2013-UpcomingEvents"></a>Upcoming Events</h3><p>CloudStack will be represented at a number of events in the next few weeks:</p><ul><li><b>OSSI DHS Industry Day</b> David Nalley is on a panel and will talk about Apache CloudStack at the <a href="http://www.oss-institute.org/component/events/event/30" target="_blank" rel="nofollow" class="external-link">OSSI Industry Day</a> in Linthicum, Maryland on Monday, 14 January 2013.</li><li><b>DC Riak Users Group</b> David Nalley is speaking about CloudStack at the <a href="http://www.meetup.com/Riak-DC/events/94513602/" target="_blank" rel="nofollow" class="external-link">DC Riak Users Group</a> in Washington DC on Wednesday, 16 January 2013.</li><li><b>PuppetCamp Silicon Valley</b>: David Nalley is <a href="http://puppetcampsiliconvalley2013.eventbrite.com/" target="_blank" rel="nofollow" class="external-link">speaking about CloudStack at PuppetCamp Silicon Valley</a> on Friday, 18 January 2013.</li><li><b>PuppetCamp Sydney</b>: Joe Brockmeier is <a href="http://puppetcampsydney2013.eventbrite.com/" target="_blank" rel="nofollow" class="external-link">speaking about Apache CloudStack at PuppetCamp Sydney</a> on Thursday, 24 January 2013.</li><li><b>Linux.conf.au</b>: Joe Brockmeier is <a href="https://lca2013.linux.org.au/schedule/30073/view_talk?day=monday" target="_blank" rel="nofollow" class="external-link">speaking about Apache CloudStack during the Cloud Infrastructure, Distributed Storage and High Availability miniconf</a> on Monday (28 January, 2013).</li><li><b>FOSDEM</b>: Sebastien Goasguen is <a href="https://fosdem.org/2013/schedule/event/cloudstack/" target="_blank" rel="nofollow" class="external-link">speaking about Apache CloudStack features and tools</a> during the <a href="https://fosdem.org/2013/schedule/track/cloud/" target="_blank" rel="nofollow" class="external-link">cloud DevRoom</a> at FOSDEM on Sunday (3 February, 2013).</li><li><b>Build a Cloud Day (BACD)</b>: Full day <a href="http://buildacloud.org/about-cloudstack/cloudstack-events/viewevent/140-build-a-cloud-day-ghent-2013.html" target="_blank" rel="nofollow" class="external-link">workshop</a> on CloudStack co-located with Puppet Camp in Ghent, Belgium (1 February, 2013).</li><li><b>UK/European User Group Meet-up</b> : Shapeblue is organizing a <a href="http://buildacloud.org/about-cloudstack/cloudstack-events/viewevent/141-ukeuropean-user-group-meet-up.html" target="_blank" rel="nofollow" class="external-link">meet-up</a>. (January 16th, 2013)</li></ul><h3><a name="ApacheCloudStackWeeklyNews-14January2013-Jira"></a>Jira</h3><p>In the last 30 days (as of 11 January, 2013) 345 issues have been created in Jira, and 85 have been resolved.</p><ul><li>Unassigned Issues: 299 as of 11 January, 2013. <a href="http://is.gd/Nj4yuN" target="_blank" rel="nofollow" class="external-link">Please see if any of the issues are something you can help with</a>.</li><li>There are <a href="http://is.gd/Nj4yuN" target="_blank" rel="nofollow" class="external-link">84 open issues affecting 4.1.0</a>.</li><li>75 issues are of <a href="http://is.gd/1eRl59" target="_blank" rel="nofollow" class="external-link">blocker, critical, or major status</a>.</li></ul><h3><a name="ApacheCloudStackWeeklyNews-14January2013-NewCommittersandPPMCMembers"></a>New Committers and PPMC Members</h3><ul><li>Sebastien Goasguen and Kelcey Damage were welcomed as new committers.</li></ul></div><footer class="row docusaurus-mt-lg blogPostFooterDetailsFull_mRVl"><div class="col margin-top--sm"><a href="https://github.com/apache/cloudstack-www/tree/main/blog/2013-01-14-apache_cloudstack_weekly_news_14.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_Z9Sw" 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></footer></article><nav class="pagination-nav docusaurus-mt-lg" aria-label="Blog post page navigation"><a class="pagination-nav__link pagination-nav__link--prev" href="/blog/apache_cloudstack_weekly_news_21"><div class="pagination-nav__sublabel">Newer Post</div><div class="pagination-nav__label">Apache CloudStack Weekly News - 21 January 2013</div></a><a class="pagination-nav__link pagination-nav__link--next" href="/blog/apache_cloudstack_4_0_0"><div class="pagination-nav__sublabel">Older Post</div><div class="pagination-nav__label">Apache CloudStack 4.0.0-incubating Released</div></a></nav></main></div></div></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>