#Licensed to the Apache Software Foundation (ASF) under one
#or more contributor license agreements.  See the NOTICE file
#distributed with this work for additional information
#regarding copyright ownership.  The ASF licenses this file
#to you under the Apache License, Version 2.0 (the
#"License"); you may not use this file except in compliance
#with the License.  You may obtain a copy of the License at
#http://www.apache.org/licenses/LICENSE-2.0
#Unless required by applicable law or agreed to in writing,
#software distributed under the License is distributed on an
#"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
#KIND, either express or implied.  See the License for the
#specific language governing permissions and limitations
#under the License.
msgid ""
msgstr ""
"Project-Id-Version: 0\n"
"POT-Creation-Date: 2013-04-12T11:19:37\n"
"PO-Revision-Date: 2013-04-12T11:19:37\n"
"Last-Translator: Automatically generated\n"
"Language-Team: None\n"
"MIME-Version: 1.0\n"
"Content-Type: application/x-publican; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

#. Tag: title
#, no-c-format
msgid "Welcome to &PRODUCT; 4.1"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Welcome to the 4.1.0 release of &PRODUCT;, the first major release from the Apache CloudStack project since its graduation from the Apache Incubator."
msgstr ""

#. Tag: para
#, no-c-format
msgid "This document contains information specific to this release of &PRODUCT;, including upgrade instructions from prior releases, new features added to &PRODUCT;, API changes, and issues fixed in the release. For installation instructions, please see the <ulink url=\"http://cloudstack.apache.org/docs/en-US/Apache_CloudStack/4.1.0/html/Installation_Guide/index.html\">Installation Guide</ulink>. For usage and administration instructions, please see the <ulink url=\"http://cloudstack.apache.org/docs/en-US/Apache_CloudStack/4.1.0/html/Admin_Guide/index.html\">&PRODUCT; Administrator's Guide</ulink>. Developers and users who wish to work with the API will find instruction in the <ulink url=\"http://cloudstack.apache.org/docs/en-US/Apache_CloudStack/4.0.1-incubating/html/API_Developers_Guide/index.html\">&PRODUCT; API Developer's Guide</ulink>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "If you find any errors or problems in this guide, please see <xref linkend=\"feedback\" />. We hope you enjoy working with &PRODUCT;!"
msgstr ""

#. Tag: title
#, no-c-format
msgid "Upgrade Instructions"
msgstr ""

#. Tag: para
#, no-c-format
msgid "This section contains upgrade instructions from prior versions of CloudStack to Apache CloudStack 4.1.0. We include instructions on upgrading to Apache CloudStack from pre-Apache versions of Citrix CloudStack (last version prior to Apache is 3.0.2) and from the releases made while CloudStack was in the Apache Incubator."
msgstr ""

#. Tag: para
#, no-c-format
msgid "If you run into any issues during upgrades, please feel free to ask questions on users@apache.cloudstack.org or dev@apache.cloudstack.org."
msgstr ""

#. Tag: title
#, no-c-format
msgid "Upgrade from 4.0.x to 4.1.0"
msgstr ""

#. Tag: para
#, no-c-format
msgid "This section will guide you from Apache CloudStack 4.0.x versions to &PRODUCT; 4.1.0."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Any steps that are hypervisor-specific will be called out with a note."
msgstr ""

#. Tag: title
#, no-c-format
msgid "Package Structure Changes"
msgstr ""

#. Tag: para
#, no-c-format
msgid "The package structure for &PRODUCT; has changed significantly since the 4.0.x releases. If you've compiled your own packages, you'll notice that the package names and the number of packages has changed. This is <emphasis>not</emphasis> a bug."
msgstr ""

#. Tag: para
#, no-c-format
msgid "However, this <emphasis>does</emphasis> mean that the procedure is not as simple as an <command>apt-get upgrade</command> or <command>yum update</command>, so please follow this section carefully."
msgstr ""

#. Tag: para
#, no-c-format
msgid "We recommend reading through this section once or twice before beginning your upgrade procedure, and working through it on a test system before working on a production system."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Most users of &PRODUCT; manage the installation and upgrades of &PRODUCT; with one of Linux's predominant package systems, RPM or APT. This guide assumes you'll be using RPM and Yum (for Red Hat Enterprise Linux or CentOS), or APT and Debian packages (for Ubuntu)."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Create RPM or Debian packages (as appropriate) and a repository from the 4.1.0 source, or check the Apache CloudStack downloads page at <ulink url=\"http://cloudstack.apache.org/downloads.html\">http://cloudstack.apache.org/downloads.html</ulink> for package repositories supplied by community members. You will need them for step <xref linkend=\"upgrade-deb-packages\" /> or step <xref linkend=\"upgrade-rpm-packages\" />."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Instructions for creating packages from the &PRODUCT; source are in the <ulink url=\"http://cloudstack.apache.org/docs/en-US/index.html\">Installation Guide</ulink>."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Stop your management server or servers. Run this on all management server hosts:"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "<prompt>#</prompt> service cloud-management stop"
msgstr ""

#. Tag: para
#, no-c-format
msgid "If you are running a usage server or usage servers, stop those as well:"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "<prompt>#</prompt> service cloud-usage stop"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Make a backup of your MySQL database. If you run into any issues or need to roll back the upgrade, this will assist in debugging or restoring your existing environment. You'll be prompted for your password."
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "<prompt>#</prompt> mysqldump -u root -p cloud &gt; cloudstack-backup.sql"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Whether you're upgrading a Red Hat/CentOS based system or Ubuntu based system, you're going to need to stop the CloudStack management server before proceeding."
msgstr ""

#. Tag: para
#, no-c-format
msgid "If you have made changes to <filename>/etc/cloud/management/components.xml</filename>, you'll need to carry these over manually to the new file, <filename>/etc/cloudstack/management/componentContext.xml</filename>. This is not done automatically. (If you're unsure, we recommend making a backup of the original <filename>components.xml</filename> to be on the safe side."
msgstr ""

