<!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 February 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_11"><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 February 2013 | Apache CloudStack"><meta data-rh="true" name="description" content="In the past week, the 4.0.1-incubating release passed its VOTE on the general@incubator.apache.org list, work continued on 4.1.0, and there were active discussions on using Gerrit, cloud-init, and whether memory usage has increased following the adoption of the Spring framework."><meta data-rh="true" property="og:description" content="In the past week, the 4.0.1-incubating release passed its VOTE on the general@incubator.apache.org list, work continued on 4.1.0, and there were active discussions on using Gerrit, cloud-init, and whether memory usage has increased following the adoption of the Spring framework."><meta data-rh="true" property="og:type" content="article"><meta data-rh="true" property="article:published_time" content="2013-02-11T00: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_11"><link data-rh="true" rel="alternate" href="https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_11" hreflang="en"><link data-rh="true" rel="alternate" href="https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_11" 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="In the past week, the 4.0.1-incubating release passed its VOTE on the general@incubator.apache.org list, work continued on 4.1.0, and there were active discussions on using Gerrit, cloud-init, and whether memory usage has increased following the adoption of the Spring framework."><header><h1 class="title_f1Hy" itemprop="headline">Apache CloudStack Weekly News - 11 February 2013</h1><div class="container_mt6G margin-vert--md"><time datetime="2013-02-11T00:00:00.000Z" itemprop="datePublished">February 11, 2013</time></div></header><div id="__blog-post-container" class="markdown" itemprop="articleBody"><p>In the past week, the 4.0.1-incubating release passed its VOTE on the general@incubator.apache.org list, work continued on 4.1.0, and there were active discussions on using Gerrit, cloud-init, and whether memory usage has increased following the adoption of the Spring framework. </p><h3><a name="ApacheCloudstackWeeklyNews-11February2013-MajorDiscussionsandIssues"></a>Major Discussions and Issues</h3><p>Some of the major discussions and issues that have taken place on cloudstack-dev and cloudstack-users in the past week. This is by no means exhaustive, if you need to be up-to-date on <b>all</b> development issues in the project, you&#x27;ll definitely want to be subscribed to the mailing lists!</p><h5><a name="ApacheCloudstackWeeklyNews-11February2013-Gerritproposedasreviewmechanism"></a>Gerrit proposed as review mechanism</h5><p>Alex Huang <a href="http://markmail.org/message/inerurmjtc6v57ba" target="_blank" rel="nofollow" class="external-link">kicked off a discussion</a> about using <a href="http://code.google.com/p/gerrit/" target="_blank" rel="nofollow" class="external-link">Gerrit</a>. David Nalley pointed out that <a href="http://markmail.org/message/kitfyx5cqvyeopwl" target="_blank" rel="nofollow" class="external-link">many of the problems Alex looks to solve with Gerrit are &quot;social/cultural problems&quot;</a> that a technical solution alone won&#x27;t fix. </p><p>Hugo Trippaers also voiced concerns about implementing Gerrit, saying that &quot;a formal process like Gerrit&quot; isn&#x27;t necessary. </p><blockquote><p>The committer status is granted based on the trust we put in a certain individuals to take care of the CloudStack project, for me that included taking the responsibility that any contributions are up to spec. I want to trust my fellow committers that they know what they are doing and i don&#x27;t feel the need to second guess that by wanting to look over their code before they can commit it.</p></blockquote><h5><a name="ApacheCloudstackWeeklyNews-11February2013-Cloudinitvs.homegrownscripts"></a>Cloud-init vs. homegrown scripts</h5><p>David Nalley <a href="http://markmail.org/message/qs7k4akccoh7slk5" target="_blank" rel="nofollow" class="external-link">raised a question from the Ghent Build-a-Cloud-Day</a> about &quot;whether or not to package the SSH key reset and password reset utilities, or whether we should focus our PW/SSH efforts on cloud-init.&quot; </p><p>Wido den Hollander voiced support for cloud-init, saying &quot;We want CloudStack to be accepted by more and more users and they probably want to use cloud-init. cloud-init has cool Puppet and Chef plugins as well which make it very <br>easy to get it all up and running.&quot;</p><p>Chiradeep Vittal says he likes cloud-init, but worried that adopting cloud-init would be &quot;hurting the investment of existing CloudStack users who have built hundreds of templates with the extant scripts.&quot; </p><p>Wido says that &quot;the scripts should keep working&quot; but preferred to avoid packaging the homegrown scripts and encouraging new users/new setups to go with cloud-init.</p><p>Chip <a href="http://markmail.org/message/y5z3c7fnpotyzdmb" target="_blank" rel="nofollow" class="external-link">says that</a> &quot;I&#x27;m in agreement that the existing scripts would need to remain as a supported option for quite some time.  I consider things like that to actually be related to our semver version numbering, although it&#x27;s not specifically our CS query API, it&#x27;s a similar interface expectation.&quot;</p><h5><a name="ApacheCloudstackWeeklyNews-11February2013-ChangestoCPUandmemoryovercommitfeature"></a>Changes to CPU and memory overcommit feature</h5><p>Abhinandan Prateek forwarded a note from Bharat Kumar about changes to the way capacity is calculated in CloudStack. </p><blockquote><p>I have made changes to the way capacity is calculated in CloudStack ,<br>please review and comment.</p><p>I will illustrate this with an example.</p><p>let us say we have a host with<br>Actual Total capacity=4GB ram,</p><p>and the overcommit ratio be 2.</p><p>Current way       <br>Total capacity= 4*2= 8GB.<br>Values after deploying 4 VMs with 1GB in service offering.<br>Allocated per vm =1GB.<br>Used=4GB<br>Available=8-4=4GB</p><p>now if we decrease the overcommit ratio to 1<br>Total Capacity = 4*1=4GB.<br>used Capacity = 4GB.<br>Available = 4-4=0. (implies 100% usage. can also go to more than 100%)</p></blockquote><h5><a name="ApacheCloudstackWeeklyNews-11February2013-JVMMemoryusageincreasedwithlatestmaster"></a>JVM Memory usage increased with latest master</h5><p>The latest master is <a href="http://markmail.org/message/ye35yeey6ooxyegb" target="_blank" rel="nofollow" class="external-link">consuming nearly 900MB of memory</a>, according to Koushik Das. </p><p>There&#x27;s some discussion as to the cause of this, and <a href="https://issues.apache.org/jira/browse/CLOUDSTACK-1169" target="_blank" rel="nofollow" class="external-link">CLOUDSTACK-1168</a> (&quot;Memory usage is very high&quot;) has been created. If you&#x27;re testing master/4.1 and run into this problem, it&#x27;d be helpful to update the ticket with your experience and the environment you&#x27;re seeeing the issue in. </p><h5><a name="ApacheCloudstackWeeklyNews-11February2013-Blockerstorunautomatedtests"></a>Blockers to run automated tests</h5><p>Sudha Ponnaganti <a href="http://markmail.org/message/yn3eb7gqzzfzadqt" target="_blank" rel="nofollow" class="external-link">brought up a couple of issues</a> on February 8th that are blocking automated testing. <a href="https://issues.apache.org/jira/browse/CLOUDSTACK-1216" target="_blank" rel="nofollow" class="external-link">CLOUDSTACK-1216</a> has been fixed, <a href="https://issues.apache.org/jira/browse/CLOUDSTACK-1200" target="_blank" rel="nofollow" class="external-link">CLOUDSTACK-1200</a> (Unknown column &#x27;vm_instance.disk_offering_id&#x27; in table vm_instance, db exception shown in MS log) is still unresolved.</p><h5><a name="ApacheCloudstackWeeklyNews-11February2013-CloudStack4.0.1incubatingpassesVOTE"></a>CloudStack 4.0.1-incubating passes VOTE</h5><p>Joe Brockmeier <a href="http://markmail.org/message/ef4exivtkmhekhxh" target="_blank" rel="nofollow" class="external-link">announced on Friday</a> that the first point release from the CloudStack 4.0 branch has passed its vote on general@incubator.apache.org with +1 votes from Jim Jagielski, Olivier Lamy, and Alex Karasulu. No -1 or +0 votes were cast. </p><p>The release has been pushed to the mirrors and will be announced on Tuesday, February 12. </p><h5><a name="ApacheCloudstackWeeklyNews-11February2013-ACS4.1ReleaseScheduleReminder"></a>ACS 4.1 Release Schedule Reminder</h5><p>Chip Childers sent out a reminder <a href="http://markmail.org/thread/k7xf5jmznsf6gruo" target="_blank" rel="nofollow" class="external-link">about the release schedule for CloudStack 4.1.0</a> on Monday. </p><blockquote><p>2013-02-28 is the end of our test phase, and should be the end of the doc finalization for the release.</p><p>We&#x27;ll shift into a mode where the 4.1 branch should only be updated by me after that date (after you ask for a cherry-pick for a critical bug or translation update).</p></blockquote><p>Chip also noted that there are 15 features/improvements listed as &quot;open&quot; for 4.1, and asked that the reporter/assignee update to &quot;In Progress&quot; or move the target release to 4.2 or Future, as appropriate.</p><h3><a name="ApacheCloudstackWeeklyNews-11February2013-UpcomingEvents"></a>Upcoming Events</h3><p>John Kinsella has <a href="http://markmail.org/thread/frj26yjlgn7gty6x" target="_blank" rel="nofollow" class="external-link">announced the first Bay Area CloudStack Meetup to be held in San Jose</a> on February 20th. </p><ul><li><b>Build a Cloud Day (BACD)</b>: <a href="http://buildacloud.org/about-diy-cloud-computing/cloud-events/viewevent/138-build-a-cloud-day-scale11x.html" target="_blank" rel="nofollow" class="external-link">Full day BACD</a> at SCALE on Friday (22 February 2013).</li><li><b>SCALE 11x</b>: Meet with CloudStack folks at SCALE (23-24 February 2013). The CloudStack project will have a booth at the event, plus a number of talks on the schedule:<ul><li><a href="http://www.socallinuxexpo.org/scale11x/presentations/taking-open-cloud-11-cloudstack" target="_blank" rel="nofollow" class="external-link">Taking the Cloud to 11 with CloudStack</a> - Joe Brockmeier</li></ul></li><li><b>ApacheCon North America</b>: ApacheCon NA is in Portland, Oregon from 26 February to 28 February. Cloud is a hot topic at ApacheCon North America and you&#x27;ll find quite a bit of CloudStack content on the schedule:<ul><li><a href="http://na.apachecon.com/schedule/presentation/126/" target="_blank" rel="nofollow" class="external-link">Apache CloudStack&#x27;s Plugin Model: Balancing the Cathedral with a Bazaar</a> - Donal Lafferty</li><li><a href="http://na.apachecon.com/schedule/presentation/127/" target="_blank" rel="nofollow" class="external-link">Top 10 Network Issues in Apache CloudStack</a> - Kirk Kosinski</li><li><a href="http://na.apachecon.com/schedule/presentation/128/" target="_blank" rel="nofollow" class="external-link">Advanced CloudStack Troubleshooting using Log Analysis</a> - Kirk Kosinski</li><li><a href="http://na.apachecon.com/schedule/presentation/129/" target="_blank" rel="nofollow" class="external-link">Scalable Object Storage with Apache CloudStack and Apache Hadoop</a> - Chiradeep Vittal</li><li><a href="http://na.apachecon.com/schedule/presentation/116/" target="_blank" rel="nofollow" class="external-link">Getting to Know Apache CloudStack</a> - Joe Brockmeier</li><li><a href="http://na.apachecon.com/schedule/presentation/145/" target="_blank" rel="nofollow" class="external-link">DevCloud: A CloudStack Sandbox</a> - Sebastien Goasguen</li><li><a href="http://na.apachecon.com/schedule/presentation/146/" target="_blank" rel="nofollow" class="external-link">Powering CloudStack with Ceph RDB</a> - Patrick McGarry</li><li><a href="http://na.apachecon.com/schedule/presentation/147/" target="_blank" rel="nofollow" class="external-link">Software Defined Networking in Apache CloudStack</a> - Chiradeep Vittal</li></ul></li></ul><h3><a name="ApacheCloudstackWeeklyNews-11February2013-Jira"></a>Jira</h3><p>Status for 4.1 as of Monday, 11 February - by priority:</p><ul><li>5 <a href="http://is.gd/blockers41acs" target="_blank" rel="nofollow" class="external-link">Blocker bugs</a></li><li>13 <a href="http://is.gd/critical41acs" target="_blank" rel="nofollow" class="external-link">Critical bugs</a></li><li>212 <a href="http://is.gd/major41acs" target="_blank" rel="nofollow" class="external-link">Major bugs</a></li><li>35 <a href="http://is.gd/minor41acs" target="_blank" rel="nofollow" class="external-link">Minor bugs</a></li></ul><p>Of the remaining bugs for 4.1.0, 103 are <a href="http://is.gd/unassigned41acs" target="_blank" rel="nofollow" class="external-link">currently unassigned</a>.</p><h3><a name="ApacheCloudstackWeeklyNews-11February2013-NewCommittersandPPMCMembers"></a>New Committers and PPMC Members</h3><p>No new committers or PPMC members were announced this week. </p><h3><a name="ApacheCloudstackWeeklyNews-11February2013-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></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-02-11-apache_cloudstack_weekly_news_11.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_4_0_11"><div class="pagination-nav__sublabel">Newer Post</div><div class="pagination-nav__label">Apache CloudStack 4.0.1-incubating Released</div></a><a class="pagination-nav__link pagination-nav__link--next" href="/blog/apache_cloudstack_weekly_news_4"><div class="pagination-nav__sublabel">Older Post</div><div class="pagination-nav__label">Apache CloudStack Weekly News - 4 February 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.d78c67af.js"></script>
<script src="/assets/js/main.8e0276ef.js"></script>
</body>
</html>