<!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 - 22 April 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_22"><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 - 22 April 2013 | Apache CloudStack"><meta data-rh="true" name="description" content="This time around, we have two release VOTEs in progress, which means that 4.1.0 is just about out the door. The CloudStack Collaboration Conference 2013 has been announced for June 23rd through 25th. You&#x27;ll also want to check in on the discussions about the length of the release cycle, Chip Childers and David Nalley appearing on FLOSS Weekly, and much more."><meta data-rh="true" property="og:description" content="This time around, we have two release VOTEs in progress, which means that 4.1.0 is just about out the door. The CloudStack Collaboration Conference 2013 has been announced for June 23rd through 25th. You&#x27;ll also want to check in on the discussions about the length of the release cycle, Chip Childers and David Nalley appearing on FLOSS Weekly, and much more."><meta data-rh="true" property="og:type" content="article"><meta data-rh="true" property="article:published_time" content="2013-04-23T00: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_22"><link data-rh="true" rel="alternate" href="https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_22" hreflang="en"><link data-rh="true" rel="alternate" href="https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_22" 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.f5d0adb2.js" as="script">
<link rel="preload" href="/assets/js/main.0cf32215.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 time around, we have two release VOTEs in progress, which means that 4.1.0 is just about out the door. The CloudStack Collaboration Conference 2013 has been announced for June 23rd through 25th. You&#x27;ll also want to check in on the discussions about the length of the release cycle, Chip Childers and David Nalley appearing on FLOSS Weekly, and much more."><header><h1 class="title_f1Hy" itemprop="headline">Apache CloudStack Weekly News - 22 April 2013</h1><div class="container_mt6G margin-vert--md"><time datetime="2013-04-23T00:00:00.000Z" itemprop="datePublished">April 23, 2013</time></div></header><div id="__blog-post-container" class="markdown" itemprop="articleBody"><p><a href="/img/imported/ab378739-3c34-48ea-9495-2c49e23e58d6"><img loading="lazy" src="/img/imported/ab378739-3c34-48ea-9495-2c49e23e58d6?t=true" alt="square-cloudmonkey.png" align="left" hspace="5" vspace="5" class="img_ev3q"></a>This time around, we have two release VOTEs in progress, which means that 4.1.0 is just about out the door. The CloudStack Collaboration Conference 2013 <a href="http://markmail.org/message/uqj2nazm6dcpg7h7" target="_blank" rel="nofollow" class="external-link">has been announced for June 23rd through 25th</a>. You&#x27;ll also want to check in on the discussions about the length of the release cycle, Chip Childers and David Nalley appearing on FLOSS Weekly, and much more. </p><p>A lot has happened since the last issue of the CloudStack Weekly News, and not just because the community&#x27;s been busy - we missed getting last week&#x27;s issue out. Sorry about that! If you&#x27;d like to see consistent weekly delivery, check the end of the newsletter to see how you can help.</p><h3><a name="ApacheCloudStackWeeklyNews-22April2013-MajorDiscussions"></a>Major Discussions</h3><p>In this section, we summarize some of the more interesting discussions taking place in the CloudStack community. While we try to pull out the discussions that are &quot;don&#x27;t miss&quot; discussions to anyone who&#x27;s involved in using or contributing to CloudStack, it&#x27;s a really good idea to <a href="http://cloudstack.apache.org/mailing-lists.html" target="_blank" rel="nofollow" class="external-link">make sure you&#x27;re subscribed</a> to the mailing lists and follow along. </p><h5><a name="ApacheCloudStackWeeklyNews-22April2013-ReleaseSchedule"></a>Release Schedule</h5><p>Animesh Chaturvedi <a href="http://markmail.org/message/6suq2fhltdvgvcxd" target="_blank" rel="nofollow" class="external-link">started a discussion last week</a> about the release schedule for 4.2.0, trying to nail down the specific dates for feature freeze, docs freeze, etc. That was <a href="http://markmail.org/message/cp23tewephjuxv7f" target="_blank" rel="nofollow" class="external-link">accompanied by a question of whether we should consider a six-month cycle</a>. Ultimately, no resolution was reached on the schedule. </p><p>Animesh has <a href="http://markmail.org/message/3ctdwor5hfbpa3vx" target="_blank" rel="nofollow" class="external-link">started a new thread to discuss the release cycle</a>.</p><h5><a name="ApacheCloudStackWeeklyNews-22April2013-EasierSimpleInstalls"></a>Easier Simple Installs</h5><p>David has <a href="http://markmail.org/message/zvo3t26zjvedblah" target="_blank" rel="nofollow" class="external-link">started a conversation on dev@ about the ease, or lack thereof, of installing CloudStack</a>. David says, &quot;what I want to do is get rid of sections 2-4 of the quick install guide, and replace it with - &#x27;run this one or two lines worth of commands&#x27; (<a href="http://s.apache.org/runbook" target="_blank" rel="nofollow" class="external-link">http://s.apache.org/runbook</a>).&quot; David describes what he&#x27;d like to see: </p><blockquote><p>The all-in-one installation process I&#x27;d like to see:</p><p>Install your host OS Install an meta-RPM/Deb that either (installs everything, or alternatively configures a repo - or just installs the repo and the stuff I need to install with) Run a command that activates one of these config tools - configures the machine, installs the packages I need, and gets me to the point where I&#x27;m ready to login and go through the beautiful new user gui setup stuff. </p></blockquote><p>No further comments on this so far. </p><h5><a name="ApacheCloudStackWeeklyNews-22April2013-DevelopingaStorageBackupObjectStorePluginFramework"></a>Developing a Storage Backup Object Store Plugin Framework</h5><p>Min Chin <a href="http://markmail.org/message/cspb6xweeupfvpit" target="_blank" rel="nofollow" class="external-link">has proposed a storage backup object store plugin framework</a> that would &quot;allow CloudStack to systematically manage and configure various types of backup data stores from different vendors, like NFS, S3, Swift, etc.&quot; Specifically, Min says:</p><blockquote><p>With this new plugin framework, we would like to achieve following functionalities: </p><p>1. Support different object store providers in a uniform and pluggable fashion. <br>2. Enable region wide object backup using S3-like object store. <br>3. Provide pluggable data motion strategies to handle data transfer from one data store to another data store. <br>4. Provide a scalable cache storage framework while moving data between primary storage and backup storage for certain hypervisor needs.  <br>5. Support flexible combinations of primary storage, secondary storage and hypervisors, such as (NFS, NFS, Xen), (NF3, S3, Vmware), (ISCSI, Swift, KVM), ..., etc.</p></blockquote><p>The FS is <a href="https://cwiki.apache.org/CLOUDSTACK/storage-backup-object-store-plugin-framework.html" target="_blank" rel="nofollow" class="external-link">on the wiki</a>, and Min says in a follow-up that there&#x27;s a plan to &quot;provide a sample plugin implementation&quot; for the work.</p><p>With regards to compatibility concerns, Edison Su <a href="http://markmail.org/message/sstnaimx62mnyles" target="_blank" rel="nofollow" class="external-link">responds</a> that existing APIs &quot;can still be wired to new code&quot; so that they continue to work, but &quot;we can mark them as deprecated in the API document.&quot; Edison also notes that it can co-exist with the existing deployments and upgrades from pre-4.2.0 versions to 4.2.0 if the feature is accepted.</p><h5><a name="ApacheCloudStackWeeklyNews-22April2013-VOTEsfor4.1.0and4.0.2"></a>VOTEs for 4.1.0 and 4.0.2</h5><p>After a couple of false starts, it looks like the third time is the charm for the 4.0.2 release. Joe Brockmeier <a href="http://markmail.org/message/nfe2lyxj4mjsmxdb" target="_blank" rel="nofollow" class="external-link">started the third voting round on Saturday 20 April</a>, and it has quite a few +1 (binding) votes so far. Unless -1&#x27;ed by Tuesday morning, it will be ready for release. </p><p>Chip has also <a href="http://markmail.org/thread/vfcje3fs5ilvm47c" target="_blank" rel="nofollow" class="external-link">started the first vote</a> for 4.1.0, which will be open for 72 hours - assuming no show-stopping defects are found, and it garners at least 3 +1 PMC votes. Note that <b>everyone</b> in the CloudStack community is encouraged to test out the release candidate and cast a vote, regardless of whether the vote is &quot;binding&quot; or not. More testing is always better, and an informed -1 from a non-PMC member isn&#x27;t going to be ignored when deciding whether to release or not. </p><h5><a name="ApacheCloudStackWeeklyNews-22April2013-DomainAdminLimitations"></a>Domain Admin Limitations</h5><p>Pranav Saxena has <a href="http://markmail.org/message/ucxsapyannat2z6b" target="_blank" rel="nofollow" class="external-link">raised a discussion about the limitations for DOMAIN admins</a>, and wonders &quot;why hasn&#x27;t the domain -admin been given the privilege of creating sub-child domains himself? Are there any concerns/threats because of which the current architecture doesn&#x27;t serve this purpose?&quot; Alena Prokharchyk responds that there <a href="http://markmail.org/message/nyzosjot2ov5lb7m" target="_blank" rel="nofollow" class="external-link">may be a feature request matching Pranav&#x27;s concerns</a> and suggests checking its status. This might be a good feature/improvement to see in 4.2.0 if there&#x27;s not already work afoot.</p><h3><a name="ApacheCloudStackWeeklyNews-22April2013-CloudStackPlanetPostsfromtheCloudStackCommunity"></a>CloudStack Planet - Posts from the CloudStack Community</h3><ul><li><b><a href="http://www.chipchilders.com/blog/2013/4/10/floss-weekly-interview-on-apache-cloudstack.html" target="_blank" rel="nofollow" class="external-link">FLOSS Weekly Interview on Apache CloudStack</a></b>: Chip and David appeared on FLOSS Weekly on April 10th. If you missed the live show, be sure to checkout the <a href="http://twit.tv/show/floss-weekly/247" target="_blank" rel="nofollow" class="external-link">video</a>.</li></ul><ul><li><b><a href="http://www.youtube.com/watch?v=vvgIkF1e1QE" target="_blank" rel="nofollow" class="external-link">4.0.2 Testing Procedure</a></b>: Sebastien Goasguen has <a href="http://www.youtube.com/watch?v=vvgIkF1e1QE" target="_blank" rel="nofollow" class="external-link">put together a screencast</a> for testing the 4.0.2 release that also might be worth looking over for folks interested in testing any CloudStack release.</li></ul><ul><li><b><a href="http://buildacloud.org/blog/254-google-summer-of-code-2013-with-cloudstack.html" target="_blank" rel="nofollow" class="external-link">Google Summer of Code with CloudStack</a></b>: Sebastien has also <a href="http://buildacloud.org/blog/254-google-summer-of-code-2013-with-cloudstack.html" target="_blank" rel="nofollow" class="external-link">put together a slide show</a> about contributing to the Google Summer of Code (GSoC) with CloudStack.</li></ul><ul><li><b><a href="http://www.cupfighter.net/index.php/2013/04/knife-cloudstack-plugin-0-0-14-has-been-released-but-what-does-this-mean/" target="_blank" rel="nofollow" class="external-link">Knife CloudStack plugin 0.0.14 has been released</a></b>: Sander Botman writes about the latest release of the CloudStack plugin. David has also <a href="http://buildacloud.org/blog/252-a-new-version-of-the-knife-cloudstack-plugin-appears.html" target="_blank" rel="nofollow" class="external-link">written about the new knife-cloudstack plugin</a>.</li></ul><ul><li><b><a href="http://buildacloud.org/blog/253-to-rest-or-not-to-rest.html" target="_blank" rel="nofollow" class="external-link">To REST or not to REST</a></b>: Sebastien tackles the question, &quot;is the CloudStack API RESTful?&quot; The short answer is &quot;<a href="http://buildacloud.org/blog/253-to-rest-or-not-to-rest.html" target="_blank" rel="nofollow" class="external-link">the CloudStack API is RESTlike but not RESTful</a> since it is only based on the GET method. Being an http based API that can return JSON does not make it a RESTfull API. This should not be seen as negative criticism but just a clarification.&quot; Read the rest for the full scoop.</li></ul><ul><li><b><a href="http://blog.widodh.nl/2013/04/cloudstack-zone-x-is-is-not-ready-to-launch-console-proxy-yet/" target="_blank" rel="nofollow" class="external-link">Zone X is Not Ready to Launch Console Proxy Yet</a></b>: Wido den Hollander writes about an odd error that he troubleshot to find an unlikely culprit.</li></ul><h3><a name="ApacheCloudStackWeeklyNews-22April2013-UpcomingEvents"></a>Upcoming Events</h3><ul><li><b><a href="http://linuxfestnorthwest.org/" target="_blank" rel="nofollow" class="external-link">LinuxFest Northwest</a></b> is being held in Bellingham, Washington from 27 April to 28 April.<ul><li>Mark Hinkle is presenting the <a href="http://linuxfestnorthwest.org/content/hitchikers-guide-open-source-cloud-computing" target="_blank" rel="nofollow" class="external-link">Hitchhiker&#x27;s Guide to Open Source Cloud Computing</a> on Saturday 27 April at 11:00.</li><li>David Nalley is presenting <a href="http://linuxfestnorthwest.org/content/building-iaas-clouds-apache-cloudstack" target="_blank" rel="nofollow" class="external-link">Building IaaS Clouds with Apache CloudStack</a> on Saturday 27 April at 1:30.</li></ul></li><li><b>Storage in Apache CloudStack</b> being held by the <a href="http://www.meetup.com/CloudStack-SF-Bay-Area-Users-Group/events/108916562/" target="_blank" rel="nofollow" class="external-link">CloudStack SF Bay Area Users Group</a> on April 30, 2013 @ Citrix Conference Center, sign up on the Meetup.com Website.</li><li><b><a href="http://buildacloud.org/about-diy-cloud-computing/cloud-events/viewevent/148-build-a-cloud-day-cloudcon-san-francisco-ca.html" target="_blank" rel="nofollow" class="external-link">Build a Cloud Day CloudCon San Francisco</a></b> being held at the South San Francisco Conference Center on 15 May.</li><li><b><a href="http://cloudstackcollab.net/" target="_blank" rel="nofollow" class="external-link">CloudStack Collaboration Conference 2013</a></b> is being held from 23 June to 25 June in Santa Clara, CA at the Santa Clara Convention Center. See the <a href="http://cloudstackcollab.net/CfP/" target="_blank" rel="nofollow" class="external-link">Call for Proposals</a> if you&#x27;re interested in speaking!</li></ul><p>If you want to check in on events related to Apache CloudStack, see the <a href="http://lanyrd.com/topics/apache-cloudstack/" target="_blank" rel="nofollow" class="external-link">Lanyard Page for the Apache CloudStack topic</a>. </p><h3><a name="ApacheCloudStackWeeklyNews-22April2013-Jira"></a>Jira</h3><p>With the 4.0.2 and 4.1.0 VOTES in process, it&#x27;s time to start looking at bugs against <a href="https://issues.apache.org/jira/browse/CLOUDSTACK/fixforversion/12324122" target="_blank" rel="nofollow" class="external-link">4.1.1</a> and <a href="https://issues.apache.org/jira/browse/CLOUDSTACK/fixforversion/12323906" target="_blank" rel="nofollow" class="external-link">4.2.0</a>.</p><p>At the moment, bugs against 4.1.0 haven&#x27;t been re-assigned to 4.1.1. This means that the bug counts for 4.1.1 are much lower than they should be. Taking into account the actual number of bugs, we&#x27;re looking at one blocker bug, two critical bugs, 114 major bugs, and 25 minor.</p><p>For 4.2.0, we have:</p><ul><li>5 <a href="http://is.gd/blocker_acs420" target="_blank" rel="nofollow" class="external-link">blocker bugs for 4.2.0</a>.</li><li>34 <a href="http://is.gd/critical_acs420" target="_blank" rel="nofollow" class="external-link">critical bugs for 4.2.0</a>.</li><li>263 <a href="http://is.gd/major_acs420" target="_blank" rel="nofollow" class="external-link">major bugs for 4.2.0</a>.</li><li>35 <a href="http://is.gd/minor_acs420" target="_blank" rel="nofollow" class="external-link">minor bugs for 4.2.0</a>.</li></ul><h3><a name="ApacheCloudStackWeeklyNews-22April2013-NewCommittersandPMCMembers"></a>New Committers and PMC Members</h3><ul><li>Bruno Demion was invited to become a committer and <a href="http://markmail.org/search/list:org.apache.incubator.cloudstack-dev+New+Committer:+Bruno+Demion+%28a.k.a+milamber%29" target="_blank" rel="nofollow" class="external-link">has accepted</a>.</li></ul><ul><li>Go Chiba was invited to become a committer and <a href="http://markmail.org/message/5yn6fbeim33bm7d3" target="_blank" rel="nofollow" class="external-link">has accepted</a>.</li></ul><ul><li>Prasanna Santhanam was invited to become a PMC member and <a href="http://markmail.org/message/iifnhhkfext3gbve" target="_blank" rel="nofollow" class="external-link">has accepted</a>.</li></ul><p>Please join us in congratulating all of the new committers and PMC members!</p><h3><a name="ApacheCloudStackWeeklyNews-22April2013-ContributingtotheWeeklyNews"></a>Contributing to the Weekly News</h3><p>Want to keep reading the CloudStack Weekly News? Many hands make light work, but having only one editor means getting the weekly news out every week is a &quot;best effort&quot; activity. A healthy community publication needs several contributors to ensure weekly issues go out on time.</p><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.) </p><p>Alternatively, you can send a note to the marketing@cloudstack.apache.org 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-04-23-apache_cloudstack_weekly_news_22.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_2"><div class="pagination-nav__sublabel">Newer Post</div><div class="pagination-nav__label">Apache CloudStack 4.0.2 Released</div></a><a class="pagination-nav__link pagination-nav__link--next" href="/blog/apache_cloudstack_weekly_news_8"><div class="pagination-nav__sublabel">Older Post</div><div class="pagination-nav__label">Apache CloudStack Weekly News - 8 April 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.f5d0adb2.js"></script>
<script src="/assets/js/main.0cf32215.js"></script>
</body>
</html>