#. Tag: para
#, no-c-format
msgid "If you are using Ubuntu, follow this procedure to upgrade your packages. If not, skip to step <xref linkend=\"upgrade-rpm-packages\" />."
msgstr ""

#. Tag: title
#, no-c-format
msgid "Community Packages"
msgstr ""

#. Tag: para
#, no-c-format
msgid "This section assumes you're using the community supplied packages for &PRODUCT;. If you've created your own packages and APT repository, substitute your own URL for the ones used in these examples."
msgstr ""

#. Tag: para
#, no-c-format
msgid "The first order of business will be to change the sources list for each system with &PRODUCT; packages. This means all management servers, and any hosts that have the KVM agent. (No changes should be necessary for hosts that are running VMware or Xen.)"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Start by opening <filename>/etc/apt/sources.list.d/cloudstack.list</filename> on any systems that have &PRODUCT; packages installed."
msgstr ""

#. Tag: para
#, no-c-format
msgid "This file should have one line, which contains:"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "deb http://cloudstack.apt-get.eu/ubuntu precise 4.0"
msgstr ""

#. Tag: para
#, no-c-format
msgid "We'll change it to point to the new package repository:"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "deb http://cloudstack.apt-get.eu/ubuntu precise 4.1"
msgstr ""

#. Tag: para
#, no-c-format
msgid "If you're using your own package repository, change this line to read as appropriate for your 4.1.0 repository."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Now update your apt package list:"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "$ sudo apt-get update"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Now that you have the repository configured, it's time to install the <filename>cloudstack-management</filename> package. This will pull in any other dependencies you need."
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "$ sudo apt-get install cloudstack-management"
msgstr ""

#. Tag: para
#, no-c-format
msgid "You will need to manually install the <filename>cloudstack-agent</filename> package:"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "$ sudo apt-get install cloudstack-agent"
msgstr ""

#. Tag: para
#, no-c-format
msgid "During the installation of <filename>cloudstack-agent</filename>, APT will copy your <filename>agent.properties</filename>, <filename>log4j-cloud.xml</filename>, and <filename>environment.properties</filename> from <filename>/etc/cloud/agent</filename> to <filename>/etc/cloudstack/agent</filename>."
msgstr ""

#. Tag: para
#, no-c-format
msgid "When prompted whether you wish to keep your configuration, say Yes."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Verify that the file <filename>/etc/cloudstack/agent/environment.properties</filename> has a line that reads:"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "paths.script=/usr/share/cloudstack-common"
msgstr ""

#. Tag: para
#, no-c-format
msgid "If not, add the line."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Restart the agent:"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "\n"
"service cloud-agent stop\n"
"killall jsvc\n"
"service cloudstack-agent start\n"
"                            "
msgstr ""

#. Tag: para
#, no-c-format
msgid "During the upgrade, <filename>log4j-cloud.xml</filename> was simply copied over, so the logs will continue to be added to <filename>/var/log/cloud/agent/agent.log</filename>. There's nothing <emphasis>wrong</emphasis> with this, but if you prefer to be consistent, you can change this by copying over the sample configuration file:"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "\n"
"cd /etc/cloudstack/agent\n"
"mv log4j-cloud.xml.dpkg-dist log4j-cloud.xml\n"
"service cloudstack-agent restart\n"
"                            "
msgstr ""

#. Tag: para
#, no-c-format
msgid "Once the agent is running, you can uninstall the old cloud-* packages from your system:"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "sudo dpkg --purge cloud-agent"
msgstr ""

#. Tag: para
#, no-c-format
msgid "The package names have changed between 4.0 and 4.1, so upgrading the packages won't happen automatically with a <command>yum update</command>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Once you've upgraded the packages on your management servers, you'll need to restart the system VMs. Make sure port 8096 is open to do this."
msgstr ""

#. Tag: para
#, no-c-format
msgid "There is a script that will do this for you, all you need to do is run the script and supply the IP address for your MySQL instance and your MySQL credentials:"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "<prompt>#</prompt> nohup cloudstack-sysvmadm -d <replaceable>IP address</replaceable> -u cloud -p -a &gt; sysvm.log 2&gt;&amp;1 &amp;"
msgstr ""

#. Tag: para
#, no-c-format
msgid "You can monitor the log for progress. The process of restarting the system VMs can take an hour or more."
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "<prompt>#</prompt> tail -f sysvm.log"
msgstr ""

#. Tag: para
#, no-c-format
msgid "The output to <filename>sysvm.log</filename> will look something like this:"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "\n"
"Stopping and starting 1 secondary storage vm(s)...\n"
"Done stopping and starting secondary storage vm(s)\n"
"Stopping and starting 1 console proxy vm(s)...\n"
"Done stopping and starting console proxy vm(s).\n"
"Stopping and starting 4 running routing vm(s)...\n"
"Done restarting router(s).\n"
"                    "
msgstr ""

#. Tag: title
#, no-c-format
msgid "For Xen Hosts: Copy vhd-utils"
msgstr ""

#. Tag: para
#, no-c-format
msgid "This step is only for CloudStack installs that are using Xen hosts."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Copy the file <filename>vhd-utils</filename> to <filename>/usr/share/cloudstack-common/scripts/vm/hypervisor/xenserver</filename>."
msgstr ""

#. Tag: title
#, no-c-format
msgid "Upgrade from 3.0.2 to 4.1.0"
msgstr ""

#. Tag: para
#, no-c-format
msgid "This section will guide you from Citrix CloudStack 3.0.2 to Apache CloudStack 4.1.0. Sections that are hypervisor-specific will be called out with a note."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Ensure that you query your IP address usage records and process them or make a backup. During the upgrade you will lose the old IP address usage records."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Starting in 3.0.2, the usage record format for IP addresses is the same as the rest of the usage types. Instead of a single record with the assignment and release dates, separate records are generated per aggregation period with start and end dates. After upgrading, any existing IP address usage records in the old format will no longer be available."
msgstr ""

