slaprunner.py 8.67 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
# -*- coding: utf-8 -*-
##############################################################################
#
# Copyright (c) 2013 Vifib SARL and Contributors. All Rights Reserved.
#
# WARNING: This program as such is intended to be used by professional
# programmers who take the whole responsibility of assessing all potential
# consequences resulting from its eventual inadequacies and bugs
# End users who are looking for a ready-to-use solution with commercial
# guarantees and support are strongly adviced to contract a Free Software
# Service Company
#
# This program 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.
#
# This program 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, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
#
##############################################################################

from .resiliencytestsuite import ResiliencyTestSuite

31
import base64
32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53
import cookielib
import random
import string
import time
import urllib2

class NotHttpOkException(Exception):
  pass

class SlaprunnerTestSuite(ResiliencyTestSuite):
  """
  Run Slaprunner Resiliency Test.
  It is highly suggested to read ResiliencyTestSuite code.
  """
  def __init__(self,
               server_url, key_file, cert_file,
               computer_id, partition_id, software,
               namebase, slaprunner_rootinstance_name,
               total_instance_count="3"):

    # Setup urllib2 with cookie support
    cookie_jar = cookielib.CookieJar()
54 55 56
    self._opener_director = urllib2.build_opener(
        urllib2.HTTPCookieProcessor(cookie_jar)
    )
57 58 59 60 61 62

    ResiliencyTestSuite.__init__(
        self,
        server_url, key_file, cert_file,
        computer_id, partition_id, software,
        namebase,
63 64
        slaprunner_rootinstance_name,
        300
65 66
    )

67

68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85
  def _connectToSlaprunner(self, resource, data=None):
    """
    Utility.
    Connect through HTTP to the slaprunner instance.
    Require self.slaprunner_backend_url to be set.
    """
    url = "%s/%s" % (self.slaprunner_backend_url, resource)
    if data:
      result = self._opener_director.open(url, data=data)
    else:
      result = self._opener_director.open(url)

    if result.getcode() is not 200:
      raise NotHttpOkException(result.getcode())
    return result.read()

  def _login(self):
    self.logger.debug('Logging in...')
86 87 88 89
    self._connectToSlaprunner('doLogin', data='clogin=%s&cpwd=%s' % (
        self.slaprunner_user,
        self.slaprunner_password)
    )
90 91 92

  def _retrieveInstanceLogFile(self):
    """
93 94
    Store the logfile (=data) of the instance, check it is not empty nor it is
    html.
95
    """
96 97 98 99
    data = self._connectToSlaprunner(
        resource='fileBrowser',
        data='opt=9&filename=log.log&dir=instance_root%252Fslappart0%252Fvar%252Flog%252F'
    )
100 101 102
    self.logger.info('Retrieved data are:\n%s' % data)

    if data.find('<') is not -1:
103 104 105
      raise IOError(
          'Could not retrieve logfile content: retrieved content is html.'
      )
106
    if data.find('Could not load') is not -1:
107 108 109
      raise IOError(
          'Could not retrieve logfile content: server could not load the file.'
      )
110
    if data.find('Hello') is -1:
111 112 113
      raise IOError(
          'Could not retrieve logfile content: retrieve content does not match "Hello".'
      )
114 115
    return data

116 117 118 119 120 121
  def _waitForSoftwareBuild(self):
    while self._connectToSlaprunner(resource='slapgridResult', data='position=0&log=').find('"software": true') is not -1:
      self.logger.info('Software release is still building. Sleeping...')
      time.sleep(15)
    self.logger.info('Software Release has been built / is no longer building.')

122
  def _buildSoftwareRelease(self):
123 124 125 126 127 128
    self.logger.info('Building the Software Release...')
    try:
      self._connectToSlaprunner(resource='runSoftwareProfile')
    except (NotHttpOkException, urllib2.HTTPError):
      # The nginx frontend might timeout before software release is finished.
      pass
129
    self._waitForSoftwareBuild()
130

131
  def _deployInstance(self):
132 133 134 135 136 137 138 139 140 141 142
    self.logger.info('Deploying instance...')
    try:
      self._connectToSlaprunner(resource='runInstanceProfile')
    except (NotHttpOkException, urllib2.HTTPError):
      # The nginx frontend might timeout before someftware release is finished.
      pass
    while self._connectToSlaprunner(resource='slapgridResult', data='position=0&log=').find('"instance": true') is not -1:
      self.logger.info('Buildout is still running. Sleeping...')
      time.sleep(15)
    self.logger.info('Instance has been deployed.')

