<!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 - 24 July 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_24"><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 - 24 July 2013 | Apache CloudStack"><meta data-rh="true" name="description" content="Welcome back to another exciting issue of the Apache CloudStack Weekly News. This week, we take a look at the progress towards 4.2.0, major discussions on the Apache CloudStack mailing lists, and much more."><meta data-rh="true" property="og:description" content="Welcome back to another exciting issue of the Apache CloudStack Weekly News. This week, we take a look at the progress towards 4.2.0, major discussions on the Apache CloudStack mailing lists, and much more."><meta data-rh="true" property="og:type" content="article"><meta data-rh="true" property="article:published_time" content="2013-07-25T00: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_24"><link data-rh="true" rel="alternate" href="https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_24" hreflang="en"><link data-rh="true" rel="alternate" href="https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_24" 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="Welcome back to another exciting issue of the Apache CloudStack Weekly News. This week, we take a look at the progress towards 4.2.0, major discussions on the Apache CloudStack mailing lists, and much more."><header><h1 class="title_f1Hy" itemprop="headline">Apache CloudStack Weekly News - 24 July 2013</h1><div class="container_mt6G margin-vert--md"><time datetime="2013-07-25T00:00:00.000Z" itemprop="datePublished">July 25, 2013</time></div></header><div id="__blog-post-container" class="markdown" itemprop="articleBody"><p>Welcome back to another exciting issue of the <a href="http://cloudstack.apache.org" target="_blank" rel="nofollow" class="external-link">Apache CloudStack</a> Weekly News. This week, we take a look at the progress towards 4.2.0, major discussions on the Apache CloudStack mailing lists, and much more. </p><h3><a name="ApacheCloudStackWeeklyNews-24July2013-MajorDiscussions"></a>Major Discussions</h3><h5><a name="ApacheCloudStackWeeklyNews-24July2013-4.2ReleaseCodingStartingtoWrapup"></a>4.2 Release Coding Starting to Wrap-up</h5><p>With a less than a week left before code freeze for the 4.2 release on 7/29, there is a lot of work still to be done and a lot of bugs that need to be worked out. With this major release many new and existing features need the blocker and critical bugs cleared out as soon as possible. There&#x27;s been great teamwork in the community. <a href="http://markmail.org/message/gurcwi24lhfwut7s" target="_blank" rel="nofollow" class="external-link">Animesh Chaturvedi points out the work that still needs to be done</a>:</p><blockquote><p>...For the days remaining to code freeze, lets prioritize fixing blockers and critical over majors. As from last week in order to clear up our backlog I request you to help out on aggressively fixing the issues. The unassigned issue list is available at <a href="http://s.apache.org/BlH/" target="_blank" rel="nofollow" class="external-link">http://s.apache.org/BlH/</a>. When you fix a bug in 4.2 please make sure it is also fixed in master.</p><p>The outstanding resolved issues now stand at 492 with 250 blockers and critical still to be verified. As with fixing issues now we need to focus on blockers and critical first.</p><p>The detailed bug status is captured below.</p><div class="table-wrap"><table class="confluenceTable"><tbody><tr><th class="confluenceTh">Bugs</th><th class="confluenceTh">This Week </th><th class="confluenceTh"> </th><th class="confluenceTh"> </th><th class="confluenceTh"> </th><th class="confluenceTh">Last Week    </th><th class="confluenceTh"> </th><th class="confluenceTh"> </th><th class="confluenceTh"> </th></tr><tr><td class="confluenceTd"> </td><td class="confluenceTd">   Blocker </td><td class="confluenceTd">  Critical</td><td class="confluenceTd"> Major </td><td class="confluenceTd"> Total </td><td class="confluenceTd">   Blocker </td><td class="confluenceTd"> Critical </td><td class="confluenceTd"> Major </td><td class="confluenceTd"> Total </td></tr><tr><td class="confluenceTd">  Incoming       </td><td class="confluenceTd">        29 </td><td class="confluenceTd">       48 </td><td class="confluenceTd">    64 </td><td class="confluenceTd">   144 </td><td class="confluenceTd">        31 </td><td class="confluenceTd">       40 </td><td class="confluenceTd">    46 </td><td class="confluenceTd">   120 </td></tr><tr><td class="confluenceTd"> Outgoing        </td><td class="confluenceTd">        37 </td><td class="confluenceTd">       68 </td><td class="confluenceTd">    51 </td><td class="confluenceTd">   159 </td><td class="confluenceTd">        33 </td><td class="confluenceTd">       38 </td><td class="confluenceTd">    65 </td><td class="confluenceTd">   140 </td></tr><tr><td class="confluenceTd"> Open Unassigned </td><td class="confluenceTd">         6 </td><td class="confluenceTd">       13 </td><td class="confluenceTd">   149 </td><td class="confluenceTd">   208 </td><td class="confluenceTd">         6 </td><td class="confluenceTd">       46 </td><td class="confluenceTd">   120 </td><td class="confluenceTd">   226 </td></tr><tr><th class="confluenceTh">Open Total      </th><td class="confluenceTd">        24 </td><td class="confluenceTd">       68 </td><td class="confluenceTd">   239 </td><td class="confluenceTd">   392 </td><td class="confluenceTd">        30 </td><td class="confluenceTd">       84 </td><td class="confluenceTd">   213 </td><td class="confluenceTd">   388 </td></tr></tbody></table></div><p>The status for features or improvement is depicted in table below</p><div class="table-wrap"><table class="confluenceTable"><tbody><tr><th class="confluenceTh">New Features / Improvements </th><th class="confluenceTh">Today     </th><th class="confluenceTh">Last Week </th></tr><tr><td class="confluenceTd"> Closed                      </td><td class="confluenceTd">        13 </td><td class="confluenceTd">        12 </td></tr><tr><td class="confluenceTd"> Resolved                    </td><td class="confluenceTd">        60 </td><td class="confluenceTd">        59 </td></tr><tr><td class="confluenceTd"> In Progress                 </td><td class="confluenceTd">         9 </td><td class="confluenceTd">        10 </td></tr><tr><td class="confluenceTd"> Reopened                    </td><td class="confluenceTd">         2 </td><td class="confluenceTd">         2 </td></tr><tr><td class="confluenceTd"> Ready To Review             </td><td class="confluenceTd">         0 </td><td class="confluenceTd">         0 </td></tr><tr><td class="confluenceTd"> Open                        </td><td class="confluenceTd">        18 </td><td class="confluenceTd">        19 </td></tr><tr><th class="confluenceTh">Total                       </th><td class="confluenceTd">       102 </td><td class="confluenceTd">       102 </td></tr></tbody></table></div></blockquote><h5><a name="ApacheCloudStackWeeklyNews-24July2013-4.1.1ReleaseCandidateVoteisNowOpen"></a>4.1.1 Release Candidate Vote is Now Open</h5><p>4.1.1 patch release has been in the works for a while now and has quite a few fixes in it since the release of 4.1.0 on June 5th. The <a href="https://dist.apache.org/repos/dist/dev/cloudstack/4.1.1/" target="_blank" rel="nofollow" class="external-link">release candidate</a> was cut on Monday and the <a href="http://markmail.org/message/36burcs46xcbglji" target="_blank" rel="nofollow" class="external-link">Vote is now open</a> until Saturday. Please provide your testing results and vote.</p><h5><a name="ApacheCloudStackWeeklyNews-24July2013-BylawschangeforCommitterandPMCMemberNomination"></a>Bylaws change for Committer and PMC Member Nomination</h5><p>To make the process of allowing for nomination of Committers and PMC members into the CloudStack community, Chip Childers has started a discussion on changing the bylaws to change the voting process of the PMC Group from a lazy consensus to a majority process. <a href="http://markmail.org/message/a635t4mcty5edbl5" target="_blank" rel="nofollow" class="external-link">Join in the discussion</a>.</p><blockquote><p>As it stands now, we currently use a &quot;Lazy Consensus&quot; model (yes Noah, I know we didn&#x27;t define that term correctly as of now, but I think that&#x27;s a different discussion). We currently have that term defined as:</p><p>Lazy Consensus - Lazy consensus requires 3 binding +1 votes and no binding -1 votes.</p><p>I&#x27;d like to propose that we change the PMC and Committer voting rule to use the Lazy 2/3 Majority approach defined as:</p><p>Lazy 2/3 majority votes requires at least 3 binding votes and twice as many binding +1 votes as binding -1 votes. <br>...</p></blockquote><h5><a name="ApacheCloudStackWeeklyNews-24July2013-PossiblyEndingtheIRCChats"></a>Possibly Ending the IRC Chats</h5><p>After low attendance in weekly IRC chats, Joe Brockmeier has raised the question about the <a href="http://markmail.org/message/n7ex7rdvfguhwylr" target="_blank" rel="nofollow" class="external-link">need for regular IRC chats</a>. IRC chats have been in place for a long time with the community. Make sure to stay involved with the discussion and let your voice be heard.</p><h5><a name="ApacheCloudStackWeeklyNews-24July2013-HowYourCodingMayAffectOthers"></a>How Your Coding May Affect Others</h5><p>Brian Federle noticed when working on the GUI code in Master <a href="http://markmail.org/message/ki42u4n6i7mbjaj4" target="_blank" rel="nofollow" class="external-link">recently that the tab style had changed</a>. This started a large rebase and merge of the UI code of other developers in the community. While the original commit had the best intention and was committed correctly for 4.3, the review and commit were done within a short time frame and didn&#x27;t give the community much time to see it and understand the impact. Make sure to communicate and be aware of what impacts your code might have on others working on the same objects as you. </p><p>Chip Childers pointed out:</p><blockquote><p>...that sweeping changes like this (or architectural changes as well) are best done <b>early</b> in a release cycle. The challenge we&#x27;ve run into here is that while 4.2 work is proceeding, master is open for 4.3 changes (and there is a preference that if something big is going to come in, nows the time to do it).</p></blockquote><h5><a name="ApacheCloudStackWeeklyNews-24July2013-NewComponentsinJIRA"></a>New Components in JIRA</h5><p>To help clarify better on what a bug is all about, and to get it to the right visibility on it, <a href="http://markmail.org/message/tc74y3fqs27tu6uy" target="_blank" rel="nofollow" class="external-link">Prasanna Santhanam and Animesh Chaturvedi</a> have added several new component fields in JIRA to help with bug distinction. The new components:</p><ul><li>Infra - Infrastructure managed by the project - CloudStack - (jenkins, builds, repos, mirrors)</li><li>SystemVM - SystemVM appliances, images, scripts, ssvm, cpvm</li><li>Virtual Router - Anything related to the Virtual Router appliance</li><li>XCP - Xen Cloud Platform</li><li>UCS - Cisco UCS System</li><li>Upgrade - Upgrade scripts, process, database</li></ul><h3><a name="ApacheCloudStackWeeklyNews-24July2013-CloudStackPlanet"></a>CloudStack Planet</h3><h5><a name="ApacheCloudStackWeeklyNews-24July2013-DoYouHaveOneoftheCoolestCloudStackClouds%3F"></a>Do You Have One of the Coolest CloudStack Clouds?</h5><p>Gregg Watkins is doing a video on the Coolest Clouds and is <a href="http://markmail.org/message/7grezc77jioti5di" target="_blank" rel="nofollow" class="external-link">looking for participants</a>. Gregg has already spent most of the summer working with the project putting together videos on CloudStack, the CloudStack Collaboration Conference and is now looking to show case some of the best clouds in the world ran on Apache CloudStack. If you would like to participate please reach out to Gregg on the Dev or User lists.</p><blockquote><p>The last video I plan on making this summer is a short video featuring some<br>of the coolest clouds and I am hoping you all will help me since we are all<br>so spread out.</p><p>Here is what I am needing to make this project a success:   A webcam<br>interview of you (questions below) and screen casts/capture of your cloud<br>in action.</p><p>Because my fellowship ends August 9th I will need this information by no<br>later than the <b>29th of July.</b>  </p><p>While I appreciate how busy all of you are, I am hoping you can carve a few<br>moments out of a day this week and complete the questions and capture some<br>of your cloud.  If you need any assistance in either capturing video<br>interviews or screens please let me know and I can help you.</p><p>This project is a great way to get your project some more visibility and I<br>thank you in advance for any help you can provide.  Please let me know if<br>you have any questions or concerns.<br>...</p></blockquote><h5><a name="ApacheCloudStackWeeklyNews-24July2013-ApacheWhirrandCloudStackforBigDataintheClouds"></a>Apache Whirr and CloudStack for Big Data in the Clouds</h5><p>Sebastien Goasguen has a <a href="http://sebgoa.blogspot.com/2013/07/apache-whirr-and-cloudstack-for-big.html" target="_blank" rel="nofollow" class="external-link">tutorial on his blog about using Apache Whirr with CloudStack</a>. &quot;In this tutorial we introduce Apache Whirr, an application that can be used to define, provision and configure big data solutions on CloudStack based clouds. Whirr automatically starts instances in the cloud and boostrapps hadoop on them. It can also add packages such as Hive, Hbase and Yarn for map-reduce jobs.&quot;</p><h3><a name="ApacheCloudStackWeeklyNews-24July2013-Events"></a>Events</h3><ul><li><b><a href="http://www.oscon.com/oscon2013" target="_blank" rel="nofollow" class="external-link">O&#x27;Reilly&#x27;s Open Source Convention (OSCON)</a></b> is being held July 22-26 at Oregon Convention Center, Portland Oregon. There will be several CloudStack talks.</li><li><b><a href="https://cephdayny.eventbrite.com/" target="_blank" rel="nofollow" class="external-link">Ceph Day NYC</a></b> will feature David Nalley speaking on CloudStack. Come learn out CloudStack and Ceph on August 1.</li><li><b>CloudStack Study Meeting</b> Suzuki-san will be organizing a study meeting in Osaka on August 2.</li><li><b><a href="http://www.ospn.jp/osc2012-kyoto/" target="_blank" rel="nofollow" class="external-link">OSC Kyoto</a></b> The <a href="http://cloudstack.jp/" target="_blank" rel="nofollow" class="external-link">Japanese CloudStack User Group (JCSUG)</a> will be presenting at the Open Source Conference in Kyoto on August 2-3.</li><li><b><a href="http://www.meetup.com/CloudStack-SF-Bay-Area-Users-Group/events/117379992/" target="_blank" rel="nofollow" class="external-link">CloudStack Meetup</a></b> at SAP Labs in Palo Alto, CA on August 7th from 6:00 to 9:00 p.m. Be sure to RSVP on Meetup.com!</li><li><b><a href="http://lanyrd.com/2013/build-a-cloud-day-london/" target="_blank" rel="nofollow" class="external-link">Build a Cloud Day - London</a></b> being hosted by Sebastien Goasguen, being held on September 5.</li><li><b><a href="http://www.cloudplugfest.org/about-cloud-plugfests" target="_blank" rel="nofollow" class="external-link">Cloud Plug Fest</a></b> offers a variety of Tutorials and sessions, including OpenStack and CloudStack, in Madrid, Spain September 16-20.</li><li><b><a href="http://lanyrd.com/2013/build-a-cloud-day-geneva-switzerland/" target="_blank" rel="nofollow" class="external-link">Build a Cloud Day - Switzerland</a></b> has Sebastien Goasguen teaching you and helping you build clouds across Europe on September 26.</li><li><b><a href="http://lanyrd.com/2013/cloudstack-collaboration-conference/" target="_blank" rel="nofollow" class="external-link">CloudStack Collaboration Conference</a></b> planning is well underway for Amsterdam, Netherlands. Put it on your calendar now for November 20-22.</li></ul><h3><a name="ApacheCloudStackWeeklyNews-24July2013-NewCommittersandPMCMembers"></a>New Committers and PMC Members</h3><p>No new committers or PMC members have been announced in the last newsletter period. </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-07-25-apache_cloudstack_weekly_news_24.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_1_1"><div class="pagination-nav__sublabel">Newer Post</div><div class="pagination-nav__label">Apache CloudStack 4.1.1 Released</div></a><a class="pagination-nav__link pagination-nav__link--next" href="/blog/cloudstack_weekly_news_10_july"><div class="pagination-nav__sublabel">Older Post</div><div class="pagination-nav__label">CloudStack Weekly News - 10 July 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>