#. Tag: para
#, no-c-format
msgid "The following upgrade instructions apply only if you're using VMware hosts. If you're not using VMware hosts, skip this step and move on to <xref linkend=\"stopping-usage-servers\" />."
msgstr ""

#. Tag: para
#, no-c-format
msgid "In each zone that includes VMware hosts, you need to add a new system VM template."
msgstr ""

#. Tag: para
#, no-c-format
msgid "While running the existing 3.0.2 system, log in to the UI as root administrator."
msgstr ""

#. Tag: para
#, no-c-format
msgid "In the left navigation bar, click Templates."
msgstr ""

#. Tag: para
#, no-c-format
msgid "In Select view, click Templates."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Click Register template."
msgstr ""

#. Tag: para
#, no-c-format
msgid "The Register template dialog box is displayed."
msgstr ""

#. Tag: para
#, no-c-format
msgid "In the Register template dialog box, specify the following values (do not change these):"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Field"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Value"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Name"
msgstr ""

#. Tag: para
#, no-c-format
msgid "systemvm-vmware-4.0"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Description"
msgstr ""

#. Tag: para
#, no-c-format
msgid "URL"
msgstr ""

#. Tag: para
#, no-c-format
msgid "http://download.cloud.com/templates/burbank/burbank-systemvm-08012012.ova"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Zone"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Choose the zone where this hypervisor is used"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Hypervisor"
msgstr ""

#. Tag: para
#, no-c-format
msgid "VMware"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Format"
msgstr ""

#. Tag: para
#, no-c-format
msgid "OVA"
msgstr ""

#. Tag: para
#, no-c-format
msgid "OS Type"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Debian GNU/Linux 5.0 (32-bit)"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Extractable"
msgstr ""

#. Tag: para
#, no-c-format
msgid "no"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Password Enabled"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Public"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Featured"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Watch the screen to be sure that the template downloads successfully and enters the READY state. Do not proceed until this is successful."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Stop all Usage Servers if running. Run this on all Usage Server hosts."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Stop the Management Servers. Run this on all Management Server hosts."
msgstr ""

#. Tag: para
#, no-c-format
msgid "On the MySQL master, take a backup of the MySQL databases. We recommend performing this step even in test upgrades. If there is an issue, this will assist with debugging."
msgstr ""

#. Tag: para
#, no-c-format
msgid "In the following commands, it is assumed that you have set the root password on the database, which is a CloudStack recommended best practice. Substitute your own MySQL root password."
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "<prompt>#</prompt> <command>mysqldump</command> -u root -p<replaceable>mysql_password</replaceable> cloud &gt; <filename>cloud-backup.dmp</filename>\n"
"                        <prompt>#</prompt> <command>mysqldump</command> -u root -p<replaceable>mysql_password</replaceable> cloud_usage &gt; <filename>cloud-usage-backup.dmp</filename>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Either build RPM/DEB packages as detailed in the Installation Guide, or use one of the community provided yum/apt repositories to gain access to the &PRODUCT; binaries."
msgstr ""

#. Tag: para
#, no-c-format
msgid "After you have configured an appropriate yum or apt repository, you may execute the one of the following commands as appropriate for your environment in order to upgrade &PRODUCT;:"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "<prompt>#</prompt> <command>yum</command> update cloud-*"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "<prompt>#</prompt> <command>apt-get</command> update\n"
"                            <prompt>#</prompt> <command>apt-get</command> upgrade cloud-*"
msgstr ""

#. Tag: para
#, no-c-format
msgid "You will, of course, have to agree to the changes suggested by Yum or APT."
msgstr ""

#. Tag: para
#, no-c-format
msgid "If the upgrade output includes a message similar to the following, then some custom content was found in your old components.xml, and you need to merge the two files:"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "warning: /etc/cloud/management/components.xml created as /etc/cloud/management/components.xml.rpmnew "
msgstr ""

#. Tag: para
#, no-c-format
msgid "Instructions follow in the next step."
msgstr ""

#. Tag: para
#, no-c-format
msgid "If you have made changes to your copy of <filename>/etc/cloud/management/components.xml</filename> the changes will be preserved in the upgrade. However, you need to do the following steps to place these changes in a new version of the file which is compatible with version 4.1.0."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Make a backup copy of <filename>/etc/cloud/management/components.xml</filename>. For example:"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "# mv /etc/cloud/management/components.xml /etc/cloud/management/components.xml-backup"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Copy <filename>/etc/cloud/management/components.xml.rpmnew</filename> to create a new <filename>/etc/cloud/management/components.xml</filename>:"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "# cp -ap /etc/cloud/management/components.xml.rpmnew /etc/cloud/management/components.xml"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Merge your changes from the backup file into the new <filename>components.xml</filename>."
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "# vi /etc/cloud/management/components.xml"
msgstr ""

#. Tag: para
#, no-c-format
msgid "If you have more than one management server node, repeat the upgrade steps on each node."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Start the first Management Server. Do not start any other Management Server nodes yet."
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "<prompt>#</prompt> service cloud-management start"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Wait until the databases are upgraded. Ensure that the database upgrade is complete. After confirmation, start the other Management Servers one at a time by running the same command on each node."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Failing to restart the Management Server indicates a problem in the upgrade. Having the Management Server restarted without any issues indicates that the upgrade is successfully completed."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Start all Usage Servers (if they were running on your previous version). Perform this on each Usage Server host."
msgstr ""

#. Tag: para
#, no-c-format
msgid "<command># service cloud-usage start</command>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Additional steps are required for each KVM host. These steps will not affect running guests in the cloud. These steps are required only for clouds using KVM as hosts and only on the KVM hosts."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Configure a yum or apt respository containing the &PRODUCT; packages as outlined in the Installation Guide."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Stop the running agent."
msgstr ""