143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183
  def _gitClone(self):
    self.logger.debug('Doing git clone of git.erp5.org/repos/slapos.git...')
    try:
      self._connectToSlaprunner(
          resource='cloneRepository',
          data='repo=http://git.erp5.org/repos/slapos.git&name=workspace/slapos&email=slapos@slapos.org&user=slapos'
      )
    except (NotHttpOkException, urllib2.HTTPError):
      # cloning can be very long.
      # XXX: quite dirty way to check.
      while self._connectToSlaprunner('getProjectStatus', data='project=workspace/slapos').find('On branch master') is -1:
        self.logger.info('git-cloning ongoing, sleeping...')

  def _openSoftwareRelease(self, software_name):
    self.logger.debug('Opening %s software release...' % software_name)
    self._connectToSlaprunner(
        resource='setCurrentProject',
        data='path=workspace/slapos/software/%s/' % software_name
    )


  def generateData(self):
    self.slaprunner_password = ''.join(
        random.SystemRandom().sample(string.ascii_lowercase, 8)
    )
    self.slaprunner_user = 'slapos'
    self.logger.info('Generated slaprunner user is: %s' % self.slaprunner_user)
    self.logger.info('Generated slaprunner password is: %s' % self.slaprunner_password)

  def pushDataOnMainInstance(self):
    """
    Create a dummy Software Release,
    Build it,
    Wait for build to be successful,
    Deploy instance,
    Wait for instance to be started.
    Store the main IP of the slaprunner for future use.
    """
    self.logger.debug('Getting the backend URL and recovery code...')
    parameter_dict = self._getPartitionParameterDict()
    self.slaprunner_backend_url = parameter_dict['backend_url']
184 185
    #XXX dirty but is used to delete /login from published backend_url
    self.slaprunner_backend_url = self.slaprunner_backend_url[:-5]
186 187
    self.logger.info('backend_url is %s.' % self.slaprunner_backend_url)
    slaprunner_recovery_code = parameter_dict['password_recovery_code']
188

189 190 191 192 193 194 195 196 197 198
    self.logger.debug('Creating the slaprunner account...')
    self._connectToSlaprunner(
        resource='configAccount',
        data='name=slapos&username=%s&email=slapos@slapos.org&password=%s&rcode=%s' % (
            self.slaprunner_user,
            self.slaprunner_password,
            slaprunner_recovery_code
        )
    )

199 200 201
    b64string = base64.encodestring('%s:%s' % (self.slaprunner_user, self.slaprunner_password))[:-1]
    self._opener_director.addheaders = [('Authorization', 'Basic %s'%b64string)]

202 203 204 205 206 207 208 209 210 211
    self._login()

    self._gitClone()
    # XXX should be taken from parameter.
    self._openSoftwareRelease('helloworld')

    self._buildSoftwareRelease()
    self._deployInstance()

    self.data = self._retrieveInstanceLogFile()
212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227

  def checkDataOnCloneInstance(self):
    """
    Check that:
      * backend_url is different
      * Software Release profile is the same,
      * Software Release is built and is the same, (?)
      * Instance is deployed and is the same.
    """
    # XXX: does the promise wait for the software to be built and the instance to be ready?
    old_slaprunner_backend_url = self.slaprunner_backend_url
    self.slaprunner_backend_url = self._returnNewInstanceParameter(
        parameter_key='backend_url',
        old_parameter_value=old_slaprunner_backend_url
    )
    self._login()
228
    self._waitForSoftwareBuild()
229 230 231
    # XXX: in theory, it should be done automatically by slaprunner.
    #      In practice, it is still too dangerous for ERP5 instances.
    self._deployInstance()
232 233 234 235 236 237 238 239 240 241 242 243 244 245 246
    new_data = self._retrieveInstanceLogFile()

    if new_data == self.data:
      self.logger.info('Data are the same: success.')
      return True
    else:
      self.logger.info('Data are different: failure.')


def runTestSuite(*args, **kwargs):
  """
  Run Slaprunner Resiliency Test.
  """
  return SlaprunnerTestSuite(*args, **kwargs).runTestSuite()