7548706b09
Generic driver jobs are failing because of timeouts when establishing the initial ssh connection from manila-share to the service VM. Bump up the default value of the connection timeout for paramiko client and also set the banner timeout since the failure occurred during banner exchange. Set the two timeouts to the same value for now. This ensures that the connection timeout is at least as long as the banner timeout and there is no current need in manila to control these independently. This is more of a workaround than a real fix since a real fix would remove the delay during banner exchange. I suspect that the real fix will need to be in neutron/ovs though. Change-Id: Ib5e59faaf9667b9cb5e7d4072531b7d6c3d4da39 Partial-bug: #1807216
1200 lines
50 KiB
Bash
Executable File
1200 lines
50 KiB
Bash
Executable File
#!/bin/bash
|
|
|
|
# Plugin file for enabling manila services
|
|
# ----------------------------------------
|
|
|
|
# Save trace setting
|
|
XTRACE=$(set +o | grep xtrace)
|
|
set -o xtrace
|
|
|
|
# Entry Points
|
|
# ------------
|
|
|
|
function _clean_share_group {
|
|
local vg=$1
|
|
local vg_prefix=$2
|
|
# Clean out existing shares
|
|
for lv in `sudo lvs --noheadings -o lv_name $vg`; do
|
|
# vg_prefix prefixes the LVs we want
|
|
if [[ "${lv#$vg_prefix}" != "$lv" ]]; then
|
|
sudo umount -f $MANILA_MNT_DIR/$lv
|
|
sudo lvremove -f $vg/$lv
|
|
sudo rm -rf $MANILA_MNT_DIR/$lv
|
|
fi
|
|
done
|
|
}
|
|
|
|
function _clean_manila_lvm_backing_file {
|
|
local vg=$1
|
|
|
|
# if there is no logical volume left, it's safe to attempt a cleanup
|
|
# of the backing file
|
|
if [ -z "`sudo lvs --noheadings -o lv_name $vg`" ]; then
|
|
# if the backing physical device is a loop device, it was probably setup by devstack
|
|
VG_DEV=$(sudo losetup -j $DATA_DIR/${vg}-backing-file | awk -F':' '/backing-file/ { print $1
|
|
}')
|
|
if [[ -n "$VG_DEV" ]]; then
|
|
sudo losetup -d $VG_DEV
|
|
rm -f $DATA_DIR/${vg}-backing-file
|
|
fi
|
|
fi
|
|
}
|
|
|
|
function _clean_zfsonlinux_data {
|
|
for filename in "$MANILA_ZFSONLINUX_BACKEND_FILES_CONTAINER_DIR"/*; do
|
|
if [[ $(sudo zpool list | grep $filename) ]]; then
|
|
echo "Destroying zpool named $filename"
|
|
sudo zpool destroy -f $filename
|
|
file="$MANILA_ZFSONLINUX_BACKEND_FILES_CONTAINER_DIR$filename"
|
|
echo "Destroying file named $file"
|
|
rm -f $file
|
|
fi
|
|
done
|
|
}
|
|
|
|
# cleanup_manila - Remove residual data files, anything left over from previous
|
|
# runs that a clean run would need to clean up
|
|
function cleanup_manila {
|
|
# All stuff, that are created by share drivers will be cleaned up by other services.
|
|
_clean_share_group $SHARE_GROUP $SHARE_NAME_PREFIX
|
|
_clean_manila_lvm_backing_file $SHARE_GROUP
|
|
_clean_zfsonlinux_data
|
|
}
|
|
|
|
# _config_manila_apache_wsgi() - Configure manila-api wsgi application.
|
|
function _config_manila_apache_wsgi {
|
|
local manila_api_apache_conf
|
|
local venv_path=""
|
|
manila_api_apache_conf=$(apache_site_config_for manila-api)
|
|
|
|
sudo cp $MANILA_DIR/devstack/apache-manila.template $manila_api_apache_conf
|
|
sudo sed -e "
|
|
s|%APACHE_NAME%|$APACHE_NAME|g;
|
|
s|%MANILA_BIN_DIR%|$MANILA_BIN_DIR|g;
|
|
s|%PORT%|$MANILA_SERVICE_PORT|g;
|
|
s|%APIWORKERS%|$API_WORKERS|g;
|
|
s|%USER%|$STACK_USER|g;
|
|
" -i $manila_api_apache_conf
|
|
}
|
|
|
|
# configure_default_backends - configures default Manila backends with generic driver.
|
|
function configure_default_backends {
|
|
# Configure two default backends with generic drivers onboard
|
|
for group_name in $MANILA_BACKEND1_CONFIG_GROUP_NAME $MANILA_BACKEND2_CONFIG_GROUP_NAME; do
|
|
iniset $MANILA_CONF $group_name share_driver $SHARE_DRIVER
|
|
if [ "$MANILA_BACKEND1_CONFIG_GROUP_NAME" == "$group_name" ]; then
|
|
iniset $MANILA_CONF $group_name share_backend_name $MANILA_SHARE_BACKEND1_NAME
|
|
else
|
|
iniset $MANILA_CONF $group_name share_backend_name $MANILA_SHARE_BACKEND2_NAME
|
|
fi
|
|
iniset $MANILA_CONF $group_name path_to_public_key $MANILA_PATH_TO_PUBLIC_KEY
|
|
iniset $MANILA_CONF $group_name path_to_private_key $MANILA_PATH_TO_PRIVATE_KEY
|
|
iniset $MANILA_CONF $group_name service_image_name $MANILA_SERVICE_IMAGE_NAME
|
|
iniset $MANILA_CONF $group_name service_instance_user $MANILA_SERVICE_INSTANCE_USER
|
|
iniset $MANILA_CONF $group_name driver_handles_share_servers True
|
|
|
|
if [ "$SHARE_DRIVER" == $MANILA_CONTAINER_DRIVER ]; then
|
|
iniset $MANILA_CONF $group_name network_api_class $MANILA_NETWORK_API_CLASS
|
|
iniset $MANILA_CONF $group_name neutron_host_id $(hostname)
|
|
iniset $MANILA_CONF $group_name neutron_vnic_type $MANILA_NEUTRON_VNIC_TYPE
|
|
fi
|
|
|
|
if [ $(trueorfalse False MANILA_USE_SERVICE_INSTANCE_PASSWORD) == True ]; then
|
|
iniset $MANILA_CONF $group_name service_instance_password $MANILA_SERVICE_INSTANCE_PASSWORD
|
|
fi
|
|
|
|
if [ "$SHARE_DRIVER" == "manila.share.drivers.generic.GenericShareDriver" ]; then
|
|
iniset $MANILA_CONF $group_name ssh_conn_timeout $MANILA_SSH_TIMEOUT
|
|
fi
|
|
done
|
|
}
|
|
|
|
# set_config_opts - this allows to set any config opt to any config group,
|
|
# parsing env vars by prefix special 'MANILA_OPTGROUP_'.
|
|
function set_config_opts {
|
|
# expects only one param - name of config group(s) as list separated by commas
|
|
GROUP_NAMES=$1
|
|
if [[ -n "$GROUP_NAMES" ]]; then
|
|
for be in ${GROUP_NAMES//,/ }; do
|
|
# get backend_specific opt values
|
|
prefix=MANILA_OPTGROUP_$be\_
|
|
( set -o posix ; set ) | grep ^$prefix | while read -r line ; do
|
|
# parse it to opt names and values
|
|
opt=${line#$prefix}
|
|
opt_name=${opt%%=*}
|
|
opt_value=${opt##*=}
|
|
iniset $MANILA_CONF $be $opt_name $opt_value
|
|
done
|
|
done
|
|
fi
|
|
}
|
|
|
|
# set_cinder_quotas - Sets Cinder quotas, that is useful for generic driver,
|
|
# which uses Cinder volumes and snapshots.
|
|
function set_cinder_quotas {
|
|
# Update Cinder configuration to make sure default quotas are enough
|
|
# for Manila using Generic driver with parallel testing.
|
|
if is_service_enabled cinder; then
|
|
if [[ ! "$CINDER_CONF" ]]; then
|
|
CINDER_CONF=/etc/cinder/cinder.conf
|
|
fi
|
|
iniset $CINDER_CONF DEFAULT quota_volumes 50
|
|
iniset $CINDER_CONF DEFAULT quota_snapshots 50
|
|
iniset $CINDER_CONF DEFAULT quota_gigabytes 1000
|
|
fi
|
|
}
|
|
|
|
# configure_manila - Set config files, create data dirs, etc
|
|
function configure_manila {
|
|
if [[ ! -d $MANILA_CONF_DIR ]]; then
|
|
sudo mkdir -p $MANILA_CONF_DIR
|
|
fi
|
|
sudo chown $STACK_USER $MANILA_CONF_DIR
|
|
|
|
if [[ -f $MANILA_DIR/etc/manila/policy.json ]]; then
|
|
cp -p $MANILA_DIR/etc/manila/policy.json $MANILA_CONF_DIR
|
|
fi
|
|
|
|
# Set the paths of certain binaries
|
|
MANILA_ROOTWRAP=$(get_rootwrap_location manila)
|
|
|
|
# If Manila ships the new rootwrap filters files, deploy them
|
|
# (owned by root) and add a parameter to $MANILA_ROOTWRAP
|
|
ROOTWRAP_MANILA_SUDOER_CMD="$MANILA_ROOTWRAP"
|
|
if [[ -d $MANILA_DIR/etc/manila/rootwrap.d ]]; then
|
|
# Wipe any existing rootwrap.d files first
|
|
if [[ -d $MANILA_CONF_DIR/rootwrap.d ]]; then
|
|
sudo rm -rf $MANILA_CONF_DIR/rootwrap.d
|
|
fi
|
|
# Deploy filters to /etc/manila/rootwrap.d
|
|
sudo mkdir -m 755 $MANILA_CONF_DIR/rootwrap.d
|
|
sudo cp $MANILA_DIR/etc/manila/rootwrap.d/*.filters $MANILA_CONF_DIR/rootwrap.d
|
|
sudo chown -R root:root $MANILA_CONF_DIR/rootwrap.d
|
|
sudo chmod 644 $MANILA_CONF_DIR/rootwrap.d/*
|
|
# Set up rootwrap.conf, pointing to /etc/manila/rootwrap.d
|
|
sudo cp $MANILA_DIR/etc/manila/rootwrap.conf $MANILA_CONF_DIR/
|
|
sudo sed -e "s:^filters_path=.*$:filters_path=$MANILA_CONF_DIR/rootwrap.d:" -i $MANILA_CONF_DIR/rootwrap.conf
|
|
sudo chown root:root $MANILA_CONF_DIR/rootwrap.conf
|
|
sudo chmod 0644 $MANILA_CONF_DIR/rootwrap.conf
|
|
# Specify rootwrap.conf as first parameter to manila-rootwrap
|
|
MANILA_ROOTWRAP="$MANILA_ROOTWRAP $MANILA_CONF_DIR/rootwrap.conf"
|
|
ROOTWRAP_MANILA_SUDOER_CMD="$MANILA_ROOTWRAP *"
|
|
fi
|
|
|
|
TEMPFILE=`mktemp`
|
|
echo "$USER ALL=(root) NOPASSWD: $ROOTWRAP_MANILA_SUDOER_CMD" >$TEMPFILE
|
|
chmod 0440 $TEMPFILE
|
|
sudo chown root:root $TEMPFILE
|
|
sudo mv $TEMPFILE /etc/sudoers.d/manila-rootwrap
|
|
|
|
cp $MANILA_DIR/etc/manila/api-paste.ini $MANILA_API_PASTE_INI
|
|
|
|
# Remove old conf file if exists
|
|
rm -f $MANILA_CONF
|
|
|
|
configure_auth_token_middleware $MANILA_CONF manila $MANILA_AUTH_CACHE_DIR
|
|
|
|
iniset $MANILA_CONF DEFAULT auth_strategy keystone
|
|
iniset $MANILA_CONF DEFAULT debug True
|
|
iniset $MANILA_CONF DEFAULT scheduler_driver $MANILA_SCHEDULER_DRIVER
|
|
iniset $MANILA_CONF DEFAULT share_name_template ${SHARE_NAME_PREFIX}%s
|
|
iniset $MANILA_CONF DATABASE connection `database_connection_url manila`
|
|
iniset $MANILA_CONF DATABASE max_pool_size 40
|
|
iniset $MANILA_CONF DEFAULT api_paste_config $MANILA_API_PASTE_INI
|
|
iniset $MANILA_CONF DEFAULT rootwrap_config $MANILA_CONF_DIR/rootwrap.conf
|
|
iniset $MANILA_CONF DEFAULT osapi_share_extension manila.api.contrib.standard_extensions
|
|
iniset $MANILA_CONF DEFAULT state_path $MANILA_STATE_PATH
|
|
|
|
# Note: Sample share types will still be created if the below is False
|
|
|
|
if [ $(trueorfalse False MANILA_CONFIGURE_DEFAULT_TYPES) == True ]; then
|
|
iniset $MANILA_CONF DEFAULT default_share_type $MANILA_DEFAULT_SHARE_TYPE
|
|
iniset $MANILA_CONF DEFAULT default_share_group_type $MANILA_DEFAULT_SHARE_GROUP_TYPE
|
|
fi
|
|
|
|
if ! [[ -z $MANILA_SHARE_MIGRATION_PERIOD_TASK_INTERVAL ]]; then
|
|
iniset $MANILA_CONF DEFAULT migration_driver_continue_update_interval $MANILA_SHARE_MIGRATION_PERIOD_TASK_INTERVAL
|
|
fi
|
|
|
|
if ! [[ -z $MANILA_DATA_COPY_CHECK_HASH ]]; then
|
|
iniset $MANILA_CONF DEFAULT check_hash $MANILA_DATA_COPY_CHECK_HASH
|
|
fi
|
|
|
|
iniset $MANILA_CONF DEFAULT enabled_share_protocols $MANILA_ENABLED_SHARE_PROTOCOLS
|
|
|
|
iniset $MANILA_CONF oslo_concurrency lock_path $MANILA_LOCK_PATH
|
|
|
|
iniset $MANILA_CONF DEFAULT wsgi_keep_alive False
|
|
|
|
iniset $MANILA_CONF DEFAULT lvm_share_volume_group $SHARE_GROUP
|
|
|
|
# Set the replica_state_update_interval
|
|
iniset $MANILA_CONF DEFAULT replica_state_update_interval $MANILA_REPLICA_STATE_UPDATE_INTERVAL
|
|
|
|
if is_service_enabled neutron; then
|
|
configure_auth_token_middleware $MANILA_CONF neutron $MANILA_AUTH_CACHE_DIR neutron
|
|
fi
|
|
if is_service_enabled nova; then
|
|
configure_auth_token_middleware $MANILA_CONF nova $MANILA_AUTH_CACHE_DIR nova
|
|
fi
|
|
if is_service_enabled cinder; then
|
|
configure_auth_token_middleware $MANILA_CONF cinder $MANILA_AUTH_CACHE_DIR cinder
|
|
fi
|
|
|
|
# Note: set up config group does not mean that this backend will be enabled.
|
|
# To enable it, specify its name explicitly using "enabled_share_backends" opt.
|
|
configure_default_backends
|
|
default_backends=$MANILA_BACKEND1_CONFIG_GROUP_NAME
|
|
if [ "$MANILA_MULTI_BACKEND" = "True" ]; then
|
|
default_backends+=,$MANILA_BACKEND2_CONFIG_GROUP_NAME
|
|
fi
|
|
if [ ! $MANILA_ENABLED_BACKENDS ]; then
|
|
# If $MANILA_ENABLED_BACKENDS is not set, use configured backends by default
|
|
export MANILA_ENABLED_BACKENDS=$default_backends
|
|
fi
|
|
iniset $MANILA_CONF DEFAULT enabled_share_backends $MANILA_ENABLED_BACKENDS
|
|
|
|
if [ ! -f $MANILA_PATH_TO_PRIVATE_KEY ]; then
|
|
ssh-keygen -N "" -t rsa -f $MANILA_PATH_TO_PRIVATE_KEY;
|
|
fi
|
|
|
|
iniset $MANILA_CONF DEFAULT manila_service_keypair_name $MANILA_SERVICE_KEYPAIR_NAME
|
|
|
|
if is_service_enabled tls-proxy; then
|
|
# Set the service port for a proxy to take the original
|
|
iniset $MANILA_CONF DEFAULT osapi_share_listen_port $MANILA_SERVICE_PORT_INT
|
|
fi
|
|
|
|
iniset_rpc_backend manila $MANILA_CONF DEFAULT
|
|
|
|
setup_logging $MANILA_CONF
|
|
|
|
MANILA_CONFIGURE_GROUPS=${MANILA_CONFIGURE_GROUPS:-"$MANILA_ENABLED_BACKENDS"}
|
|
set_config_opts $MANILA_CONFIGURE_GROUPS
|
|
set_config_opts DEFAULT
|
|
|
|
if [ $(trueorfalse False MANILA_USE_MOD_WSGI) == True ]; then
|
|
_config_manila_apache_wsgi
|
|
fi
|
|
}
|
|
|
|
|
|
function create_manila_service_keypair {
|
|
if is_service_enabled nova; then
|
|
local keypair_exists=$( openstack keypair list | grep " $MANILA_SERVICE_KEYPAIR_NAME " )
|
|
if [[ -z $keypair_exists ]]; then
|
|
openstack keypair create $MANILA_SERVICE_KEYPAIR_NAME --public-key $MANILA_PATH_TO_PUBLIC_KEY
|
|
fi
|
|
fi
|
|
}
|
|
|
|
|
|
function is_driver_enabled {
|
|
driver_name=$1
|
|
for BE in ${MANILA_ENABLED_BACKENDS//,/ }; do
|
|
share_driver=$(iniget $MANILA_CONF $BE share_driver)
|
|
if [ "$share_driver" == "$driver_name" ]; then
|
|
return 0
|
|
fi
|
|
done
|
|
return 1
|
|
}
|
|
|
|
|
|
# create_service_share_servers - creates service Nova VMs, one per generic
|
|
# driver, and only if it is configured to mode without handling of share servers.
|
|
function create_service_share_servers {
|
|
created_admin_network=false
|
|
for BE in ${MANILA_ENABLED_BACKENDS//,/ }; do
|
|
driver_handles_share_servers=$(iniget $MANILA_CONF $BE driver_handles_share_servers)
|
|
share_driver=$(iniget $MANILA_CONF $BE share_driver)
|
|
generic_driver='manila.share.drivers.generic.GenericShareDriver'
|
|
if [[ $share_driver == $generic_driver ]]; then
|
|
if [[ $(trueorfalse False driver_handles_share_servers) == False ]]; then
|
|
vm_name='manila_service_share_server_'$BE
|
|
local vm_exists=$( openstack server list --all-projects | grep " $vm_name " )
|
|
if [[ -z $vm_exists ]]; then
|
|
private_net_id=$(openstack network show $PRIVATE_NETWORK_NAME -f value -c id)
|
|
vm_id=$(openstack server create $vm_name \
|
|
--flavor $MANILA_SERVICE_VM_FLAVOR_NAME \
|
|
--image $MANILA_SERVICE_IMAGE_NAME \
|
|
--nic net-id=$private_net_id \
|
|
--security-group $MANILA_SERVICE_SECGROUP \
|
|
--key-name $MANILA_SERVICE_KEYPAIR_NAME \
|
|
| grep ' id ' | get_field 2)
|
|
else
|
|
vm_id=$(openstack server show $vm_name -f value -c id)
|
|
fi
|
|
|
|
floating_ip=$(openstack floating ip create $PUBLIC_NETWORK_NAME --subnet $PUBLIC_SUBNET_NAME | grep 'floating_ip_address' | get_field 2)
|
|
# TODO(rishabh-d-dave): For time being circumvent the bug -
|
|
# https://bugs.launchpad.net/python-openstackclient/+bug/1747721
|
|
# Once fixed, replace the following 3 lines by -
|
|
# openstack server add floating ip $vm_id $floating_ip
|
|
vm_port_id=$(openstack port list --server $vm_id -c ID -f \
|
|
value)
|
|
openstack floating ip set --port $vm_port_id $floating_ip
|
|
|
|
iniset $MANILA_CONF $BE service_instance_name_or_id $vm_id
|
|
iniset $MANILA_CONF $BE service_net_name_or_ip $floating_ip
|
|
iniset $MANILA_CONF $BE tenant_net_name_or_ip $PRIVATE_NETWORK_NAME
|
|
else
|
|
if is_service_enabled neutron; then
|
|
if ! [[ -z $MANILA_ADMIN_NET_RANGE ]]; then
|
|
if [ $created_admin_network == false ]; then
|
|
project_id=$(openstack project show $SERVICE_PROJECT_NAME -c id -f value)
|
|
local admin_net_id=$( openstack network show admin_net -f value -c id )
|
|
if [[ -z $admin_net_id ]]; then
|
|
openstack network create admin_net --project $project_id
|
|
admin_net_id=$(openstack network show admin_net -f value -c id)
|
|
fi
|
|
|
|
local admin_subnet_id=$( openstack subnet show admin_subnet -f value -c id )
|
|
if [[ -z $admin_subnet_id ]]; then
|
|
openstack subnet create admin_subnet --project $project_id --ip-version 4 --network $admin_net_id --gateway None --subnet-range $MANILA_ADMIN_NET_RANGE
|
|
admin_subnet_id=$(openstack subnet show admin_subnet -f value -c id)
|
|
fi
|
|
created_admin_network=true
|
|
fi
|
|
iniset $MANILA_CONF $BE admin_network_id $admin_net_id
|
|
iniset $MANILA_CONF $BE admin_subnet_id $admin_subnet_id
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
done
|
|
configure_data_service_generic_driver
|
|
}
|
|
|
|
function configure_data_service_generic_driver {
|
|
enabled_backends=(${MANILA_ENABLED_BACKENDS//,/ })
|
|
share_driver=$(iniget $MANILA_CONF ${enabled_backends[0]} share_driver)
|
|
generic_driver='manila.share.drivers.generic.GenericShareDriver'
|
|
if [[ $share_driver == $generic_driver ]]; then
|
|
driver_handles_share_servers=$(iniget $MANILA_CONF ${enabled_backends[0]} driver_handles_share_servers)
|
|
if [[ $(trueorfalse False driver_handles_share_servers) == False ]]; then
|
|
iniset $MANILA_CONF DEFAULT data_node_access_ip $PUBLIC_NETWORK_GATEWAY
|
|
else
|
|
if ! [[ -z $MANILA_DATA_NODE_IP ]]; then
|
|
iniset $MANILA_CONF DEFAULT data_node_access_ip $MANILA_DATA_NODE_IP
|
|
fi
|
|
fi
|
|
fi
|
|
}
|
|
# create_manila_service_flavor - creates flavor, that will be used by backends
|
|
# with configured generic driver to boot Nova VMs with.
|
|
function create_manila_service_flavor {
|
|
if is_service_enabled nova; then
|
|
local flavor_exists=$( openstack flavor list | grep " $MANILA_SERVICE_VM_FLAVOR_NAME " )
|
|
if [[ -z $flavor_exists ]]; then
|
|
# Create flavor for Manila's service VM
|
|
openstack flavor create \
|
|
$MANILA_SERVICE_VM_FLAVOR_NAME \
|
|
--id $MANILA_SERVICE_VM_FLAVOR_REF \
|
|
--ram $MANILA_SERVICE_VM_FLAVOR_RAM \
|
|
--disk $MANILA_SERVICE_VM_FLAVOR_DISK \
|
|
--vcpus $MANILA_SERVICE_VM_FLAVOR_VCPUS
|
|
fi
|
|
fi
|
|
}
|
|
|
|
# create_manila_service_image - creates image, that will be used by backends
|
|
# with configured generic driver to boot Nova VMs from.
|
|
function create_manila_service_image {
|
|
if is_service_enabled nova; then
|
|
TOKEN=$(openstack token issue -c id -f value)
|
|
local image_exists=$( openstack image list | grep " $MANILA_SERVICE_IMAGE_NAME " )
|
|
if [[ -z $image_exists ]]; then
|
|
# Download Manila's image
|
|
if is_service_enabled g-reg; then
|
|
upload_image $MANILA_SERVICE_IMAGE_URL $TOKEN
|
|
fi
|
|
fi
|
|
fi
|
|
}
|
|
|
|
# create_manila_service_secgroup - creates security group that is used by
|
|
# Nova VMs when generic driver is configured.
|
|
function create_manila_service_secgroup {
|
|
# Create a secgroup
|
|
if ! openstack security group list | grep -q $MANILA_SERVICE_SECGROUP; then
|
|
openstack security group create $MANILA_SERVICE_SECGROUP --description "$MANILA_SERVICE_SECGROUP description"
|
|
if ! timeout 30 sh -c "while ! openstack security group list | grep -q $MANILA_SERVICE_SECGROUP; do sleep 1; done"; then
|
|
echo "Security group not created"
|
|
exit 1
|
|
fi
|
|
fi
|
|
|
|
# Configure Security Group Rules
|
|
if ! openstack security group rule list $MANILA_SERVICE_SECGROUP | grep -q icmp; then
|
|
openstack security group rule create $MANILA_SERVICE_SECGROUP --protocol icmp
|
|
fi
|
|
if ! openstack security group rule list $MANILA_SERVICE_SECGROUP | grep -q " tcp .* 22 "; then
|
|
openstack security group rule create $MANILA_SERVICE_SECGROUP --protocol tcp --dst-port 22
|
|
fi
|
|
if ! openstack security group rule list $MANILA_SERVICE_SECGROUP | grep -q " tcp .* 2049 "; then
|
|
openstack security group rule create $MANILA_SERVICE_SECGROUP --protocol tcp --dst-port 2049
|
|
fi
|
|
if ! openstack security group rule list $MANILA_SERVICE_SECGROUP | grep -q " udp .* 2049 "; then
|
|
openstack security group rule create $MANILA_SERVICE_SECGROUP --protocol udp --dst-port 2049
|
|
fi
|
|
if ! openstack security group rule list $MANILA_SERVICE_SECGROUP | grep -q " udp .* 445 "; then
|
|
openstack security group rule create $MANILA_SERVICE_SECGROUP --protocol udp --dst-port 445
|
|
fi
|
|
if ! openstack security group rule list $MANILA_SERVICE_SECGROUP | grep -q " tcp .* 445 "; then
|
|
openstack security group rule create $MANILA_SERVICE_SECGROUP --protocol tcp --dst-port 445
|
|
fi
|
|
if ! openstack security group rule list $MANILA_SERVICE_SECGROUP | grep -q " tcp .* 139 "; then
|
|
openstack security group rule create $MANILA_SERVICE_SECGROUP --protocol tcp --dst-port 137:139
|
|
fi
|
|
if ! openstack security group rule list $MANILA_SERVICE_SECGROUP | grep -q " udp .* 139 "; then
|
|
openstack security group rule create $MANILA_SERVICE_SECGROUP --protocol udp --dst-port 137:139
|
|
fi
|
|
|
|
# List secgroup rules
|
|
openstack security group rule list $MANILA_SERVICE_SECGROUP
|
|
}
|
|
|
|
# create_manila_accounts - Set up common required manila accounts
|
|
function create_manila_accounts {
|
|
|
|
create_service_user "manila"
|
|
|
|
# Set up Manila v1 service and endpoint
|
|
get_or_create_service "manila" "share" "Manila Shared Filesystem Service"
|
|
get_or_create_endpoint "share" "$REGION_NAME" \
|
|
"$MANILA_SERVICE_PROTOCOL://$MANILA_SERVICE_HOST:$MANILA_SERVICE_PORT/v1/\$(tenant_id)s" \
|
|
"$MANILA_SERVICE_PROTOCOL://$MANILA_SERVICE_HOST:$MANILA_SERVICE_PORT/v1/\$(tenant_id)s" \
|
|
"$MANILA_SERVICE_PROTOCOL://$MANILA_SERVICE_HOST:$MANILA_SERVICE_PORT/v1/\$(tenant_id)s"
|
|
|
|
# Set up Manila v2 service and endpoint
|
|
get_or_create_service "manilav2" "sharev2" "Manila Shared Filesystem Service V2"
|
|
get_or_create_endpoint "sharev2" "$REGION_NAME" \
|
|
"$MANILA_SERVICE_PROTOCOL://$MANILA_SERVICE_HOST:$MANILA_SERVICE_PORT/v2/\$(tenant_id)s" \
|
|
"$MANILA_SERVICE_PROTOCOL://$MANILA_SERVICE_HOST:$MANILA_SERVICE_PORT/v2/\$(tenant_id)s" \
|
|
"$MANILA_SERVICE_PROTOCOL://$MANILA_SERVICE_HOST:$MANILA_SERVICE_PORT/v2/\$(tenant_id)s"
|
|
}
|
|
|
|
# create_default_share_group_type - create share group type that will be set as default.
|
|
function create_default_share_group_type {
|
|
local type_exists=$( manila share-group-type-list | grep " $MANILA_DEFAULT_SHARE_GROUP_TYPE " )
|
|
if [[ -z $type_exists ]]; then
|
|
manila share-group-type-create $MANILA_DEFAULT_SHARE_GROUP_TYPE $MANILA_DEFAULT_SHARE_TYPE
|
|
fi
|
|
if [[ $MANILA_DEFAULT_SHARE_GROUP_TYPE_SPECS ]]; then
|
|
manila share-group-type-key $MANILA_DEFAULT_SHARE_GROUP_TYPE set $MANILA_DEFAULT_SHARE_GROUP_TYPE_SPECS
|
|
fi
|
|
}
|
|
|
|
# create_default_share_type - create share type that will be set as default
|
|
# if $MANILA_CONFIGURE_DEFAULT_TYPES is set to True, if set to False, the share
|
|
# type identified by $MANILA_DEFAULT_SHARE_TYPE is still created, but not
|
|
# configured as default.
|
|
function create_default_share_type {
|
|
echo "Waiting for Manila API to start..."
|
|
if ! wait_for_service 60 $MANILA_SERVICE_PROTOCOL://$MANILA_SERVICE_HOST:$MANILA_SERVICE_PORT; then
|
|
die $LINENO "Manila did not start"
|
|
fi
|
|
|
|
enabled_backends=(${MANILA_ENABLED_BACKENDS//,/ })
|
|
driver_handles_share_servers=$(iniget $MANILA_CONF ${enabled_backends[0]} driver_handles_share_servers)
|
|
|
|
local type_exists=$( manila type-list | grep " $MANILA_DEFAULT_SHARE_TYPE " )
|
|
if [[ -z $type_exists ]]; then
|
|
local command_args="$MANILA_DEFAULT_SHARE_TYPE $driver_handles_share_servers"
|
|
#if is_driver_enabled $MANILA_CONTAINER_DRIVER; then
|
|
# # TODO(aovchinnikov): Remove this condition when Container driver supports
|
|
# # snapshots
|
|
# command_args="$command_args --snapshot_support false"
|
|
#fi
|
|
manila type-create $command_args
|
|
fi
|
|
if [[ $MANILA_DEFAULT_SHARE_TYPE_EXTRA_SPECS ]]; then
|
|
manila type-key $MANILA_DEFAULT_SHARE_TYPE set $MANILA_DEFAULT_SHARE_TYPE_EXTRA_SPECS
|
|
fi
|
|
}
|
|
|
|
# create_custom_share_types - create share types suitable for both possible
|
|
# driver modes with names "dhss_true" and "dhss_false".
|
|
function create_custom_share_types {
|
|
manila type-create dhss_true True
|
|
if [[ $MANILA_DHSS_TRUE_SHARE_TYPE_EXTRA_SPECS ]]; then
|
|
manila type-key dhss_true set $MANILA_DHSS_TRUE_SHARE_TYPE_EXTRA_SPECS
|
|
fi
|
|
|
|
manila type-create dhss_false False
|
|
if [[ $MANILA_DHSS_FALSE_SHARE_TYPE_EXTRA_SPECS ]]; then
|
|
manila type-key dhss_false set $MANILA_DHSS_FALSE_SHARE_TYPE_EXTRA_SPECS
|
|
fi
|
|
}
|
|
|
|
# configure_backing_file - Set up backing file for LVM
|
|
function configure_backing_file {
|
|
if ! sudo vgs $SHARE_GROUP; then
|
|
if [ "$CONFIGURE_BACKING_FILE" = "True" ]; then
|
|
SHARE_BACKING_FILE=${SHARE_BACKING_FILE:-$DATA_DIR/${SHARE_GROUP}-backing-file}
|
|
# Only create if the file doesn't already exists
|
|
[[ -f $SHARE_BACKING_FILE ]] || truncate -s $SHARE_BACKING_FILE_SIZE $SHARE_BACKING_FILE
|
|
DEV=`sudo losetup -f --show $SHARE_BACKING_FILE`
|
|
else
|
|
DEV=$SHARE_BACKING_FILE
|
|
fi
|
|
# Only create if the loopback device doesn't contain $SHARE_GROUP
|
|
if ! sudo vgs $SHARE_GROUP; then sudo vgcreate $SHARE_GROUP $DEV; fi
|
|
fi
|
|
|
|
mkdir -p $MANILA_STATE_PATH/shares
|
|
mkdir -p /tmp/shares
|
|
}
|
|
|
|
# init_manila - Initializes database and creates manila dir if absent
|
|
function init_manila {
|
|
|
|
if is_service_enabled $DATABASE_BACKENDS; then
|
|
# (re)create manila database
|
|
recreate_database manila
|
|
|
|
$MANILA_BIN_DIR/manila-manage db sync
|
|
|
|
if [[ $(trueorfalse False MANILA_USE_DOWNGRADE_MIGRATIONS) == True ]]; then
|
|
# Use both - upgrade and downgrade migrations to verify that
|
|
# downgrade migrations do not break structure of Manila database.
|
|
$MANILA_BIN_DIR/manila-manage db downgrade
|
|
$MANILA_BIN_DIR/manila-manage db sync
|
|
fi
|
|
|
|
# Display version as debug-action (see bug/1473400)
|
|
$MANILA_BIN_DIR/manila-manage db version
|
|
fi
|
|
|
|
if [ "$SHARE_DRIVER" == "manila.share.drivers.lvm.LVMShareDriver" ]; then
|
|
if is_service_enabled m-shr; then
|
|
# Configure a default volume group called '`lvm-shares`' for the share
|
|
# service if it does not yet exist. If you don't wish to use a file backed
|
|
# volume group, create your own volume group called ``stack-volumes`` before
|
|
# invoking ``stack.sh``.
|
|
#
|
|
# By default, the backing file is 8G in size, and is stored in ``/opt/stack/data``.
|
|
|
|
configure_backing_file
|
|
fi
|
|
elif [ "$SHARE_DRIVER" == $MANILA_CONTAINER_DRIVER ]; then
|
|
if is_service_enabled m-shr; then
|
|
SHARE_GROUP=$MANILA_CONTAINER_VOLUME_GROUP_NAME
|
|
configure_backing_file
|
|
fi
|
|
|
|
elif [ "$SHARE_DRIVER" == "manila.share.drivers.zfsonlinux.driver.ZFSonLinuxShareDriver" ]; then
|
|
if is_service_enabled m-shr; then
|
|
mkdir -p $MANILA_ZFSONLINUX_BACKEND_FILES_CONTAINER_DIR
|
|
file_counter=0
|
|
MANILA_ZFSONLINUX_SERVICE_IP=${MANILA_ZFSONLINUX_SERVICE_IP:-"127.0.0.1"}
|
|
for BE in ${MANILA_ENABLED_BACKENDS//,/ }; do
|
|
if [[ $file_counter == 0 ]]; then
|
|
# NOTE(vponomaryov): create two pools for first ZFS backend
|
|
# to cover different use cases that are supported by driver:
|
|
# - Support of more than one zpool for share backend.
|
|
# - Support of nested datasets.
|
|
local first_file="$MANILA_ZFSONLINUX_BACKEND_FILES_CONTAINER_DIR"/alpha
|
|
local second_file="$MANILA_ZFSONLINUX_BACKEND_FILES_CONTAINER_DIR"/betta
|
|
truncate -s $MANILA_ZFSONLINUX_ZPOOL_SIZE $first_file
|
|
truncate -s $MANILA_ZFSONLINUX_ZPOOL_SIZE $second_file
|
|
sudo zpool create alpha $first_file
|
|
sudo zpool create betta $second_file
|
|
# Create subdir (nested dataset) for second pool
|
|
sudo zfs create betta/subdir
|
|
iniset $MANILA_CONF $BE zfs_zpool_list alpha,betta/subdir
|
|
elif [[ $file_counter == 1 ]]; then
|
|
local file="$MANILA_ZFSONLINUX_BACKEND_FILES_CONTAINER_DIR"/gamma
|
|
truncate -s $MANILA_ZFSONLINUX_ZPOOL_SIZE $file
|
|
sudo zpool create gamma $file
|
|
iniset $MANILA_CONF $BE zfs_zpool_list gamma
|
|
else
|
|
local filename=file"$file_counter"
|
|
local file="$MANILA_ZFSONLINUX_BACKEND_FILES_CONTAINER_DIR"/"$filename"
|
|
truncate -s $MANILA_ZFSONLINUX_ZPOOL_SIZE $file
|
|
sudo zpool create $filename $file
|
|
iniset $MANILA_CONF $BE zfs_zpool_list $filename
|
|
fi
|
|
iniset $MANILA_CONF $BE zfs_share_export_ip $MANILA_ZFSONLINUX_SHARE_EXPORT_IP
|
|
iniset $MANILA_CONF $BE zfs_service_ip $MANILA_ZFSONLINUX_SERVICE_IP
|
|
iniset $MANILA_CONF $BE zfs_dataset_creation_options $MANILA_ZFSONLINUX_DATASET_CREATION_OPTIONS
|
|
iniset $MANILA_CONF $BE zfs_use_ssh $MANILA_ZFSONLINUX_USE_SSH
|
|
iniset $MANILA_CONF $BE zfs_ssh_username $MANILA_ZFSONLINUX_SSH_USERNAME
|
|
iniset $MANILA_CONF $BE replication_domain $MANILA_ZFSONLINUX_REPLICATION_DOMAIN
|
|
iniset $MANILA_CONF $BE driver_handles_share_servers False
|
|
let "file_counter=file_counter+1"
|
|
done
|
|
# Install the server's SSH key in our known_hosts file
|
|
eval STACK_HOME=~$STACK_USER
|
|
ssh-keyscan ${MANILA_ZFSONLINUX_SERVICE_IP} >> $STACK_HOME/.ssh/known_hosts
|
|
# If the server is this machine, setup trust for ourselves (otherwise you're on your own)
|
|
if [ "$MANILA_ZFSONLINUX_SERVICE_IP" = "127.0.0.1" ] || [ "$MANILA_ZFSONLINUX_SERVICE_IP" = "localhost" ] ; then
|
|
# Trust our own SSH keys
|
|
eval SSH_USER_HOME=~$MANILA_ZFSONLINUX_SSH_USERNAME
|
|
cat $STACK_HOME/.ssh/*.pub >> $SSH_USER_HOME/.ssh/authorized_keys
|
|
# Give ssh user sudo access
|
|
echo "$MANILA_ZFSONLINUX_SSH_USERNAME ALL=(ALL) NOPASSWD: ALL" | sudo tee -a /etc/sudoers > /dev/null
|
|
iniset $MANILA_CONF DEFAULT data_node_access_ip $MANILA_ZFSONLINUX_SERVICE_IP
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# Create cache dir
|
|
sudo mkdir -p $MANILA_AUTH_CACHE_DIR
|
|
sudo chown $STACK_USER $MANILA_AUTH_CACHE_DIR
|
|
rm -f $MANILA_AUTH_CACHE_DIR/*
|
|
}
|
|
|
|
# check_nfs_kernel_service_state_ubuntu- Make sure nfsd is running
|
|
function check_nfs_kernel_service_state_ubuntu {
|
|
# (aovchinnikov): Workaround for nfs-utils bug 1052264
|
|
if [[ $(sudo service nfs-kernel-server status &> /dev/null || echo 'fail') == 'fail' ]]; then
|
|
echo "Apparently nfsd is not running. Trying to fix that."
|
|
sudo mkdir -p "/media/nfsdonubuntuhelper"
|
|
# (aovchinnikov): shell wrapping is needed for cases when a file to be written
|
|
# is owned by root.
|
|
sudo sh -c "echo '/media/nfsdonubuntuhelper 127.0.0.1(ro)' >> /etc/exports"
|
|
sudo service nfs-kernel-server start
|
|
fi
|
|
if [[ $(sudo service nfs-kernel-server status &> /dev/null || echo 'fail') == 'fail' ]]; then
|
|
echo "Failed to start nfsd. Exiting."
|
|
exit 1
|
|
fi
|
|
}
|
|
|
|
function _install_nfs_and_samba {
|
|
if is_ubuntu; then
|
|
install_package nfs-kernel-server nfs-common samba
|
|
check_nfs_kernel_service_state_ubuntu
|
|
elif is_fedora; then
|
|
install_package nfs-utils samba
|
|
sudo systemctl enable smb.service
|
|
sudo systemctl start smb.service
|
|
sudo systemctl enable nfs-server.service
|
|
sudo systemctl start nfs-server.service
|
|
elif is_suse; then
|
|
install_package nfs-kernel-server nfs-utils samba
|
|
else
|
|
echo "This distro is not supported. Skipping step of NFS and Samba installation."
|
|
fi
|
|
}
|
|
|
|
# install_manilaclient - Collect source and prepare
|
|
# In order to install from git, add LIBS_FROM_GIT="python-manilaclient"
|
|
# to local.conf
|
|
function install_manilaclient {
|
|
if use_library_from_git "python-manilaclient"; then
|
|
git_clone $MANILACLIENT_REPO $MANILACLIENT_DIR $MANILACLIENT_BRANCH
|
|
setup_develop $MANILACLIENT_DIR
|
|
else
|
|
pip_install python-manilaclient
|
|
fi
|
|
}
|
|
|
|
# install_manila - Collect source and prepare
|
|
function install_manila {
|
|
setup_develop $MANILA_DIR
|
|
|
|
if is_service_enabled m-shr; then
|
|
|
|
if [[ ! $(systemctl is-active nfs-ganesha.service) == 'active' ]]; then
|
|
_install_nfs_and_samba
|
|
fi
|
|
|
|
if [ "$SHARE_DRIVER" == "manila.share.drivers.zfsonlinux.driver.ZFSonLinuxShareDriver" ]; then
|
|
if [[ $(sudo zfs list &> /dev/null && sudo zpool list &> /dev/null || echo 'absent') == 'absent' ]]; then
|
|
# ZFS not found, try to install it
|
|
if is_ubuntu; then
|
|
if [[ $(lsb_release -s -d) == *"14.04"* ]]; then
|
|
# Trusty
|
|
sudo apt-get install -y software-properties-common
|
|
sudo apt-add-repository --yes ppa:zfs-native/stable
|
|
|
|
# Workaround for bug #1609696
|
|
sudo apt-mark hold grub*
|
|
|
|
sudo apt-get -y -q update && sudo apt-get -y -q upgrade
|
|
|
|
# Workaround for bug #1609696
|
|
sudo apt-mark unhold grub*
|
|
|
|
sudo apt-get install -y linux-headers-generic
|
|
sudo apt-get install -y build-essential
|
|
sudo apt-get install -y ubuntu-zfs
|
|
|
|
elif [[ $(echo $(lsb_release -rs) '>=' 16.04 | bc -l) == 1 ]]; then
|
|
# Xenial and beyond
|
|
sudo apt-get install -y zfsutils-linux
|
|
else
|
|
echo "Only 'Trusty', 'Xenial' and newer releases of Ubuntu are supported."
|
|
exit 1
|
|
fi
|
|
else
|
|
echo "Manila Devstack plugin supports installation "\
|
|
"of ZFS packages only for 'Ubuntu' distros. "\
|
|
"Please, install it first by other means or add its support "\
|
|
"for your distro."
|
|
exit 1
|
|
fi
|
|
sudo modprobe zfs
|
|
sudo modprobe zpool
|
|
fi
|
|
check_nfs_kernel_service_state_ubuntu
|
|
elif [ "$SHARE_DRIVER" == $MANILA_CONTAINER_DRIVER ]; then
|
|
if is_ubuntu; then
|
|
echo "Installing docker...."
|
|
install_docker_ubuntu
|
|
echo "Importing docker image"
|
|
import_docker_service_image_ubuntu
|
|
elif is_fedora; then
|
|
echo "Installing docker...."
|
|
install_docker_fedora
|
|
echo "Importing docker image"
|
|
# TODO(tbarron): See if using a fedora container image
|
|
# is faster/smaller because of fewer extra dependencies.
|
|
import_docker_service_image_ubuntu
|
|
else
|
|
echo "Manila Devstack plugin does not support Container Driver on"\
|
|
" distros other than Ubuntu or Fedora."
|
|
exit 1
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
}
|
|
|
|
#configure_samba - Configure node as Samba server
|
|
function configure_samba {
|
|
if [ "$SHARE_DRIVER" == "manila.share.drivers.lvm.LVMShareDriver" ]; then
|
|
# TODO(vponomaryov): add here condition for ZFSonLinux driver too
|
|
# when it starts to support SAMBA
|
|
samba_daemon_name=smbd
|
|
if is_service_enabled m-shr; then
|
|
if is_fedora; then
|
|
samba_daemon_name=smb
|
|
fi
|
|
sudo service $samba_daemon_name restart || echo "Couldn't restart '$samba_daemon_name' service"
|
|
fi
|
|
|
|
if [[ -e /usr/share/samba/smb.conf ]]; then
|
|
sudo cp /usr/share/samba/smb.conf $SMB_CONF
|
|
fi
|
|
sudo chown $STACK_USER -R /etc/samba
|
|
iniset $SMB_CONF global include registry
|
|
iniset $SMB_CONF global security user
|
|
if [ ! -d "$SMB_PRIVATE_DIR" ]; then
|
|
sudo mkdir $SMB_PRIVATE_DIR
|
|
sudo touch $SMB_PRIVATE_DIR/secrets.tdb
|
|
fi
|
|
|
|
for backend_name in ${MANILA_ENABLED_BACKENDS//,/ }; do
|
|
iniset $MANILA_CONF $backend_name driver_handles_share_servers False
|
|
iniset $MANILA_CONF $backend_name lvm_share_export_ips $MANILA_LVM_SHARE_EXPORT_IPS
|
|
done
|
|
iniset $MANILA_CONF DEFAULT data_node_access_ip $HOST_IP
|
|
fi
|
|
}
|
|
|
|
# start_manila_api - starts manila API services and checks its availability
|
|
function start_manila_api {
|
|
if [ $(trueorfalse False MANILA_USE_MOD_WSGI) == True ]; then
|
|
install_apache_wsgi
|
|
enable_apache_site manila-api
|
|
restart_apache_server
|
|
tail_log m-api /var/log/$APACHE_NAME/manila_api.log
|
|
else
|
|
run_process m-api "$MANILA_BIN_DIR/manila-api --config-file $MANILA_CONF"
|
|
fi
|
|
|
|
echo "Waiting for Manila API to start..."
|
|
if ! wait_for_service $SERVICE_TIMEOUT $MANILA_SERVICE_PROTOCOL://$MANILA_SERVICE_HOST:$MANILA_SERVICE_PORT; then
|
|
die $LINENO "Manila API did not start"
|
|
fi
|
|
|
|
# Start proxies if enabled
|
|
if is_service_enabled tls-proxy; then
|
|
start_tls_proxy '*' $MANILA_SERVICE_PORT $MANILA_SERVICE_HOST $MANILA_SERVICE_PORT_INT &
|
|
fi
|
|
}
|
|
|
|
# start_rest_of_manila - starts non-api manila services
|
|
function start_rest_of_manila {
|
|
run_process m-shr "$MANILA_BIN_DIR/manila-share --config-file $MANILA_CONF"
|
|
run_process m-sch "$MANILA_BIN_DIR/manila-scheduler --config-file $MANILA_CONF"
|
|
run_process m-dat "$MANILA_BIN_DIR/manila-data --config-file $MANILA_CONF"
|
|
}
|
|
|
|
# start_manila - start all manila services. This function is kept for compatibility
|
|
# reasons with old approach.
|
|
function start_manila {
|
|
start_manila_api
|
|
start_rest_of_manila
|
|
}
|
|
|
|
# stop_manila - Stop running processes
|
|
function stop_manila {
|
|
# Disable manila api service
|
|
if [ $(trueorfalse False MANILA_USE_MOD_WSGI) == True ]; then
|
|
disable_apache_site manila-api
|
|
restart_apache_server
|
|
else
|
|
stop_process m-api
|
|
fi
|
|
|
|
# Kill all other manila processes
|
|
for serv in m-sch m-shr m-dat; do
|
|
stop_process $serv
|
|
done
|
|
}
|
|
|
|
function install_manila_tempest_plugin {
|
|
MANILA_TEMPEST_PLUGIN_REPO=${MANILA_TEMPEST_PLUGIN_REPO:-${GIT_BASE}/openstack/manila-tempest-plugin.git}
|
|
MANILA_TEMPEST_PLUGIN_BRANCH=${MANILA_TEMPEST_PLUGIN_BRANCH:-master}
|
|
MANILA_TEMPEST_PLUGIN_DIR=$DEST/manila-tempest-plugin
|
|
|
|
git_clone $MANILA_TEMPEST_PLUGIN_REPO $MANILA_TEMPEST_PLUGIN_DIR $MANILA_TEMPEST_PLUGIN_BRANCH
|
|
setup_develop $MANILA_TEMPEST_PLUGIN_DIR
|
|
}
|
|
|
|
# update_tempest - Function used for updating Tempest config if Tempest service enabled
|
|
function update_tempest {
|
|
if is_service_enabled tempest; then
|
|
TEMPEST_CONFIG=${TEMPEST_CONFIG:-$TEMPEST_DIR/etc/tempest.conf}
|
|
ADMIN_TENANT_NAME=${ADMIN_TENANT_NAME:-"admin"}
|
|
ADMIN_DOMAIN_NAME=${ADMIN_DOMAIN_NAME:-"Default"}
|
|
ADMIN_PASSWORD=${ADMIN_PASSWORD:-"secretadmin"}
|
|
|
|
if [ $(trueorfalse False MANILA_USE_SERVICE_INSTANCE_PASSWORD) == True ]; then
|
|
iniset $TEMPEST_CONFIG share image_password $MANILA_SERVICE_INSTANCE_PASSWORD
|
|
fi
|
|
iniset $TEMPEST_CONFIG share image_with_share_tools $MANILA_SERVICE_IMAGE_NAME
|
|
iniset $TEMPEST_CONFIG auth admin_username ${ADMIN_USERNAME:-"admin"}
|
|
iniset $TEMPEST_CONFIG auth admin_password ${ADMIN_PASSWORD:-"secretadmin"}
|
|
iniset $TEMPEST_CONFIG auth admin_tenant_name $ADMIN_TENANT_NAME
|
|
iniset $TEMPEST_CONFIG auth admin_domain_name $ADMIN_DOMAIN_NAME
|
|
iniset $TEMPEST_CONFIG identity username ${TEMPEST_USERNAME:-"demo"}
|
|
iniset $TEMPEST_CONFIG identity password $ADMIN_PASSWORD
|
|
iniset $TEMPEST_CONFIG identity tenant_name ${TEMPEST_TENANT_NAME:-"demo"}
|
|
iniset $TEMPEST_CONFIG identity domain_name $ADMIN_DOMAIN_NAME
|
|
iniset $TEMPEST_CONFIG identity alt_username ${ALT_USERNAME:-"alt_demo"}
|
|
iniset $TEMPEST_CONFIG identity alt_password $ADMIN_PASSWORD
|
|
iniset $TEMPEST_CONFIG identity alt_tenant_name ${ALT_TENANT_NAME:-"alt_demo"}
|
|
iniset $TEMPEST_CONFIG identity alt_domain_name $ADMIN_DOMAIN_NAME
|
|
fi
|
|
}
|
|
|
|
function install_docker_ubuntu {
|
|
sudo apt-get update
|
|
install_package apparmor
|
|
install_package docker.io
|
|
}
|
|
|
|
function install_docker_fedora {
|
|
sudo yum install -y docker
|
|
sudo systemctl enable docker
|
|
sudo systemctl start docker
|
|
}
|
|
|
|
function download_image {
|
|
local image_url=$1
|
|
|
|
local image image_fname
|
|
|
|
image_fname=`basename "$image_url"`
|
|
if [[ $image_url != file* ]]; then
|
|
# Downloads the image (uec ami+akistyle), then extracts it.
|
|
if [[ ! -f $FILES/$image_fname || "$(stat -c "%s" $FILES/$image_fname)" = "0" ]]; then
|
|
wget --progress=dot:giga -c $image_url -O $FILES/$image_fname
|
|
if [[ $? -ne 0 ]]; then
|
|
echo "Not found: $image_url"
|
|
return
|
|
fi
|
|
fi
|
|
image="$FILES/${image_fname}"
|
|
else
|
|
# File based URL (RFC 1738): ``file://host/path``
|
|
# Remote files are not considered here.
|
|
# unix: ``file:///home/user/path/file``
|
|
# windows: ``file:///C:/Documents%20and%20Settings/user/path/file``
|
|
image=$(echo $image_url | sed "s/^file:\/\///g")
|
|
if [[ ! -f $image || "$(stat -c "%s" $image)" == "0" ]]; then
|
|
echo "Not found: $image_url"
|
|
return
|
|
fi
|
|
fi
|
|
}
|
|
|
|
function import_docker_service_image_ubuntu {
|
|
GZIPPED_IMG_NAME=`basename "$MANILA_DOCKER_IMAGE_URL"`
|
|
IMG_NAME_LOAD=${GZIPPED_IMG_NAME%.*}
|
|
LOCAL_IMG_NAME=${IMG_NAME_LOAD%.*}
|
|
if [[ "$(sudo docker images -q $LOCAL_IMG_NAME)" == "" ]]; then
|
|
download_image $MANILA_DOCKER_IMAGE_URL
|
|
# Import image in Docker
|
|
gzip -d $FILES/$GZIPPED_IMG_NAME
|
|
sudo docker load --input $FILES/$IMG_NAME_LOAD
|
|
fi
|
|
}
|
|
|
|
function remove_docker_service_image {
|
|
sudo docker rmi $MANILA_DOCKER_IMAGE_ALIAS
|
|
}
|
|
|
|
|
|
function install_libraries {
|
|
if [ $(trueorfalse False MANILA_MULTI_BACKEND) == True ]; then
|
|
if [ $(trueorfalse True RUN_MANILA_HOST_ASSISTED_MIGRATION_TESTS) == True ]; then
|
|
if is_ubuntu; then
|
|
install_package nfs-common
|
|
else
|
|
install_package nfs-utils
|
|
fi
|
|
fi
|
|
fi
|
|
}
|
|
|
|
function setup_ipv6 {
|
|
|
|
# save IPv6 default route to add back later after enabling forwarding
|
|
local default_route=$(ip -6 route | grep default | cut -d ' ' -f1,2,3,4,5)
|
|
|
|
# make sure those system values are set
|
|
sudo sysctl -w net.ipv6.conf.lo.disable_ipv6=0
|
|
sudo sysctl -w net.ipv6.conf.all.accept_ra=2
|
|
sudo sysctl -w net.ipv6.conf.all.forwarding=1
|
|
|
|
# Disable in-band as our communication is only internal
|
|
sudo ovs-vsctl set Bridge $PUBLIC_BRIDGE other_config:disable-in-band=true
|
|
|
|
# Create address scopes and subnet pools
|
|
openstack address scope create --share --ip-version 4 scope-v4
|
|
openstack address scope create --share --ip-version 6 scope-v6
|
|
openstack subnet pool create $SUBNETPOOL_NAME_V4 --default-prefix-length $SUBNETPOOL_SIZE_V4 --pool-prefix $SUBNETPOOL_PREFIX_V4 --address-scope scope-v4 --default --share
|
|
openstack subnet pool create $SUBNETPOOL_NAME_V6 --default-prefix-length $SUBNETPOOL_SIZE_V6 --pool-prefix $SUBNETPOOL_PREFIX_V6 --address-scope scope-v6 --default --share
|
|
|
|
# Create example private network and router
|
|
openstack router create $Q_ROUTER_NAME
|
|
openstack network create $PRIVATE_NETWORK_NAME
|
|
openstack subnet create --ip-version 6 --use-default-subnet-pool --ipv6-address-mode $IPV6_ADDRESS_MODE --ipv6-ra-mode $IPV6_RA_MODE --network $PRIVATE_NETWORK_NAME $IPV6_PRIVATE_SUBNET_NAME
|
|
openstack subnet create --ip-version 4 --use-default-subnet-pool --network $PRIVATE_NETWORK_NAME $PRIVATE_SUBNET_NAME
|
|
openstack router add subnet $Q_ROUTER_NAME $IPV6_PRIVATE_SUBNET_NAME
|
|
openstack router add subnet $Q_ROUTER_NAME $PRIVATE_SUBNET_NAME
|
|
|
|
# Create public network
|
|
openstack network create $PUBLIC_NETWORK_NAME --external --default --provider-network-type flat --provider-physical-network $PUBLIC_PHYSICAL_NETWORK
|
|
local public_gateway_ipv6=$(openstack subnet create $IPV6_PUBLIC_SUBNET_NAME --ip-version 6 --network $PUBLIC_NETWORK_NAME --subnet-pool $SUBNETPOOL_NAME_V6 --no-dhcp -c gateway_ip -f value)
|
|
local public_gateway_ipv4=$(openstack subnet create $PUBLIC_SUBNET_NAME --ip-version 4 --network $PUBLIC_NETWORK_NAME --subnet-range $FLOATING_RANGE --no-dhcp -c gateway_ip -f value)
|
|
|
|
# Set router to use public network
|
|
openstack router set --external-gateway $PUBLIC_NETWORK_NAME $Q_ROUTER_NAME
|
|
|
|
# Configure interfaces due to NEUTRON_CREATE_INITIAL_NETWORKS=False
|
|
local ipv4_cidr_len=${FLOATING_RANGE#*/}
|
|
sudo ip -6 addr add "$public_gateway_ipv6"/$SUBNETPOOL_SIZE_V6 dev $PUBLIC_BRIDGE
|
|
sudo ip addr add $PUBLIC_NETWORK_GATEWAY/"$ipv4_cidr_len" dev $PUBLIC_BRIDGE
|
|
|
|
# Enabling interface is needed due to NEUTRON_CREATE_INITIAL_NETWORKS=False
|
|
sudo ip link set $PUBLIC_BRIDGE up
|
|
|
|
if [ "$SHARE_DRIVER" == "manila.share.drivers.lvm.LVMShareDriver" ]; then
|
|
for backend_name in ${MANILA_ENABLED_BACKENDS//,/ }; do
|
|
iniset $MANILA_CONF $backend_name lvm_share_export_ips $public_gateway_ipv4,$public_gateway_ipv6
|
|
done
|
|
iniset $MANILA_CONF DEFAULT data_node_access_ip $public_gateway_ipv4
|
|
fi
|
|
|
|
# install Quagga for setting up the host routes dynamically
|
|
install_package quagga
|
|
|
|
# set Quagga daemons
|
|
(
|
|
echo "zebra=yes"
|
|
echo "bgpd=yes"
|
|
echo "ospfd=no"
|
|
echo "ospf6d=no"
|
|
echo "ripd=no"
|
|
echo "ripngd=no"
|
|
echo "isisd=no"
|
|
echo "babeld=no"
|
|
) | sudo tee /etc/quagga/daemons > /dev/null
|
|
|
|
# set Quagga zebra.conf
|
|
(
|
|
echo "hostname dsvm"
|
|
echo "password openstack"
|
|
echo "log file /var/log/quagga/zebra.log"
|
|
) | sudo tee /etc/quagga/zebra.conf > /dev/null
|
|
|
|
# set Quagga vtysh.conf
|
|
(
|
|
echo "service integrated-vtysh-config"
|
|
echo "username quagga nopassword"
|
|
) | sudo tee /etc/quagga/vtysh.conf > /dev/null
|
|
|
|
# set Quagga bgpd.conf
|
|
(
|
|
echo "log file /var/log/quagga/bgpd.log"
|
|
echo "bgp multiple-instance"
|
|
echo "router bgp 200"
|
|
echo " bgp router-id 1.2.3.4"
|
|
echo " neighbor $public_gateway_ipv6 remote-as 100"
|
|
echo " neighbor $public_gateway_ipv6 passive"
|
|
echo " address-family ipv6"
|
|
echo " neighbor $public_gateway_ipv6 activate"
|
|
echo "line vty"
|
|
echo "debug bgp events"
|
|
echo "debug bgp filters"
|
|
echo "debug bgp fsm"
|
|
echo "debug bgp keepalives"
|
|
echo "debug bgp updates"
|
|
) | sudo tee /etc/quagga/bgpd.conf > /dev/null
|
|
|
|
# Quagga logging
|
|
sudo mkdir -p /var/log/quagga
|
|
sudo touch /var/log/quagga/zebra.log
|
|
sudo touch /var/log/quagga/bgpd.log
|
|
sudo chown -R quagga:quagga /var/log/quagga
|
|
|
|
|
|
GetOSVersion
|
|
QUAGGA_SERVICES="zebra bgpd"
|
|
if [[ is_ubuntu && "$os_CODENAME" == "xenial" ]]; then
|
|
# In Ubuntu Xenial, the services bgpd and zebra are under
|
|
# one systemd unit: quagga
|
|
QUAGGA_SERVICES="quagga"
|
|
elif is_fedora; then
|
|
# Disable SELinux rule that conflicts with Zebra
|
|
sudo setsebool -P zebra_write_config 1
|
|
fi
|
|
sudo systemctl enable $QUAGGA_SERVICES
|
|
sudo systemctl restart $QUAGGA_SERVICES
|
|
|
|
# log the systemd status
|
|
sudo systemctl status $QUAGGA_SERVICES
|
|
|
|
# add default IPv6 route back
|
|
if ! [[ -z $default_route ]]; then
|
|
# "replace" should ignore "RTNETLINK answers: File exists"
|
|
# error if the route wasn't flushed by the bgp setup we did earlier.
|
|
sudo ip -6 route replace $default_route
|
|
fi
|
|
|
|
}
|
|
|
|
# Main dispatcher
|
|
if [[ "$1" == "stack" && "$2" == "install" ]]; then
|
|
echo_summary "Installing Manila Client"
|
|
install_manilaclient
|
|
echo_summary "Installing Manila"
|
|
install_manila
|
|
set_cinder_quotas
|
|
elif [[ "$1" == "stack" && "$2" == "post-config" ]]; then
|
|
echo_summary "Configuring Manila"
|
|
configure_manila
|
|
echo_summary "Initializing Manila"
|
|
init_manila
|
|
echo_summary "Installing extra libraries"
|
|
install_libraries
|
|
echo_summary "Creating Manila entities for auth service"
|
|
create_manila_accounts
|
|
|
|
# Cinder config update
|
|
if is_service_enabled cinder && [[ -n "$CINDER_OVERSUBSCRIPTION_RATIO" ]]; then
|
|
CINDER_CONF=${CINDER_CONF:-/etc/cinder/cinder.conf}
|
|
CINDER_ENABLED_BACKENDS=$(iniget $CINDER_CONF DEFAULT enabled_backends)
|
|
for BN in ${CINDER_ENABLED_BACKENDS//,/ }; do
|
|
iniset $CINDER_CONF $BN lvm_max_over_subscription_ratio $CINDER_OVERSUBSCRIPTION_RATIO
|
|
done
|
|
iniset $CINDER_CONF DEFAULT max_over_subscription_ratio $CINDER_OVERSUBSCRIPTION_RATIO
|
|
fi
|
|
elif [[ "$1" == "stack" && "$2" == "extra" ]]; then
|
|
if is_service_enabled nova; then
|
|
echo_summary "Creating Manila service flavor"
|
|
create_manila_service_flavor
|
|
|
|
echo_summary "Creating Manila service security group"
|
|
create_manila_service_secgroup
|
|
fi
|
|
|
|
# Skip image downloads when disabled.
|
|
# This way vendor Manila driver CI tests can skip
|
|
# this potentially long and unnecessary download.
|
|
if [ "$MANILA_SERVICE_IMAGE_ENABLED" = "True" ]; then
|
|
echo_summary "Creating Manila service image"
|
|
create_manila_service_image
|
|
else
|
|
echo_summary "Skipping download of Manila service image"
|
|
fi
|
|
|
|
if is_service_enabled nova; then
|
|
echo_summary "Creating Manila service keypair"
|
|
create_manila_service_keypair
|
|
fi
|
|
|
|
echo_summary "Configure Samba server"
|
|
configure_samba
|
|
|
|
echo_summary "Configuring IPv6"
|
|
if [ $(trueorfalse False MANILA_SETUP_IPV6) == True ]; then
|
|
setup_ipv6
|
|
fi
|
|
|
|
echo_summary "Starting Manila API"
|
|
start_manila_api
|
|
|
|
# Workaround for bug #1660304
|
|
if [ "$SHARE_DRIVER" != "manila.share.drivers.generic.GenericShareDriver" ]; then
|
|
echo_summary "Starting rest of Manila services - scheduler, share and data"
|
|
start_rest_of_manila
|
|
fi
|
|
|
|
echo_summary "Creating Manila default share type"
|
|
create_default_share_type
|
|
|
|
echo_summary "Creating Manila default share group type"
|
|
create_default_share_group_type
|
|
|
|
echo_summary "Creating Manila custom share types"
|
|
create_custom_share_types
|
|
|
|
echo_summary "Manila UI is no longer enabled by default. \
|
|
Add enable_plugin manila-ui https://git.openstack.org/openstack/manila-ui \
|
|
to your local.conf file to enable Manila UI"
|
|
|
|
elif [[ "$1" == "stack" && "$2" == "test-config" ]]; then
|
|
###########################################################################
|
|
# NOTE(vponomaryov): Workaround for bug #1660304
|
|
# We are able to create Nova VMs now only when last Nova step is performed
|
|
# which is registration of cell0. It is registered as last action in
|
|
# "post-extra" section.
|
|
if is_service_enabled nova; then
|
|
echo_summary "Creating Manila service VMs for generic driver \
|
|
backends for which handlng of share servers is disabled."
|
|
create_service_share_servers
|
|
fi
|
|
|
|
if [ "$SHARE_DRIVER" == "manila.share.drivers.generic.GenericShareDriver" ]; then
|
|
echo_summary "Starting rest of Manila services - scheduler, share and data"
|
|
start_rest_of_manila
|
|
fi
|
|
###########################################################################
|
|
|
|
echo_summary "Fetching and installing manila-tempest-plugin system-wide"
|
|
install_manila_tempest_plugin
|
|
echo_summary "Update Tempest config"
|
|
update_tempest
|
|
fi
|
|
|
|
if [[ "$1" == "unstack" ]]; then
|
|
cleanup_manila
|
|
fi
|
|
|
|
if [[ "$1" == "clean" ]]; then
|
|
cleanup_manila
|
|
sudo rm -rf /etc/manila
|
|
fi
|
|
|
|
# Restore xtrace
|
|
$XTRACE
|