#. Tag: para
#, no-c-format
msgid "<command># service cloud-agent stop</command>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Update the agent software with one of the following command sets as appropriate for your environment."
msgstr ""

#. Tag: para
#, no-c-format
msgid "<command># yum update cloud-*</command>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<command># apt-get update</command>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<command># apt-get upgrade cloud-*</command>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Start the agent."
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "# service cloud-agent start"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Edit <filename>/etc/cloud/agent/agent.properties</filename> to change the resource parameter from \"com.cloud.agent.resource.computing.LibvirtComputingResource\" to \"com.cloud.hypervisor.kvm.resource.LibvirtComputingResource\"."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Start the cloud agent and cloud management services."
msgstr ""

#. Tag: para
#, no-c-format
msgid "When the Management Server is up and running, log in to the CloudStack UI and restart the virtual router for proper functioning of all the features."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Log in to the CloudStack UI as administrator, and check the status of the hosts. All hosts should come to Up state (except those that you know to be offline). You may need to wait 20 or 30 minutes, depending on the number of hosts."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Troubleshooting: If login fails, clear your browser cache and reload the page."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Do not proceed to the next step until the hosts show in Up state."
msgstr ""

#. Tag: para
#, no-c-format
msgid "If you are upgrading from 3.0.2, perform the following:"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Ensure that the admin port is set to 8096 by using the \"integration.api.port\" global parameter."
msgstr ""

#. Tag: para
#, no-c-format
msgid "This port is used by the cloud-sysvmadm script at the end of the upgrade procedure. For information about how to set this parameter, see \"Setting Global Configuration Parameters\" in the Installation Guide."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Restart the Management Server."
msgstr ""

#. Tag: para
#, no-c-format
msgid "If you don't want the admin port to remain open, you can set it to null after the upgrade is done and restart the management server."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Run the <command>cloud-sysvmadm</command> script to stop, then start, all Secondary Storage VMs, Console Proxy VMs, and virtual routers. Run the script once on each management server. Substitute your own IP address of the MySQL instance, the MySQL user to connect as, and the password to use for that user. In addition to those parameters, provide the <command>-c</command> and <command>-r</command> arguments. For example:"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<command># nohup cloud-sysvmadm -d 192.168.1.5 -u cloud -p password -c -r &gt; sysvm.log 2&gt;&amp;1 &amp;</command>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<command># tail -f sysvm.log</command>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "This might take up to an hour or more to run, depending on the number of accounts in the system."
msgstr ""

#. Tag: para
#, no-c-format
msgid "If needed, upgrade all Citrix XenServer hypervisor hosts in your cloud to a version supported by CloudStack 4.1.0. The supported versions are XenServer 5.6 SP2 and 6.0.2. Instructions for upgrade can be found in the CloudStack 4.1.0 Installation Guide under \"Upgrading XenServer Versions.\""
msgstr ""

#. Tag: para
#, no-c-format
msgid "Now apply the XenServer hotfix XS602E003 (and any other needed hotfixes) to XenServer v6.0.2 hypervisor hosts."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Disconnect the XenServer cluster from CloudStack."
msgstr ""

#. Tag: para
#, no-c-format
msgid "In the left navigation bar of the CloudStack UI, select Infrastructure. Under Clusters, click View All. Select the XenServer cluster and click Actions - Unmanage."
msgstr ""

#. Tag: para
#, no-c-format
msgid "This may fail if there are hosts not in one of the states Up, Down, Disconnected, or Alert. You may need to fix that before unmanaging this cluster."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Wait until the status of the cluster has reached Unmanaged. Use the CloudStack UI to check on the status. When the cluster is in the unmanaged state, there is no connection to the hosts in the cluster."
msgstr ""

#. Tag: para
#, no-c-format
msgid "To clean up the VLAN, log in to one XenServer host and run:"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<command>/opt/xensource/bin/cloud-clean-vlan.sh</command>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Now prepare the upgrade by running the following on one XenServer host:"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<command>/opt/xensource/bin/cloud-prepare-upgrade.sh</command>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "If you see a message like \"can't eject CD\", log in to the VM and unmount the CD, then run this script again."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Upload the hotfix to the XenServer hosts. Always start with the Xen pool master, then the slaves. Using your favorite file copy utility (e.g. WinSCP), copy the hotfixes to the host. Place them in a temporary folder such as /tmp."
msgstr ""

#. Tag: para
#, no-c-format
msgid "On the Xen pool master, upload the hotfix with this command:"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<command>xe patch-upload file-name=XS602E003.xsupdate</command>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Make a note of the output from this command, which is a UUID for the hotfix file. You'll need it in another step later."
msgstr ""

#. Tag: para
#, no-c-format
msgid "(Optional) If you are applying other hotfixes as well, you can repeat the commands in this section with the appropriate hotfix number. For example, XS602E004.xsupdate."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Manually live migrate all VMs on this host to another host. First, get a list of the VMs on this host:"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<command># xe vm-list</command>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Then use this command to migrate each VM. Replace the example host name and VM name with your own:"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<command># xe vm-migrate live=true host=<replaceable>host-name</replaceable> vm=<replaceable>VM-name</replaceable></command>"
msgstr ""

#. Tag: title
#, no-c-format
msgid "Troubleshooting"
msgstr ""

#. Tag: para
#, no-c-format
msgid "If you see a message like \"You attempted an operation on a VM which requires PV drivers to be installed but the drivers were not detected,\" run:"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<command>/opt/xensource/bin/make_migratable.sh b6cf79c8-02ee-050b-922f-49583d9f1a14</command>."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Apply the hotfix. First, get the UUID of this host:"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "# xe host-list"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Then use the following command to apply the hotfix. Replace the example host UUID with the current host ID, and replace the hotfix UUID with the output from the patch-upload command you ran on this machine earlier. You can also get the hotfix UUID by running xe patch-list."
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "<command>xe</command> patch-apply host-uuid=<replaceable>host-uuid</replaceable> uuid=<replaceable>hotfix-uuid</replaceable>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Copy the following files from the CloudStack Management Server to the host."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Copy from here..."
msgstr ""

