pax_global_header00006660000000000000000000000064120730767050014521gustar00rootroot0000000000000052 comment=4debb1f8eb57ef035fec1cb4250d5316d51a3adf devstack-diablo-eol/000077500000000000000000000000001207307670500146765ustar00rootroot00000000000000devstack-diablo-eol/.gitignore000066400000000000000000000000331207307670500166620ustar00rootroot00000000000000proto *~ *.log src localrc devstack-diablo-eol/.gitreview000066400000000000000000000001211207307670500166760ustar00rootroot00000000000000[gerrit] host=review.openstack.org port=29418 project=openstack-dev/devstack.git devstack-diablo-eol/AUTHORS000066400000000000000000000012521207307670500157460ustar00rootroot00000000000000Andy Smith Anthony Young Brad Hall Chmouel Boudjnah Dean Troyer Devin Carlen Eddie Hebert Jake Dahn James E. Blair Jason Cannavale Jay Pipes Jesse Andrews Justin Shepherd Kiall Mac Innes Scott Moser Todd Willey Tres Henry Vishvananda Ishaya Yun Mao devstack-diablo-eol/README.md000066400000000000000000000025731207307670500161640ustar00rootroot00000000000000Tool to quickly deploy openstack dev environments. # Goals * To quickly build dev openstack environments in clean oneiric environments * To describe working configurations of openstack (which code branches work together? what do config files look like for those branches?) * To make it easier for developers to dive into openstack so that they can productively contribute without having to understand every part of the system at once * To make it easy to prototype cross-project features Read more at http://devstack.org (built from the gh-pages branch) Be sure to carefully read these scripts before you run them as they install software and may alter your networking configuration. # To start a dev cloud on your local machine (installing on a dedicated vm is safer!): ./stack.sh If working correctly, you should be able to access openstack endpoints, like: * Horizon: http://myhost/ * Keystone: http://myhost:5000/v2.0/ # Customizing You can tweak environment variables by creating file name 'localrc' should you need to override defaults. It is likely that you will need to do this to tweak your networking configuration should you need to access your cloud from a different host. # Todo * Add python-novaclient cli support * syslog * Add volume support * Add quantum support # Future * idea: move from screen to tmux? * idea: create a live-cd / vmware preview image using this? devstack-diablo-eol/exercise.sh000077500000000000000000000023161207307670500170460ustar00rootroot00000000000000#!/usr/bin/env bash source ./stackrc # Run everything in the exercises/ directory that isn't explicitly disabled # comma separated list of script basenames to skip # to refrain from exercising euca.sh use SKIP_EXERCISES=euca SKIP_EXERCISES=${SKIP_EXERCISES:-""} # Locate the scripts we should run EXERCISE_DIR=$(dirname "$0")/exercises basenames=$(for b in `ls $EXERCISE_DIR/*.sh`; do basename $b .sh; done) # Track the state of each script passes="" failures="" skips="" # Loop over each possible script (by basename) for script in $basenames; do if [[ "$SKIP_EXERCISES" =~ $script ]] ; then skips="$skips $script" else echo ========================= echo Running $script echo ========================= $EXERCISE_DIR/$script.sh if [[ $? -ne 0 ]] ; then failures="$failures $script" else passes="$passes $script" fi fi done # output status of exercise run echo ========================= echo ========================= for script in $skips; do echo SKIP $script done for script in $passes; do echo PASS $script done for script in $failures; do echo FAILED $script done if [ -n "$failures" ] ; then exit 1 fi devstack-diablo-eol/exercises/000077500000000000000000000000001207307670500166705ustar00rootroot00000000000000devstack-diablo-eol/exercises/euca.sh000077500000000000000000000017551207307670500201540ustar00rootroot00000000000000#!/usr/bin/env bash # we will use the ``euca2ools`` cli tool that wraps the python boto # library to test ec2 compatibility # # This script exits on an error so that errors don't compound and you see # only the first error that occured. set -o errexit # Print the commands being run so that we can see the command that triggers # an error. It is also useful for following allowing as the install occurs. set -o xtrace # Settings # ======== # Use openrc + stackrc + localrc for settings pushd $(cd $(dirname "$0")/.. && pwd) source ./openrc popd # find a machine image to boot IMAGE=`euca-describe-images | grep machine | cut -f2` # launch it INSTANCE=`euca-run-instances $IMAGE | grep INSTANCE | cut -f2` # assure it has booted within a reasonable time if ! timeout $RUNNING_TIMEOUT sh -c "while euca-describe-instances $INSTANCE | grep -q running; do sleep 1; done"; then echo "server didn't become active within $RUNNING_TIMEOUT seconds" exit 1 fi euca-terminate-instances $INSTANCE devstack-diablo-eol/exercises/floating_ips.sh000077500000000000000000000114441207307670500217110ustar00rootroot00000000000000#!/usr/bin/env bash # **exercise.sh** - using the cloud can be fun # we will use the ``nova`` cli tool provided by the ``python-novaclient`` # package # # This script exits on an error so that errors don't compound and you see # only the first error that occured. set -o errexit # Print the commands being run so that we can see the command that triggers # an error. It is also useful for following allowing as the install occurs. set -o xtrace # Settings # ======== # Use openrc + stackrc + localrc for settings pushd $(cd $(dirname "$0")/.. && pwd) source ./openrc popd # Get a token for clients that don't support service catalog # ========================================================== # manually create a token by querying keystone (sending JSON data). Keystone # returns a token and catalog of endpoints. We use python to parse the token # and save it. TOKEN=`curl -s -d "{\"auth\":{\"passwordCredentials\": {\"username\": \"$NOVA_USERNAME\", \"password\": \"$NOVA_PASSWORD\"}}}" -H "Content-type: application/json" http://$HOST_IP:5000/v2.0/tokens | python -c "import sys; import json; tok = json.loads(sys.stdin.read()); print tok['access']['token']['id'];"` # Launching a server # ================== # List servers for tenant: nova list # Images # ------ # Nova has a **deprecated** way of listing images. nova image-list # But we recommend using glance directly glance -A $TOKEN index # Let's grab the id of the first AMI image to launch IMAGE=`glance -A $TOKEN index | egrep ami | cut -d" " -f1` # Security Groups # --------------- SECGROUP=test_secgroup # List of secgroups: nova secgroup-list # Create a secgroup nova secgroup-create $SECGROUP "test_secgroup description" # determine flavor # ---------------- # List of flavors: nova flavor-list # and grab the first flavor in the list to launch FLAVOR=`nova flavor-list | head -n 4 | tail -n 1 | cut -d"|" -f2` NAME="myserver" nova boot --flavor $FLAVOR --image $IMAGE $NAME --security_groups=$SECGROUP # Testing # ======= # First check if it spins up (becomes active and responds to ping on # internal ip). If you run this script from a nova node, you should # bypass security groups and have direct access to the server. # Waiting for boot # ---------------- # Max time to wait while vm goes from build to active state ACTIVE_TIMEOUT=${ACTIVE_TIMEOUT:-10} # Max time till the vm is bootable BOOT_TIMEOUT=${BOOT_TIMEOUT:-15} # Max time to wait for proper association and dis-association. ASSOCIATE_TIMEOUT=${ASSOCIATE_TIMEOUT:-10} # check that the status is active within ACTIVE_TIMEOUT seconds if ! timeout $ACTIVE_TIMEOUT sh -c "while ! nova show $NAME | grep status | grep -q ACTIVE; do sleep 1; done"; then echo "server didn't become active!" exit 1 fi # get the IP of the server IP=`nova show $NAME | grep "private network" | cut -d"|" -f3` # for single node deployments, we can ping private ips MULTI_HOST=${MULTI_HOST:-0} if [ "$MULTI_HOST" = "0" ]; then # sometimes the first ping fails (10 seconds isn't enough time for the VM's # network to respond?), so let's ping for a default of 15 seconds with a # timeout of a second for each ping. if ! timeout $BOOT_TIMEOUT sh -c "while ! ping -c1 -w1 $IP; do sleep 1; done"; then echo "Couldn't ping server" exit 1 fi else # On a multi-host system, without vm net access, do a sleep to wait for the boot sleep $BOOT_TIMEOUT fi # Security Groups & Floating IPs # ------------------------------ # allow icmp traffic (ping) nova secgroup-add-rule $SECGROUP icmp -1 -1 0.0.0.0/0 # List rules for a secgroup nova secgroup-list-rules $SECGROUP # allocate a floating ip nova floating-ip-create # store floating address FLOATING_IP=`nova floating-ip-list | grep None | head -1 | cut -d '|' -f2 | sed 's/ //g'` # add floating ip to our server nova add-floating-ip $NAME $FLOATING_IP # test we can ping our floating ip within ASSOCIATE_TIMEOUT seconds if ! timeout $ASSOCIATE_TIMEOUT sh -c "while ! ping -c1 -w1 $FLOATING_IP; do sleep 1; done"; then echo "Couldn't ping server with floating ip" exit 1 fi # dis-allow icmp traffic (ping) nova secgroup-delete-rule $SECGROUP icmp -1 -1 0.0.0.0/0 # FIXME (anthony): make xs support security groups if [ "$VIRT_DRIVER" != "xenserver" ]; then # test we can aren't able to ping our floating ip within ASSOCIATE_TIMEOUT seconds if ! timeout $ASSOCIATE_TIMEOUT sh -c "while ping -c1 -w1 $FLOATING_IP; do sleep 1; done"; then print "Security group failure - ping should not be allowed!" echo "Couldn't ping server with floating ip" exit 1 fi fi # de-allocate the floating ip nova floating-ip-delete $FLOATING_IP # shutdown the server nova delete $NAME # Delete a secgroup nova secgroup-delete $SECGROUP # FIXME: validate shutdown within 5 seconds # (nova show $NAME returns 1 or status != ACTIVE)? devstack-diablo-eol/exercises/swift.sh000077500000000000000000000023431207307670500203650ustar00rootroot00000000000000#!/usr/bin/env bash # Test swift via the command line tools that ship with it. # This script exits on an error so that errors don't compound and you see # only the first error that occured. set -o errexit # Print the commands being run so that we can see the command that triggers # an error. It is also useful for following allowing as the install occurs. set -o xtrace # Settings # ======== # Use openrc + stackrc + localrc for settings pushd $(cd $(dirname "$0")/.. && pwd) source ./openrc popd # Testing Swift # ============= # Check if we have to swift via keystone swift --auth-version 2 -A http://${HOST_IP}:5000/v2.0 -U admin -K $ADMIN_PASSWORD stat # We start by creating a test container swift --auth-version 2 -A http://${HOST_IP}:5000/v2.0 -U admin -K $ADMIN_PASSWORD post testcontainer # add some files into it. swift --auth-version 2 -A http://${HOST_IP}:5000/v2.0 -U admin -K $ADMIN_PASSWORD upload testcontainer /etc/issue # list them swift --auth-version 2 -A http://${HOST_IP}:5000/v2.0 -U admin -K $ADMIN_PASSWORD list testcontainer # And we may want to delete them now that we have tested that # everything works. swift --auth-version 2 -A http://${HOST_IP}:5000/v2.0 -U admin -K $ADMIN_PASSWORD delete testcontainer devstack-diablo-eol/files/000077500000000000000000000000001207307670500160005ustar00rootroot00000000000000devstack-diablo-eol/files/000-default.template000066400000000000000000000014431207307670500214600ustar00rootroot00000000000000 WSGIScriptAlias / %HORIZON_DIR%/openstack-dashboard/dashboard/wsgi/django.wsgi WSGIDaemonProcess horizon user=%USER% group=%USER% processes=3 threads=10 SetEnv APACHE_RUN_USER %USER% SetEnv APACHE_RUN_GROUP %USER% WSGIProcessGroup horizon DocumentRoot %HORIZON_DIR%/.blackhole/ Alias /media %HORIZON_DIR%/openstack-dashboard/media Alias /vpn /opt/stack/vpn Options FollowSymLinks AllowOverride None Options Indexes FollowSymLinks MultiViews AllowOverride None Order allow,deny allow from all ErrorLog /var/log/apache2/error.log LogLevel warn CustomLog /var/log/apache2/access.log combined devstack-diablo-eol/files/apts/000077500000000000000000000000001207307670500167475ustar00rootroot00000000000000devstack-diablo-eol/files/apts/general000066400000000000000000000003551207307670500203120ustar00rootroot00000000000000pep8 pylint python-pip screen unzip wget psmisc git lsof # useful when debugging openssh-server vim-nox locate # useful when debugging python-virtualenv python-unittest2 iputils-ping wget curl tcpdump euca2ools # only for testing client devstack-diablo-eol/files/apts/glance000066400000000000000000000001771207307670500201300ustar00rootroot00000000000000python-eventlet python-routes python-greenlet python-argparse python-sqlalchemy python-wsgiref python-pastedeploy python-xattr devstack-diablo-eol/files/apts/horizon000066400000000000000000000003401207307670500203570ustar00rootroot00000000000000apache2 # NOPRIME libapache2-mod-wsgi # NOPRIME python-dateutil python-paste python-pastedeploy python-anyjson python-routes python-xattr python-sqlalchemy python-webob python-kombu pylint pep8 python-eventlet python-nose devstack-diablo-eol/files/apts/keystone000066400000000000000000000003151207307670500205320ustar00rootroot00000000000000python-setuptools python-dev python-lxml python-pastescript python-pastedeploy python-paste sqlite3 python-pysqlite2 python-sqlalchemy python-webob python-greenlet python-routes libldap2-dev libsasl2-dev devstack-diablo-eol/files/apts/nova000066400000000000000000000015341207307670500176400ustar00rootroot00000000000000dnsmasq-base dnsmasq-utils # for dhcp_release only available in dist:oneiric kpartx parted arping # used for send_arp_for_ha option in nova-network mysql-server # NOPRIME python-mysqldb python-xattr # needed for glance which is needed for nova --- this shouldn't be here python-lxml # needed for glance which is needed for nova --- this shouldn't be here kvm gawk iptables ebtables sqlite3 sudo kvm libvirt-bin # NOPRIME vlan curl rabbitmq-server # NOPRIME socat # used by ajaxterm python-mox python-paste python-migrate python-gflags python-greenlet python-libvirt python-libxml2 python-routes python-netaddr python-pastedeploy python-eventlet python-cheetah python-carrot python-tempita python-sqlalchemy python-suds python-lockfile python-m2crypto python-boto python-kombu # Stuff for diablo volumes iscsitarget # NOPRIME iscsitarget-dkms # NOPRIME lvm2 devstack-diablo-eol/files/apts/novnc000066400000000000000000000000151207307670500200110ustar00rootroot00000000000000python-numpy devstack-diablo-eol/files/apts/swift000066400000000000000000000003501207307670500200240ustar00rootroot00000000000000curl gcc memcached # NOPRIME python-configobj python-coverage python-dev python-eventlet python-greenlet python-netifaces python-nose python-pastedeploy python-setuptools python-simplejson python-webob python-xattr sqlite3 xfsprogs devstack-diablo-eol/files/glance-api.conf000066400000000000000000000133611207307670500206530ustar00rootroot00000000000000[DEFAULT] # Show more verbose log output (sets INFO log level output) verbose = True # Show debugging output in logs (sets DEBUG log level output) debug = True # Which backend store should Glance use by default is not specified # in a request to add a new image to Glance? Default: 'file' # Available choices are 'file', 'swift', and 's3' default_store = file # Address to bind the API server bind_host = 0.0.0.0 # Port the bind the API server to bind_port = 9292 # Address to find the registry server registry_host = 0.0.0.0 # Port the registry server is listening on registry_port = 9191 # Log to this file. Make sure you do not set the same log # file for both the API and registry servers! #log_file = %DEST%/glance/api.log # Send logs to syslog (/dev/log) instead of to file specified by `log_file` use_syslog = %SYSLOG% # ============ Notification System Options ===================== # Notifications can be sent when images are create, updated or deleted. # There are three methods of sending notifications, logging (via the # log_file directive), rabbit (via a rabbitmq queue) or noop (no # notifications sent, the default) notifier_strategy = noop # Configuration options if sending notifications via rabbitmq (these are # the defaults) rabbit_host = localhost rabbit_port = 5672 rabbit_use_ssl = false rabbit_userid = guest rabbit_password = guest rabbit_virtual_host = / rabbit_notification_topic = glance_notifications # ============ Filesystem Store Options ======================== # Directory that the Filesystem backend store # writes image data to filesystem_store_datadir = %DEST%/glance/images/ # ============ Swift Store Options ============================= # Address where the Swift authentication service lives swift_store_auth_address = 127.0.0.1:8080/v1.0/ # User to authenticate against the Swift authentication service swift_store_user = jdoe # Auth key for the user authenticating against the # Swift authentication service swift_store_key = a86850deb2742ec3cb41518e26aa2d89 # Container within the account that the account should use # for storing images in Swift swift_store_container = glance # Do we create the container if it does not exist? swift_store_create_container_on_put = False # What size, in MB, should Glance start chunking image files # and do a large object manifest in Swift? By default, this is # the maximum object size in Swift, which is 5GB swift_store_large_object_size = 5120 # When doing a large object manifest, what size, in MB, should # Glance write chunks to Swift? This amount of data is written # to a temporary disk buffer during the process of chunking # the image file, and the default is 200MB swift_store_large_object_chunk_size = 200 # Whether to use ServiceNET to communicate with the Swift storage servers. # (If you aren't RACKSPACE, leave this False!) # # To use ServiceNET for authentication, prefix hostname of # `swift_store_auth_address` with 'snet-'. # Ex. https://example.com/v1.0/ -> https://snet-example.com/v1.0/ swift_enable_snet = False # ============ S3 Store Options ============================= # Address where the S3 authentication service lives s3_store_host = 127.0.0.1:8080/v1.0/ # User to authenticate against the S3 authentication service s3_store_access_key = <20-char AWS access key> # Auth key for the user authenticating against the # S3 authentication service s3_store_secret_key = <40-char AWS secret key> # Container within the account that the account should use # for storing images in S3. Note that S3 has a flat namespace, # so you need a unique bucket name for your glance images. An # easy way to do this is append your AWS access key to "glance". # S3 buckets in AWS *must* be lowercased, so remember to lowercase # your AWS access key if you use it in your bucket name below! s3_store_bucket = glance # Do we create the bucket if it does not exist? s3_store_create_bucket_on_put = False # ============ Image Cache Options ======================== image_cache_enabled = False # Directory that the Image Cache writes data to # Make sure this is also set in glance-pruner.conf image_cache_datadir = /var/lib/glance/image-cache/ # Number of seconds after which we should consider an incomplete image to be # stalled and eligible for reaping image_cache_stall_timeout = 86400 # ============ Delayed Delete Options ============================= # Turn on/off delayed delete delayed_delete = False # Delayed delete time in seconds scrub_time = 43200 # Directory that the scrubber will use to remind itself of what to delete # Make sure this is also set in glance-scrubber.conf scrubber_datadir = /var/lib/glance/scrubber [pipeline:glance-api] #pipeline = versionnegotiation context apiv1app # NOTE: use the following pipeline for keystone pipeline = versionnegotiation authtoken context apiv1app # To enable Image Cache Management API replace pipeline with below: # pipeline = versionnegotiation context imagecache apiv1app # NOTE: use the following pipeline for keystone auth (with caching) # pipeline = versionnegotiation authtoken context imagecache apiv1app [pipeline:versions] pipeline = versionsapp [app:versionsapp] paste.app_factory = glance.api.versions:app_factory [app:apiv1app] paste.app_factory = glance.api.v1:app_factory [filter:versionnegotiation] paste.filter_factory = glance.api.middleware.version_negotiation:filter_factory [filter:imagecache] paste.filter_factory = glance.api.middleware.image_cache:filter_factory [filter:context] paste.filter_factory = glance.common.context:filter_factory [filter:authtoken] paste.filter_factory = keystone.middleware.auth_token:filter_factory service_protocol = http service_host = 127.0.0.1 service_port = 5000 auth_host = 127.0.0.1 auth_port = 35357 auth_protocol = http auth_uri = http://127.0.0.1:5000/ admin_token = %SERVICE_TOKEN% devstack-diablo-eol/files/glance-registry.conf000066400000000000000000000044071207307670500217530ustar00rootroot00000000000000[DEFAULT] # Show more verbose log output (sets INFO log level output) verbose = True # Show debugging output in logs (sets DEBUG log level output) debug = True # Address to bind the registry server bind_host = 0.0.0.0 # Port the bind the registry server to bind_port = 9191 # Log to this file. Make sure you do not set the same log # file for both the API and registry servers! #log_file = %DEST%/glance/registry.log # Where to store images filesystem_store_datadir = %DEST%/glance/images # Send logs to syslog (/dev/log) instead of to file specified by `log_file` use_syslog = %SYSLOG% # SQLAlchemy connection string for the reference implementation # registry server. Any valid SQLAlchemy connection string is fine. # See: http://www.sqlalchemy.org/docs/05/reference/sqlalchemy/connections.html#sqlalchemy.create_engine sql_connection = %SQL_CONN% # Period in seconds after which SQLAlchemy should reestablish its connection # to the database. # # MySQL uses a default `wait_timeout` of 8 hours, after which it will drop # idle connections. This can result in 'MySQL Gone Away' exceptions. If you # notice this, you can lower this value to ensure that SQLAlchemy reconnects # before MySQL can drop the connection. sql_idle_timeout = 3600 # Limit the api to return `param_limit_max` items in a call to a container. If # a larger `limit` query param is provided, it will be reduced to this value. api_limit_max = 1000 # If a `limit` query param is not provided in an api request, it will # default to `limit_param_default` limit_param_default = 25 [pipeline:glance-registry] #pipeline = context registryapp # NOTE: use the following pipeline for keystone pipeline = authtoken keystone_shim context registryapp [app:registryapp] paste.app_factory = glance.registry.server:app_factory [filter:context] context_class = glance.registry.context.RequestContext paste.filter_factory = glance.common.context:filter_factory [filter:authtoken] paste.filter_factory = keystone.middleware.auth_token:filter_factory service_protocol = http service_host = 127.0.0.1 service_port = 5000 auth_host = 127.0.0.1 auth_port = 35357 auth_protocol = http auth_uri = http://127.0.0.1:5000/ admin_token = %SERVICE_TOKEN% [filter:keystone_shim] paste.filter_factory = keystone.middleware.glance_auth_token:filter_factory devstack-diablo-eol/files/horizon_settings.py000066400000000000000000000054511207307670500217670ustar00rootroot00000000000000import os DEBUG = True TEMPLATE_DEBUG = DEBUG PROD = False USE_SSL = False LOCAL_PATH = os.path.dirname(os.path.abspath(__file__)) # FIXME: We need to change this to mysql, instead of sqlite. DATABASES = { 'default': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': os.path.join(LOCAL_PATH, 'dashboard_openstack.sqlite3'), }, } CACHE_BACKEND = 'dummy://' # Add apps to horizon installation. INSTALLED_APPS = ( 'dashboard', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'django_openstack', 'django_openstack.templatetags', 'mailer', ) # Send email to the console by default EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend' # Or send them to /dev/null #EMAIL_BACKEND = 'django.core.mail.backends.dummy.EmailBackend' # django-mailer uses a different settings attribute MAILER_EMAIL_BACKEND = EMAIL_BACKEND # Configure these for your outgoing email host # EMAIL_HOST = 'smtp.my-company.com' # EMAIL_PORT = 25 # EMAIL_HOST_USER = 'djangomail' # EMAIL_HOST_PASSWORD = 'top-secret!' # FIXME: This needs to be changed to allow for multi-node setup. OPENSTACK_KEYSTONE_URL = "http://localhost:5000/v2.0/" OPENSTACK_KEYSTONE_ADMIN_URL = "http://localhost:35357/v2.0" OPENSTACK_KEYSTONE_DEFAULT_ROLE = "Member" # NOTE(tres): Available services should come from the service # catalog in Keystone. SWIFT_ENABLED = False # Configure quantum connection details for networking QUANTUM_ENABLED = False QUANTUM_URL = '127.0.0.1' QUANTUM_PORT = '9696' QUANTUM_TENANT = '1234' QUANTUM_CLIENT_VERSION='0.1' # No monitoring links currently EXTERNAL_MONITORING = [] # Uncomment the following segment to silence most logging # django.db and boto DEBUG logging is extremely verbose. #LOGGING = { # 'version': 1, # # set to True will disable all logging except that specified, unless # # nothing is specified except that django.db.backends will still log, # # even when set to True, so disable explicitly # 'disable_existing_loggers': False, # 'handlers': { # 'null': { # 'level': 'DEBUG', # 'class': 'django.utils.log.NullHandler', # }, # 'console': { # 'level': 'DEBUG', # 'class': 'logging.StreamHandler', # }, # }, # 'loggers': { # # Comment or Uncomment these to turn on/off logging output # 'django.db.backends': { # 'handlers': ['null'], # 'propagate': False, # }, # 'django_openstack': { # 'handlers': ['null'], # 'propagate': False, # }, # } #} # How much ram on each compute host? COMPUTE_HOST_RAM_GB = 16 devstack-diablo-eol/files/keystone.conf000066400000000000000000000047501207307670500205160ustar00rootroot00000000000000[DEFAULT] # Show more verbose log output (sets INFO log level output) verbose = False # Show debugging output in logs (sets DEBUG log level output) debug = False # Which backend store should Keystone use by default. # Default: 'sqlite' # Available choices are 'sqlite' [future will include LDAP, PAM, etc] default_store = sqlite # Log to this file. Make sure you do not set the same log # file for both the API and registry servers! log_file = %DEST%/keystone/keystone.log # List of backends to be configured backends = keystone.backends.sqlalchemy #For LDAP support, add: ,keystone.backends.ldap # Dictionary Maps every service to a header.Missing services would get header # X_(SERVICE_NAME) Key => Service Name, Value => Header Name service-header-mappings = { 'nova' : 'X-Server-Management-Url', 'swift' : 'X-Storage-Url', 'cdn' : 'X-CDN-Management-Url'} # Address to bind the API server # TODO Properties defined within app not available via pipeline. service_host = 0.0.0.0 # Port the bind the API server to service_port = 5000 # Address to bind the Admin API server admin_host = 0.0.0.0 # Port the bind the Admin API server to admin_port = 35357 #Role that allows to perform admin operations. keystone-admin-role = KeystoneAdmin #Role that allows to perform service admin operations. keystone-service-admin-role = KeystoneServiceAdmin [keystone.backends.sqlalchemy] # SQLAlchemy connection string for the reference implementation registry # server. Any valid SQLAlchemy connection string is fine. # See: http://bit.ly/ideIpI #sql_connection = sqlite:///keystone.db sql_connection = %SQL_CONN% backend_entities = ['UserRoleAssociation', 'Endpoints', 'Role', 'Tenant', 'User', 'Credentials', 'EndpointTemplates', 'Token', 'Service'] # Period in seconds after which SQLAlchemy should reestablish its connection # to the database. sql_idle_timeout = 30 [pipeline:admin] pipeline = urlrewritefilter admin_api [pipeline:keystone-legacy-auth] pipeline = urlrewritefilter legacy_auth RAX-KEY-extension service_api [app:service_api] paste.app_factory = keystone.server:service_app_factory [app:admin_api] paste.app_factory = keystone.server:admin_app_factory [filter:urlrewritefilter] paste.filter_factory = keystone.middleware.url:filter_factory [filter:legacy_auth] paste.filter_factory = keystone.frontends.legacy_token_auth:filter_factory [filter:RAX-KEY-extension] paste.filter_factory = keystone.contrib.extensions.service.raxkey.frontend:filter_factory devstack-diablo-eol/files/keystone_data.sh000077500000000000000000000052531207307670500211760ustar00rootroot00000000000000#!/bin/bash BIN_DIR=${BIN_DIR:-.} # Tenants $BIN_DIR/keystone-manage $* tenant add admin $BIN_DIR/keystone-manage $* tenant add demo $BIN_DIR/keystone-manage $* tenant add invisible_to_admin # Users $BIN_DIR/keystone-manage $* user add admin %ADMIN_PASSWORD% $BIN_DIR/keystone-manage $* user add demo %ADMIN_PASSWORD% # Roles $BIN_DIR/keystone-manage $* role add Admin $BIN_DIR/keystone-manage $* role add Member $BIN_DIR/keystone-manage $* role add KeystoneAdmin $BIN_DIR/keystone-manage $* role add KeystoneServiceAdmin $BIN_DIR/keystone-manage $* role add sysadmin $BIN_DIR/keystone-manage $* role add netadmin $BIN_DIR/keystone-manage $* role grant Admin admin admin $BIN_DIR/keystone-manage $* role grant Member demo demo $BIN_DIR/keystone-manage $* role grant sysadmin demo demo $BIN_DIR/keystone-manage $* role grant netadmin demo demo $BIN_DIR/keystone-manage $* role grant Member demo invisible_to_admin $BIN_DIR/keystone-manage $* role grant Admin admin demo $BIN_DIR/keystone-manage $* role grant Admin admin $BIN_DIR/keystone-manage $* role grant KeystoneAdmin admin $BIN_DIR/keystone-manage $* role grant KeystoneServiceAdmin admin # Services $BIN_DIR/keystone-manage $* service add nova compute "Nova Compute Service" $BIN_DIR/keystone-manage $* service add glance image "Glance Image Service" $BIN_DIR/keystone-manage $* service add keystone identity "Keystone Identity Service" $BIN_DIR/keystone-manage $* service add swift object-store "Swift Service" #endpointTemplates $BIN_DIR/keystone-manage $* endpointTemplates add RegionOne nova http://%SERVICE_HOST%:8774/v1.1/%tenant_id% http://%SERVICE_HOST%:8774/v1.1/%tenant_id% http://%SERVICE_HOST%:8774/v1.1/%tenant_id% 1 1 $BIN_DIR/keystone-manage $* endpointTemplates add RegionOne glance http://%SERVICE_HOST%:9292/v1 http://%SERVICE_HOST%:9292/v1 http://%SERVICE_HOST%:9292/v1 1 1 $BIN_DIR/keystone-manage $* endpointTemplates add RegionOne keystone http://%SERVICE_HOST%:5000/v2.0 http://%SERVICE_HOST%:35357/v2.0 http://%SERVICE_HOST%:5000/v2.0 1 1 $BIN_DIR/keystone-manage $* endpointTemplates add RegionOne swift http://%SERVICE_HOST%:8080/v1/AUTH_%tenant_id% http://%SERVICE_HOST%:8080/ http://%SERVICE_HOST%:8080/v1/AUTH_%tenant_id% 1 1 # Tokens $BIN_DIR/keystone-manage $* token add %SERVICE_TOKEN% admin admin 2015-02-05T00:00 # EC2 related creds - note we are setting the secret key to ADMIN_PASSWORD # but keystone doesn't parse them - it is just a blob from keystone's # point of view $BIN_DIR/keystone-manage $* credentials add admin EC2 'admin' '%ADMIN_PASSWORD%' admin || echo "no support for adding credentials" $BIN_DIR/keystone-manage $* credentials add demo EC2 'demo' '%ADMIN_PASSWORD%' demo || echo "no support for adding credentials" devstack-diablo-eol/files/nova-api-paste.ini000066400000000000000000000061671207307670500213370ustar00rootroot00000000000000####### # EC2 # ####### [composite:ec2] use = egg:Paste#urlmap /: ec2versions /services/Cloud: ec2cloud /services/Admin: ec2admin /latest: ec2metadata /2007-01-19: ec2metadata /2007-03-01: ec2metadata /2007-08-29: ec2metadata /2007-10-10: ec2metadata /2007-12-15: ec2metadata /2008-02-01: ec2metadata /2008-09-01: ec2metadata /2009-04-04: ec2metadata /1.0: ec2metadata [pipeline:ec2cloud] pipeline = logrequest totoken authtoken keystonecontext cloudrequest authorizer ec2executor [pipeline:ec2admin] pipeline = logrequest totoken authtoken keystonecontext adminrequest authorizer ec2executor [pipeline:ec2metadata] pipeline = logrequest ec2md [pipeline:ec2versions] pipeline = logrequest ec2ver [filter:logrequest] paste.filter_factory = nova.api.ec2:RequestLogging.factory [filter:ec2lockout] paste.filter_factory = nova.api.ec2:Lockout.factory [filter:totoken] paste.filter_factory = keystone.middleware.ec2_token:EC2Token.factory [filter:ec2noauth] paste.filter_factory = nova.api.ec2:NoAuth.factory [filter:authenticate] paste.filter_factory = nova.api.ec2:Authenticate.factory [filter:cloudrequest] controller = nova.api.ec2.cloud.CloudController paste.filter_factory = nova.api.ec2:Requestify.factory [filter:adminrequest] controller = nova.api.ec2.admin.AdminController paste.filter_factory = nova.api.ec2:Requestify.factory [filter:authorizer] paste.filter_factory = nova.api.ec2:Authorizer.factory [app:ec2executor] paste.app_factory = nova.api.ec2:Executor.factory [app:ec2ver] paste.app_factory = nova.api.ec2:Versions.factory [app:ec2md] paste.app_factory = nova.api.ec2.metadatarequesthandler:MetadataRequestHandler.factory ############# # Openstack # ############# [composite:osapi] use = egg:Paste#urlmap /: osversions /v1.0: openstackapi10 /v1.1: openstackapi11 [pipeline:openstackapi10] pipeline = faultwrap authtoken keystonecontext ratelimit osapiapp10 [pipeline:openstackapi11] pipeline = faultwrap authtoken keystonecontext ratelimit extensions osapiapp11 [filter:faultwrap] paste.filter_factory = nova.api.openstack:FaultWrapper.factory [filter:auth] paste.filter_factory = nova.api.openstack.auth:AuthMiddleware.factory [filter:noauth] paste.filter_factory = nova.api.openstack.auth:NoAuthMiddleware.factory [filter:ratelimit] paste.filter_factory = nova.api.openstack.limits:RateLimitingMiddleware.factory [filter:extensions] paste.filter_factory = nova.api.openstack.extensions:ExtensionMiddleware.factory [app:osapiapp10] paste.app_factory = nova.api.openstack:APIRouterV10.factory [app:osapiapp11] paste.app_factory = nova.api.openstack:APIRouterV11.factory [pipeline:osversions] pipeline = faultwrap osversionapp [app:osversionapp] paste.app_factory = nova.api.openstack.versions:Versions.factory ########## # Shared # ########## [filter:keystonecontext] paste.filter_factory = keystone.middleware.nova_keystone_context:NovaKeystoneContext.factory [filter:authtoken] paste.filter_factory = keystone.middleware.auth_token:filter_factory service_protocol = http service_host = 127.0.0.1 service_port = 5000 auth_host = 127.0.0.1 auth_port = 35357 auth_protocol = http auth_uri = http://127.0.0.1:5000/ admin_token = %SERVICE_TOKEN% devstack-diablo-eol/files/pips/000077500000000000000000000000001207307670500167535ustar00rootroot00000000000000devstack-diablo-eol/files/pips/horizon000066400000000000000000000002641207307670500203700ustar00rootroot00000000000000Django==1.3 django-nose==0.1.2 django-mailer django-registration==0.7 python-cloudfiles sqlalchemy-migrate -e git+https://github.com/jacobian/openstack.compute.git#egg=openstack devstack-diablo-eol/files/pips/keystone000066400000000000000000000000101207307670500205260ustar00rootroot00000000000000PassLib devstack-diablo-eol/files/pips/openstack-integration-tests000066400000000000000000000000051207307670500243410ustar00rootroot00000000000000pika devstack-diablo-eol/files/screenrc000066400000000000000000000002471207307670500175320ustar00rootroot00000000000000hardstatus on hardstatus alwayslastline hardstatus string "%{.bW}%-w%{.rW}%n %t%{-}%+w %=%{..G}%H %{..Y}%d/%m %c" defscrollback 10240 vbell off startup_message off devstack-diablo-eol/files/sources.list000066400000000000000000000011001207307670500203500ustar00rootroot00000000000000deb http://mirror.rackspace.com/ubuntu/ %DIST% main restricted deb http://mirror.rackspace.com/ubuntu/ %DIST%-updates main restricted deb http://mirror.rackspace.com/ubuntu/ %DIST% universe deb http://mirror.rackspace.com/ubuntu/ %DIST%-updates universe deb http://mirror.rackspace.com/ubuntu/ %DIST% multiverse deb http://mirror.rackspace.com/ubuntu/ %DIST%-updates multiverse deb http://security.ubuntu.com/ubuntu %DIST%-security main restricted deb http://security.ubuntu.com/ubuntu %DIST%-security universe deb http://security.ubuntu.com/ubuntu %DIST%-security multiverse devstack-diablo-eol/files/sudo/000077500000000000000000000000001207307670500167525ustar00rootroot00000000000000devstack-diablo-eol/files/sudo/nova000066400000000000000000000055641207307670500176520ustar00rootroot00000000000000Cmnd_Alias NOVADEVCMDS = /bin/chmod /var/lib/nova/tmp/*/root/.ssh, \ /bin/chown /var/lib/nova/tmp/*/root/.ssh, \ /bin/chown, \ /bin/chmod, \ /bin/dd, \ /sbin/ifconfig, \ /sbin/ip, \ /sbin/route, \ /sbin/iptables, \ /sbin/iptables-save, \ /sbin/iptables-restore, \ /sbin/ip6tables-save, \ /sbin/ip6tables-restore, \ /sbin/kpartx, \ /sbin/losetup, \ /sbin/lvcreate, \ /sbin/lvdisplay, \ /sbin/lvremove, \ /bin/mkdir, \ /bin/mount, \ /sbin/pvcreate, \ /usr/bin/tee, \ /sbin/tune2fs, \ /bin/umount, \ /sbin/vgcreate, \ /usr/bin/virsh, \ /usr/bin/qemu-nbd, \ /usr/sbin/brctl, \ /sbin/brctl, \ /usr/sbin/radvd, \ /usr/sbin/vblade-persist, \ /sbin/pvcreate, \ /sbin/aoe-discover, \ /sbin/vgcreate, \ /bin/aoe-stat, \ /bin/kill, \ /sbin/vconfig, \ /usr/sbin/ietadm, \ /sbin/vgs, \ /sbin/iscsiadm, \ /usr/bin/socat, \ /sbin/parted, \ /usr/sbin/dnsmasq, \ /usr/sbin/arping %USER% ALL = (root) NOPASSWD: SETENV: NOVADEVCMDS devstack-diablo-eol/files/swift/000077500000000000000000000000001207307670500171345ustar00rootroot00000000000000devstack-diablo-eol/files/swift/account-server.conf000066400000000000000000000005211207307670500227410ustar00rootroot00000000000000[DEFAULT] devices = %NODE_PATH%/node mount_check = false bind_port = %BIND_PORT% user = %USER% log_facility = LOG_LOCAL%LOG_FACILITY% swift_dir = %SWIFT_CONFIG_LOCATION% [pipeline:main] pipeline = account-server [app:account-server] use = egg:swift#account [account-replicator] vm_test_mode = yes [account-auditor] [account-reaper] devstack-diablo-eol/files/swift/container-server.conf000066400000000000000000000005601207307670500232720ustar00rootroot00000000000000[DEFAULT] devices = %NODE_PATH%/node mount_check = false bind_port = %BIND_PORT% user = %USER% log_facility = LOG_LOCAL%LOG_FACILITY% swift_dir = %SWIFT_CONFIG_LOCATION% [pipeline:main] pipeline = container-server [app:container-server] use = egg:swift#container [container-replicator] vm_test_mode = yes [container-updater] [container-auditor] [container-sync] devstack-diablo-eol/files/swift/object-server.conf000066400000000000000000000005141207307670500225550ustar00rootroot00000000000000[DEFAULT] devices = %NODE_PATH%/node mount_check = false bind_port = %BIND_PORT% user = %USER% log_facility = LOG_LOCAL%LOG_FACILITY% swift_dir = %SWIFT_CONFIG_LOCATION% [pipeline:main] pipeline = object-server [app:object-server] use = egg:swift#object [object-replicator] vm_test_mode = yes [object-updater] [object-auditor] devstack-diablo-eol/files/swift/proxy-server.conf000066400000000000000000000013471207307670500224750ustar00rootroot00000000000000[DEFAULT] bind_port = 8080 user = %USER% log_facility = LOG_LOCAL1 swift_dir = %SWIFT_CONFIG_LOCATION% [pipeline:main] pipeline = healthcheck cache %AUTH_SERVER% proxy-server [app:proxy-server] use = egg:swift#proxy allow_account_management = true account_autocreate = true [filter:keystone] use = egg:swiftkeystone2#keystone2 keystone_admin_token = %SERVICE_TOKEN% keystone_url = http://localhost:35357/v2.0 keystone_admin_group = Member [filter:tempauth] use = egg:swift#tempauth user_admin_admin = admin .admin .reseller_admin user_test_tester = testing .admin user_test2_tester2 = testing2 .admin user_test_tester3 = testing3 bind_ip = 0.0.0.0 [filter:healthcheck] use = egg:swift#healthcheck [filter:cache] use = egg:swift#memcache devstack-diablo-eol/files/swift/rsyncd.conf000066400000000000000000000032171207307670500213100ustar00rootroot00000000000000uid = %USER% gid = %GROUP% log file = /var/log/rsyncd.log pid file = /var/run/rsyncd.pid address = 127.0.0.1 [account6012] max connections = 25 path = %SWIFT_DATA_LOCATION%/1/node/ read only = false lock file = /var/lock/account6012.lock [account6022] max connections = 25 path = %SWIFT_DATA_LOCATION%/2/node/ read only = false lock file = /var/lock/account6022.lock [account6032] max connections = 25 path = %SWIFT_DATA_LOCATION%/3/node/ read only = false lock file = /var/lock/account6032.lock [account6042] max connections = 25 path = %SWIFT_DATA_LOCATION%/4/node/ read only = false lock file = /var/lock/account6042.lock [container6011] max connections = 25 path = %SWIFT_DATA_LOCATION%/1/node/ read only = false lock file = /var/lock/container6011.lock [container6021] max connections = 25 path = %SWIFT_DATA_LOCATION%/2/node/ read only = false lock file = /var/lock/container6021.lock [container6031] max connections = 25 path = %SWIFT_DATA_LOCATION%/3/node/ read only = false lock file = /var/lock/container6031.lock [container6041] max connections = 25 path = %SWIFT_DATA_LOCATION%/4/node/ read only = false lock file = /var/lock/container6041.lock [object6010] max connections = 25 path = %SWIFT_DATA_LOCATION%/1/node/ read only = false lock file = /var/lock/object6010.lock [object6020] max connections = 25 path = %SWIFT_DATA_LOCATION%/2/node/ read only = false lock file = /var/lock/object6020.lock [object6030] max connections = 25 path = %SWIFT_DATA_LOCATION%/3/node/ read only = false lock file = /var/lock/object6030.lock [object6040] max connections = 25 path = %SWIFT_DATA_LOCATION%/4/node/ read only = false lock file = /var/lock/object6040.lock devstack-diablo-eol/files/swift/swift-remakerings000077500000000000000000000023301207307670500225210ustar00rootroot00000000000000#!/bin/bash cd %SWIFT_CONFIG_LOCATION% rm -f *.builder *.ring.gz backups/*.builder backups/*.ring.gz swift-ring-builder object.builder create %SWIFT_PARTITION_POWER_SIZE% 3 1 swift-ring-builder object.builder add z1-127.0.0.1:6010/sdb1 1 swift-ring-builder object.builder add z2-127.0.0.1:6020/sdb2 1 swift-ring-builder object.builder add z3-127.0.0.1:6030/sdb3 1 swift-ring-builder object.builder add z4-127.0.0.1:6040/sdb4 1 swift-ring-builder object.builder rebalance swift-ring-builder container.builder create %SWIFT_PARTITION_POWER_SIZE% 3 1 swift-ring-builder container.builder add z1-127.0.0.1:6011/sdb1 1 swift-ring-builder container.builder add z2-127.0.0.1:6021/sdb2 1 swift-ring-builder container.builder add z3-127.0.0.1:6031/sdb3 1 swift-ring-builder container.builder add z4-127.0.0.1:6041/sdb4 1 swift-ring-builder container.builder rebalance swift-ring-builder account.builder create %SWIFT_PARTITION_POWER_SIZE% 3 1 swift-ring-builder account.builder add z1-127.0.0.1:6012/sdb1 1 swift-ring-builder account.builder add z2-127.0.0.1:6022/sdb2 1 swift-ring-builder account.builder add z3-127.0.0.1:6032/sdb3 1 swift-ring-builder account.builder add z4-127.0.0.1:6042/sdb4 1 swift-ring-builder account.builder rebalance devstack-diablo-eol/files/swift/swift-startmain000077500000000000000000000000441207307670500222140ustar00rootroot00000000000000#!/bin/bash swift-init all restart devstack-diablo-eol/files/swift/swift.conf000066400000000000000000000001561207307670500211410ustar00rootroot00000000000000[swift-hash] # random unique string that can never change (DO NOT LOSE) swift_hash_path_suffix = %SWIFT_HASH% devstack-diablo-eol/openrc000066400000000000000000000051101207307670500161040ustar00rootroot00000000000000#!/usr/bin/env bash # Load local configuration source ./stackrc # Set api host endpoint, defaulting to HOST_IP but allowing override by SERVICE_HOST HOST_IP=${HOST_IP:-127.0.0.1} SERVICE_HOST=${SERVICE_HOST:-$HOST_IP} # Nova original used project_id as the *account* that owned resources (servers, # ip address, ...) With the addition of Keystone we have standardized on the # term **tenant** as the entity that owns the resources. **novaclient** still # uses the old deprecated terms project_id. Note that this field should now be # set to tenant_name, not tenant_id. export NOVA_PROJECT_ID=${TENANT:-demo} # In addition to the owning entity (tenant), nova stores the entity performing # the action as the **user**. export NOVA_USERNAME=${NOVA_USERNAME:-demo} # With Keystone you pass the keystone password instead of an api key. # The most recent versions of novaclient use NOVA_PASSWORD instead of NOVA_API_KEY export NOVA_PASSWORD=${ADMIN_PASSWORD:-secrete} # With the addition of Keystone, to use an openstack cloud you should # authenticate against keystone, which returns a **Token** and **Service # Catalog**. The catalog contains the endpoint for all services the user/tenant # has access to - including nova, glance, keystone, swift, ... We currently # recommend using the 2.0 *auth api*. # # *NOTE*: Using the 2.0 *auth api* does not mean that compute api is 2.0. We # will use the 1.1 *compute api* export NOVA_URL=${NOVA_URL:-http://$SERVICE_HOST:5000/v2.0/} # Currently novaclient needs you to specify the *compute api* version. This # needs to match the config of your catalog returned by Keystone. export NOVA_VERSION=${NOVA_VERSION:-1.1} # FIXME - why does this need to be specified? export NOVA_REGION_NAME=${NOVA_REGION_NAME:-RegionOne} # Set the ec2 url so euca2ools works export EC2_URL=${EC2_URL:-http://$SERVICE_HOST:8773/services/Cloud} # Access key is set in the initial keystone data to be the same as username export EC2_ACCESS_KEY=${NOVA_USERNAME:-demo} # Secret key is set in the initial keystone data to the admin password export EC2_SECRET_KEY=${ADMIN_PASSWORD:-secrete} # set log level to DEBUG (helps debug issues) # export NOVACLIENT_DEBUG=1 # Max time till the vm is bootable export BOOT_TIMEOUT=${BOOT_TIMEOUT:-15} # Max time to wait while vm goes from build to active state export ACTIVE_TIMEOUT=${ACTIVE_TIMEOUT:-10} # Max time from run instance command until it is running export RUNNING_TIMEOUT=${RUNNING_TIMEOUT:-$(($BOOT_TIMEOUT + $ACTIVE_TIMEOUT))} # Max time to wait for proper IP association and dis-association. export ASSOCIATE_TIMEOUT=${ASSOCIATE_TIMEOUT:-10} devstack-diablo-eol/stack.sh000077500000000000000000001364171207307670500163560ustar00rootroot00000000000000#!/usr/bin/env bash # **stack.sh** is an opinionated openstack developer installation. # This script installs and configures *nova*, *glance*, *horizon* and *keystone* # This script allows you to specify configuration options of what git # repositories to use, enabled services, network configuration and various # passwords. If you are crafty you can run the script on multiple nodes using # shared settings for common resources (mysql, rabbitmq) and build a multi-node # developer install. # To keep this script simple we assume you are running on an **Ubuntu 11.10 # Oneiric** machine. It should work in a VM or physical server. Additionally # we put the list of *apt* and *pip* dependencies and other configuration files # in this repo. So start by grabbing this script and the dependencies. # Learn more and get the most recent version at http://devstack.org # Sanity Check # ============ # Warn users who aren't on oneiric, but allow them to override check and attempt # installation with ``FORCE=yes ./stack`` DISTRO=$(lsb_release -c -s) if [[ ! ${DISTRO} =~ (oneiric) ]]; then echo "WARNING: this script has only been tested on oneiric" if [[ "$FORCE" != "yes" ]]; then echo "If you wish to run this script anyway run with FORCE=yes" exit 1 fi fi # Keep track of the current devstack directory. TOP_DIR=$(cd $(dirname "$0") && pwd) # stack.sh keeps the list of **apt** and **pip** dependencies in external # files, along with config templates and other useful files. You can find these # in the ``files`` directory (next to this script). We will reference this # directory using the ``FILES`` variable in this script. FILES=$TOP_DIR/files if [ ! -d $FILES ]; then echo "ERROR: missing devstack/files - did you grab more than just stack.sh?" exit 1 fi # Settings # ======== # This script is customizable through setting environment variables. If you # want to override a setting you can either:: # # export MYSQL_PASSWORD=anothersecret # ./stack.sh # # You can also pass options on a single line ``MYSQL_PASSWORD=simple ./stack.sh`` # # Additionally, you can put any local variables into a ``localrc`` file, like:: # # MYSQL_PASSWORD=anothersecret # MYSQL_USER=hellaroot # # We try to have sensible defaults, so you should be able to run ``./stack.sh`` # in most cases. # # We source our settings from ``stackrc``. This file is distributed with devstack # and contains locations for what repositories to use. If you want to use other # repositories and branches, you can add your own settings with another file called # ``localrc`` # # If ``localrc`` exists, then ``stackrc`` will load those settings. This is # useful for changing a branch or repository to test other versions. Also you # can store your other settings like **MYSQL_PASSWORD** or **ADMIN_PASSWORD** instead # of letting devstack generate random ones for you. source ./stackrc # Destination path for installation ``DEST`` DEST=${DEST:-/opt/stack} # Configure services to syslog instead of writing to individual log files SYSLOG=${SYSLOG:-False} # apt-get wrapper to just get arguments set correctly function apt_get() { local sudo="sudo" [ "$(id -u)" = "0" ] && sudo="env" $sudo DEBIAN_FRONTEND=noninteractive apt-get \ --option "Dpkg::Options::=--force-confold" --assume-yes "$@" } # OpenStack is designed to be run as a regular user (Horizon will fail to run # as root, since apache refused to startup serve content from root user). If # stack.sh is run as root, it automatically creates a stack user with # sudo privileges and runs as that user. if [[ $EUID -eq 0 ]]; then ROOTSLEEP=${ROOTSLEEP:-10} echo "You are running this script as root." echo "In $ROOTSLEEP seconds, we will create a user 'stack' and run as that user" sleep $ROOTSLEEP # since this script runs as a normal user, we need to give that user # ability to run sudo dpkg -l sudo || apt_get update && apt_get install sudo if ! getent passwd stack >/dev/null; then echo "Creating a user called stack" useradd -U -G sudo -s /bin/bash -d $DEST -m stack fi echo "Giving stack user passwordless sudo priviledges" # some uec images sudoers does not have a '#includedir'. add one. grep -q "^#includedir.*/etc/sudoers.d" /etc/sudoers || echo "#includedir /etc/sudoers.d" >> /etc/sudoers ( umask 226 && echo "stack ALL=(ALL) NOPASSWD:ALL" \ > /etc/sudoers.d/50_stack_sh ) echo "Copying files to stack user" STACK_DIR="$DEST/${PWD##*/}" cp -r -f "$PWD" "$STACK_DIR" chown -R stack "$STACK_DIR" if [[ "$SHELL_AFTER_RUN" != "no" ]]; then exec su -c "set -e; cd $STACK_DIR; bash stack.sh; bash" stack else exec su -c "set -e; cd $STACK_DIR; bash stack.sh" stack fi exit 1 else # Our user needs passwordless priviledges for certain commands which nova # uses internally. # Natty uec images sudoers does not have a '#includedir'. add one. sudo grep -q "^#includedir.*/etc/sudoers.d" /etc/sudoers || echo "#includedir /etc/sudoers.d" | sudo tee -a /etc/sudoers TEMPFILE=`mktemp` cat $FILES/sudo/nova > $TEMPFILE sed -e "s,%USER%,$USER,g" -i $TEMPFILE chmod 0440 $TEMPFILE sudo chown root:root $TEMPFILE sudo mv $TEMPFILE /etc/sudoers.d/stack_sh_nova fi # Set the destination directories for openstack projects NOVA_DIR=$DEST/nova HORIZON_DIR=$DEST/horizon GLANCE_DIR=$DEST/glance KEYSTONE_DIR=$DEST/keystone NOVACLIENT_DIR=$DEST/python-novaclient OPENSTACKX_DIR=$DEST/openstackx NOVNC_DIR=$DEST/noVNC SWIFT_DIR=$DEST/swift SWIFT_KEYSTONE_DIR=$DEST/swift-keystone2 QUANTUM_DIR=$DEST/quantum # Default Quantum Plugin Q_PLUGIN=${Q_PLUGIN:-openvswitch} # Specify which services to launch. These generally correspond to screen tabs ENABLED_SERVICES=${ENABLED_SERVICES:-g-api,g-reg,key,n-api,n-cpu,n-net,n-sch,n-vnc,horizon,mysql,rabbit,openstackx} # Name of the lvm volume group to use/create for iscsi volumes VOLUME_GROUP=${VOLUME_GROUP:-nova-volumes} # Nova hypervisor configuration. We default to libvirt whth **kvm** but will # drop back to **qemu** if we are unable to load the kvm module. Stack.sh can # also install an **LXC** based system. VIRT_DRIVER=${VIRT_DRIVER:-libvirt} LIBVIRT_TYPE=${LIBVIRT_TYPE:-kvm} # nova supports pluggable schedulers. ``SimpleScheduler`` should work in most # cases unless you are working on multi-zone mode. SCHEDULER=${SCHEDULER:-nova.scheduler.simple.SimpleScheduler} # Use the eth0 IP unless an explicit is set by ``HOST_IP`` environment variable if [ ! -n "$HOST_IP" ]; then HOST_IP=`LC_ALL=C /sbin/ifconfig eth0 | grep -m 1 'inet addr:'| cut -d: -f2 | awk '{print $1}'` if [ "$HOST_IP" = "" ]; then echo "Could not determine host ip address." echo "If this is not your first run of stack.sh, it is " echo "possible that nova moved your eth0 ip address to the FLAT_NETWORK_BRIDGE." echo "Please specify your HOST_IP in your localrc." exit 1 fi fi # Service startup timeout SERVICE_TIMEOUT=${SERVICE_TIMEOUT:-60} # Generic helper to configure passwords function read_password { set +o xtrace var=$1; msg=$2 pw=${!var} localrc=$TOP_DIR/localrc # If the password is not defined yet, proceed to prompt user for a password. if [ ! $pw ]; then # If there is no localrc file, create one if [ ! -e $localrc ]; then touch $localrc fi # Presumably if we got this far it can only be that our localrc is missing # the required password. Prompt user for a password and write to localrc. echo '' echo '################################################################################' echo $msg echo '################################################################################' echo "This value will be written to your localrc file so you don't have to enter it again." echo "It is probably best to avoid spaces and weird characters." echo "If you leave this blank, a random default value will be used." echo "Enter a password now:" read $var pw=${!var} if [ ! $pw ]; then pw=`openssl rand -hex 10` fi eval "$var=$pw" echo "$var=$pw" >> $localrc fi set -o xtrace } # Nova Network Configuration # -------------------------- # FIXME: more documentation about why these are important flags. Also # we should make sure we use the same variable names as the flag names. # Allow the use of an alternate hostname (such as localhost/127.0.0.1) for service endpoints. SERVICE_HOST=${SERVICE_HOST:-$HOST_IP} PUBLIC_INTERFACE=${PUBLIC_INTERFACE:-eth0} FIXED_RANGE=${FIXED_RANGE:-10.0.0.0/24} FIXED_NETWORK_SIZE=${FIXED_NETWORK_SIZE:-256} FLOATING_RANGE=${FLOATING_RANGE:-172.24.4.224/28} NET_MAN=${NET_MAN:-FlatDHCPManager} EC2_DMZ_HOST=${EC2_DMZ_HOST:-$SERVICE_HOST} FLAT_NETWORK_BRIDGE=${FLAT_NETWORK_BRIDGE:-br100} VLAN_INTERFACE=${VLAN_INTERFACE:-$PUBLIC_INTERFACE} # Multi-host is a mode where each compute node runs its own network node. This # allows network operations and routing for a VM to occur on the server that is # running the VM - removing a SPOF and bandwidth bottleneck. MULTI_HOST=${MULTI_HOST:-False} # If you are using FlatDHCP on multiple hosts, set the ``FLAT_INTERFACE`` # variable but make sure that the interface doesn't already have an # ip or you risk breaking things. # # **DHCP Warning**: If your flat interface device uses DHCP, there will be a # hiccup while the network is moved from the flat interface to the flat network # bridge. This will happen when you launch your first instance. Upon launch # you will lose all connectivity to the node, and the vm launch will probably # fail. # # If you are running on a single node and don't need to access the VMs from # devices other than that node, you can set the flat interface to the same # value as ``FLAT_NETWORK_BRIDGE``. This will stop the network hiccup from # occurring. FLAT_INTERFACE=${FLAT_INTERFACE:-eth0} ## FIXME(ja): should/can we check that FLAT_INTERFACE is sane? # Using Quantum networking: # # Make sure that q-svc is enabled in ENABLED_SERVICES. If it is the network # manager will be set to the QuantumManager. # # If you're planning to use the Quantum openvswitch plugin, set Q_PLUGIN to # "openvswitch" and make sure the q-agt service is enabled in # ENABLED_SERVICES. # # With Quantum networking the NET_MAN variable is ignored. # MySQL & RabbitMQ # ---------------- # We configure Nova, Horizon, Glance and Keystone to use MySQL as their # database server. While they share a single server, each has their own # database and tables. # By default this script will install and configure MySQL. If you want to # use an existing server, you can pass in the user/password/host parameters. # You will need to send the same ``MYSQL_PASSWORD`` to every host if you are doing # a multi-node devstack installation. MYSQL_HOST=${MYSQL_HOST:-localhost} MYSQL_USER=${MYSQL_USER:-root} read_password MYSQL_PASSWORD "ENTER A PASSWORD TO USE FOR MYSQL." # don't specify /db in this string, so we can use it for multiple services BASE_SQL_CONN=${BASE_SQL_CONN:-mysql://$MYSQL_USER:$MYSQL_PASSWORD@$MYSQL_HOST} # Rabbit connection info RABBIT_HOST=${RABBIT_HOST:-localhost} read_password RABBIT_PASSWORD "ENTER A PASSWORD TO USE FOR RABBIT." # Glance connection info. Note the port must be specified. GLANCE_HOSTPORT=${GLANCE_HOSTPORT:-$SERVICE_HOST:9292} # SWIFT # ----- # TODO: implement glance support # TODO: add logging to different location. # By default the location of swift drives and objects is located inside # the swift source directory. SWIFT_DATA_LOCATION variable allow you to redefine # this. SWIFT_DATA_LOCATION=${SWIFT_DATA_LOCATION:-${SWIFT_DIR}/data} # We are going to have the configuration files inside the source # directory, change SWIFT_CONFIG_LOCATION if you want to adjust that. SWIFT_CONFIG_LOCATION=${SWIFT_CONFIG_LOCATION:-${SWIFT_DIR}/config} # devstack will create a loop-back disk formatted as XFS to store the # swift data. By default the disk size is 1 gigabyte. The variable # SWIFT_LOOPBACK_DISK_SIZE specified in bytes allow you to change # that. SWIFT_LOOPBACK_DISK_SIZE=${SWIFT_LOOPBACK_DISK_SIZE:-1000000} # The ring uses a configurable number of bits from a path’s MD5 hash as # a partition index that designates a device. The number of bits kept # from the hash is known as the partition power, and 2 to the partition # power indicates the partition count. Partitioning the full MD5 hash # ring allows other parts of the cluster to work in batches of items at # once which ends up either more efficient or at least less complex than # working with each item separately or the entire cluster all at once. # By default we define 9 for the partition count (which mean 512). SWIFT_PARTITION_POWER_SIZE=${SWIFT_PARTITION_POWER_SIZE:-9} # We only ask for Swift Hash if we have enabled swift service. if [[ "$ENABLED_SERVICES" =~ "swift" ]]; then # SWIFT_HASH is a random unique string for a swift cluster that # can never change. read_password SWIFT_HASH "ENTER A RANDOM SWIFT HASH." fi # Keystone # -------- # Service Token - Openstack components need to have an admin token # to validate user tokens. read_password SERVICE_TOKEN "ENTER A SERVICE_TOKEN TO USE FOR THE SERVICE ADMIN TOKEN." # Horizon currently truncates usernames and passwords at 20 characters read_password ADMIN_PASSWORD "ENTER A PASSWORD TO USE FOR HORIZON AND KEYSTONE (20 CHARS OR LESS)." LOGFILE=${LOGFILE:-"$PWD/stack.sh.$$.log"} ( # So that errors don't compound we exit on any errors so you see only the # first error that occurred. trap failed ERR failed() { local r=$? set +o xtrace [ -n "$LOGFILE" ] && echo "${0##*/} failed: full log in $LOGFILE" exit $r } # Print the commands being run so that we can see the command that triggers # an error. It is also useful for following along as the install occurs. set -o xtrace # create the destination directory and ensure it is writable by the user sudo mkdir -p $DEST if [ ! -w $DEST ]; then sudo chown `whoami` $DEST fi # Install Packages # ================ # # Openstack uses a fair number of other projects. # - We are going to install packages only for the services needed. # - We are parsing the packages files and detecting metadatas. # - If there is a NOPRIME as comment mean we are not doing the install # just yet. # - If we have the meta-keyword distro:DISTRO or # distro:DISTRO1,DISTRO2 it will be installed only for those # distros (case insensitive). function get_packages() { local file_to_parse="general" local service for service in ${ENABLED_SERVICES//,/ }; do if [[ $service == n-* ]]; then if [[ ! $file_to_parse =~ nova ]]; then file_to_parse="${file_to_parse} nova" fi elif [[ $service == g-* ]]; then if [[ ! $file_to_parse =~ glance ]]; then file_to_parse="${file_to_parse} glance" fi elif [[ $service == key* ]]; then if [[ ! $file_to_parse =~ keystone ]]; then file_to_parse="${file_to_parse} keystone" fi elif [[ -e $FILES/apts/${service} ]]; then file_to_parse="${file_to_parse} $service" fi done for file in ${file_to_parse}; do local fname=${FILES}/apts/${file} local OIFS line package distros distro [[ -e $fname ]] || { echo "missing: $fname"; exit 1 ;} OIFS=$IFS IFS=$'\n' for line in $(<${fname}); do if [[ $line =~ "NOPRIME" ]]; then continue fi if [[ $line =~ (.*)#.*dist:([^ ]*) ]]; then # We are using BASH regexp matching feature. package=${BASH_REMATCH[1]} distros=${BASH_REMATCH[2]} for distro in ${distros//,/ }; do #In bash ${VAR,,} will lowecase VAR [[ ${distro,,} == ${DISTRO,,} ]] && echo $package done continue fi echo ${line%#*} done IFS=$OIFS done } # install apt requirements apt_get update apt_get install $(get_packages) # install python requirements sudo PIP_DOWNLOAD_CACHE=/var/cache/pip pip install --use-mirrors `cat $FILES/pips/*` # git clone only if directory doesn't exist already. Since ``DEST`` might not # be owned by the installation user, we create the directory and change the # ownership to the proper user. function git_clone { GIT_REMOTE=$1 GIT_DEST=$2 GIT_BRANCH=$3 # do a full clone only if the directory doesn't exist if [ ! -d $GIT_DEST ]; then git clone $GIT_REMOTE $GIT_DEST cd $2 # This checkout syntax works for both branches and tags git checkout $GIT_BRANCH elif [[ "$RECLONE" == "yes" ]]; then # if it does exist then simulate what clone does if asked to RECLONE cd $GIT_DEST # set the url to pull from and fetch git remote set-url origin $GIT_REMOTE git fetch origin # remove the existing ignored files (like pyc) as they cause breakage # (due to the py files having older timestamps than our pyc, so python # thinks the pyc files are correct using them) find $GIT_DEST -name '*.pyc' -delete git checkout -f origin/$GIT_BRANCH # a local branch might not exist git branch -D $GIT_BRANCH || true git checkout -b $GIT_BRANCH fi } # compute service git_clone $NOVA_REPO $NOVA_DIR $NOVA_BRANCH # python client library to nova that horizon (and others) use git_clone $NOVACLIENT_REPO $NOVACLIENT_DIR $NOVACLIENT_BRANCH # glance, swift middleware and nova api needs keystone middleware if [[ "$ENABLED_SERVICES" =~ "key" || "$ENABLED_SERVICES" =~ "g-api" || "$ENABLED_SERVICES" =~ "n-api" || "$ENABLED_SERVICES" =~ "swift" ]]; then # unified auth system (manages accounts/tokens) git_clone $KEYSTONE_REPO $KEYSTONE_DIR $KEYSTONE_BRANCH fi if [[ "$ENABLED_SERVICES" =~ "swift" ]]; then # storage service git_clone $SWIFT_REPO $SWIFT_DIR $SWIFT_BRANCH # swift + keystone middleware git_clone $SWIFT_KEYSTONE_REPO $SWIFT_KEYSTONE_DIR $SWIFT_KEYSTONE_BRANCH fi if [[ "$ENABLED_SERVICES" =~ "g-api" || "$ENABLED_SERVICES" =~ "n-api" ]]; then # image catalog service git_clone $GLANCE_REPO $GLANCE_DIR $GLANCE_BRANCH fi if [[ "$ENABLED_SERVICES" =~ "n-vnc" ]]; then # a websockets/html5 or flash powered VNC console for vm instances git_clone $NOVNC_REPO $NOVNC_DIR $NOVNC_BRANCH fi if [[ "$ENABLED_SERVICES" =~ "horizon" ]]; then # django powered web control panel for openstack git_clone $HORIZON_REPO $HORIZON_DIR $HORIZON_BRANCH $HORIZON_TAG fi if [[ "$ENABLED_SERVICES" =~ "openstackx" ]]; then # openstackx is a collection of extensions to openstack.compute & nova # that is *deprecated*. The code is being moved into python-novaclient & nova. git_clone $OPENSTACKX_REPO $OPENSTACKX_DIR $OPENSTACKX_BRANCH fi if [[ "$ENABLED_SERVICES" =~ "quantum" ]]; then # quantum git_clone $QUANTUM_REPO $QUANTUM_DIR $QUANTUM_BRANCH fi # Initialization # ============== # setup our checkouts so they are installed into python path # allowing ``import nova`` or ``import glance.client`` if [[ "$ENABLED_SERVICES" =~ "key" || "$ENABLED_SERVICES" =~ "g-api" || "$ENABLED_SERVICES" =~ "n-api" || "$ENABLED_SERVICES" =~ "swift" ]]; then cd $KEYSTONE_DIR; sudo python setup.py develop fi if [[ "$ENABLED_SERVICES" =~ "swift" ]]; then cd $SWIFT_DIR; sudo python setup.py develop cd $SWIFT_KEYSTONE_DIR; sudo python setup.py develop fi if [[ "$ENABLED_SERVICES" =~ "g-api" || "$ENABLED_SERVICES" =~ "n-api" ]]; then cd $GLANCE_DIR; sudo python setup.py develop fi cd $NOVACLIENT_DIR; sudo python setup.py develop cd $NOVA_DIR; sudo python setup.py develop if [[ "$ENABLED_SERVICES" =~ "openstackx" ]]; then cd $OPENSTACKX_DIR; sudo python setup.py develop fi if [[ "$ENABLED_SERVICES" =~ "horizon" ]]; then cd $HORIZON_DIR/django-openstack; sudo python setup.py develop cd $HORIZON_DIR/openstack-dashboard; sudo python setup.py develop fi if [[ "$ENABLED_SERVICES" =~ "quantum" ]]; then cd $QUANTUM_DIR; sudo python setup.py develop fi # Add a useful screenrc. This isn't required to run openstack but is we do # it since we are going to run the services in screen for simple cp $FILES/screenrc ~/.screenrc # Rabbit # --------- if [[ "$ENABLED_SERVICES" =~ "rabbit" ]]; then # Install and start rabbitmq-server # the temp file is necessary due to LP: #878600 tfile=$(mktemp) apt_get install rabbitmq-server > "$tfile" 2>&1 cat "$tfile" rm -f "$tfile" # change the rabbit password since the default is "guest" sudo rabbitmqctl change_password guest $RABBIT_PASSWORD fi # Mysql # --------- if [[ "$ENABLED_SERVICES" =~ "mysql" ]]; then # Seed configuration with mysql password so that apt-get install doesn't # prompt us for a password upon install. cat <$HOME/.my.cnf [client] user=$MYSQL_USER password=$MYSQL_PASSWORD host=$MYSQL_HOST EOF chmod 0600 $HOME/.my.cnf fi # Install and start mysql-server apt_get install mysql-server # Update the DB to give user ‘$MYSQL_USER’@’%’ full control of the all databases: sudo mysql -uroot -p$MYSQL_PASSWORD -h127.0.0.1 -e "GRANT ALL PRIVILEGES ON *.* TO '$MYSQL_USER'@'%' identified by '$MYSQL_PASSWORD';" # Edit /etc/mysql/my.cnf to change ‘bind-address’ from localhost (127.0.0.1) to any (0.0.0.0) and restart the mysql service: sudo sed -i 's/127.0.0.1/0.0.0.0/g' /etc/mysql/my.cnf sudo service mysql restart fi # Horizon # --------- # Setup the django horizon application to serve via apache/wsgi if [[ "$ENABLED_SERVICES" =~ "horizon" ]]; then # Install apache2, which is NOPRIME'd apt_get install apache2 libapache2-mod-wsgi # Horizon currently imports quantum even if you aren't using it. Instead # of installing quantum we can create a simple module that will pass the # initial imports mkdir -p $HORIZON_DIR/openstack-dashboard/quantum || true touch $HORIZON_DIR/openstack-dashboard/quantum/__init__.py touch $HORIZON_DIR/openstack-dashboard/quantum/client.py # ``local_settings.py`` is used to override horizon default settings. cp $FILES/horizon_settings.py $HORIZON_DIR/openstack-dashboard/local/local_settings.py # Initialize the horizon database (it stores sessions and notices shown to # users). The user system is external (keystone). cd $HORIZON_DIR/openstack-dashboard dashboard/manage.py syncdb # create an empty directory that apache uses as docroot sudo mkdir -p $HORIZON_DIR/.blackhole ## Configure apache's 000-default to run horizon sudo cp $FILES/000-default.template /etc/apache2/sites-enabled/000-default sudo sed -e "s,%USER%,$USER,g" -i /etc/apache2/sites-enabled/000-default sudo sed -e "s,%HORIZON_DIR%,$HORIZON_DIR,g" -i /etc/apache2/sites-enabled/000-default sudo service apache2 restart fi # Glance # ------ if [[ "$ENABLED_SERVICES" =~ "g-reg" ]]; then GLANCE_IMAGE_DIR=$DEST/glance/images # Delete existing images rm -rf $GLANCE_IMAGE_DIR # Use local glance directories mkdir -p $GLANCE_IMAGE_DIR # (re)create glance database mysql -u$MYSQL_USER -p$MYSQL_PASSWORD -e 'DROP DATABASE IF EXISTS glance;' mysql -u$MYSQL_USER -p$MYSQL_PASSWORD -e 'CREATE DATABASE glance;' # Copy over our glance configurations and update them GLANCE_CONF=$GLANCE_DIR/etc/glance-registry.conf cp $FILES/glance-registry.conf $GLANCE_CONF sudo sed -e "s,%SQL_CONN%,$BASE_SQL_CONN/glance,g" -i $GLANCE_CONF sudo sed -e "s,%SERVICE_TOKEN%,$SERVICE_TOKEN,g" -i $GLANCE_CONF sudo sed -e "s,%DEST%,$DEST,g" -i $GLANCE_CONF sudo sed -e "s,%SYSLOG%,$SYSLOG,g" -i $GLANCE_CONF GLANCE_API_CONF=$GLANCE_DIR/etc/glance-api.conf cp $FILES/glance-api.conf $GLANCE_API_CONF sudo sed -e "s,%DEST%,$DEST,g" -i $GLANCE_API_CONF sudo sed -e "s,%SERVICE_TOKEN%,$SERVICE_TOKEN,g" -i $GLANCE_API_CONF sudo sed -e "s,%SYSLOG%,$SYSLOG,g" -i $GLANCE_API_CONF fi # Nova # ---- if [[ "$ENABLED_SERVICES" =~ "n-api" ]]; then # We are going to use a sample http middleware configuration based on the # one from the keystone project to launch nova. This paste config adds # the configuration required for nova to validate keystone tokens. We add # our own service token to the configuration. cp $FILES/nova-api-paste.ini $NOVA_DIR/bin sed -e "s,%SERVICE_TOKEN%,$SERVICE_TOKEN,g" -i $NOVA_DIR/bin/nova-api-paste.ini fi if [[ "$ENABLED_SERVICES" =~ "n-cpu" ]]; then # Virtualization Configuration # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # attempt to load modules: network block device - used to manage qcow images sudo modprobe nbd || true # Check for kvm (hardware based virtualization). If unable to initialize # kvm, we drop back to the slower emulation mode (qemu). Note: many systems # come with hardware virtualization disabled in BIOS. if [[ "$LIBVIRT_TYPE" == "kvm" ]]; then apt_get install libvirt-bin sudo modprobe kvm || true if [ ! -e /dev/kvm ]; then echo "WARNING: Switching to QEMU" LIBVIRT_TYPE=qemu fi fi # Install and configure **LXC** if specified. LXC is another approach to # splitting a system into many smaller parts. LXC uses cgroups and chroot # to simulate multiple systems. if [[ "$LIBVIRT_TYPE" == "lxc" ]]; then apt_get install lxc # lxc uses cgroups (a kernel interface via virtual filesystem) configured # and mounted to ``/cgroup`` sudo mkdir -p /cgroup if ! grep -q cgroup /etc/fstab; then echo none /cgroup cgroup cpuacct,memory,devices,cpu,freezer,blkio 0 0 | sudo tee -a /etc/fstab fi if ! mount -n | grep -q cgroup; then sudo mount /cgroup fi fi # The user that nova runs as needs to be member of libvirtd group otherwise # nova-compute will be unable to use libvirt. sudo usermod -a -G libvirtd `whoami` # libvirt detects various settings on startup, as we potentially changed # the system configuration (modules, filesystems), we need to restart # libvirt to detect those changes. sudo /etc/init.d/libvirt-bin restart # Instance Storage # ~~~~~~~~~~~~~~~~ # Nova stores each instance in its own directory. mkdir -p $NOVA_DIR/instances # You can specify a different disk to be mounted and used for backing the # virtual machines. If there is a partition labeled nova-instances we # mount it (ext filesystems can be labeled via e2label). if [ -L /dev/disk/by-label/nova-instances ]; then if ! mount -n | grep -q $NOVA_DIR/instances; then sudo mount -L nova-instances $NOVA_DIR/instances sudo chown -R `whoami` $NOVA_DIR/instances fi fi # Clean out the instances directory. sudo rm -rf $NOVA_DIR/instances/* fi if [[ "$ENABLED_SERVICES" =~ "n-net" ]]; then # delete traces of nova networks from prior runs sudo killall dnsmasq || true rm -rf $NOVA_DIR/networks mkdir -p $NOVA_DIR/networks fi # Storage Service if [[ "$ENABLED_SERVICES" =~ "swift" ]]; then # We first do a bit of setup by creating the directories and # changing the permissions so we can run it as our user. USER_GROUP=$(id -g) sudo mkdir -p ${SWIFT_DATA_LOCATION}/drives sudo chown -R $USER:${USER_GROUP} ${SWIFT_DATA_LOCATION}/drives # We then create a loopback disk and format it to XFS. if [[ ! -e ${SWIFT_DATA_LOCATION}/drives/images/swift.img ]]; then mkdir -p ${SWIFT_DATA_LOCATION}/drives/images sudo touch ${SWIFT_DATA_LOCATION}/drives/images/swift.img sudo chown $USER: ${SWIFT_DATA_LOCATION}/drives/images/swift.img dd if=/dev/zero of=${SWIFT_DATA_LOCATION}/drives/images/swift.img \ bs=1024 count=0 seek=${SWIFT_LOOPBACK_DISK_SIZE} mkfs.xfs -f -i size=1024 ${SWIFT_DATA_LOCATION}/drives/images/swift.img fi # After the drive being created we mount the disk with a few mount # options to make it most efficient as possible for swift. mkdir -p ${SWIFT_DATA_LOCATION}/drives/sdb1 if ! egrep -q ${SWIFT_DATA_LOCATION}/drives/sdb1 /proc/mounts; then sudo mount -t xfs -o loop,noatime,nodiratime,nobarrier,logbufs=8 \ ${SWIFT_DATA_LOCATION}/drives/images/swift.img ${SWIFT_DATA_LOCATION}/drives/sdb1 fi # We then create link to that mounted location so swift would know # where to go. for x in {1..4}; do sudo ln -sf ${SWIFT_DATA_LOCATION}/drives/sdb1/$x ${SWIFT_DATA_LOCATION}/$x; done # We now have to emulate a few different servers into one we # create all the directories needed for swift tmpd="" for d in ${SWIFT_DATA_LOCATION}/drives/sdb1/{1..4} \ ${SWIFT_CONFIG_LOCATION}/{object,container,account}-server \ ${SWIFT_DATA_LOCATION}/{1..4}/node/sdb1 /var/run/swift; do [[ -d $d ]] && continue sudo install -o ${USER} -g $USER_GROUP -d $d done # We do want to make sure this is all owned by our user. sudo chown -R $USER: ${SWIFT_DATA_LOCATION}/{1..4}/node sudo chown -R $USER: ${SWIFT_CONFIG_LOCATION} # swift-init has a bug using /etc/swift until bug #885595 is fixed # we have to create a link sudo ln -sf ${SWIFT_CONFIG_LOCATION} /etc/swift # Swift use rsync to syncronize between all the different # partitions (which make more sense when you have a multi-node # setup) we configure it with our version of rsync. sed -e "s/%GROUP%/${USER_GROUP}/;s/%USER%/$USER/;s,%SWIFT_DATA_LOCATION%,$SWIFT_DATA_LOCATION," $FILES/swift/rsyncd.conf | sudo tee /etc/rsyncd.conf sudo sed -i '/^RSYNC_ENABLE=false/ { s/false/true/ }' /etc/default/rsync # By default Swift will be installed with the tempauth middleware # which has some default username and password if you have # configured keystone it will checkout the directory. if [[ "$ENABLED_SERVICES" =~ "key" ]]; then swift_auth_server=keystone # We install the memcache server as this is will be used by the # middleware to cache the tokens auths for a long this is needed. apt_get install memcached # We need a special version of bin/swift which understand the # OpenStack api 2.0, we download it until this is getting # integrated in swift. sudo curl -s -o/usr/local/bin/swift \ 'https://review.openstack.org/gitweb?p=openstack/swift.git;a=blob_plain;f=bin/swift;hb=48bfda6e2fdf3886c98bd15649887d54b9a2574e' else swift_auth_server=tempauth fi # We do the install of the proxy-server and swift configuration # replacing a few directives to match our configuration. sed "s,%SWIFT_CONFIG_LOCATION%,${SWIFT_CONFIG_LOCATION},;s/%USER%/$USER/;s/%SERVICE_TOKEN%/${SERVICE_TOKEN}/;s/%AUTH_SERVER%/${swift_auth_server}/" \ $FILES/swift/proxy-server.conf|sudo tee ${SWIFT_CONFIG_LOCATION}/proxy-server.conf sed -e "s/%SWIFT_HASH%/$SWIFT_HASH/" $FILES/swift/swift.conf > ${SWIFT_CONFIG_LOCATION}/swift.conf # We need to generate a object/account/proxy configuration # emulating 4 nodes on different ports we have a little function # that help us doing that. function generate_swift_configuration() { local server_type=$1 local bind_port=$2 local log_facility=$3 local node_number for node_number in {1..4}; do node_path=${SWIFT_DATA_LOCATION}/${node_number} sed -e "s,%SWIFT_CONFIG_LOCATION%,${SWIFT_CONFIG_LOCATION},;s,%USER%,$USER,;s,%NODE_PATH%,${node_path},;s,%BIND_PORT%,${bind_port},;s,%LOG_FACILITY%,${log_facility}," \ $FILES/swift/${server_type}-server.conf > ${SWIFT_CONFIG_LOCATION}/${server_type}-server/${node_number}.conf bind_port=$(( ${bind_port} + 10 )) log_facility=$(( ${log_facility} + 1 )) done } generate_swift_configuration object 6010 2 generate_swift_configuration container 6011 2 generate_swift_configuration account 6012 2 # We create two helper scripts : # # - swift-remakerings # Allow to recreate rings from scratch. # - swift-startmain # Restart your full cluster. # sed -e "s,%SWIFT_CONFIG_LOCATION%,${SWIFT_CONFIG_LOCATION},;s/%SWIFT_PARTITION_POWER_SIZE%/$SWIFT_PARTITION_POWER_SIZE/" $FILES/swift/swift-remakerings | \ sudo tee /usr/local/bin/swift-remakerings sudo install -m755 $FILES/swift/swift-startmain /usr/local/bin/ sudo chmod +x /usr/local/bin/swift-* # We then can start rsync. sudo /etc/init.d/rsync restart || : # Create our ring for the object/container/account. /usr/local/bin/swift-remakerings # And now we launch swift-startmain to get our cluster running # ready to be tested. /usr/local/bin/swift-startmain || : unset s swift_hash swift_auth_server tmpd fi # Volume Service # -------------- if [[ "$ENABLED_SERVICES" =~ "n-vol" ]]; then # # Configure a default volume group called 'nova-volumes' for the nova-volume # 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 'nova-volumes' before # invoking stack.sh. # # By default, the backing file is 2G in size, and is stored in /opt/stack. apt_get install iscsitarget-dkms iscsitarget if ! sudo vgdisplay | grep -q $VOLUME_GROUP; then VOLUME_BACKING_FILE=${VOLUME_BACKING_FILE:-$DEST/nova-volumes-backing-file} VOLUME_BACKING_FILE_SIZE=${VOLUME_BACKING_FILE_SIZE:-2052M} truncate -s $VOLUME_BACKING_FILE_SIZE $VOLUME_BACKING_FILE DEV=`sudo losetup -f --show $VOLUME_BACKING_FILE` sudo vgcreate $VOLUME_GROUP $DEV fi # Configure iscsitarget sudo sed 's/ISCSITARGET_ENABLE=false/ISCSITARGET_ENABLE=true/' -i /etc/default/iscsitarget sudo /etc/init.d/iscsitarget restart fi function add_nova_flag { echo "$1" >> $NOVA_DIR/bin/nova.conf } # (re)create nova.conf rm -f $NOVA_DIR/bin/nova.conf add_nova_flag "--verbose" add_nova_flag "--allow_admin_api" add_nova_flag "--scheduler_driver=$SCHEDULER" add_nova_flag "--dhcpbridge_flagfile=$NOVA_DIR/bin/nova.conf" add_nova_flag "--fixed_range=$FIXED_RANGE" if [[ "$ENABLED_SERVICES" =~ "q-svc" ]]; then add_nova_flag "--network_manager=nova.network.quantum.manager.QuantumManager" if [[ "$Q_PLUGIN" = "openvswitch" ]]; then add_nova_flag "--libvirt_vif_type=ethernet" add_nova_flag "--libvirt_vif_driver=nova.virt.libvirt.vif.LibvirtOpenVswitchDriver" fi else add_nova_flag "--network_manager=nova.network.manager.$NET_MAN" fi if [[ "$ENABLED_SERVICES" =~ "n-vol" ]]; then add_nova_flag "--volume_group=$VOLUME_GROUP" fi add_nova_flag "--my_ip=$HOST_IP" add_nova_flag "--public_interface=$PUBLIC_INTERFACE" add_nova_flag "--vlan_interface=$VLAN_INTERFACE" add_nova_flag "--sql_connection=$BASE_SQL_CONN/nova" add_nova_flag "--libvirt_type=$LIBVIRT_TYPE" if [[ "$ENABLED_SERVICES" =~ "openstackx" ]]; then add_nova_flag "--osapi_extensions_path=$OPENSTACKX_DIR/extensions" fi if [[ "$ENABLED_SERVICES" =~ "n-vnc" ]]; then add_nova_flag "--vncproxy_url=http://$SERVICE_HOST:6080" add_nova_flag "--vncproxy_wwwroot=$NOVNC_DIR/" fi add_nova_flag "--api_paste_config=$NOVA_DIR/bin/nova-api-paste.ini" add_nova_flag "--image_service=nova.image.glance.GlanceImageService" add_nova_flag "--ec2_dmz_host=$EC2_DMZ_HOST" add_nova_flag "--rabbit_host=$RABBIT_HOST" add_nova_flag "--rabbit_password=$RABBIT_PASSWORD" add_nova_flag "--glance_api_servers=$GLANCE_HOSTPORT" add_nova_flag "--force_dhcp_release" if [ -n "$INSTANCES_PATH" ]; then add_nova_flag "--instances_path=$INSTANCES_PATH" fi if [ "$MULTI_HOST" != "False" ]; then add_nova_flag "--multi_host" add_nova_flag "--send_arp_for_ha" fi if [ "$SYSLOG" != "False" ]; then add_nova_flag "--use_syslog" fi # You can define extra nova conf flags by defining the array EXTRA_FLAGS, # For Example: EXTRA_FLAGS=(--foo --bar=2) for I in "${EXTRA_FLAGS[@]}"; do add_nova_flag $I done # XenServer # --------- if [ "$VIRT_DRIVER" = 'xenserver' ]; then read_password XENAPI_PASSWORD "ENTER A PASSWORD TO USE FOR XEN." add_nova_flag "--connection_type=xenapi" add_nova_flag "--xenapi_connection_url=http://169.254.0.1" add_nova_flag "--xenapi_connection_username=root" add_nova_flag "--xenapi_connection_password=$XENAPI_PASSWORD" add_nova_flag "--flat_injected=False" add_nova_flag "--flat_interface=eth1" add_nova_flag "--flat_network_bridge=xenbr1" add_nova_flag "--public_interface=eth3" else add_nova_flag "--flat_network_bridge=$FLAT_NETWORK_BRIDGE" if [ -n "$FLAT_INTERFACE" ]; then add_nova_flag "--flat_interface=$FLAT_INTERFACE" fi fi # Nova Database # ~~~~~~~~~~~~~ # All nova components talk to a central database. We will need to do this step # only once for an entire cluster. if [[ "$ENABLED_SERVICES" =~ "mysql" ]]; then # (re)create nova database mysql -u$MYSQL_USER -p$MYSQL_PASSWORD -e 'DROP DATABASE IF EXISTS nova;' mysql -u$MYSQL_USER -p$MYSQL_PASSWORD -e 'CREATE DATABASE nova;' # (re)create nova database $NOVA_DIR/bin/nova-manage db sync fi # Keystone # -------- if [[ "$ENABLED_SERVICES" =~ "key" ]]; then # (re)create keystone database mysql -u$MYSQL_USER -p$MYSQL_PASSWORD -e 'DROP DATABASE IF EXISTS keystone;' mysql -u$MYSQL_USER -p$MYSQL_PASSWORD -e 'CREATE DATABASE keystone;' # FIXME (anthony) keystone should use keystone.conf.example KEYSTONE_CONF=$KEYSTONE_DIR/etc/keystone.conf cp $FILES/keystone.conf $KEYSTONE_CONF sudo sed -e "s,%SQL_CONN%,$BASE_SQL_CONN/keystone,g" -i $KEYSTONE_CONF sudo sed -e "s,%DEST%,$DEST,g" -i $KEYSTONE_CONF # keystone_data.sh creates our admin user and our ``SERVICE_TOKEN``. KEYSTONE_DATA=$KEYSTONE_DIR/bin/keystone_data.sh cp $FILES/keystone_data.sh $KEYSTONE_DATA sudo sed -e "s,%SERVICE_HOST%,$SERVICE_HOST,g" -i $KEYSTONE_DATA sudo sed -e "s,%SERVICE_TOKEN%,$SERVICE_TOKEN,g" -i $KEYSTONE_DATA sudo sed -e "s,%ADMIN_PASSWORD%,$ADMIN_PASSWORD,g" -i $KEYSTONE_DATA # initialize keystone with default users/endpoints BIN_DIR=$KEYSTONE_DIR/bin bash $KEYSTONE_DATA fi # Launch Services # =============== # nova api crashes if we start it with a regular screen command, # so send the start command by forcing text into the window. # Only run the services specified in ``ENABLED_SERVICES`` # our screen helper to launch a service in a hidden named screen function screen_it { NL=`echo -ne '\015'` if [[ "$ENABLED_SERVICES" =~ "$1" ]]; then if [[ "$USE_TMUX" =~ "yes" ]]; then tmux new-window -t stack -a -n "$1" "bash" tmux send-keys "$2" C-M else screen -S stack -X screen -t $1 # sleep to allow bash to be ready to be send the command - we are # creating a new window in screen and then sends characters, so if # bash isn't running by the time we send the command, nothing happens sleep 1 screen -S stack -p $1 -X stuff "$2$NL" fi fi } # create a new named screen to run processes in screen -d -m -S stack -t stack sleep 1 # launch the glance registry service if [[ "$ENABLED_SERVICES" =~ "g-reg" ]]; then screen_it g-reg "cd $GLANCE_DIR; bin/glance-registry --config-file=etc/glance-registry.conf" fi # launch the glance api and wait for it to answer before continuing if [[ "$ENABLED_SERVICES" =~ "g-api" ]]; then screen_it g-api "cd $GLANCE_DIR; bin/glance-api --config-file=etc/glance-api.conf" echo "Waiting for g-api ($GLANCE_HOSTPORT) to start..." if ! timeout $SERVICE_TIMEOUT sh -c "while ! wget -q -O- http://$GLANCE_HOSTPORT; do sleep 1; done"; then echo "g-api did not start" exit 1 fi fi # launch the keystone and wait for it to answer before continuing if [[ "$ENABLED_SERVICES" =~ "key" ]]; then screen_it key "cd $KEYSTONE_DIR && $KEYSTONE_DIR/bin/keystone --config-file $KEYSTONE_CONF -d" echo "Waiting for keystone to start..." if ! timeout $SERVICE_TIMEOUT sh -c "while ! wget -q -O- http://127.0.0.1:5000; do sleep 1; done"; then echo "keystone did not start" exit 1 fi fi # launch the nova-api and wait for it to answer before continuing if [[ "$ENABLED_SERVICES" =~ "n-api" ]]; then screen_it n-api "cd $NOVA_DIR && $NOVA_DIR/bin/nova-api" echo "Waiting for nova-api to start..." if ! timeout $SERVICE_TIMEOUT sh -c "while ! wget -q -O- http://127.0.0.1:8774; do sleep 1; done"; then echo "nova-api did not start" exit 1 fi fi # Quantum if [[ "$ENABLED_SERVICES" =~ "q-svc" ]]; then # Install deps # FIXME add to files/apts/quantum, but don't install if not needed! apt_get install openvswitch-switch openvswitch-datapath-dkms # Create database for the plugin/agent if [[ "$Q_PLUGIN" = "openvswitch" ]]; then if [[ "$ENABLED_SERVICES" =~ "mysql" ]]; then mysql -u$MYSQL_USER -p$MYSQL_PASSWORD -e 'CREATE DATABASE IF NOT EXISTS ovs_quantum;' else echo "mysql must be enabled in order to use the $Q_PLUGIN Quantum plugin." exit 1 fi fi QUANTUM_PLUGIN_INI_FILE=$QUANTUM_DIR/quantum/plugins.ini # Make sure we're using the openvswitch plugin sed -i -e "s/^provider =.*$/provider = quantum.plugins.openvswitch.ovs_quantum_plugin.OVSQuantumPlugin/g" $QUANTUM_PLUGIN_INI_FILE screen_it q-svc "cd $QUANTUM_DIR && export PYTHONPATH=.:$PYTHONPATH; python $QUANTUM_DIR/bin/quantum $QUANTUM_DIR/etc/quantum.conf" fi # Quantum agent (for compute nodes) if [[ "$ENABLED_SERVICES" =~ "q-agt" ]]; then if [[ "$Q_PLUGIN" = "openvswitch" ]]; then # Set up integration bridge OVS_BRIDGE=${OVS_BRIDGE:-br-int} sudo ovs-vsctl --no-wait -- --if-exists del-br $OVS_BRIDGE sudo ovs-vsctl --no-wait add-br $OVS_BRIDGE sudo ovs-vsctl --no-wait br-set-external-id $OVS_BRIDGE bridge-id br-int fi # Start up the quantum <-> openvswitch agent screen_it q-agt "sleep 4; sudo python $QUANTUM_DIR/quantum/plugins/openvswitch/agent/ovs_quantum_agent.py $QUANTUM_DIR/quantum/plugins/openvswitch/ovs_quantum_plugin.ini -v" fi # If we're using Quantum (i.e. q-svc is enabled), network creation has to # happen after we've started the Quantum service. if [[ "$ENABLED_SERVICES" =~ "mysql" ]]; then # create a small network $NOVA_DIR/bin/nova-manage network create private $FIXED_RANGE 1 $FIXED_NETWORK_SIZE if [[ "$ENABLED_SERVICES" =~ "q-svc" ]]; then echo "Not creating floating IPs (not supported by QuantumManager)" else # create some floating ips $NOVA_DIR/bin/nova-manage floating create $FLOATING_RANGE fi fi # Launching nova-compute should be as simple as running ``nova-compute`` but # have to do a little more than that in our script. Since we add the group # ``libvirtd`` to our user in this script, when nova-compute is run it is # within the context of our original shell (so our groups won't be updated). # Use 'sg' to execute nova-compute as a member of the libvirtd group. screen_it n-cpu "cd $NOVA_DIR && sg libvirtd $NOVA_DIR/bin/nova-compute" screen_it n-vol "cd $NOVA_DIR && $NOVA_DIR/bin/nova-volume" screen_it n-net "cd $NOVA_DIR && $NOVA_DIR/bin/nova-network" screen_it n-sch "cd $NOVA_DIR && $NOVA_DIR/bin/nova-scheduler" if [[ "$ENABLED_SERVICES" =~ "n-vnc" ]]; then screen_it n-vnc "cd $NOVNC_DIR && ./utils/nova-wsproxy.py --flagfile $NOVA_DIR/bin/nova.conf --web . 6080" fi if [[ "$ENABLED_SERVICES" =~ "horizon" ]]; then screen_it horizon "cd $HORIZON_DIR && sudo tail -f /var/log/apache2/error.log" fi # Install Images # ============== # Upload an image to glance. # # The default image is a small ***TTY*** testing image, which lets you login # the username/password of root/password. # # TTY also uses cloud-init, supporting login via keypair and sending scripts as # userdata. See https://help.ubuntu.com/community/CloudInit for more on cloud-init # # Override ``IMAGE_URLS`` with a comma-separated list of uec images. # # * **natty**: http://uec-images.ubuntu.com/natty/current/natty-server-cloudimg-amd64.tar.gz # * **oneiric**: http://uec-images.ubuntu.com/oneiric/current/oneiric-server-cloudimg-amd64.tar.gz if [[ "$ENABLED_SERVICES" =~ "g-reg" ]]; then # Create a directory for the downloaded image tarballs. mkdir -p $FILES/images # Option to upload legacy ami-tty, which works with xenserver if [ $UPLOAD_LEGACY_TTY ]; then if [ ! -f $FILES/tty.tgz ]; then wget -c http://images.ansolabs.com/tty.tgz -O $FILES/tty.tgz fi tar -zxf $FILES/tty.tgz -C $FILES/images RVAL=`glance add -A $SERVICE_TOKEN name="tty-kernel" is_public=true container_format=aki disk_format=aki < $FILES/images/aki-tty/image` KERNEL_ID=`echo $RVAL | cut -d":" -f2 | tr -d " "` RVAL=`glance add -A $SERVICE_TOKEN name="tty-ramdisk" is_public=true container_format=ari disk_format=ari < $FILES/images/ari-tty/image` RAMDISK_ID=`echo $RVAL | cut -d":" -f2 | tr -d " "` glance add -A $SERVICE_TOKEN name="tty" is_public=true container_format=ami disk_format=ami kernel_id=$KERNEL_ID ramdisk_id=$RAMDISK_ID < $FILES/images/ami-tty/image fi for image_url in ${IMAGE_URLS//,/ }; do # Downloads the image (uec ami+aki style), then extracts it. IMAGE_FNAME=`basename "$image_url"` IMAGE_NAME=`basename "$IMAGE_FNAME" .tar.gz` if [ ! -f $FILES/$IMAGE_FNAME ]; then wget -c $image_url -O $FILES/$IMAGE_FNAME fi # Extract ami and aki files tar -zxf $FILES/$IMAGE_FNAME -C $FILES/images # Use glance client to add the kernel the root filesystem. # We parse the results of the first upload to get the glance ID of the # kernel for use when uploading the root filesystem. RVAL=`glance add -A $SERVICE_TOKEN name="$IMAGE_NAME-kernel" is_public=true container_format=aki disk_format=aki < $FILES/images/$IMAGE_NAME-vmlinuz*` KERNEL_ID=`echo $RVAL | cut -d":" -f2 | tr -d " "` glance add -A $SERVICE_TOKEN name="$IMAGE_NAME" is_public=true container_format=ami disk_format=ami kernel_id=$KERNEL_ID < $FILES/images/$IMAGE_NAME.img done fi # Fin # === ) 2>&1 | tee "${LOGFILE}" # Check that the left side of the above pipe succeeded for ret in "${PIPESTATUS[@]}"; do [ $ret -eq 0 ] || exit $ret; done ( # Using the cloud # =============== echo "" echo "" echo "" # If you installed the horizon on this server, then you should be able # to access the site using your browser. if [[ "$ENABLED_SERVICES" =~ "horizon" ]]; then echo "horizon is now available at http://$SERVICE_HOST/" fi # If keystone is present, you can point nova cli to this server if [[ "$ENABLED_SERVICES" =~ "key" ]]; then echo "keystone is serving at http://$SERVICE_HOST:5000/v2.0/" echo "examples on using novaclient command line is in exercise.sh" echo "the default users are: admin and demo" echo "the password: $ADMIN_PASSWORD" fi # indicate how long this took to run (bash maintained variable 'SECONDS') echo "stack.sh completed in $SECONDS seconds." ) | tee -a "$LOGFILE" devstack-diablo-eol/stackrc000066400000000000000000000032721207307670500162570ustar00rootroot00000000000000# compute service NOVA_REPO=https://github.com/openstack/nova.git NOVA_BRANCH=stable/diablo # storage service SWIFT_REPO=https://github.com/openstack/swift.git SWIFT_BRANCH=stable/diablo # swift and keystone integration SWIFT_KEYSTONE_REPO=https://github.com/cloudbuilders/swift-keystone2.git SWIFT_KEYSTONE_BRANCH=master # image catalog service GLANCE_REPO=https://github.com/openstack/glance.git GLANCE_BRANCH=stable/diablo # unified auth system (manages accounts/tokens) KEYSTONE_REPO=https://github.com/openstack/keystone.git KEYSTONE_BRANCH=stable/diablo # a websockets/html5 or flash powered VNC console for vm instances NOVNC_REPO=https://github.com/cloudbuilders/noVNC.git NOVNC_BRANCH=diablo # django powered web control panel for openstack HORIZON_REPO=https://github.com/openstack/horizon.git HORIZON_BRANCH=stable/diablo # python client library to nova that horizon (and others) use NOVACLIENT_REPO=https://github.com/openstack/python-novaclient.git NOVACLIENT_BRANCH=master # openstackx is a collection of extensions to openstack.compute & nova # that is *deprecated*. The code is being moved into python-novaclient & nova. OPENSTACKX_REPO=https://github.com/cloudbuilders/openstackx.git OPENSTACKX_BRANCH=diablo # quantum service QUANTUM_REPO=https://github.com/openstack/quantum QUANTUM_BRANCH=stable/diablo # CI test suite CITEST_REPO=https://github.com/openstack/openstack-integration-tests.git CITEST_BRANCH=master # Specify a comma-separated list of uec images to download and install into glance. IMAGE_URLS=http://smoser.brickies.net/ubuntu/ttylinux-uec/ttylinux-uec-amd64-11.2_2.6.35-15_1.tar.gz # allow local overrides of env variables if [ -f ./localrc ]; then source ./localrc fi devstack-diablo-eol/tools/000077500000000000000000000000001207307670500160365ustar00rootroot00000000000000devstack-diablo-eol/tools/build_bm.sh000077500000000000000000000012311207307670500201470ustar00rootroot00000000000000#!/usr/bin/env bash # Build an OpenStack install on a bare metal machine. set +x # Source params source ./stackrc # Param string to pass to stack.sh. Like "EC2_DMZ_HOST=192.168.1.1 MYSQL_USER=nova" STACKSH_PARAMS=${STACKSH_PARAMS:-} # Option to use the version of devstack on which we are currently working USE_CURRENT_DEVSTACK=${USE_CURRENT_DEVSTACK:-1} # Configure the runner RUN_SH=`mktemp` cat > $RUN_SH <$CONFIG_CONF_TMP <$CONFIG_INI_TMP <$CONFIG_INI_TMP <>$CONFIG_INI_TMP <$CFG <$PXEDIR/stack-initrd.gz fi cp -pu $PXEDIR/stack-initrd.gz $DEST_DIR/ubuntu if [ ! -r $PXEDIR/vmlinuz-*-generic ]; then MNTDIR=`mktemp -d --tmpdir mntXXXXXXXX` mount -t ext4 -o loop $PXEDIR/stack-initrd.img $MNTDIR if [ ! -r $MNTDIR/boot/vmlinuz-*-generic ]; then echo "No kernel found" umount $MNTDIR rmdir $MNTDIR exit 1 else cp -pu $MNTDIR/boot/vmlinuz-*-generic $PXEDIR fi umount $MNTDIR rmdir $MNTDIR fi # Get generic kernel version KNAME=`basename $PXEDIR/vmlinuz-*-generic` KVER=${KNAME#vmlinuz-} cp -pu $PXEDIR/vmlinuz-$KVER $DEST_DIR/ubuntu cat >>$CFG <>$CFG <>$CFG <> $MNTDIR/etc/sudoers umount $MNTDIR rmdir $MNTDIR qemu-nbd -d $NBD NBD="" mv $DEV_FILE_TMP $DEV_FILE fi rm -f $DEV_FILE_TMP # clone git repositories onto the system # ====================================== IMG_FILE_TMP=`mktemp $IMG_FILE.XXXXXX` if [ ! -r $IMG_FILE ]; then NBD=`map_nbd $DEV_FILE` # Pre-create the image file # FIXME(dt): This should really get the partition size to # pre-create the image file dd if=/dev/zero of=$IMG_FILE_TMP bs=1 count=1 seek=$((2*1024*1024*1024)) # Create filesystem image for RAM disk dd if=${NBD}p1 of=$IMG_FILE_TMP bs=1M qemu-nbd -d $NBD NBD="" mv $IMG_FILE_TMP $IMG_FILE fi rm -f $IMG_FILE_TMP MNTDIR=`mktemp -d --tmpdir mntXXXXXXXX` mount -t ext4 -o loop $IMG_FILE $MNTDIR cp -p /etc/resolv.conf $MNTDIR/etc/resolv.conf # We need to install a non-virtual kernel and modules to boot from if [ ! -r "`ls $MNTDIR/boot/vmlinuz-*-generic | head -1`" ]; then chroot $MNTDIR apt-get install -y linux-generic fi # git clone only if directory doesn't exist already. Since ``DEST`` might not # be owned by the installation user, we create the directory and change the # ownership to the proper user. function git_clone { # clone new copy or fetch latest changes CHECKOUT=${MNTDIR}$2 if [ ! -d $CHECKOUT ]; then mkdir -p $CHECKOUT git clone $1 $CHECKOUT else pushd $CHECKOUT git fetch popd fi # FIXME(ja): checkout specified version (should works for branches and tags) pushd $CHECKOUT # checkout the proper branch/tag git checkout $3 # force our local version to be the same as the remote version git reset --hard origin/$3 popd # give ownership to the stack user chroot $MNTDIR chown -R stack $2 } git_clone $NOVA_REPO $DEST/nova $NOVA_BRANCH git_clone $GLANCE_REPO $DEST/glance $GLANCE_BRANCH git_clone $KEYSTONE_REPO $DEST/keystone $KEYSTONE_BRANCH git_clone $NOVNC_REPO $DEST/novnc $NOVNC_BRANCH git_clone $HORIZON_REPO $DEST/horizon $HORIZON_BRANCH git_clone $NOVACLIENT_REPO $DEST/python-novaclient $NOVACLIENT_BRANCH git_clone $OPENSTACKX_REPO $DEST/openstackx $OPENSTACKX_BRANCH # Use this version of devstack rm -rf $MNTDIR/$DEST/devstack cp -pr $CWD $MNTDIR/$DEST/devstack chroot $MNTDIR chown -R stack $DEST/devstack # Configure host network for DHCP mkdir -p $MNTDIR/etc/network cat > $MNTDIR/etc/network/interfaces <$MNTDIR/etc/hostname echo "127.0.0.1 localhost ramstack" >$MNTDIR/etc/hosts # Configure the runner RUN_SH=$MNTDIR/$DEST/run.sh cat > $RUN_SH < $DEST/run.sh.log echo >> $DEST/run.sh.log echo >> $DEST/run.sh.log echo "All done! Time to start clicking." >> $DEST/run.sh.log EOF # Make the run.sh executable chmod 755 $RUN_SH chroot $MNTDIR chown stack $DEST/run.sh umount $MNTDIR rmdir $MNTDIR devstack-diablo-eol/tools/build_uec.sh000077500000000000000000000173511207307670500203370ustar00rootroot00000000000000#!/usr/bin/env bash # Make sure that we have the proper version of ubuntu (only works on oneiric) if ! egrep -q "oneiric" /etc/lsb-release; then echo "This script only works with ubuntu oneiric." exit 1 fi # Keep track of the current directory TOOLS_DIR=$(cd $(dirname "$0") && pwd) TOP_DIR=`cd $TOOLS_DIR/..; pwd` cd $TOP_DIR # Source params source ./stackrc # Ubuntu distro to install DIST_NAME=${DIST_NAME:-oneiric} # Configure how large the VM should be GUEST_SIZE=${GUEST_SIZE:-10G} # exit on error to stop unexpected errors set -o errexit set -o xtrace # Abort if localrc is not set if [ ! -e $TOP_DIR/localrc ]; then echo "You must have a localrc with ALL necessary passwords defined before proceeding." echo "See stack.sh for required passwords." exit 1 fi # Install deps if needed DEPS="kvm libvirt-bin kpartx cloud-utils curl" apt-get install -y --force-yes $DEPS || true # allow this to fail gracefully for concurrent builds # Where to store files and instances WORK_DIR=${WORK_DIR:-/opt/uecstack} # Where to store images image_dir=$WORK_DIR/images/$DIST_NAME mkdir -p $image_dir # Start over with a clean base image, if desired if [ $CLEAN_BASE ]; then rm -f $image_dir/disk fi # Get the base image if it does not yet exist if [ ! -e $image_dir/disk ]; then $TOOLS_DIR/get_uec_image.sh -r $GUEST_SIZE $DIST_NAME $image_dir/disk $image_dir/kernel fi # Copy over dev environment if COPY_ENV is set. # This will also copy over your current devstack. if [ $COPY_ENV ]; then cd $TOOLS_DIR ./copy_dev_environment_to_uec.sh $image_dir/disk fi # Option to warm the base image with software requirements. if [ $WARM_CACHE ]; then cd $TOOLS_DIR ./warm_apts_and_pips_for_uec.sh $image_dir/disk fi # Name of our instance, used by libvirt GUEST_NAME=${GUEST_NAME:-devstack} # Mop up after previous runs virsh destroy $GUEST_NAME || true # Where this vm is stored vm_dir=$WORK_DIR/instances/$GUEST_NAME # Create vm dir and remove old disk mkdir -p $vm_dir rm -f $vm_dir/disk # Create a copy of the base image qemu-img create -f qcow2 -b $image_dir/disk $vm_dir/disk # Back to devstack cd $TOP_DIR GUEST_NETWORK=${GUEST_NETWORK:-1} GUEST_RECREATE_NET=${GUEST_RECREATE_NET:-yes} GUEST_IP=${GUEST_IP:-192.168.$GUEST_NETWORK.50} GUEST_CIDR=${GUEST_CIDR:-$GUEST_IP/24} GUEST_NETMASK=${GUEST_NETMASK:-255.255.255.0} GUEST_GATEWAY=${GUEST_GATEWAY:-192.168.$GUEST_NETWORK.1} GUEST_MAC=${GUEST_MAC:-"02:16:3e:07:69:`printf '%02X' $GUEST_NETWORK`"} GUEST_RAM=${GUEST_RAM:-1524288} GUEST_CORES=${GUEST_CORES:-1} # libvirt.xml configuration NET_XML=$vm_dir/net.xml NET_NAME=${NET_NAME:-devstack-$GUEST_NETWORK} cat > $NET_XML < $NET_NAME EOF if [[ "$GUEST_RECREATE_NET" == "yes" ]]; then virsh net-destroy $NET_NAME || true # destroying the network isn't enough to delete the leases rm -f /var/lib/libvirt/dnsmasq/$NET_NAME.leases virsh net-create $vm_dir/net.xml fi # libvirt.xml configuration LIBVIRT_XML=$vm_dir/libvirt.xml cat > $LIBVIRT_XML < $GUEST_NAME $GUEST_RAM hvm $image_dir/kernel root=/dev/vda ro console=ttyS0 init=/usr/lib/cloud-init/uncloud-init ds=nocloud-net;s=http://192.168.$GUEST_NETWORK.1:4567/ ubuntu-pass=ubuntu $GUEST_CORES EOF rm -rf $vm_dir/uec cp -r $TOOLS_DIR/uec $vm_dir/uec # set metadata cat > $vm_dir/uec/meta-data< $vm_dir/uec/user-data< localrc <> $vm_dir/uec/user-data< /opt/stack/.ssh/authorized_keys chown -R stack /opt/stack chmod 700 /opt/stack/.ssh chmod 600 /opt/stack/.ssh/authorized_keys grep -q "^#includedir.*/etc/sudoers.d" /etc/sudoers || echo "#includedir /etc/sudoers.d" >> /etc/sudoers ( umask 226 && echo "stack ALL=(ALL) NOPASSWD:ALL" \ > /etc/sudoers.d/50_stack_sh ) EOF fi # Run stack.sh cat >> $vm_dir/uec/user-data< $MNT_DIR/etc/network/interfaces <$MNT_DIR/etc/hostname echo "127.0.0.1 localhost ramstack" >$MNT_DIR/etc/hosts # Configure the runner RUN_SH=$MNT_DIR/$DEST/run.sh cat > $RUN_SH < $DEST/run.sh.log echo >> $DEST/run.sh.log echo >> $DEST/run.sh.log echo "All done! Time to start clicking." >> $DEST/run.sh.log EOF # Make the run.sh executable chmod 755 $RUN_SH chroot $MNT_DIR chown stack $DEST/run.sh umount $MNT_DIR/dev umount $MNT_DIR rmdir $MNT_DIR mv $DEST_FILE_TMP $DEST_FILE rm -f $DEST_FILE_TMP trap - SIGHUP SIGINT SIGTERM SIGQUIT EXIT devstack-diablo-eol/tools/build_usb_boot.sh000077500000000000000000000064021207307670500213720ustar00rootroot00000000000000#!/bin/bash -e # build_usb_boot.sh - Create a syslinux boot environment # # build_usb_boot.sh destdev # # Assumes syslinux is installed # Needs to run as root DEST_DIR=${1:-/tmp/syslinux-boot} PXEDIR=${PXEDIR:-/opt/ramstack/pxe} PROGDIR=`dirname $0` # Clean up any resources that may be in use cleanup() { set +o errexit # Mop up temporary files if [ -n "$DEST_DEV" ]; then umount $DEST_DIR rmdir $DEST_DIR fi if [ -n "$MNTDIR" -a -d "$MNTDIR" ]; then umount $MNTDIR rmdir $MNTDIR fi # Kill ourselves to signal any calling process trap 2; kill -2 $$ } trap cleanup SIGHUP SIGINT SIGTERM SIGQUIT EXIT # Keep track of the current directory TOOLS_DIR=$(cd $(dirname "$0") && pwd) TOP_DIR=`cd $TOOLS_DIR/..; pwd` if [ -b $DEST_DIR ]; then # We have a block device, install syslinux and mount it DEST_DEV=$DEST_DIR DEST_DIR=`mktemp -d --tmpdir mntXXXXXX` mount $DEST_DEV $DEST_DIR if [ ! -d $DEST_DIR/syslinux ]; then mkdir -p $DEST_DIR/syslinux fi # Install syslinux on the device syslinux --install --directory syslinux $DEST_DEV else # We have a directory (for sanity checking output) DEST_DEV="" if [ ! -d $DEST_DIR/syslinux ]; then mkdir -p $DEST_DIR/syslinux fi fi # Get some more stuff from syslinux for i in memdisk menu.c32; do cp -pu /usr/lib/syslinux/$i $DEST_DIR/syslinux done CFG=$DEST_DIR/syslinux/syslinux.cfg cat >$CFG <$PXEDIR/stack-initrd.gz fi cp -pu $PXEDIR/stack-initrd.gz $DEST_DIR/ubuntu if [ ! -r $PXEDIR/vmlinuz-*-generic ]; then MNTDIR=`mktemp -d --tmpdir mntXXXXXXXX` mount -t ext4 -o loop $PXEDIR/stack-initrd.img $MNTDIR if [ ! -r $MNTDIR/boot/vmlinuz-*-generic ]; then echo "No kernel found" umount $MNTDIR rmdir $MNTDIR if [ -n "$DEST_DEV" ]; then umount $DEST_DIR rmdir $DEST_DIR fi exit 1 else cp -pu $MNTDIR/boot/vmlinuz-*-generic $PXEDIR fi umount $MNTDIR rmdir $MNTDIR fi # Get generic kernel version KNAME=`basename $PXEDIR/vmlinuz-*-generic` KVER=${KNAME#vmlinuz-} cp -pu $PXEDIR/vmlinuz-$KVER $DEST_DIR/ubuntu cat >>$CFG <>$CFG <>$CFG < $STAGING_DIR/etc/sudoers.d/50_stack_sh ) # Gracefully cp only if source file/dir exists function cp_it { if [ -e $1 ] || [ -d $1 ]; then cp -pRL $1 $2 fi } # Copy over your ssh keys and env if desired cp_it ~/.ssh $STAGING_DIR/$DEST/.ssh cp_it ~/.ssh/id_rsa.pub $STAGING_DIR/$DEST/.ssh/authorized_keys cp_it ~/.gitconfig $STAGING_DIR/$DEST/.gitconfig cp_it ~/.vimrc $STAGING_DIR/$DEST/.vimrc cp_it ~/.bashrc $STAGING_DIR/$DEST/.bashrc # Copy devstack rm -rf $STAGING_DIR/$DEST/devstack cp_it . $STAGING_DIR/$DEST/devstack # Give stack ownership over $DEST so it may do the work needed chroot $STAGING_DIR chown -R stack $DEST # Unmount umount $STAGING_DIR devstack-diablo-eol/tools/get_uec_image.sh000077500000000000000000000045371207307670500211630ustar00rootroot00000000000000#!/bin/bash # get_uec_image.sh - Prepare Ubuntu UEC images CACHEDIR=${CACHEDIR:-/opt/stack/cache} ROOTSIZE=${ROOTSIZE:-2000} # Keep track of the current directory TOOLS_DIR=$(cd $(dirname "$0") && pwd) TOP_DIR=`cd $TOOLS_DIR/..; pwd` # exit on error to stop unexpected errors set -o errexit usage() { echo "Usage: $0 - Fetch and prepare Ubuntu images" echo "" echo "$0 [-r rootsize] release imagefile [kernel]" echo "" echo "-r size - root fs size (min 2000MB)" echo "release - Ubuntu release: jaunty - oneric" echo "imagefile - output image file" echo "kernel - output kernel" exit 1 } # Clean up any resources that may be in use cleanup() { set +o errexit # Mop up temporary files if [ -n "$IMG_FILE_TMP" -a -e "$IMG_FILE_TMP" ]; then rm -f $IMG_FILE_TMP fi # Kill ourselves to signal any calling process trap 2; kill -2 $$ } while getopts hr: c; do case $c in h) usage ;; r) ROOTSIZE=$OPTARG ;; esac done shift `expr $OPTIND - 1` if [[ ! "$#" -eq "2" && ! "$#" -eq "3" ]]; then usage fi # Default args DIST_NAME=$1 IMG_FILE=$2 IMG_FILE_TMP=`mktemp $IMG_FILE.XXXXXX` KERNEL=$3 case $DIST_NAME in oneiric) ;; natty) ;; maverick) ;; lucid) ;; *) echo "Unknown release: $DIST_NAME" usage ;; esac trap cleanup SIGHUP SIGINT SIGTERM SIGQUIT EXIT # Check dependencies if [ ! -x "`which qemu-img`" -o -z "`dpkg -l | grep cloud-utils`" ]; then # Missing KVM? apt_get install qemu-kvm cloud-utils fi # Find resize script RESIZE=`which resize-part-image || which uec-resize-image` if [ -z "$RESIZE" ]; then echo "resize tool from cloud-utils not found" exit 1 fi # Get the UEC image UEC_NAME=$DIST_NAME-server-cloudimg-amd64 if [ ! -d $CACHEDIR ]; then mkdir -p $CACHEDIR/$DIST_NAME fi if [ ! -e $CACHEDIR/$DIST_NAME/$UEC_NAME.tar.gz ]; then (cd $CACHEDIR/$DIST_NAME && wget -N http://uec-images.ubuntu.com/$DIST_NAME/current/$UEC_NAME.tar.gz) (cd $CACHEDIR/$DIST_NAME && tar Sxvzf $UEC_NAME.tar.gz) fi $RESIZE $CACHEDIR/$DIST_NAME/$UEC_NAME.img ${ROOTSIZE} $IMG_FILE_TMP mv $IMG_FILE_TMP $IMG_FILE # Copy kernel to destination if [ -n "$KERNEL" ]; then cp -p $CACHEDIR/$DIST_NAME/*-vmlinuz-virtual $KERNEL fi trap - SIGHUP SIGINT SIGTERM SIGQUIT EXIT devstack-diablo-eol/tools/install_openvpn.sh000077500000000000000000000105341207307670500216130ustar00rootroot00000000000000#!/bin/bash # install_openvpn.sh - Install OpenVPN and generate required certificates # # install_openvpn.sh --client name # install_openvpn.sh --server [name] # # name is used on the CN of the generated cert, and the filename of # the configuration, certificate and key files. # # --server mode configures the host with a running OpenVPN server instance # --client mode creates a tarball of a client configuration for this server # Get config file if [ -e localrc.vpn ]; then . localrc.vpn fi # VPN Config VPN_SERVER=${VPN_SERVER:-`ifconfig eth0 | awk "/inet addr:/ { print \$2 }" | cut -d: -f2`} # 50.56.12.212 VPN_PROTO=${VPN_PROTO:-tcp} VPN_PORT=${VPN_PORT:-6081} VPN_DEV=${VPN_DEV:-tun} VPN_BRIDGE=${VPN_BRIDGE:-br0} VPN_CLIENT_NET=${VPN_CLIENT_NET:-172.16.28.0} VPN_CLIENT_MASK=${VPN_CLIENT_MASK:-255.255.255.0} VPN_CLIENT_DHCP="${VPN_CLIENT_DHCP:-172.16.28.1 172.16.28.254}" VPN_LOCAL_NET=${VPN_LOCAL_NET:-10.0.0.0} VPN_LOCAL_MASK=${VPN_LOCAL_MASK:-255.255.0.0} VPN_DIR=/etc/openvpn CA_DIR=/etc/openvpn/easy-rsa usage() { echo "$0 - OpenVPN install and certificate generation" echo "" echo "$0 --client name" echo "$0 --server [name]" echo "" echo " --server mode configures the host with a running OpenVPN server instance" echo " --client mode creates a tarball of a client configuration for this server" exit 1 } if [ -z $1 ]; then usage fi # Install OpenVPN VPN_EXEC=`which openvpn` if [ -z "$VPN_EXEC" -o ! -x "$VPN_EXEC" ]; then apt-get install -y openvpn bridge-utils fi if [ ! -d $CA_DIR ]; then cp -pR /usr/share/doc/openvpn/examples/easy-rsa/2.0/ $CA_DIR fi OPWD=`pwd` cd $CA_DIR source ./vars # Override the defaults export KEY_COUNTRY="US" export KEY_PROVINCE="TX" export KEY_CITY="SanAntonio" export KEY_ORG="Cloudbuilders" export KEY_EMAIL="rcb@lists.rackspace.com" if [ ! -r $CA_DIR/keys/dh1024.pem ]; then # Initialize a new CA $CA_DIR/clean-all $CA_DIR/build-dh $CA_DIR/pkitool --initca openvpn --genkey --secret $CA_DIR/keys/ta.key ## Build a TLS key fi do_server() { NAME=$1 # Generate server certificate $CA_DIR/pkitool --server $NAME (cd $CA_DIR/keys; cp $NAME.crt $NAME.key ca.crt dh1024.pem ta.key $VPN_DIR ) cat >$VPN_DIR/br-up <$VPN_DIR/br-down <$VPN_DIR/$NAME.conf <$TMP_DIR/$HOST.conf <$VPN_DIR/hostname fi do_server $NAME ;; --clean) $CA_DIR/clean-all ;; *) usage esac devstack-diablo-eol/tools/jenkins/000077500000000000000000000000001207307670500174775ustar00rootroot00000000000000devstack-diablo-eol/tools/jenkins/README.md000066400000000000000000000024571207307670500207660ustar00rootroot00000000000000Getting Started With Jenkins and Devstack ========================================= This little corner of devstack is to show how to get an Openstack jenkins environment up and running quickly, using the rcb configuration methodology. To create a jenkins server -------------------------- cd tools/jenkins/jenkins_home ./build_jenkins.sh This will create a jenkins environment configured with sample test scripts that run against xen and kvm. Configuring XS -------------- In order to make the tests for XS work, you must install xs 5.6 on a separate machine, and install the the jenkins public key on that server. You then need to create the /var/lib/jenkins/xenrc on your jenkins server like so: MYSQL_PASSWORD=secrete SERVICE_TOKEN=secrete ADMIN_PASSWORD=secrete RABBIT_PASSWORD=secrete # This is the password for your guest (for both stack and root users) GUEST_PASSWORD=secrete # Do not download the usual images yet! IMAGE_URLS="" FLOATING_RANGE=192.168.1.224/28 VIRT_DRIVER=xenserver # Explicitly set multi-host MULTI_HOST=1 # Give extra time for boot ACTIVE_TIMEOUT=45 # IMPORTANT: This is the ip of your xenserver XEN_IP=10.5.5.1 # IMPORTANT: The following must be set to your dom0 root password! XENAPI_PASSWORD='MY_XEN_ROOT_PW' devstack-diablo-eol/tools/jenkins/adapters/000077500000000000000000000000001207307670500213025ustar00rootroot00000000000000devstack-diablo-eol/tools/jenkins/adapters/euca.sh000077500000000000000000000003651207307670500225620ustar00rootroot00000000000000#!/bin/bash # Echo commands, exit on error set -o xtrace set -o errexit TOP_DIR=$(cd ../../.. && pwd) HEAD_IP=`cat $TOP_DIR/addresses | grep HEAD | cut -d "=" -f2` ssh stack@$HEAD_IP 'cd devstack && source openrc && cd exercises && ./euca.sh' devstack-diablo-eol/tools/jenkins/adapters/floating_ips.sh000077500000000000000000000003751207307670500243240ustar00rootroot00000000000000#!/bin/bash # Echo commands, exit on error set -o xtrace set -o errexit TOP_DIR=$(cd ../../.. && pwd) HEAD_IP=`cat $TOP_DIR/addresses | grep HEAD | cut -d "=" -f2` ssh stack@$HEAD_IP 'cd devstack && source openrc && cd exercises && ./floating_ips.sh' devstack-diablo-eol/tools/jenkins/build_configuration.sh000077500000000000000000000007231207307670500240660ustar00rootroot00000000000000#!/bin/bash EXECUTOR_NUMBER=$1 CONFIGURATION=$2 ADAPTER=$3 RC=$4 function usage() { echo "Usage: $0 - Build a configuration" echo "" echo "$0 [EXECUTOR_NUMBER] [CONFIGURATION] [ADAPTER] [RC (optional)]" exit 1 } # Validate inputs if [[ "$EXECUTOR_NUMBER" = "" || "$CONFIGURATION" = "" || "$ADAPTER" = "" ]]; then usage fi # Execute configuration script cd configurations && ./$CONFIGURATION.sh $EXECUTOR_NUMBER $CONFIGURATION $ADAPTER "$RC" devstack-diablo-eol/tools/jenkins/configurations/000077500000000000000000000000001207307670500225315ustar00rootroot00000000000000devstack-diablo-eol/tools/jenkins/configurations/kvm.sh000077500000000000000000000026341207307670500236720ustar00rootroot00000000000000#!/bin/bash # exit on error to stop unexpected errors set -o errexit set -o xtrace EXECUTOR_NUMBER=$1 CONFIGURATION=$2 ADAPTER=$3 RC=$4 function usage() { echo "Usage: $0 - Build a test configuration" echo "" echo "$0 [EXECUTOR_NUMBER] [CONFIGURATION] [ADAPTER] [RC (optional)]" exit 1 } # Validate inputs if [[ "$EXECUTOR_NUMBER" = "" || "$CONFIGURATION" = "" || "$ADAPTER" = "" ]]; then usage fi # This directory CUR_DIR=$(cd $(dirname "$0") && pwd) # devstack directory cd ../../.. TOP_DIR=$(pwd) # Deps apt-get install -y --force-yes libvirt-bin || true # Name test instance based on executor BASE_NAME=executor-`printf "%02d" $EXECUTOR_NUMBER` GUEST_NAME=$BASE_NAME.$ADAPTER virsh list | grep $BASE_NAME | cut -d " " -f1 | xargs -n 1 virsh destroy || true virsh net-list | grep $BASE_NAME | cut -d " " -f1 | xargs -n 1 virsh net-destroy || true # Configure localrc cat <localrc RECLONE=yes GUEST_NETWORK=$EXECUTOR_NUMBER GUEST_NAME=$GUEST_NAME FLOATING_RANGE=192.168.$EXECUTOR_NUMBER.128/27 GUEST_CORES=1 GUEST_RAM=12574720 MYSQL_PASSWORD=chicken RABBIT_PASSWORD=chicken SERVICE_TOKEN=chicken ADMIN_PASSWORD=chicken USERNAME=admin TENANT=admin NET_NAME=$BASE_NAME ACTIVE_TIMEOUT=45 BOOT_TIMEOUT=45 $RC EOF cd tools sudo ./build_uec.sh # Make the address of the instances available to test runners echo HEAD=`cat /var/lib/libvirt/dnsmasq/$BASE_NAME.leases | cut -d " " -f3` > $TOP_DIR/addresses devstack-diablo-eol/tools/jenkins/configurations/xs.sh000077500000000000000000000020431207307670500235210ustar00rootroot00000000000000#!/bin/bash set -o errexit set -o xtrace EXECUTOR_NUMBER=$1 CONFIGURATION=$2 ADAPTER=$3 RC=$4 function usage() { echo "Usage: $0 - Build a test configuration" echo "" echo "$0 [EXECUTOR_NUMBER] [CONFIGURATION] [ADAPTER] [RC (optional)]" exit 1 } # Validate inputs if [[ "$EXECUTOR_NUMBER" = "" || "$CONFIGURATION" = "" || "$ADAPTER" = "" ]]; then usage fi # Configuration of xenrc XENRC=/var/lib/jenkins/xenrc if [ ! -e $XENRC ]; then echo "/var/lib/jenkins/xenrc is not present! See README.md" exit 1 fi # Move to top of devstack cd ../../.. # Use xenrc as the start of our localrc cp $XENRC localrc # Set the PUB_IP PUB_IP=192.168.1.1$EXECUTOR_NUMBER echo "PUB_IP=$PUB_IP" >> localrc # Overrides echo "$RC" >> localrc # Source localrc . localrc # Make host ip available to tester echo "HEAD=$PUB_IP" > addresses # Build configuration REMOTE_DEVSTACK=/root/devstack ssh root@$XEN_IP "rm -rf $REMOTE_DEVSTACK" scp -pr . root@$XEN_IP:$REMOTE_DEVSTACK ssh root@$XEN_IP "cd $REMOTE_DEVSTACK/tools/xen && ./build_domU.sh" devstack-diablo-eol/tools/jenkins/jenkins_home/000077500000000000000000000000001207307670500221505ustar00rootroot00000000000000devstack-diablo-eol/tools/jenkins/jenkins_home/.gitignore000066400000000000000000000000271207307670500241370ustar00rootroot00000000000000builds workspace *.sw* devstack-diablo-eol/tools/jenkins/jenkins_home/build_jenkins.sh000077500000000000000000000061501207307670500253310ustar00rootroot00000000000000#!/bin/bash # Echo commands, exit on error set -o xtrace set -o errexit # Make sure only root can run our script if [[ $EUID -ne 0 ]]; then echo "This script must be run as root" exit 1 fi # This directory CUR_DIR=$(cd $(dirname "$0") && pwd) # Configure trunk jenkins! echo "deb http://pkg.jenkins-ci.org/debian binary/" > /etc/apt/sources.list.d/jenkins.list wget -q -O - http://pkg.jenkins-ci.org/debian/jenkins-ci.org.key | sudo apt-key add - apt-get update # Clean out old jenkins - useful if you are having issues upgrading CLEAN_JENKINS=${CLEAN_JENKINS:-no} if [ "$CLEAN_JENKINS" = "yes" ]; then apt-get remove jenkins jenkins-common fi # Install software DEPS="jenkins cloud-utils" apt-get install -y --force-yes $DEPS # Install jenkins if [ ! -e /var/lib/jenkins ]; then echo "Jenkins installation failed" exit 1 fi # Make sure user has configured a jenkins ssh pubkey if [ ! -e /var/lib/jenkins/.ssh/id_rsa.pub ]; then echo "Public key for jenkins is missing. This is used to ssh into your instances." echo "Please run "su -c ssh-keygen jenkins" before proceeding" exit 1 fi # Setup sudo JENKINS_SUDO=/etc/sudoers.d/jenkins cat > $JENKINS_SUDO < $JENKINS_GITCONF < 4 Jenkins jenkins@rcb.me EOF # Add build numbers JOBS=`ls jobs` for job in ${JOBS// / }; do if [ ! -e jobs/$job/nextBuildNumber ]; then echo 1 > jobs/$job/nextBuildNumber fi done # Set ownership to jenkins chown -R jenkins $CUR_DIR # Make sure this directory is accessible to jenkins if ! su -c "ls $CUR_DIR" jenkins; then echo "Your devstack directory is not accessible by jenkins." echo "There is a decent chance you are trying to run this from a directory in /root." echo "If so, try moving devstack elsewhere (eg. /opt/devstack)." exit 1 fi # Move aside old jobs, if present if [ ! -h /var/lib/jenkins/jobs ]; then echo "Installing jobs symlink" if [ -d /var/lib/jenkins/jobs ]; then mv /var/lib/jenkins/jobs /var/lib/jenkins/jobs.old fi fi # Set up jobs symlink rm -f /var/lib/jenkins/jobs ln -s $CUR_DIR/jobs /var/lib/jenkins/jobs # List of plugins PLUGINS=http://hudson-ci.org/downloads/plugins/build-timeout/1.6/build-timeout.hpi,http://mirrors.jenkins-ci.org/plugins/git/1.1.12/git.hpi,http://hudson-ci.org/downloads/plugins/global-build-stats/1.2/global-build-stats.hpi,http://hudson-ci.org/downloads/plugins/greenballs/1.10/greenballs.hpi,http://download.hudson-labs.org/plugins/console-column-plugin/1.0/console-column-plugin.hpi # Configure plugins for plugin in ${PLUGINS//,/ }; do name=`basename $plugin` dest=/var/lib/jenkins/plugins/$name if [ ! -e $dest ]; then curl -L $plugin -o $dest fi done # Restart jenkins /etc/init.d/jenkins stop || true /etc/init.d/jenkins start devstack-diablo-eol/tools/jenkins/jenkins_home/clean.sh000077500000000000000000000010741207307670500235730ustar00rootroot00000000000000#!/bin/bash # This script is not yet for general consumption. set -o errexit if [ ! "$FORCE" = "yes" ]; then echo "FORCE not set to 'yes'. Make sure this is something you really want to do. Exiting." exit 1 fi virsh list | cut -d " " -f1 | grep -v "-" | egrep -e "[0-9]" | xargs -n 1 virsh destroy || true virsh net-list | grep active | cut -d " " -f1 | xargs -n 1 virsh net-destroy || true killall dnsmasq || true if [ "$CLEAN" = "yes" ]; then rm -rf jobs fi rm /var/lib/jenkins/jobs git checkout -f git fetch git merge origin/jenkins ./build_jenkins.sh devstack-diablo-eol/tools/jenkins/jenkins_home/jobs/000077500000000000000000000000001207307670500231055ustar00rootroot00000000000000devstack-diablo-eol/tools/jenkins/jenkins_home/jobs/diablo-kvm_ha/000077500000000000000000000000001207307670500256025ustar00rootroot00000000000000devstack-diablo-eol/tools/jenkins/jenkins_home/jobs/diablo-kvm_ha/config.xml000066400000000000000000000054701207307670500275770ustar00rootroot00000000000000 false RC 2 origin +refs/heads/*:refs/remotes/origin/* git://github.com/cloudbuilders/devstack.git master false false false false false false false Default false true false false false false ADAPTER euca floating_ips sed -i 's/) 2>&1 | tee "${LOGFILE}"/)/' stack.sh set -o errexit cd tools/jenkins sudo ./build_configuration.sh $EXECUTOR_NUMBER kvm $ADAPTER "$RC" set -o errexit cd tools/jenkins ./run_test.sh $EXECUTOR_NUMBER $ADAPTER $RC "$RC" false devstack-diablo-eol/tools/jenkins/jenkins_home/jobs/diablo-kvm_ha/configurations/000077500000000000000000000000001207307670500306345ustar00rootroot00000000000000devstack-diablo-eol/tools/jenkins/jenkins_home/jobs/diablo-kvm_ha/configurations/axis-ADAPTER/000077500000000000000000000000001207307670500326565ustar00rootroot00000000000000devstack-diablo-eol/tools/jenkins/jenkins_home/jobs/diablo-kvm_ha/configurations/axis-ADAPTER/euca/000077500000000000000000000000001207307670500335735ustar00rootroot00000000000000config.xml000066400000000000000000000007571207307670500355140ustar00rootroot00000000000000devstack-diablo-eol/tools/jenkins/jenkins_home/jobs/diablo-kvm_ha/configurations/axis-ADAPTER/euca false false false false false false floatingips/000077500000000000000000000000001207307670500351165ustar00rootroot00000000000000devstack-diablo-eol/tools/jenkins/jenkins_home/jobs/diablo-kvm_ha/configurations/axis-ADAPTERconfig.xml000066400000000000000000000007571207307670500371160ustar00rootroot00000000000000devstack-diablo-eol/tools/jenkins/jenkins_home/jobs/diablo-kvm_ha/configurations/axis-ADAPTER/floatingips false false false false false false devstack-diablo-eol/tools/jenkins/jenkins_home/jobs/diablo-xs_ha/000077500000000000000000000000001207307670500254375ustar00rootroot00000000000000devstack-diablo-eol/tools/jenkins/jenkins_home/jobs/diablo-xs_ha/config.xml000066400000000000000000000061751207307670500274370ustar00rootroot00000000000000 In order for this to work, you must create a /var/lib/jenkins/xenrc file as described in README.md false RC 2 origin +refs/heads/*:refs/remotes/origin/* git://github.com/cloudbuilders/devstack.git master false false false false false false false Default false true false false false false ADAPTER euca floating_ips sed -i 's/) 2>&1 | tee "${LOGFILE}"/)/' stack.sh set -o errexit cd tools/jenkins sudo ./build_configuration.sh $EXECUTOR_NUMBER xs $ADAPTER "$RC" #!/bin/bash set -o errexit set -o xtrace . localrc # Unlike kvm, ssh to the xen host to run tests, in case the test instance is launch with a host only network ssh root@$XEN_IP "cd devstack && . localrc && cd tools/jenkins && ./run_test.sh $EXECUTOR_NUMBER $ADAPTER '$RC'" true devstack-diablo-eol/tools/jenkins/jenkins_home/print_summary.py000077500000000000000000000022701207307670500254370ustar00rootroot00000000000000#!/usr/bin/python import urllib import json import sys def print_usage(): print "Usage: %s [jenkins_url (eg. http://50.56.12.202:8080/)]"\ % sys.argv[0] sys.exit() def fetch_blob(url): return json.loads(urllib.urlopen(url + '/api/json').read()) if len(sys.argv) < 2: print_usage() BASE_URL = sys.argv[1] root = fetch_blob(BASE_URL) results = {} for job_url in root['jobs']: job = fetch_blob(job_url['url']) if job.get('activeConfigurations'): (tag, name) = job['name'].split('-') if not results.get(tag): results[tag] = {} if not results[tag].get(name): results[tag][name] = [] for config_url in job['activeConfigurations']: config = fetch_blob(config_url['url']) log_url = '' if config.get('lastBuild'): log_url = config['lastBuild']['url'] + 'console' results[tag][name].append({'test': config['displayName'], 'status': config['color'], 'logUrl': log_url, 'healthReport': config['healthReport']}) print json.dumps(results) devstack-diablo-eol/tools/jenkins/run_test.sh000077500000000000000000000005611207307670500217030ustar00rootroot00000000000000#!/bin/bash EXECUTOR_NUMBER=$1 ADAPTER=$2 RC=$3 function usage() { echo "Usage: $0 - Run a test" echo "" echo "$0 [EXECUTOR_NUMBER] [ADAPTER] [RC (optional)]" exit 1 } # Validate inputs if [[ "$EXECUTOR_NUMBER" = "" || "$ADAPTER" = "" ]]; then usage fi # Execute configuration script cd adapters && ./$ADAPTER.sh $EXECUTOR_NUMBER $ADAPTER "$RC" devstack-diablo-eol/tools/rfc.sh000077500000000000000000000103121207307670500171440ustar00rootroot00000000000000#!/bin/sh -e # Copyright (c) 2010-2011 Gluster, Inc. # This initial version of this file was taken from the source tree # of GlusterFS. It was not directly attributed, but is assumed to be # Copyright (c) 2010-2011 Gluster, Inc and release GPLv3 # Subsequent modifications are Copyright (c) 2011 OpenStack, LLC. # # GlusterFS is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published # by the Free Software Foundation; either version 3 of the License, # or (at your option) any later version. # # GlusterFS is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see # . branch="master"; set_hooks_commit_msg() { top_dir=`git rev-parse --show-toplevel` f="${top_dir}/.git/hooks/commit-msg"; u="https://review.openstack.org/tools/hooks/commit-msg"; if [ -x "$f" ]; then return; fi curl -o $f $u || wget -O $f $u; chmod +x $f; GIT_EDITOR=true git commit --amend } add_remote() { username=$1 project=$2 echo "No remote set, testing ssh://$username@review.openstack.org:29418" if project_list=`ssh -p29418 -o StrictHostKeyChecking=no $username@review.openstack.org gerrit ls-projects 2>/dev/null` then echo "$username@review.openstack.org:29418 worked." if echo $project_list | grep $project >/dev/null then echo "Creating a git remote called gerrit that maps to:" echo " ssh://$username@review.openstack.org:29418/$project" git remote add gerrit ssh://$username@review.openstack.org:29418/$project else echo "The current project name, $project, is not a known project." echo "Please either reclone from github/gerrit or create a" echo "remote named gerrit that points to the intended project." return 1 fi return 0 fi return 1 } check_remote() { if ! git remote | grep gerrit >/dev/null 2>&1 then origin_project=`git remote show origin | grep 'Fetch URL' | perl -nle '@fields = split(m|[:/]|); $len = $#fields; print $fields[$len-1], "/", $fields[$len];'` if add_remote $USERNAME $origin_project then return 0 else echo "Your local name doesn't work on Gerrit." echo -n "Enter Gerrit username (same as launchpad): " read gerrit_user if add_remote $gerrit_user $origin_project then return 0 else echo "Can't infer where gerrit is - please set a remote named" echo "gerrit manually and then try again." echo echo "For more information, please see:" echo "\thttp://wiki.openstack.org/GerritWorkflow" exit 1 fi fi fi } rebase_changes() { git fetch; GIT_EDITOR=true git rebase -i origin/$branch || exit $?; } assert_diverge() { if ! git diff origin/$branch..HEAD | grep -q . then echo "No changes between the current branch and origin/$branch." exit 1 fi } main() { set_hooks_commit_msg; check_remote; rebase_changes; assert_diverge; bug=$(git show --format='%s %b' | perl -nle 'if (/\b([Bb]ug|[Ll][Pp])\s*[#:]?\s*(\d+)/) {print "$2"; exit}') bp=$(git show --format='%s %b' | perl -nle 'if (/\b([Bb]lue[Pp]rint|[Bb][Pp])\s*[#:]?\s*([0-9a-zA-Z-_]+)/) {print "$2"; exit}') if [ "$DRY_RUN" = 1 ]; then drier='echo -e Please use the following command to send your commits to review:\n\n' else drier= fi local_branch=`git branch | grep -Ei "\* (.*)" | cut -f2 -d' '` if [ -z "$bug" ]; then if [ -z "$bp" ]; then $drier git push gerrit HEAD:refs/for/$branch/$local_branch; else $drier git push gerrit HEAD:refs/for/$branch/bp/$bp; fi else $drier git push gerrit HEAD:refs/for/$branch/bug/$bug; fi } main "$@" devstack-diablo-eol/tools/uec/000077500000000000000000000000001207307670500166125ustar00rootroot00000000000000devstack-diablo-eol/tools/uec/meta.py000066400000000000000000000014731207307670500201170ustar00rootroot00000000000000import sys from BaseHTTPServer import HTTPServer, BaseHTTPRequestHandler from SimpleHTTPServer import SimpleHTTPRequestHandler def main(host, port, HandlerClass = SimpleHTTPRequestHandler, ServerClass = HTTPServer, protocol="HTTP/1.0"): """simple http server that listens on a give address:port""" server_address = (host, port) HandlerClass.protocol_version = protocol httpd = ServerClass(server_address, HandlerClass) sa = httpd.socket.getsockname() print "Serving HTTP on", sa[0], "port", sa[1], "..." httpd.serve_forever() if __name__ == '__main__': if sys.argv[1:]: address = sys.argv[1] else: address = '0.0.0.0' if ':' in address: host, port = address.split(':') else: host = address port = 8080 main(host, int(port)) devstack-diablo-eol/tools/warm_apts_and_pips_for_uec.sh000077500000000000000000000026251207307670500237560ustar00rootroot00000000000000#!/usr/bin/env bash # Echo commands set -o xtrace # Exit on error to stop unexpected errors set -o errexit # Keep track of the current directory TOOLS_DIR=$(cd $(dirname "$0") && pwd) TOP_DIR=`cd $TOOLS_DIR/..; pwd` # Change dir to top of devstack cd $TOP_DIR # Echo usage usage() { echo "Cache OpenStack dependencies on a uec image to speed up performance." echo "" echo "Usage: $0 [full path to raw uec base image]" } # Make sure this is a raw image if ! qemu-img info $1 | grep -q "file format: raw"; then usage exit 1 fi # Make sure we are in the correct dir if [ ! -d files/apts ]; then echo "Please run this script from devstack/tools/" exit 1 fi # Mount the image STAGING_DIR=/tmp/`echo $1 | sed "s/\//_/g"`.stage mkdir -p $STAGING_DIR umount $STAGING_DIR || true sleep 1 mount -t ext4 -o loop $1 $STAGING_DIR # Make sure that base requirements are installed cp /etc/resolv.conf $STAGING_DIR/etc/resolv.conf # Perform caching on the base image to speed up subsequent runs chroot $STAGING_DIR apt-get update chroot $STAGING_DIR apt-get install -y --download-only `cat files/apts/* | grep NOPRIME | cut -d\# -f1` chroot $STAGING_DIR apt-get install -y --force-yes `cat files/apts/* | grep -v NOPRIME | cut -d\# -f1` || true mkdir -p $STAGING_DIR/var/cache/pip PIP_DOWNLOAD_CACHE=/var/cache/pip chroot $STAGING_DIR pip install `cat files/pips/*` || true # Unmount umount $STAGING_DIR devstack-diablo-eol/tools/xen/000077500000000000000000000000001207307670500166305ustar00rootroot00000000000000devstack-diablo-eol/tools/xen/README.md000066400000000000000000000052121207307670500201070ustar00rootroot00000000000000Getting Started With XenServer 5.6 and Devstack =============================================== The purpose of the code in this directory it to help developers bootstrap a XenServer 5.6 + Openstack development environment. This file gives some pointers on how to get started. Step 1: Install Xenserver ------------------------ Install XenServer 5.6 on a clean box. You can get XenServer by signing up for an account on citrix.com, and then visiting: https://www.citrix.com/English/ss/downloads/details.asp?downloadId=2311504&productId=683148 Here are some sample Xenserver network settings for when you are just getting started (I use settings like this with a lappy + cheap wifi router): * XenServer Host IP: 192.168.1.10 * XenServer Netmask: 255.255.255.0 * XenServer Gateway: 192.168.1.1 * XenServer DNS: 192.168.1.1 Step 2: Prepare DOM0 ------------------- At this point, your server is missing some critical software that you will need to run devstack (like git). Do this to install required software: wget --no-check-certificate https://github.com/cloudbuilders/devstack/raw/xen/tools/xen/prepare_dom0.sh chmod 755 prepare_dom0.sh ./prepare_dom0.sh This script will also clone devstack in /root/devstack Step 3: Configure your localrc ----------------------------- Devstack uses a localrc for user-specific configuration. Note that the XENAPI_PASSWORD must be your dom0 root password. Of course, use real passwords if this machine is exposed. cat > /root/devstack/localrc <> /etc/sysconfig/network fi # Also, enable ip forwarding in rc.local, since the above trick isn't working if ! grep -q "echo 1 >/proc/sys/net/ipv4/ip_forward" /etc/rc.local; then echo "echo 1 >/proc/sys/net/ipv4/ip_forward" >> /etc/rc.local fi # Enable ip forwarding at runtime as well echo 1 > /proc/sys/net/ipv4/ip_forward # Directory where we stage the build STAGING_DIR=$TOP_DIR/stage # Option to clean out old stuff CLEAN=${CLEAN:-0} if [ "$CLEAN" = "1" ]; then rm -rf $STAGING_DIR fi # Download our base image. This image is made using prepare_guest.sh BASE_IMAGE_URL=${BASE_IMAGE_URL:-http://images.ansolabs.com/xen/stage.tgz} if [ ! -e $STAGING_DIR ]; then if [ ! -e /tmp/stage.tgz ]; then wget $BASE_IMAGE_URL -O /tmp/stage.tgz fi tar xfz /tmp/stage.tgz cd $TOP_DIR fi # Free up precious disk space rm -f /tmp/stage.tgz # Make sure we have a stage if [ ! -d $STAGING_DIR/etc ]; then echo "Stage is not properly set up!" exit 1 fi # Directory where our conf files are stored FILES_DIR=$TOP_DIR/files TEMPLATES_DIR=$TOP_DIR/templates # Directory for supporting script files SCRIPT_DIR=$TOP_DIR/scripts # Version of ubuntu with which we are working UBUNTU_VERSION=`cat $STAGING_DIR/etc/lsb-release | grep "DISTRIB_CODENAME=" | sed "s/DISTRIB_CODENAME=//"` KERNEL_VERSION=`ls $STAGING_DIR/boot/vmlinuz* | head -1 | sed "s/.*vmlinuz-//"` # Setup fake grub rm -rf $STAGING_DIR/boot/grub/ mkdir -p $STAGING_DIR/boot/grub/ cp $TEMPLATES_DIR/menu.lst.in $STAGING_DIR/boot/grub/menu.lst sed -e "s,@KERNEL_VERSION@,$KERNEL_VERSION,g" -i $STAGING_DIR/boot/grub/menu.lst # Setup fstab, tty, and other system stuff cp $FILES_DIR/fstab $STAGING_DIR/etc/fstab cp $FILES_DIR/hvc0.conf $STAGING_DIR/etc/init/ # Put the VPX into UTC. rm -f $STAGING_DIR/etc/localtime # Configure dns (use same dns as dom0) cp /etc/resolv.conf $STAGING_DIR/etc/resolv.conf # Copy over devstack rm -f /tmp/devstack.tar tar --exclude='stage' --exclude='xen/xvas' --exclude='xen/nova' -cvf /tmp/devstack.tar $TOP_DIR/../../../devstack cd $STAGING_DIR/opt/stack/ tar xf /tmp/devstack.tar cd $TOP_DIR # Configure OVA VDI_SIZE=$(($VDI_MB*1024*1024)) PRODUCT_BRAND=${PRODUCT_BRAND:-openstack} PRODUCT_VERSION=${PRODUCT_VERSION:-001} BUILD_NUMBER=${BUILD_NUMBER:-001} LABEL="$PRODUCT_BRAND $PRODUCT_VERSION-$BUILD_NUMBER" OVA=$STAGING_DIR/tmp/ova.xml cp $TEMPLATES_DIR/ova.xml.in $OVA sed -e "s,@VDI_SIZE@,$VDI_SIZE,g" -i $OVA sed -e "s,@PRODUCT_BRAND@,$PRODUCT_BRAND,g" -i $OVA sed -e "s,@PRODUCT_VERSION@,$PRODUCT_VERSION,g" -i $OVA sed -e "s,@BUILD_NUMBER@,$BUILD_NUMBER,g" -i $OVA # Directory for xvas XVA_DIR=$TOP_DIR/xvas # Create xva dir mkdir -p $XVA_DIR # Clean nova if desired if [ "$CLEAN" = "1" ]; then rm -rf $TOP_DIR/nova fi # Checkout nova if [ ! -d $TOP_DIR/nova ]; then git clone git://github.com/cloudbuilders/nova.git git checkout diablo fi # Run devstack on launch cat <$STAGING_DIR/etc/rc.local GUEST_PASSWORD=$GUEST_PASSWORD STAGING_DIR=/ DO_TGZ=0 bash /opt/stack/devstack/tools/xen/prepare_guest.sh su -c "/opt/stack/run.sh > /opt/stack/run.sh.log" stack exit 0 EOF # Install plugins cp -pr $TOP_DIR/nova/plugins/xenserver/xenapi/etc/xapi.d /etc/ chmod a+x /etc/xapi.d/plugins/* yum --enablerepo=base install -y parted mkdir -p /boot/guest # Set local storage il8n SR_UUID=`xe sr-list --minimal name-label="Local storage"` xe sr-param-set uuid=$SR_UUID other-config:i18n-key=local-storage # Shutdown previous runs DO_SHUTDOWN=${DO_SHUTDOWN:-1} if [ "$DO_SHUTDOWN" = "1" ]; then # Shutdown all domU's that created previously xe vm-list --minimal name-label="$LABEL" | xargs ./scripts/uninstall-os-vpx.sh # Destroy any instances that were launched for uuid in `xe vm-list | grep -1 instance | grep uuid | sed "s/.*\: //g"`; do echo "Shutting down nova instance $uuid" xe vm-unpause uuid=$uuid || true xe vm-shutdown uuid=$uuid xe vm-destroy uuid=$uuid done # Destroy orphaned vdis for uuid in `xe vdi-list | grep -1 Glance | grep uuid | sed "s/.*\: //g"`; do xe vdi-destroy uuid=$uuid done fi # Path to head xva. By default keep overwriting the same one to save space USE_SEPARATE_XVAS=${USE_SEPARATE_XVAS:-0} if [ "$USE_SEPARATE_XVAS" = "0" ]; then XVA=$XVA_DIR/$UBUNTU_VERSION.xva else XVA=$XVA_DIR/$UBUNTU_VERSION.$GUEST_NAME.xva fi # Clean old xva. In the future may not do this every time. rm -f $XVA # Configure the hostname echo $GUEST_NAME > $STAGING_DIR/etc/hostname # Hostname must resolve for rabbit cat <$STAGING_DIR/etc/hosts $MGT_IP $GUEST_NAME 127.0.0.1 localhost localhost.localdomain EOF # Configure the network INTERFACES=$STAGING_DIR/etc/network/interfaces cp $TEMPLATES_DIR/interfaces.in $INTERFACES sed -e "s,@ETH1_IP@,$VM_IP,g" -i $INTERFACES sed -e "s,@ETH1_NETMASK@,$VM_NETMASK,g" -i $INTERFACES sed -e "s,@ETH2_IP@,$MGT_IP,g" -i $INTERFACES sed -e "s,@ETH2_NETMASK@,$MGT_NETMASK,g" -i $INTERFACES sed -e "s,@ETH3_IP@,$PUB_IP,g" -i $INTERFACES sed -e "s,@ETH3_NETMASK@,$PUB_NETMASK,g" -i $INTERFACES # Gracefully cp only if source file/dir exists function cp_it { if [ -e $1 ] || [ -d $1 ]; then cp -pRL $1 $2 fi } # Copy over your ssh keys and env if desired COPYENV=${COPYENV:-1} if [ "$COPYENV" = "1" ]; then cp_it ~/.ssh $STAGING_DIR/opt/stack/.ssh cp_it ~/.ssh/id_rsa.pub $STAGING_DIR/opt/stack/.ssh/authorized_keys cp_it ~/.gitconfig $STAGING_DIR/opt/stack/.gitconfig cp_it ~/.vimrc $STAGING_DIR/opt/stack/.vimrc cp_it ~/.bashrc $STAGING_DIR/opt/stack/.bashrc fi # Configure run.sh cat <$STAGING_DIR/opt/stack/run.sh #!/bin/bash cd /opt/stack/devstack killall screen UPLOAD_LEGACY_TTY=yes HOST_IP=$PUB_IP VIRT_DRIVER=xenserver FORCE=yes MULTI_HOST=1 $STACKSH_PARAMS ./stack.sh EOF chmod 755 $STAGING_DIR/opt/stack/run.sh # Create xva if [ ! -e $XVA ]; then rm -rf /tmp/mkxva* UID=0 $SCRIPT_DIR/mkxva -o $XVA -t xva -x $OVA $STAGING_DIR $VDI_MB /tmp/ fi # Start guest $TOP_DIR/scripts/install-os-vpx.sh -f $XVA -v $VM_BR -m $MGT_BR -p $PUB_BR # If we have copied our ssh credentials, use ssh to monitor while the installation runs WAIT_TILL_LAUNCH=${WAIT_TILL_LAUNCH:-1} if [ "$WAIT_TILL_LAUNCH" = "1" ] && [ -e ~/.ssh/id_rsa.pub ] && [ "$COPYENV" = "1" ]; then # Done creating the container, let's tail the log echo echo "=============================================================" echo " -- YAY! --" echo "=============================================================" echo echo "We're done launching the vm, about to start tailing the" echo "stack.sh log. It will take a second or two to start." echo echo "Just CTRL-C at any time to stop tailing." set +o xtrace while ! ssh -q stack@$PUB_IP "[ -e run.sh.log ]"; do sleep 1 done ssh stack@$PUB_IP 'tail -f run.sh.log' & TAIL_PID=$! function kill_tail() { kill $TAIL_PID exit 1 } # Let Ctrl-c kill tail and exit trap kill_tail SIGINT echo "Waiting stack.sh to finish..." while ! ssh -q stack@$PUB_IP "grep -q 'stack.sh completed in' run.sh.log"; do sleep 1 done kill $TAIL_PID if ssh -q stack@$PUB_IP "grep -q 'stack.sh failed' run.sh.log"; then exit 1 fi echo "" echo "Finished - Zip-a-dee Doo-dah!" echo "You can then visit the OpenStack Dashboard" echo "at http://$PUB_IP, and contact other services at the usual ports." else echo "################################################################################" echo "" echo "All Finished!" echo "Now, you can monitor the progress of the stack.sh installation by " echo "tailing /opt/stack/run.sh.log from within your domU." echo "" echo "ssh into your domU now: 'ssh stack@$PUB_IP' using your password" echo "and then do: 'tail -f /opt/stack/run.sh.log'" echo "" echo "When the script completes, you can then visit the OpenStack Dashboard" echo "at http://$PUB_IP, and contact other services at the usual ports." fi devstack-diablo-eol/tools/xen/build_domU_multi.sh000077500000000000000000000023631207307670500224700ustar00rootroot00000000000000#!/usr/bin/env bash # Echo commands set -o xtrace # Head node host, which runs glance, api, keystone HEAD_PUB_IP=${HEAD_PUB_IP:-192.168.1.57} HEAD_MGT_IP=${HEAD_MGT_IP:-172.16.100.57} COMPUTE_PUB_IP=${COMPUTE_PUB_IP:-192.168.1.58} COMPUTE_MGT_IP=${COMPUTE_MGT_IP:-172.16.100.58} # Networking params FLOATING_RANGE=${FLOATING_RANGE:-192.168.1.196/30} # Variables common amongst all hosts in the cluster COMMON_VARS="$STACKSH_PARAMS MYSQL_HOST=$HEAD_MGT_IP RABBIT_HOST=$HEAD_MGT_IP GLANCE_HOSTPORT=$HEAD_MGT_IP:9292 FLOATING_RANGE=$FLOATING_RANGE" # Helper to launch containers function build_domU { GUEST_NAME=$1 PUB_IP=$2 MGT_IP=$3 DO_SHUTDOWN=$4 TERMINATE=$TERMINATE STACKSH_PARAMS="$COMMON_VARS $5" ./build_domU.sh } # Launch the head node - headnode uses a non-ip domain name, # because rabbit won't launch with an ip addr hostname :( build_domU HEADNODE $HEAD_PUB_IP $HEAD_MGT_IP 1 "ENABLED_SERVICES=g-api,g-reg,key,n-api,n-sch,n-vnc,horizon,mysql,rabbit" # Wait till the head node is up while ! curl -L http://$HEAD_PUB_IP | grep -q username; do echo "Waiting for head node ($HEAD_PUB_IP) to start..." sleep 5 done # Build the HA compute host build_domU $COMPUTE_PUB_IP $COMPUTE_PUB_IP $COMPUTE_MGT_IP 0 "ENABLED_SERVICES=n-cpu,n-net,n-api" devstack-diablo-eol/tools/xen/files/000077500000000000000000000000001207307670500177325ustar00rootroot00000000000000devstack-diablo-eol/tools/xen/files/fstab000066400000000000000000000005741207307670500207620ustar00rootroot00000000000000LABEL=vpxroot / ext3 defaults 1 1 tmpfs /dev/shm tmpfs defaults 0 0 devpts /dev/pts devpts gid=5,mode=620 0 0 sysfs /sys sysfs defaults 0 0 proc /proc proc defaults 0 0 devstack-diablo-eol/tools/xen/files/hvc0.conf000066400000000000000000000003431207307670500214410ustar00rootroot00000000000000# hvc0 - getty # # This service maintains a getty on hvc0 from the point the system is # started until it is shut down again. start on stopped rc RUNLEVEL=[2345] stop on runlevel [!2345] respawn exec /sbin/getty -8 9600 hvc0 devstack-diablo-eol/tools/xen/prepare_dom0.sh000077500000000000000000000014261207307670500215470ustar00rootroot00000000000000#!/bin/sh set -o xtrace set -o errexit # Install basics for vi and git yum -y --enablerepo=base install gcc make vim-enhanced zlib-devel openssl-devel # Simple but usable vimrc if [ ! -e /root/.vimrc ]; then cat > /root/.vimrc <$STAGING_DIR/etc/apt/sources.list deb http://us.archive.ubuntu.com/ubuntu/ oneiric main restricted deb-src http://us.archive.ubuntu.com/ubuntu/ oneiric main restricted deb http://us.archive.ubuntu.com/ubuntu/ oneiric-updates main restricted deb-src http://us.archive.ubuntu.com/ubuntu/ oneiric-updates main restricted deb http://us.archive.ubuntu.com/ubuntu/ oneiric universe deb http://us.archive.ubuntu.com/ubuntu/ oneiric-updates universe deb http://us.archive.ubuntu.com/ubuntu/ oneiric multiverse deb http://us.archive.ubuntu.com/ubuntu/ oneiric-updates multiverse EOF # Install basics chroot $STAGING_DIR apt-get update chroot $STAGING_DIR apt-get install -y linux-image-$KERNEL_VERSION chroot $STAGING_DIR apt-get install -y cracklib-runtime curl wget ssh openssh-server tcpdump ethtool chroot $STAGING_DIR apt-get install -y curl wget ssh openssh-server python-pip git vim-nox sudo chroot $STAGING_DIR pip install xenapi # Install guest utilities XEGUEST=xe-guest-utilities_5.6.100-651_amd64.deb wget http://images.ansolabs.com/xen/$XEGUEST -O $XEGUEST cp $XEGUEST $STAGING_DIR/root chroot $STAGING_DIR dpkg -i /root/$XEGUEST chroot $STAGING_DIR update-rc.d -f xe-linux-distribution remove chroot $STAGING_DIR update-rc.d xe-linux-distribution defaults # Make a small cracklib dictionary, so that passwd still works, but we don't # have the big dictionary. mkdir -p $STAGING_DIR/usr/share/cracklib echo a | chroot $STAGING_DIR cracklib-packer # Make /etc/shadow, and set the root password chroot $STAGING_DIR "pwconv" echo "root:$GUEST_PASSWORD" | chroot $STAGING_DIR chpasswd # Put the VPX into UTC. rm -f $STAGING_DIR/etc/localtime # Add stack user chroot $STAGING_DIR groupadd libvirtd chroot $STAGING_DIR useradd stack -s /bin/bash -d /opt/stack -G libvirtd echo stack:$GUEST_PASSWORD | chroot $STAGING_DIR chpasswd echo "stack ALL=(ALL) NOPASSWD: ALL" >> $STAGING_DIR/etc/sudoers # Give ownership of /opt/stack to stack user chroot $STAGING_DIR chown -R stack /opt/stack # Make our ip address hostnames look nice at the command prompt echo "export PS1='${debian_chroot:+($debian_chroot)}\\u@\\H:\\w\\$ '" >> $STAGING_DIR/opt/stack/.bashrc echo "export PS1='${debian_chroot:+($debian_chroot)}\\u@\\H:\\w\\$ '" >> $STAGING_DIR/root/.bashrc echo "export PS1='${debian_chroot:+($debian_chroot)}\\u@\\H:\\w\\$ '" >> $STAGING_DIR/etc/profile function setup_vimrc { if [ ! -e $1 ]; then # Simple but usable vimrc cat > $1 <&2 exit 1 else echo "$dest_sr" fi } find_network() { result=$(xe_min network-list bridge="$1") if [ "$result" = "" ] then result=$(xe_min network-list name-label="$1") fi echo "$result" } find_template() { xe_min template-list other-config:os-vpx=true } renumber_system_disk() { local v="$1" local vdi_uuid=$(xe_min vbd-list vm-uuid="$v" type=Disk userdevice=xvda \ params=vdi-uuid) if [ "$vdi_uuid" ] then local vbd_uuid=$(xe_min vbd-list vm-uuid="$v" vdi-uuid="$vdi_uuid") xe vbd-destroy uuid="$vbd_uuid" local new_vbd_uuid=$(xe vbd-create vm-uuid="$v" vdi-uuid="$vdi_uuid" \ device=0 bootable=true type=Disk) xe vbd-param-set other-config:owner uuid="$new_vbd_uuid" fi } create_vif() { xe vif-create vm-uuid="$1" network-uuid="$2" device="$3" } create_gi_vif() { local v="$1" # Note that we've made the outbound device eth1, so that it comes up after # the guest installer VIF, which means that the outbound one wins in terms # of gateway. local gi_network_uuid=$(xe_min network-list \ other-config:is_guest_installer_network=true) create_vif "$v" "$gi_network_uuid" "0" >/dev/null } create_vm_vif() { local v="$1" echo "Installing management interface on $BRIDGE_V." local out_network_uuid=$(find_network "$BRIDGE_V") create_vif "$v" "$out_network_uuid" "1" >/dev/null } create_management_vif() { local v="$1" echo "Installing management interface on $BRIDGE_M." local out_network_uuid=$(find_network "$BRIDGE_M") create_vif "$v" "$out_network_uuid" "2" >/dev/null } # This installs the interface for public traffic, only if a bridge is specified # The interface is not configured at this stage, but it will be, once the admin # tasks are complete for the services of this VPX create_public_vif() { local v="$1" if [[ -z $BRIDGE_P ]] then echo "Skipping installation of interface for public traffic." else echo "Installing public interface on $BRIDGE_P." pub_network_uuid=$(find_network "$BRIDGE_P") create_vif "$v" "$pub_network_uuid" "3" >/dev/null fi } label_system_disk() { local v="$1" local vdi_uuid=$(xe_min vbd-list vm-uuid="$v" type=Disk userdevice=0 \ params=vdi-uuid) xe vdi-param-set \ name-label="$NAME system disk" \ other-config:os-vpx=true \ uuid=$vdi_uuid } create_data_disk() { local v="$1" local sys_vdi_uuid=$(xe_min vbd-list vm-uuid="$v" type=Disk params=vdi-uuid) local data_vdi_uuid=$(xe_min vdi-list other-config:os-vpx-data=true) if echo "$data_vdi_uuid" | grep -q , then echo "Multiple data disks found -- assuming that you want a new one." data_vdi_uuid="" else data_in_use=$(xe_min vbd-list vdi-uuid="$data_vdi_uuid") if [ "$data_in_use" != "" ] then echo "Data disk already in use -- will create another one." data_vdi_uuid="" fi fi if [ "$data_vdi_uuid" = "" ] then echo -n "Creating new data disk ($DATA_VDI_SIZE)... " sr_uuid=$(xe_min vdi-list params=sr-uuid uuid="$sys_vdi_uuid") data_vdi_uuid=$(xe vdi-create name-label="$NAME data disk" \ sr-uuid="$sr_uuid" \ type=user \ virtual-size="$DATA_VDI_SIZE") xe vdi-param-set \ other-config:os-vpx-data=true \ uuid="$data_vdi_uuid" dom0_uuid=$(xe_min vm-list is-control-domain=true) vbd_uuid=$(xe vbd-create device=autodetect type=Disk \ vdi-uuid="$data_vdi_uuid" vm-uuid="$dom0_uuid") xe vbd-plug uuid=$vbd_uuid dev=$(xe_min vbd-list params=device uuid=$vbd_uuid) mke2fs -q -j -m0 /dev/$dev e2label /dev/$dev vpxstate xe vbd-unplug uuid=$vbd_uuid xe vbd-destroy uuid=$vbd_uuid else echo -n "Attaching old data disk... " fi vbd_uuid=$(xe vbd-create device=2 type=Disk \ vdi-uuid="$data_vdi_uuid" vm-uuid="$v") xe vbd-param-set other-config:os-vpx-data=true uuid=$vbd_uuid echo "done." } set_kernel_params() { local v="$1" local args=$KERNEL_PARAMS local cmdline=$(cat /proc/cmdline) for word in $cmdline do if echo "$word" | grep -q "geppetto" then args="$word $args" fi done if [ "$args" != "" ] then echo "Passing Geppetto args to VPX: $args." xe vm-param-set PV-args="$args" uuid="$v" fi } set_memory() { local v="$1" if [ "$RAM" != "" ] then echo "Setting RAM to $RAM MiB." [ "$BALLOONING" == 1 ] && RAM_MIN=$(($RAM / 2)) || RAM_MIN=$RAM xe vm-memory-limits-set static-min=16MiB static-max=${RAM}MiB \ dynamic-min=${RAM_MIN}MiB dynamic-max=${RAM}MiB \ uuid="$v" fi } # Make the VM auto-start on server boot. set_auto_start() { local v="$1" xe vm-param-set uuid="$v" other-config:auto_poweron=true } set_all() { local v="$1" set_kernel_params "$v" set_memory "$v" set_auto_start "$v" label_system_disk "$v" create_gi_vif "$v" create_vm_vif "$v" create_management_vif "$v" create_public_vif "$v" } log_vifs() { local v="$1" (IFS=, for vif in $(xe_min vif-list vm-uuid="$v") do dev=$(xe_min vif-list uuid="$vif" params=device) mac=$(xe_min vif-list uuid="$vif" params=MAC | sed -e 's/:/-/g') echo "eth$dev has MAC $mac." done unset IFS) | sort } destroy_vifs() { local v="$1" IFS=, for vif in $(xe_min vif-list vm-uuid="$v") do xe vif-destroy uuid="$vif" done unset IFS } get_params "$@" thisdir=$(dirname "$0") if [ "$FROM_TEMPLATE" ] then template_uuid=$(find_template) name=$(xe_min template-list params=name-label uuid="$template_uuid") echo -n "Cloning $name... " vm_uuid=$(xe vm-clone vm="$template_uuid" new-name-label="$name") xe vm-param-set is-a-template=false uuid="$vm_uuid" echo $vm_uuid. destroy_vifs "$vm_uuid" set_all "$vm_uuid" else if [ ! -f "$VPX_FILE" ] then # Search $thisdir/$VPX_FILE too. In particular, this is used when # installing the VPX from the supp-pack, because we want to be able to # invoke this script from the RPM and the firstboot script. if [ -f "$thisdir/$VPX_FILE" ] then VPX_FILE="$thisdir/$VPX_FILE" else echo "$VPX_FILE does not exist." >&2 exit 1 fi fi echo "Found OS-VPX File: $VPX_FILE. " dest_sr=$(get_dest_sr) echo -n "Installing $NAME... " vm_uuid=$(xe vm-import filename=$VPX_FILE sr-uuid="$dest_sr") echo $vm_uuid. renumber_system_disk "$vm_uuid" nl=$(xe_min vm-list params=name-label uuid=$vm_uuid) xe vm-param-set \ "name-label=${nl/ import/}" \ other-config:os-vpx=true \ uuid=$vm_uuid set_all "$vm_uuid" create_data_disk "$vm_uuid" if [ "$AS_TEMPLATE" ] then xe vm-param-set uuid="$vm_uuid" is-a-template=true \ other-config:instant=true echo -n "Installing VPX from template... " vm_uuid=$(xe vm-clone vm="$vm_uuid" new-name-label="${nl/ import/}") xe vm-param-set is-a-template=false uuid="$vm_uuid" echo "$vm_uuid." fi fi log_vifs "$vm_uuid" echo -n "Starting VM... " xe vm-start uuid=$vm_uuid echo "done." show_ip() { ip_addr=$(echo "$1" | sed -n "s,^.*"$2"/ip: \([^;]*\).*$,\1,p") echo -n "IP address for $3: " if [ "$ip_addr" = "" ] then echo "did not appear." else echo "$ip_addr." fi } if [ "$WAIT_FOR_NETWORK" ] then echo "Waiting for network configuration... " i=0 while [ $i -lt 600 ] do ip=$(xe_min vm-list params=networks uuid=$vm_uuid) if [ "$ip" != "" ] then show_ip "$ip" "1" "$BRIDGE_M" if [[ $BRIDGE_P ]] then show_ip "$ip" "2" "$BRIDGE_P" fi echo "Installation complete." exit 0 fi sleep 10 let i=i+1 done fi devstack-diablo-eol/tools/xen/scripts/mkxva000077500000000000000000000253161207307670500214020ustar00rootroot00000000000000#!/bin/bash # # Copyright (c) 2011 Citrix Systems, Inc. # Copyright 2011 OpenStack LLC. # All Rights Reserved. # # Licensed 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. # set -eu set -o xtrace VBOX_IMG=/output/packages/vbox-img usage() { cat >&2 < -t -x -o: Colon-separated list of output filenames (one for each type). -p: Create a disk label and partition within the output image -t: Colon-separated list of types of output file. xva and ovf supported. -x: XML filenames (one for each type) EOF exit 1 } # parse cmdline OPT_USE_PARTITION= OPT_TYPES= OPT_OUTPUT_FILES= OPT_XML_FILES= while getopts o:pt:x: o do case "$o" in o) OPT_OUTPUT_FILES=$(echo "$OPTARG" | sed -e 's/\s*:\s*/ /g') ;; p) OPT_USE_PARTITION=1 ;; t) OPT_TYPES=$(echo "$OPTARG" | sed -e 's/\s*:\s*/ /g') ;; x) OPT_XML_FILES=$(echo "$OPTARG" | sed -e 's/\s*:\s*/ /g') ;; [?]) usage ;; esac done shift $((OPTIND-1)) [ $# -ne 3 ] && usage FS_STAGING="$1" FS_SIZE_MIB="$2" TMPDIR="$3" if [ "$UID" = "0" ] then SUDO= else SUDO=sudo fi if [ "$FS_SIZE_MIB" = "0" ] then # Just create a dummy file. This allows developers to bypass bits of # the build by setting the size to 0. touch $OPT_OUTPUT_FILES exit 0 fi # create temporary files and dirs FS_TMPFILE=$(mktemp "$TMPDIR/mkxva-fsimg-XXXXX") XVA_TARBALL_STAGING=$(mktemp -d "$TMPDIR/mkxva-tarball-staging-XXXXX") OVF_STAGING=$(mktemp -d "$TMPDIR/mkxva-ovf-staging-XXXXX") # Find udevsettle and udevtrigger on this installation if [ -x "/sbin/udevsettle" ] ; then UDEVSETTLE="/sbin/udevsettle --timeout=30" elif [ -x "/sbin/udevadm" ] ; then UDEVSETTLE='/sbin/udevadm settle' else UDEVSETTLE='/bin/true' fi if [ -x "/sbin/udevtrigger" ] ; then UDEVTRIGGER=/sbin/udevtrigger elif [ -x "/sbin/udevadm" ] ; then UDEVTRIGGER='/sbin/udevadm trigger' else UDEVTRIGGER= fi # CLEAN_ variables track devices and mounts that must be taken down # no matter how the script exits. Loop devices are vulnerable to # exhaustion so we make every effort to remove them CLEAN_KPARTX= CLEAN_LOSETUP= CLEAN_MOUNTPOINT= cleanup_devices () { if [ -n "$CLEAN_MOUNTPOINT" ] ; then echo "Mountpoint $CLEAN_MOUNTPOINT removed on abnormal exit" $SUDO umount "$CLEAN_MOUNTPOINT" || echo "umount failed" rmdir "$CLEAN_MOUNTPOINT" || echo "rmdir failed" fi if [ -n "$CLEAN_KPARTX" ] ; then echo "kpartx devices for $CLEAN_KPARTX removed on abnormal exit" $SUDO kpartx -d "$CLEAN_KPARTX" || echo "kpartx -d failed" fi if [ -n "$CLEAN_LOSETUP" ] ; then echo "Loop device $CLEAN_LOSETUP removed on abnormal exit" $SUDO losetup -d "$CLEAN_LOSETUP" # Allow losetup errors to propagate fi } trap "cleanup_devices" EXIT make_fs_inner () { local staging="$1" local output="$2" local options="$3" CLEAN_MOUNTPOINT=$(mktemp -d "$TMPDIR/mkfs-XXXXXX") # copy staging dir contents to fs image $SUDO mount $options "$output" "$CLEAN_MOUNTPOINT" $SUDO tar -C "$staging" -c . | tar -C "$CLEAN_MOUNTPOINT" -x $SUDO umount "$CLEAN_MOUNTPOINT" rmdir "$CLEAN_MOUNTPOINT" CLEAN_MOUNTPOINT= } # Turn a staging dir into an ext3 filesystem within a partition make_fs_in_partition () { local staging="$1" local output="$2" # create new empty disk dd if=/dev/zero of="$output" bs=1M count=$FS_SIZE_MIB # Set up a loop device on the empty disk image local loopdevice=$($SUDO losetup -f) $SUDO losetup "$loopdevice" "$output" CLEAN_LOSETUP="$loopdevice" # Create a partition table and single partition. # Start partition at sector 63 to allow space for grub cat < "$CLEAN_MOUNTPOINT/boot/grub/grub.conf" </dev/null gzip "$file" else local file="$outputdir"/$(printf "%08d" $i) dd if="$diskimg" of="$file" skip=$i bs=1M count=1 2>/dev/null local chksum=$(sha1sum -b "$file") echo -n "${chksum/ */}" > "$file.checksum" fi i=$(($i + 1)) done } if [ -n "$OPT_USE_PARTITION" ] ; then make_fs_in_partition "$FS_STAGING" "$FS_TMPFILE" else make_fs "$FS_STAGING" "$FS_TMPFILE" fi VDI_SIZE=$(stat --format=%s "$FS_TMPFILE") make_xva () { local output_file="$1" local xml_file="$2" local subdir local rio if [[ `cat $xml_file` =~ "\s*class\s*VDI\s*\s*\s*id\s*(Ref:[0-9]+)" ]] then # it's a rio style xva subdir="${BASH_REMATCH[1]}"; rio=1 else # it's a geneva style xva subdir="xvda" rio=0 fi cp "$xml_file" "$XVA_TARBALL_STAGING"/ova.xml sed -i -e "s/@VDI_SIZE@/$VDI_SIZE/" "$XVA_TARBALL_STAGING"/ova.xml mkdir "$XVA_TARBALL_STAGING/$subdir" splitvdi "$FS_TMPFILE" "$XVA_TARBALL_STAGING/$subdir" "$rio" TARFILE_MEMBERS=$(cd "$XVA_TARBALL_STAGING" && echo ova.xml $subdir/*) tar -C "$XVA_TARBALL_STAGING" --format=v7 -c $TARFILE_MEMBERS -f "$output_file.tmp" mv "$output_file.tmp" "$output_file" } make_ovf () { local output_dir="$1" local xml_file="$2" local output_base=$(basename "$output_dir") local disk="$output_dir/${output_base}.vmdk" local manifest="$output_dir/${output_base}.mf" local ovf="$output_dir/${output_base}.ovf" mkdir -p "$output_dir" rm -f "$disk" $VBOX_IMG convert --srcfilename="$FS_TMPFILE" --dstfilename="$disk" \ --srcformat RAW --dstformat VMDK --variant Stream chmod 0644 "$disk" local n_bytes=$(stat --printf=%s "$disk") cp "$xml_file" "$ovf" sed -i -e "s/@MKXVA_DISK_FULLSIZE@/$VDI_SIZE/" "$ovf" sed -i -e "s/@MKXVA_DISK_SIZE@/$n_bytes/" "$ovf" sed -i -e "s/@MKXVA_DISK_MIB_SIZE@/$FS_SIZE_MIB/" "$ovf" sed -i -e "s/@MKXVA_DISK_FILENAME@/${output_base}.vmdk/" "$ovf" for to_sign in "$ovf" "$disk" do local sha1_sum=$(sha1sum "$to_sign" | cut -d' ' -f1) echo "SHA1($(basename "$to_sign"))= $sha1_sum" >> $manifest done } output_files="$OPT_OUTPUT_FILES" xml_files="$OPT_XML_FILES" # Iterate through the type list creating the relevant VMs for create_type in $OPT_TYPES do # Shift one parameter from the front of the lists create_output_file="${output_files%% *}" output_files="${output_files#* }" create_xml_file="${xml_files%% *}" xml_files="${xml_files#* }" echo "Creating $create_type appliance $create_output_file using metadata file $create_xml_file" case "$create_type" in xva) make_xva "$create_output_file" "$create_xml_file" ;; ovf) make_ovf "$create_output_file" "$create_xml_file" ;; *) echo "Unknown VM type '$create_type'" exit 1 ;; esac done # cleanup if [ -z "${DO_NOT_CLEANUP:-}" ] ; then rm -rf "$XVA_TARBALL_STAGING" rm -f "$FS_TMPFILE" fi devstack-diablo-eol/tools/xen/scripts/uninstall-os-vpx.sh000077500000000000000000000043461207307670500241300ustar00rootroot00000000000000#!/bin/bash # # Copyright (c) 2011 Citrix Systems, Inc. # Copyright 2011 OpenStack LLC. # All Rights Reserved. # # Licensed 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. # remove_data= if [ "$1" = "--remove-data" ] then remove_data=1 fi set -eu xe_min() { local cmd="$1" shift /opt/xensource/bin/xe "$cmd" --minimal "$@" } destroy_vdi() { local vbd_uuid="$1" local type=$(xe_min vbd-list uuid=$vbd_uuid params=type) local dev=$(xe_min vbd-list uuid=$vbd_uuid params=userdevice) local vdi_uuid=$(xe_min vbd-list uuid=$vbd_uuid params=vdi-uuid) if [ "$type" = 'Disk' ] && [ "$dev" != 'xvda' ] && [ "$dev" != '0' ] then echo -n "Destroying data disk... " xe vdi-destroy uuid=$vdi_uuid echo "done." fi } uninstall() { local vm_uuid="$1" local power_state=$(xe_min vm-list uuid=$vm_uuid params=power-state) if [ "$power_state" != "halted" ] then echo -n "Shutting down VM... " xe vm-shutdown vm=$vm_uuid force=true echo "done." fi if [ "$remove_data" = "1" ] then for v in $(xe_min vbd-list vm-uuid=$vm_uuid | sed -e 's/,/ /g') do destroy_vdi "$v" done fi echo -n "Deleting VM... " xe vm-uninstall vm=$vm_uuid force=true >/dev/null echo "done." } uninstall_template() { local vm_uuid="$1" if [ "$remove_data" = "1" ] then for v in $(xe_min vbd-list vm-uuid=$vm_uuid | sed -e 's/,/ /g') do destroy_vdi "$v" done fi echo -n "Deleting template... " xe template-uninstall template-uuid=$vm_uuid force=true >/dev/null echo "done." } for u in $(xe_min vm-list other-config:os-vpx=true | sed -e 's/,/ /g') do uninstall "$u" done for u in $(xe_min template-list other-config:os-vpx=true | sed -e 's/,/ /g') do uninstall_template "$u" done devstack-diablo-eol/tools/xen/templates/000077500000000000000000000000001207307670500206265ustar00rootroot00000000000000devstack-diablo-eol/tools/xen/templates/hosts.in000066400000000000000000000003041207307670500223130ustar00rootroot00000000000000127.0.0.1 localhost 127.0.0.1 %HOSTNAME% ::1 localhost ip6-localhost ip6-loopback fe00::0 ip6-localnet ff00::0 ip6-mcastprefix ff02::1 ip6-allnodes ff02::2 ip6-allrouters devstack-diablo-eol/tools/xen/templates/interfaces.in000066400000000000000000000005571207307670500233100ustar00rootroot00000000000000auto lo iface lo inet loopback auto eth0 iface eth0 inet dhcp auto eth1 iface eth1 inet static address @ETH1_IP@ netmask @ETH1_NETMASK@ post-up ethtool -K eth1 tx off auto eth2 iface eth2 inet static address @ETH2_IP@ netmask @ETH2_NETMASK@ auto eth3 iface eth3 inet static address @ETH3_IP@ netmask @ETH3_NETMASK@ devstack-diablo-eol/tools/xen/templates/menu.lst.in000066400000000000000000000002601207307670500227210ustar00rootroot00000000000000default 0 title default root (hd0,0) kernel /boot/vmlinuz-@KERNEL_VERSION@ ro root=LABEL=vpxroot console=xvc0 initrd /boot/initrd.img-@KERNEL_VERSION@ devstack-diablo-eol/tools/xen/templates/ova.xml.in000066400000000000000000000010441207307670500225410ustar00rootroot00000000000000