<!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 - 11 March 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_111"><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 - 11 March 2013 | Apache CloudStack"><meta data-rh="true" name="description" content="This week the project started the vote to determine whether the Apache CloudStack project feels ready to self-govern, discussions were held about implementing BVT (and how), and the PPMC announced its consensus for the proposed PMC chair. In addition, several technical discussions for features and processes within the project, and discussion on the -marketing list about the design of the Web site."><meta data-rh="true" property="og:description" content="This week the project started the vote to determine whether the Apache CloudStack project feels ready to self-govern, discussions were held about implementing BVT (and how), and the PPMC announced its consensus for the proposed PMC chair. In addition, several technical discussions for features and processes within the project, and discussion on the -marketing list about the design of the Web site."><meta data-rh="true" property="og:type" content="article"><meta data-rh="true" property="article:published_time" content="2013-03-12T00: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_111"><link data-rh="true" rel="alternate" href="https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_111" hreflang="en"><link data-rh="true" rel="alternate" href="https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_111" 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.60ecdf28.js" as="script">
<link rel="preload" href="/assets/js/main.2d60fa8d.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="This week the project started the vote to determine whether the Apache CloudStack project feels ready to self-govern, discussions were held about implementing BVT (and how), and the PPMC announced its consensus for the proposed PMC chair. In addition, several technical discussions for features and processes within the project, and discussion on the -marketing list about the design of the Web site."><header><h1 class="title_f1Hy" itemprop="headline">Apache CloudStack Weekly News - 11 March 2013</h1><div class="container_mt6G margin-vert--md"><time datetime="2013-03-12T00:00:00.000Z" itemprop="datePublished">March 12, 2013</time></div></header><div id="__blog-post-container" class="markdown" itemprop="articleBody"><p><img loading="lazy" src="/img/imported/3b5a1e4e-90cb-469e-a58a-512bdcc28007?t=true" alt="acwn-icon.png" align="left" class="img_ev3q">This week the project started the vote to determine whether the Apache CloudStack project feels ready to self-govern, discussions were held about implementing BVT (and how), and the PPMC announced its consensus for the proposed PMC chair. In addition, several technical discussions for features and processes within the project, and discussion on the -marketing list about the design of the Web site.</p><p>Want to keep reading the CloudStack Weekly News? See the next section for information on how to contribute.</p><h3><a name="ApacheCloudStackWeeklyNews-11March2013-ContributingtotheApacheCloudStackWeeklyNews"></a>Contributing to the Apache CloudStack Weekly News</h3><p>If you have an event, discussion, or other item to contribute to the <em>Weekly News</em>, you can add it directly to the <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/CloudStack+Weekly+News" target="_blank" rel="nofollow" class="external-link">wiki</a> by editing the issue you want your item to appear in. (The next week&#x27;s issue is created before the current issue is published - so at any time there should be at least one issue ready to edit.) Alternatively, you can send to the cloudstack-dev mailing list with a subject including <a href="" title="News">News</a>: <em>description of topic</em> or email the newsletter editor directly (jzb at apache.org), again with the subject <a href="" title="News">News</a>: <em>description of topic</em>. <b>Please include a link to the discussion in the mailing list archive or Web page with details of the event, etc.</b></p><h3><a name="ApacheCloudStackWeeklyNews-11March2013-MajorDiscussions"></a>Major Discussions</h3><p>Some of the major discussions and issues that have taken place on cloudstack-dev, cloudstack-marketing and cloudstack-users in the past week. This is by no means exhaustive, if you need to be up-to-date on all development issues in the project, you&#x27;ll definitely want to be subscribed to the mailing lists!</p><h5><a name="ApacheCloudStackWeeklyNews-11March2013-VOTE%3AGraduateApacheCloudStackfromtheIncubator"></a>VOTE: Graduate Apache CloudStack from the Incubator</h5><p>Chip Childers <a href="http://markmail.org/message/3qh2dvzvdzk5vxka" target="_blank" rel="nofollow" class="external-link">has started the vote</a> on whether to graduate Apache CloudStack from the Incubator. The vote lasts 72 hours (vote started Monday morning). If successful, the IPMC will need to vote on the resolution and recommend graduation to the Apache Board of Directors. </p><h5><a name="ApacheCloudStackWeeklyNews-11March2013-PPMCWillRecommendChipChildersasChair"></a>PPMC Will Recommend Chip Childers as Chair</h5><p>In conjunction with the graduation discussion, the CloudStack PPMC has <a href="http://markmail.org/message/hv72l22kk4dms7aj" target="_blank" rel="nofollow" class="external-link">reached consensus</a> on recommending Chip Childers as chair, once the project graduates. See <a href="http://www.apache.org/foundation/how-it-works.html#roles" target="_blank" rel="nofollow" class="external-link">How the ASF Works: Roles</a> for more on roles within Top Level Projects (TLPs).</p><h5><a name="ApacheCloudStackWeeklyNews-11March2013-MeetCatoFong"></a>Meet Cato_Fong</h5><p>If you haven&#x27;t already, Prasanna Santhanam invites everyone to <a href="http://markmail.org/message/daujidydbynx2key" target="_blank" rel="nofollow" class="external-link">meet Cato_Fong</a>, a handy IRC bot that keeps an eye on the Jenkins builds for the project. Says Prasanna, &quot;if the build is broken and the executor on builds.a.o has not yet queued the job be prepared to be ambushed by Cato_Fong!&quot;</p><h5><a name="ApacheCloudStackWeeklyNews-11March2013-SyslogEnhancements"></a>Syslog Enhancements</h5><p>Anshul Gangwar has <a href="http://markmail.org/message/iojeclbpkssbbprk" target="_blank" rel="nofollow" class="external-link">revived</a> a discussion from December about using log4j to send syslog messages. See the <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/FS+for+Syslog+Enhancements" target="_blank" rel="nofollow" class="external-link">FS</a> on the wiki, and join in the discussion on the -dev mailing list if you have anything to add. </p><h5><a name="ApacheCloudStackWeeklyNews-11March2013-GettingRidofKVMPatchdiskRaisesDiscussionofNewSystemVMProgrammingModel"></a>Getting Rid of KVM Patchdisk Raises Discussion of New System VM Programming Model</h5><p>Marcus Sorensen <a href="http://markmail.org/message/anaolzxlcpgrlnh5" target="_blank" rel="nofollow" class="external-link">started a discussion last week</a> about getting rid of the patchdisk that KVM creates on primary storage when bringing up a VM. Marcus says, &quot;This patch disk has been bugging me for awhile, as it creates a volume<br>that isn&#x27;t really tracked anywhere or known about in cloudstack&#x27;s database. Up until recently these would just litter the KVM primary<br>storages, but there&#x27;s been some triage done to attempt to clean them up when the system vms go away. It&#x27;s not perfect. It also can be<br>inefficient for certain primary storage types, for example if you end up creating a bunch of 10MB luns on a SAN for these.&quot;</p><p>Later in the discussion, Edison Su responded to Marcus&#x27; approach to handling the issue. <a href="http://markmail.org/message/2ee2z7vfo6hoq45p" target="_blank" rel="nofollow" class="external-link">Edison says</a> &quot;we put a lot of logic into init scripts inside system VM, which has unnecessarily complicated the system VM programming.&quot; Ultimately, Edison suggest that we may need &quot;to start working on a new system VM programming model now? Better to just put a Python daemon inside system VM, and provide restful API through link local IP address(or private IP if it&#x27;s vmware), then mgt server or hypervisor agent code can just send commands to the Python daemon through HTTP, instead of SSH.&quot;</p><h5><a name="ApacheCloudStackWeeklyNews-11March2013-BuildVerificationTest%28BVT%29forCloudStackCheckins"></a>Build Verification Test (BVT) for CloudStack Checkins</h5><p>Alex Huang <a href="http://markmail.org/message/kvtkfjaswopqkd7m" target="_blank" rel="nofollow" class="external-link">proposed</a> building a BVT system to &quot;ensure that checkins do not break the <a class="createlink" href="/confluence/pages/createpage.action?spaceKey=CLOUDSTACK&amp;title=master&amp;linkCreation=true&amp;fromPageId=30756122">master</a> branch.&quot; </p><p>After a fair amount of discussion, Chip Childers <a href="http://markmail.org/message/2tavrqatlyyrwmp6" target="_blank" rel="nofollow" class="external-link">responded, saying that the first step to getting Gerrit</a> is &quot;for us to agree to using it and to be able to clearly articulate <b>why</b>.  Without being able to explain our issue, we&#x27;ll be questioned about jumping to a tool-based solution by the infra team.&quot;</p><p>The entire discussion is worth a read for anyone involved in day-to-day CloudStack development. (Indeed, one hopes that <b>all</b> developers have paid close attention to this thread, not only the handful of active voices who have jumped into the discussion.)</p><h5><a name="ApacheCloudStackWeeklyNews-11March2013-ProposaltoRefactorApplianceBuildingCodeUndertools%2Fappliance"></a>Proposal to Refactor Appliance Building Code Under tools/appliance</h5><p>Rohit Yadav has proposed to &quot;<a href="http://markmail.org/message/lmvbmqvuiriyfgij" target="_blank" rel="nofollow" class="external-link">fix/refactor devcloud appliance building scripts</a> from tools/devcloud/sr to tools/appliance&quot; and &quot;to create a new devcloud that has all the build tools, IDE and possibly a lightweight desktop environment or tiling window manager.&quot;</p><h5><a name="ApacheCloudStackWeeklyNews-11March2013-IncrementalBuild"></a>Incremental Build</h5><p>Edison points out that <a href="http://markmail.org/message/a2b4tfrts3yyhary" target="_blank" rel="nofollow" class="external-link">Maven 3 doesn&#x27;t support incremental builds</a>, &quot;so it takes a long time (4-7 minutes) to make a build&quot; even with small changes in the source code. Animesh Chaturvedi <a href="http://markmail.org/message/plpuxmxocgoupqak" target="_blank" rel="nofollow" class="external-link">points out a tool that might help</a> add incremental build support to Maven, but there was no enthusiasm for changing tools away from Maven after the effort that went into switching from Ant.</p><h5><a name="ApacheCloudStackWeeklyNews-11March2013-Marketing%3AWebsiteDiscussions"></a>Marketing: Website Discussions</h5><p>There&#x27;s been a fair amount of discussion this week about improving the Apache CloudStack Web site. Sebastien Goasguen <a href="http://markmail.org/message/rzaqvo247sskdf5t" target="_blank" rel="nofollow" class="external-link">started the discussion</a> on March 5th, pointing to a site that he found &quot;simple, yet modern.&quot; The discussion has moved on to work on the <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/Website+Resources+and+Proposals" target="_blank" rel="nofollow" class="external-link">sitemap</a> and <a href="http://markmail.org/message/dnbvgwyykyyub32w" target="_blank" rel="nofollow" class="external-link">flow of the site</a>. </p><p>No firm proposals or decisions have come out of the discussion as of yet. </p><p>There&#x27;s also discussion about the <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/Website+Resources+and+Proposals" target="_blank" rel="nofollow" class="external-link">elevator pitch and top <em>N</em> features</a> of CloudStack that should be on the landing page.</p><h5><a name="ApacheCloudStackWeeklyNews-11March2013-LDAPSetupAssistance"></a>LDAP Setup Assistance</h5><p>Kirk Jantzer came to the -users list <a href="http://markmail.org/message/jbdioq4kbgay4pjl" target="_blank" rel="nofollow" class="external-link">looking for help in setting up LDAP</a>. Ilya Musayev <a href="http://markmail.org/thread/cbwtk3fub7p7yexm" target="_blank" rel="nofollow" class="external-link">shared an earlier note to -dev</a> about using Microsoft&#x27;s Active Directory (LDAP) working with CloudStack, and Kirk <a href="http://markmail.org/message/o65puxc4rgu6pe45" target="_blank" rel="nofollow" class="external-link">reported</a> that he was able to get it working by adding users with dummy passwords. </p><h5><a name="ApacheCloudStackWeeklyNews-11March2013-SystemVMTemplates"></a>System VM Templates</h5><p>Following a discussion on -users, Chip noted that 4.1.0-incubating <a href="http://markmail.org/message/douf6kgmfdbmqsyq" target="_blank" rel="nofollow" class="external-link">will use the same system VM templates</a> used by 4.0.0-incubating and CloudStack releases from Citrix prior to its donation to Apache. However, Chip adds, &quot;we&#x27;re working on an automated system VM build process that should be part of 4.2.0-incubating (allowing us to refresh the image that&#x27;s used).&quot;</p><h3><a name="ApacheCloudStackWeeklyNews-11March2013-CloudStackPlanetPostsfromtheCloudStackCommunity"></a>CloudStack Planet - Posts from the CloudStack Community</h3><ul><li>David Nalley <a href="http://buildacloud.org/blog/235-puppet-and-cloudstack.html" target="_blank" rel="nofollow" class="external-link">wrote about</a> efficient use of CloudStack using Puppet.</li></ul><ul><li>Joe Brockmeier contributed a <a href="http://buildacloud.org/blog/234-apachecon-north-america-wrap-up.html" target="_blank" rel="nofollow" class="external-link">report on ApacheCon North America</a>.</li></ul><ul><li>Sebastien <a href="http://buildacloud.org/blog/233-activeeon-integrates-with-cloudstack.html" target="_blank" rel="nofollow" class="external-link">blogged about</a> Activeeon&#x27;s integration with CloudStack.</li></ul><ul><li>Sebastien also tweeted that the videos from Build A Cloud Day Ghent are now up. The playlist includes <a href="http://www.youtube.com/playlist?list=PLb899uhkHRoZZefRW5XmCb8QBcRO7o74E" target="_blank" rel="nofollow" class="external-link">several talks focused on CloudStack</a>.</li></ul><h3><a name="ApacheCloudStackWeeklyNews-11March2013-UpcomingEvents"></a>Upcoming Events</h3><ul><li><b>New York City Cloud Computing Group</b>: <a href="http://www.meetup.com/nyccloudcomputing/events/104771232/" target="_blank" rel="nofollow" class="external-link">Deploying Apache CloudStack from API to UI</a> - New York City, Wednesday March 13, 2013.</li></ul><ul><li><b>NYLUG Meetup</b>: <a href="http://www.meetup.com/nylug-meetings/events/82181872/" target="_blank" rel="nofollow" class="external-link"><em>Open Source Private Clouds with CloudStack, Eucalyptus and OpenStack</em></a> - New York City, Thursday March 14, 2013. RSVPs open on February 28th at 6:15 p.m. Eastern.</li></ul><h3><a name="ApacheCloudStackWeeklyNews-11March2013-Jira"></a>Jira </h3><p>The number of issues for 4.1.0 has crept back up in the last week, likely because QA had been blocked from testing by some bugs previously - with those out of the way, QA is able to find more issues in the release. </p><p>Note that some of the issues are also less dire than they seem: <a href="https://issues.apache.org/jira/browse/CLOUDSTACK-1584" target="_blank" rel="nofollow" class="external-link">CLOUDSTACK-1584</a> is a blocker for release, but it&#x27;s only to ensure that an important task (adding links to the documentation for downloads) is completed before the release. </p><ul><li>Last week: 4 blocker bugs. This week: 11 <a href="http://is.gd/blockers41acs" target="_blank" rel="nofollow" class="external-link">blocker bugs</a></li><li>Last week: 18 critical bugs. This week: 29 <a href="http://is.gd/critical41acs" target="_blank" rel="nofollow" class="external-link">critical bugs</a></li><li>Last week: 191 major bugs. This week: 159 <a href="http://is.gd/major41acs" target="_blank" rel="nofollow" class="external-link">major bugs</a></li><li>Last week: 33 minor bugs. This week: 33 <a href="http://is.gd/minor41acs" target="_blank" rel="nofollow" class="external-link">minor bugs</a></li></ul><h3><a name="ApacheCloudStackWeeklyNews-11March2013-NewCommittersandPPMCMembers"></a>New Committers and PPMC Members</h3><p>No new committers or PPMC members were announced last week.</p></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-03-12-apache_cloudstack_weekly_news_111.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_181"><div class="pagination-nav__sublabel">Newer Post</div><div class="pagination-nav__label">Apache CloudStack Weekly News - 18 March 2013</div></a><a class="pagination-nav__link pagination-nav__link--next" href="/blog/apache_cloudstack_weekly_news_41"><div class="pagination-nav__sublabel">Older Post</div><div class="pagination-nav__label">Apache CloudStack Weekly News - 4 March 2013</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.60ecdf28.js"></script>
<script src="/assets/js/main.2d60fa8d.js"></script>
</body>
</html>