#. Tag: para
#, no-c-format
msgid "...to here"
msgstr ""

#. Tag: para
#, no-c-format
msgid "/usr/lib64/cloud/common/scripts/vm/hypervisor/xenserver/xenserver60/NFSSR.py"
msgstr ""

#. Tag: para
#, no-c-format
msgid "/opt/xensource/sm/NFSSR.py"
msgstr ""

#. Tag: para
#, no-c-format
msgid "/usr/lib64/cloud/common/scripts/vm/hypervisor/xenserver/setupxenserver.sh"
msgstr ""

#. Tag: para
#, no-c-format
msgid "/opt/xensource/bin/setupxenserver.sh"
msgstr ""

#. Tag: para
#, no-c-format
msgid "/usr/lib64/cloud/common/scripts/vm/hypervisor/xenserver/make_migratable.sh"
msgstr ""

#. Tag: para
#, no-c-format
msgid "/opt/xensource/bin/make_migratable.sh"
msgstr ""

#. Tag: para
#, no-c-format
msgid "(Only for hotfixes XS602E005 and XS602E007) You need to apply a new Cloud Support Pack."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Download the CSP software onto the XenServer host from one of the following links:"
msgstr ""

#. Tag: para
#, no-c-format
msgid "For hotfix XS602E005: <ulink url=\"http://coltrane.eng.hq.xensource.com/release/XenServer-6.x/XS-6.0.2/hotfixes/XS602E005/56710/xe-phase-2/xenserver-cloud-supp.tgz\">http://coltrane.eng.hq.xensource.com/release/XenServer-6.x/XS-6.0.2/hotfixes/XS602E005/56710/xe-phase-2/xenserver-cloud-supp.tgz</ulink>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "For hotfix XS602E007: <ulink url=\"http://coltrane.eng.hq.xensource.com/release/XenServer-6.x/XS-6.0.2/hotfixes/XS602E007/57824/xe-phase-2/xenserver-cloud-supp.tgz\">http://coltrane.eng.hq.xensource.com/release/XenServer-6.x/XS-6.0.2/hotfixes/XS602E007/57824/xe-phase-2/xenserver-cloud-supp.tgz</ulink>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Extract the file:"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "# tar xf xenserver-cloud-supp.tgz"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Run the following script:"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "# xe-install-supplemental-pack xenserver-cloud-supp.iso"
msgstr ""

#. Tag: para
#, no-c-format
msgid "If the XenServer host is part of a zone that uses basic networking, disable Open vSwitch (OVS):"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "# xe-switch-network-backend  bridge"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Reboot this XenServer host."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Run the following:"
msgstr ""

#. Tag: para
#, no-c-format
msgid "If the message \"mv: cannot stat `/etc/cron.daily/logrotate': No such file or directory\" appears, you can safely ignore it."
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "for pbd in `xe pbd-list currently-attached=false| grep ^uuid | awk '{print $NF}'`; do xe pbd-plug uuid=$pbd ; "
msgstr ""

#. Tag: para
#, no-c-format
msgid "On each slave host in the Xen pool, repeat these steps, starting from \"manually live migrate VMs.\""
msgstr ""

#. Tag: title
#, no-c-format
msgid "Troubleshooting Tip"
msgstr ""

#. Tag: para
#, no-c-format
msgid "If passwords which you know to be valid appear not to work after upgrade, or other UI issues are seen, try clearing your browser cache and reloading the UI page."
msgstr ""

#. Tag: title
#, no-c-format
msgid "Upgrade from 2.2.14 to 4.1.0"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Ensure that you query your IPaddress usage records and process them; for example, issue invoices for any usage that you have not yet billed users for."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Starting in 3.0.2, the usage record format for IP addresses is the same as the rest of the usage types. Instead of a single record with the assignment and release dates, separate records are generated per aggregation period with start and end dates. After upgrading to 4.1.0, any existing IP address usage records in the old format will no longer be available."
msgstr ""

#. Tag: para
#, no-c-format
msgid "If you are using version 2.2.0 - 2.2.13, first upgrade to 2.2.14 by using the instructions in the <ulink url=\"http://download.cloud.com/releases/2.2.0/CloudStack2.2.14ReleaseNotes.pdf\">2.2.14 Release Notes</ulink>."
msgstr ""

#. Tag: title
#, no-c-format
msgid "KVM Hosts"
msgstr ""

#. Tag: para
#, no-c-format
msgid "If KVM hypervisor is used in your cloud, be sure you completed the step to insert a valid username and password into the host_details table on each KVM node as described in the 2.2.14 Release Notes. This step is critical, as the database will be encrypted after the upgrade to 4.1.0."
msgstr ""

#. Tag: para
#, no-c-format
msgid "While running the 2.2.14 system, log in to the UI as root administrator."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Using the UI, add a new System VM template for each hypervisor type that is used in your cloud. In each zone, add a system VM template for each hypervisor used in that zone"
msgstr ""

#. Tag: para
#, no-c-format
msgid "In the Register template dialog box, specify the following values depending on the hypervisor type (do not change these):"
msgstr ""

#. Tag: para
#, no-c-format
msgid "XenServer"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Name: systemvm-xenserver-4.1.0"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Description: systemvm-xenserver-4.1.0"
msgstr ""

#. Tag: para
#, no-c-format
msgid "URL: http://download.cloud.com/templates/acton/acton-systemvm-02062012.vhd.bz2"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Zone: Choose the zone where this hypervisor is used"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Hypervisor: XenServer"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Format: VHD"
msgstr ""

#. Tag: para
#, no-c-format
msgid "OS Type: Debian GNU/Linux 5.0 (32-bit)"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Extractable: no"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Password Enabled: no"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Public: no"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Featured: no"
msgstr ""

#. Tag: para
#, no-c-format
msgid "KVM"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Name: systemvm-kvm-4.1.0"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Description: systemvm-kvm-4.1.0"
msgstr ""

#. Tag: para
#, no-c-format
msgid "URL: http://download.cloud.com/templates/acton/acton-systemvm-02062012.qcow2.bz2"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Hypervisor: KVM"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Format: QCOW2"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Name: systemvm-vmware-4.1.0"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Description: systemvm-vmware-4.1.0"
msgstr ""

#. Tag: para
#, no-c-format
msgid "URL: http://download.cloud.com/templates/burbank/burbank-systemvm-08012012.ova"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Hypervisor: VMware"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Format: OVA"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Watch the screen to be sure that the template downloads successfully and enters the READY state. Do not proceed until this is successful"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<emphasis role=\"bold\">WARNING</emphasis>: If you use more than one type of hypervisor in your cloud, be sure you have repeated these steps to download the system VM template for each hypervisor type. Otherwise, the upgrade will fail."
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "# service cloud-usage stop"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "<prompt>#</prompt> <command>mysqldump</command> -u root -p<replaceable>mysql_password</replaceable> cloud &gt; <filename>cloud-backup.dmp</filename>\n"
"                        <prompt>#</prompt> <command>mysqldump</command> -u root -p<replaceable>mysql_password</replaceable> cloud_usage &gt; <filename>cloud-usage-backup.dmp</filename>\n"
"                    "
msgstr ""

#. Tag: para
#, no-c-format
msgid "If you have made changes to your existing copy of the file components.xml in your previous-version CloudStack installation, the changes will be preserved in the upgrade. However, you need to do the following steps to place these changes in a new version of the file which is compatible with version 4.0.0-incubating."
msgstr ""

#. Tag: para
#, no-c-format
msgid "How will you know whether you need to do this? If the upgrade output in the previous step included a message like the following, then some custom content was found in your old components.xml, and you need to merge the two files:"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Make a backup copy of your <filename>/etc/cloud/management/components.xml</filename> file. For example:"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "<prompt>#</prompt> <command>mv</command> <filename>/etc/cloud/management/components.xml</filename> <filename>/etc/cloud/management/components.xml-backup</filename>"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "<prompt>#</prompt> <command>cp</command> -ap <filename>/etc/cloud/management/components.xml.rpmnew</filename> <filename>/etc/cloud/management/components.xml</filename>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Merge your changes from the backup file into the new components.xml file."
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "<prompt>#</prompt> <command>vi</command> <filename>/etc/cloud/management/components.xml</filename>\n"
"                            "
msgstr ""

#. Tag: para
#, no-c-format
msgid "If you have made changes to your existing copy of the <filename>/etc/cloud/management/db.properties</filename> file in your previous-version CloudStack installation, the changes will be preserved in the upgrade. However, you need to do the following steps to place these changes in a new version of the file which is compatible with version 4.0.0-incubating."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Make a backup copy of your file <filename>/etc/cloud/management/db.properties</filename>. For example:"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "<prompt>#</prompt> <command>mv</command> <filename>/etc/cloud/management/db.properties</filename> <filename>/etc/cloud/management/db.properties-backup</filename>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Copy <filename>/etc/cloud/management/db.properties.rpmnew</filename> to create a new <filename>/etc/cloud/management/db.properties</filename>:"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "<prompt>#</prompt> <command>cp</command> -ap <filename>/etc/cloud/management/db.properties.rpmnew</filename> <filename>etc/cloud/management/db.properties</filename>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Merge your changes from the backup file into the new db.properties file."
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "<prompt>#</prompt> <command>vi</command> <filename>/etc/cloud/management/db.properties</filename>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "On the management server node, run the following command. It is recommended that you use the command-line flags to provide your own encryption keys. See Password and Key Encryption in the Installation Guide."
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "<prompt>#</prompt> <command>cloud-setup-encryption</command> -e <replaceable>encryption_type</replaceable> -m <replaceable>management_server_key</replaceable> -k <replaceable>database_key</replaceable>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "When used without arguments, as in the following example, the default encryption type and keys will be used:"
msgstr ""

#. Tag: para
#, no-c-format
msgid "(Optional) For encryption_type, use file or web to indicate the technique used to pass in the database encryption password. Default: file."
msgstr ""

#. Tag: para
#, no-c-format
msgid "(Optional) For management_server_key, substitute the default key that is used to encrypt confidential parameters in the properties file. Default: password. It is highly recommended that you replace this with a more secure value"
msgstr ""

#. Tag: para
#, no-c-format
msgid "(Optional) For database_key, substitute the default key that is used to encrypt confidential parameters in the CloudStack database. Default: password. It is highly recommended that you replace this with a more secure value."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Repeat steps 10 - 14 on every management server node. If you provided your own encryption key in step 14, use the same key on all other management servers."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Wait until the databases are upgraded. Ensure that the database upgrade is complete. You should see a message like \"Complete! Done.\" After confirmation, start the other Management Servers one at a time by running the same command on each node."
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "<prompt>#</prompt> service cloud-usage start"
msgstr ""

#. Tag: para
#, no-c-format
msgid "(KVM only) Additional steps are required for each KVM host. These steps will not affect running guests in the cloud. These steps are required only for clouds using KVM as hosts and only on the KVM hosts."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Configure your CloudStack package repositories as outlined in the Installation Guide"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "# service cloud-agent stop"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Update the agent software with one of the following command sets as appropriate."
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "\n"
"                                <prompt>#</prompt> <command>apt-get</command> update\n"
"                                <prompt>#</prompt> <command>apt-get</command> upgrade cloud-*\n"
"                            "
msgstr ""

#. Tag: para
#, no-c-format
msgid "Copy the contents of the <filename>agent.properties</filename> file to the new <filename>agent.properties</filename> file by using the following command"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "<command>sed</command> -i 's/com.cloud.agent.resource.computing.LibvirtComputingResource/com.cloud.hypervisor.kvm.resource.LibvirtComputingResource/g' <filename>/etc/cloud/agent/agent.properties</filename>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Log in to the CloudStack UI as admin, and check the status of the hosts. All hosts should come to Up state (except those that you know to be offline). You may need to wait 20 or 30 minutes, depending on the number of hosts."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Do not proceed to the next step until the hosts show in the Up state. If the hosts do not come to the Up state, contact support."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Run the following script to stop, then start, all Secondary Storage VMs, Console Proxy VMs, and virtual routers."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Run the command once on one management server. Substitute your own IP address of the MySQL instance, the MySQL user to connect as, and the password to use for that user. In addition to those parameters, provide the \"-c\" and \"-r\" arguments. For example:"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "<prompt>#</prompt> <command>nohup cloud-sysvmadm</command> -d <replaceable>192.168.1.5</replaceable> -u cloud -p <replaceable>password</replaceable> -c -r &gt; sysvm.log 2&gt;&amp;1 &amp;\n"
"                                <prompt>#</prompt> <command>tail</command> -f <filename>sysvm.log</filename>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "After the script terminates, check the log to verify correct execution:"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "<prompt>#</prompt> <command>tail</command> -f <filename>sysvm.log</filename>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "The content should be like the following:"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "\n"
"Stopping and starting 1 secondary storage vm(s)...\n"
"Done stopping and starting secondary storage vm(s)\n"
"Stopping and starting 1 console proxy vm(s)...\n"
"Done stopping and starting console proxy vm(s).\n"
"Stopping and starting 4 running routing vm(s)...\n"
"Done restarting router(s).\n"
"                            "
msgstr ""

#. Tag: para
#, no-c-format
msgid "If you would like additional confirmation that the new system VM templates were correctly applied when these system VMs were rebooted, SSH into the System VM and check the version."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Use one of the following techniques, depending on the hypervisor."
msgstr ""

#. Tag: title
#, no-c-format
msgid "XenServer or KVM:"
msgstr ""

#. Tag: para
#, no-c-format
msgid "SSH in by using the link local IP address of the system VM. For example, in the command below, substitute your own path to the private key used to log in to the system VM and your own link local IP."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Run the following commands on the XenServer or KVM host on which the system VM is present:"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "<prompt>#</prompt> <command>ssh</command> -i <replaceable>private-key-path</replaceable> <replaceable>link-local-ip</replaceable> -p 3922\n"
"                        # cat /etc/cloudstack-release"
msgstr ""

#. Tag: para
#, no-c-format
msgid "The output should be like the following:"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "Cloudstack Release 4.0.0-incubating Mon Oct 9 15:10:04 PST 2012"
msgstr ""

#. Tag: title
#, no-c-format
msgid "ESXi"
msgstr ""

#. Tag: para
#, no-c-format
msgid "SSH in using the private IP address of the system VM. For example, in the command below, substitute your own path to the private key used to log in to the system VM and your own private IP."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Run the following commands on the Management Server:"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "<prompt>#</prompt> <command>ssh</command> -i <replaceable>private-key-path</replaceable> <replaceable>private-ip</replaceable> -p 3922\n"
"                        <prompt>#</prompt> <command>cat</command> <filename>/etc/cloudstack-release</filename>\n"
"                    "
msgstr ""

#. Tag: para
#, no-c-format
msgid "If needed, upgrade all Citrix XenServer hypervisor hosts in your cloud to a version supported by CloudStack 4.0.0-incubating. The supported versions are XenServer 5.6 SP2 and 6.0.2. Instructions for upgrade can be found in the CloudStack 4.0.0-incubating Installation Guide."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Apply the XenServer hotfix XS602E003 (and any other needed hotfixes) to XenServer v6.0.2 hypervisor hosts."
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "/opt/xensource/bin/cloud-clean-vlan.sh"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Prepare the upgrade by running the following on one XenServer host:"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "/opt/xensource/bin/cloud-prepare-upgrade.sh"
msgstr ""

#. Tag: para
#, no-c-format
msgid "If you see a message like \"can't eject CD\", log in to the VM and umount the CD, then run this script again."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Upload the hotfix to the XenServer hosts. Always start with the Xen pool master, then the slaves. Using your favorite file copy utility (e.g. WinSCP), copy the hotfixes to the host. Place them in a temporary folder such as /root or /tmp."
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "xe patch-upload file-name=XS602E003.xsupdate"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "# xe vm-list"
msgstr ""

#. Tag: programlisting
#, no-c-format
msgid "<prompt>#</prompt> <command>xe</command> vm-migrate live=true host=<replaceable>host-name</replaceable> vm=<replaceable>VM-name</replaceable>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<command># xe host-list</command>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<command>xe patch-apply host-uuid=<replaceable>host-uuid</replaceable> uuid=<replaceable>hotfix-uuid</replaceable></command>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<filename>/usr/lib64/cloud/common/scripts/vm/hypervisor/xenserver/xenserver60/NFSSR.py</filename>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<filename>/opt/xensource/sm/NFSSR.py</filename>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<filename>/usr/lib64/cloud/common/scripts/vm/hypervisor/xenserver/setupxenserver.sh</filename>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<filename>/opt/xensource/bin/setupxenserver.sh</filename>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<filename>/usr/lib64/cloud/common/scripts/vm/hypervisor/xenserver/make_migratable.sh</filename>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<filename>/opt/xensource/bin/make_migratable.sh</filename>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<command># tar xf xenserver-cloud-supp.tgz</command>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<command># xe-install-supplemental-pack xenserver-cloud-supp.iso</command>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<command># xe-switch-network-backend bridge</command>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<command>/opt/xensource/bin/setupxenserver.sh</command>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<command>for pbd in `xe pbd-list currently-attached=false| grep ^uuid | awk '{print $NF}'`; do xe pbd-plug uuid=$pbd ; </command>"
msgstr ""

#. Tag: title
#, no-c-format
msgid "Version 4.1.0"
msgstr ""

#. Tag: title
#, no-c-format
msgid "What’s New in 4.1"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Apache CloudStack 4.1.0 includes many new features. This section covers the most prominent new features and changes."
msgstr ""

#. Tag: title
#, no-c-format
msgid "Issues Fixed in 4.1.0"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Apache CloudStack uses <ulink url=\"https://issues.apache.org/jira/browse/CLOUDSTACK\">Jira</ulink> to track its issues. All new features and bugs for 4.1.0 have been tracked in Jira, and have a standard naming convention of \"CLOUDSTACK-NNNN\" where \"NNNN\" is the issue number."
msgstr ""

#. Tag: para
#, no-c-format
msgid "This section includes a summary of known issues against 4.0.0 that were fixed in 4.1.0."
msgstr ""

#. Tag: para
#, no-c-format
msgid "Defect"
msgstr ""

#. Tag: para
#, no-c-format
msgid "CS-16135"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Creating volumes after upgrading from snapshot taken in 2.2.14 no longer deletes the snapshot physically from the secondary storage."
msgstr ""

#. Tag: title
#, no-c-format
msgid "Known Issues in 4.1.0"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Issue ID"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<ulink url=\"https://issues.apache.org/jira/browse/CLOUDSTACK-1747\">CLOUDSTACK-1747</ulink>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "mvn deploydb only creates 4.0 DB, not 4.1"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Due to tooling changes between 4.1 and 4.2, CloudStack's database is created using the 4.0 schema and updated to the 4.1 schema when the management server starts for the first time. It's OK to see the same schema if the management server has not started yet."
msgstr ""

#. Tag: para
#, no-c-format
msgid "<ulink url=\"https://issues.apache.org/jira/browse/CLOUDSTACK-1824\">CLOUDSTACK-1824</ulink>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Service CloudStack-Management is being displayed as cloud-management service"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Many scripts and text entries have references to cloud-management rather than cloudstack-management due to the changeover between 4.0 and 4.1 to rename services. This is a minor issue and should be corrected by 4.2."
msgstr ""

#. Tag: para
#, no-c-format
msgid "<ulink url=\"https://issues.apache.org/jira/browse/CLOUDSTACK-1510\">CLOUDSTACK-1510</ulink>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "NPE when primary storage is added with wrong path"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<ulink url=\"https://issues.apache.org/jira/browse/CLOUDSTACK-1428\">CLOUDSTACK-1428</ulink>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "[UI] Instance which are created without display name are not visible when added to LB"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<ulink url=\"https://issues.apache.org/jira/browse/CLOUDSTACK-1306\">CLOUDSTACK-1306</ulink>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Better Error message when trying to deploy Vm by passing static Ipv4 addresses that are assigned to another VM/IP4 address is outside the iprange."
msgstr ""

#. Tag: para
#, no-c-format
msgid "<ulink url=\"https://issues.apache.org/jira/browse/CLOUDSTACK-1236\">CLOUDSTACK-1236</ulink>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Warning while adding Xen 6.1 host [Unable to create local link network]"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<ulink url=\"https://issues.apache.org/jira/browse/CLOUDSTACK-969\">CLOUDSTACK-969</ulink>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "api: zone response lists vlan in it as \"vlan range of zone\" but the vlan belongs to physical network"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<ulink url=\"https://issues.apache.org/jira/browse/CLOUDSTACK-963\">CLOUDSTACK-963</ulink>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "[cloud.utils.AnnotationHelper] class java.lang.Stringdoes not have a Table annotation"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<ulink url=\"https://issues.apache.org/jira/browse/CLOUDSTACK-458\">CLOUDSTACK-458</ulink>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "xen:snapshots:Storage gc fail to clean the failed snapshot images from secondarystorage"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<ulink url=\"https://issues.apache.org/jira/browse/CLOUDSTACK-315\">CLOUDSTACK-315</ulink>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Infrastructure view does not show capacity values"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<ulink url=\"https://issues.apache.org/jira/browse/CLOUDSTACK-300\">CLOUDSTACK-300</ulink>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Creation of compute offering allow combination of local storage + HA"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<ulink url=\"https://issues.apache.org/jira/browse/CLOUDSTACK-282\">CLOUDSTACK-282</ulink>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Virtual Routers do not properly resolve DNS SRV Records"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<ulink url=\"https://issues.apache.org/jira/browse/CLOUDSTACK-276\">CLOUDSTACK-276</ulink>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "SSVM ID is exposed in the Error Message thrown by AddTrafficType API"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<ulink url=\"https://issues.apache.org/jira/browse/CLOUDSTACK-270\">CLOUDSTACK-270</ulink>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Ui should not ask for a vlan range if the physical network isolation type is not VLAN"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<ulink url=\"https://issues.apache.org/jira/browse/CLOUDSTACK-245\">CLOUDSTACK-245</ulink>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "VPC ACLs are not stored and programmed consistently"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<ulink url=\"https://issues.apache.org/jira/browse/CLOUDSTACK-231\">CLOUDSTACK-231</ulink>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "Tag creation using special charecters"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<ulink url=\"https://issues.apache.org/jira/browse/CLOUDSTACK-124\">CLOUDSTACK-124</ulink>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "NetworkGarbageCollector not cleaning up networks"
msgstr ""

#. Tag: para
#, no-c-format
msgid "<ulink url=\"https://issues.apache.org/jira/browse/CLOUDSTACK-62\">CLOUDSTACK-62</ulink>"
msgstr ""

#. Tag: para
#, no-c-format
msgid "console proxy does not support any keymaps besides us, jp"
msgstr ""

