Ejemplo n.º 1
0
def setup_server(environment='development', server_root=''):
    global test_server, model

    patch_auth()
    test_server = run_server(test_mode=True,
                             environment=environment,
                             server_root=server_root)
Ejemplo n.º 2
0
def setUpModule():
    global test_server, model, host, port, ssl_port

    utils.patch_auth()
    host = '127.0.0.1'
    port = utils.get_free_port('http')
    ssl_port = utils.get_free_port('https')
    test_server = utils.run_server(host, port, ssl_port, test_mode=True)
Ejemplo n.º 3
0
 def setUp(self):
     global port, host, model, test_server
     cherrypy.request.headers = {'Accept': 'application/json'}
     model = kimchi.mockmodel.MockModel('/tmp/obj-store-test')
     patch_auth()
     port = get_free_port()
     host = '127.0.0.1'
     test_server = run_server(host, port, None, test_mode=True, model=model)
Ejemplo n.º 4
0
 def setUp(self):
     global port, host, model, test_server
     cherrypy.request.headers = {'Accept': 'application/json'}
     model = kimchi.mockmodel.MockModel('/tmp/obj-store-test')
     patch_auth()
     port = get_free_port()
     host = '127.0.0.1'
     test_server = run_server(host, port, None, test_mode=True, model=model)
Ejemplo n.º 5
0
def setUpModule():
    global test_server, model, host, port, ssl_port

    patch_auth(sudo=False)
    model = kimchi.mockmodel.MockModel("/tmp/obj-store-test")
    host = "127.0.0.1"
    port = get_free_port("http")
    test_server = run_server(host, port, None, test_mode=True, model=model)
Ejemplo n.º 6
0
def setUpModule():
    global test_server, model, host, port, ssl_port

    utils.patch_auth()
    host = '127.0.0.1'
    port = utils.get_free_port('http')
    ssl_port = utils.get_free_port('https')
    test_server = utils.run_server(host, port, ssl_port, test_mode=True)
Ejemplo n.º 7
0
def setUpModule():
    global test_server, model, host, port, ssl_port

    patch_auth(sudo=False)
    model = kimchi.mockmodel.MockModel('/tmp/obj-store-test')
    host = '127.0.0.1'
    port = get_free_port('http')
    test_server = run_server(host, port, None, test_mode=True, model=model)
Ejemplo n.º 8
0
def setUpModule():
    global test_server, model, host, port, ssl_port

    patch_auth(sudo=False)
    model = mockmodel.MockModel('/tmp/obj-store-test')
    host = '127.0.0.1'
    port = get_free_port('http')
    ssl_port = get_free_port('https')
    test_server = run_server(host, port, ssl_port, test_mode=True, model=model)
Ejemplo n.º 9
0
def setup_server(environment='development'):
    global test_server, model, host, port, ssl_port

    patch_auth()
    host = '127.0.0.1'
    port = get_free_port('http')
    ssl_port = get_free_port('https')
    test_server = run_server(host, port, ssl_port, test_mode=True,
                             environment=environment)
Ejemplo n.º 10
0
def setup_server(environment='development'):
    global test_server, model, host, port

    patch_auth()
    model = kimchi.mockmodel.MockModel('/tmp/obj-store-test')
    host = '127.0.0.1'
    port = get_free_port()
    test_server = run_server(host, port, None, test_mode=True, model=model,
                             environment=environment)
Ejemplo n.º 11
0
    def test_vm_livemigrate_persistent_API(self):
        patch_auth()

        inst = model.Model(libvirt_uri='qemu:///system',
                           objstore_loc=self.tmp_store)

        host = '127.0.0.1'
        port = get_free_port('http')
        ssl_port = get_free_port('https')
        cherrypy_port = get_free_port('cherrypy_port')

        with RollbackContext() as rollback:
            test_server = run_server(host, port, ssl_port, test_mode=True,
                                     cherrypy_port=cherrypy_port, model=inst)
            rollback.prependDefer(test_server.stop)

            self.request = partial(request, host, ssl_port)

            self.create_vm_test()
            rollback.prependDefer(utils.rollback_wrapper, self.inst.vm_delete,
                                  u'test_vm_migrate')

            # removing cdrom because it is not shared storage and will make
            # the migration fail
            dev_list = self.inst.vmstorages_get_list('test_vm_migrate')
            self.inst.vmstorage_delete('test_vm_migrate',  dev_list[0])

            try:
                self.inst.vm_start('test_vm_migrate')
            except Exception, e:
                self.fail('Failed to start the vm, reason: %s' % e.message)

            migrate_url = "/plugins/kimchi/vms/%s/migrate" % 'test_vm_migrate'

            req = json.dumps({'remote_host': KIMCHI_LIVE_MIGRATION_TEST,
                             'user': '******'})
            resp = self.request(migrate_url, req, 'POST')
            self.assertEquals(202, resp.status)
            task = json.loads(resp.read())
            wait_task(self._task_lookup, task['id'])
            task = json.loads(
                self.request(
                    '/plugins/kimchi/tasks/%s' % task['id'],
                    '{}'
                ).read()
            )
            self.assertEquals('finished', task['status'])

            try:
                remote_conn = self.get_remote_conn()
                rollback.prependDefer(remote_conn.close)
                remote_vm = remote_conn.lookupByName('test_vm_migrate')
                self.assertTrue(remote_vm.isPersistent())
                remote_vm.destroy()
                remote_vm.undefine()
            except Exception, e:
                self.fail('Migration test failed: %s' % e.message)
Ejemplo n.º 12
0
def setUpModule():
    global test_server, model, host, port, ssl_port, cherrypy_port

    patch_auth()
    model = Model(None, "/tmp/obj-store-test")
    host = "127.0.0.1"
    port = get_free_port("http")
    ssl_port = get_free_port("https")
    cherrypy_port = get_free_port("cherrypy_port")
    test_server = run_server(host, port, ssl_port, test_mode=True, cherrypy_port=cherrypy_port, model=model)
Ejemplo n.º 13
0
def setUpModule():
    global test_server, model, host, port, ssl_port

    utils.patch_auth()
    model = kimchi.mockmodel.MockModel('/tmp/obj-store-test')
    host = '127.0.0.1'
    port = utils.get_free_port('http')
    ssl_port = utils.get_free_port('https')
    test_server = utils.run_server(host, port, ssl_port, test_mode=True,
                                   model=model)
Ejemplo n.º 14
0
def setUpModule():
    global test_server, model, host, port, ssl_port, objstore_loc

    patch_auth()
    objstore_loc = config.get_object_store()
    model = kimchi.mockmodel.MockModel(objstore_loc)
    host = '127.0.0.1'
    port = get_free_port('http')
    ssl_port = get_free_port('https')
    test_server = run_server(host, port, ssl_port, test_mode=True,
                             model=model)
Ejemplo n.º 15
0
def setUpModule():
    global host, port, ssl_port, model, test_server, fake_iso
    cherrypy.request.headers = {"Accept": "application/json"}
    model = mockmodel.MockModel("/tmp/obj-store-test")
    patch_auth()
    port = get_free_port("http")
    ssl_port = get_free_port("https")
    host = "127.0.0.1"
    test_server = run_server(host, port, ssl_port, test_mode=True, model=model)
    fake_iso = "/tmp/fake.iso"
    open(fake_iso, "w").close()
Ejemplo n.º 16
0
def setUpModule():
    global test_server, model, host, port, ssl_port, cherrypy_port

    patch_auth()
    model = Model(None, '/tmp/obj-store-test')
    host = '127.0.0.1'
    port = get_free_port('http')
    ssl_port = get_free_port('https')
    cherrypy_port = get_free_port('cherrypy_port')
    test_server = run_server(host, port, ssl_port, test_mode=True,
                             cherrypy_port=cherrypy_port, model=model)
Ejemplo n.º 17
0
def setUpModule():
    global test_server, model, host, ssl_port, tmpfile

    patch_auth()
    tmpfile = tempfile.mktemp()
    model = MockModel(tmpfile)
    host = "127.0.0.1"
    port = get_free_port("http")
    ssl_port = get_free_port("https")
    cherrypy_port = get_free_port("cherrypy_port")
    test_server = run_server(host, port, ssl_port, test_mode=True, cherrypy_port=cherrypy_port, model=model)
Ejemplo n.º 18
0
def setUpModule():
    global host, port, ssl_port, model, test_server, fake_iso
    cherrypy.request.headers = {'Accept': 'application/json'}
    model = mockmodel.MockModel('/tmp/obj-store-test')
    patch_auth()
    port = get_free_port('http')
    ssl_port = get_free_port('https')
    host = '127.0.0.1'
    test_server = run_server(host, port, ssl_port, test_mode=True, model=model)
    fake_iso = '/tmp/fake.iso'
    open(fake_iso, 'w').close()
Ejemplo n.º 19
0
def setUpModule():
    global test_server, model, host, port, ssl_port, cherrypy_port, tmpfile

    utils.patch_auth()
    tmpfile = tempfile.mktemp()
    host = '127.0.0.1'
    port = utils.get_free_port('http')
    ssl_port = utils.get_free_port('https')
    cherrypy_port = utils.get_free_port('cherrypy_port')
    test_server = utils.run_server(host, port, ssl_port, test_mode=True,
                                   cherrypy_port=cherrypy_port)
Ejemplo n.º 20
0
def setUpModule():
    global test_server, model, host, port, ssl_port

    patch_auth(sudo=False)
    model = mockmodel.MockModel('/tmp/obj-store-test')
    host = '127.0.0.1'
    port = get_free_port('http')
    ssl_port = get_free_port('https')
    test_server = run_server(host, port, ssl_port, test_mode=True, model=model)

    # Create fake ISO to do the tests
    construct_fake_iso(fake_iso, True, '12.04', 'ubuntu')
Ejemplo n.º 21
0
 def setUp(self):
     global host, port, ssl_port, model, test_server, fake_iso
     cherrypy.request.headers = {'Accept': 'application/json'}
     model = kimchi.mockmodel.MockModel('/tmp/obj-store-test')
     patch_auth()
     port = get_free_port('http')
     ssl_port = get_free_port('https')
     host = '127.0.0.1'
     test_server = run_server(host, port, ssl_port, test_mode=True,
                              model=model)
     fake_iso = '/tmp/fake.iso'
     open(fake_iso, 'w').close()
Ejemplo n.º 22
0
def setUpModule():
    global test_server, model, host, port, ssl_port

    patch_auth(sudo=False)
    model = kimchi.mockmodel.MockModel('/tmp/obj-store-test')
    host = '127.0.0.1'
    port = get_free_port('http')
    ssl_port = get_free_port('https')
    test_server = run_server(host, port, ssl_port, test_mode=True, model=model)

    # Create fake ISO to do the tests
    construct_fake_iso(fake_iso, True, '12.04', 'ubuntu')
Ejemplo n.º 23
0
def setUpModule():
    global test_server, model, host, port, ssl_port, cherrypy_port, tmpfile

    utils.patch_auth()
    tmpfile = tempfile.mktemp()
    model = mockmodel.MockModel(tmpfile)
    host = '127.0.0.1'
    port = utils.get_free_port('http')
    ssl_port = utils.get_free_port('https')
    cherrypy_port = utils.get_free_port('cherrypy_port')
    test_server = utils.run_server(host, port, ssl_port, test_mode=True,
                                   cherrypy_port=cherrypy_port, model=model)
Ejemplo n.º 24
0
def setUpModule():
    global test_server, model, host, port, ssl_port

    patch_auth(sudo=False)
    model = kimchi.mockmodel.MockModel("/tmp/obj-store-test")
    host = "127.0.0.1"
    port = get_free_port("http")
    ssl_port = get_free_port("https")
    test_server = run_server(host, port, ssl_port, test_mode=True, model=model)

    # Create fake ISO to do the tests
    construct_fake_iso(fake_iso, True, "12.04", "ubuntu")
Ejemplo n.º 25
0
def setup_server(environment='development'):
    global test_server, model, host, port

    patch_auth()
    model = kimchi.mockmodel.MockModel('/tmp/obj-store-test')
    host = '127.0.0.1'
    port = get_free_port()
    test_server = run_server(host,
                             port,
                             None,
                             test_mode=True,
                             model=model,
                             environment=environment)
Ejemplo n.º 26
0
def setUpModule():
    global test_server, model, host, port, ssl_port

    utils.patch_auth()
    model = kimchi.mockmodel.MockModel('/tmp/obj-store-test')
    host = '127.0.0.1'
    port = utils.get_free_port('http')
    ssl_port = utils.get_free_port('https')
    test_server = utils.run_server(host,
                                   port,
                                   ssl_port,
                                   test_mode=True,
                                   model=model)
Ejemplo n.º 27
0
def setUpModule():
    global test_server, model, host, port, ssl_port, cherrypy_port

    patch_auth()
    model = kimchi.mockmodel.MockModel('/tmp/obj-store-test')
    host = '127.0.0.1'
    port = get_free_port('http')
    ssl_port = get_free_port('https')
    cherrypy_port = get_free_port('cherrypy_port')
    test_server = run_server(host, port, ssl_port, test_mode=True,
                             cherrypy_port=cherrypy_port, model=model)

    # Create fake ISO to do the tests
    iso_gen.construct_fake_iso(fake_iso, True, '12.04', 'ubuntu')
    iso_gen.construct_fake_iso("/var/lib/libvirt/images/fedora.iso", True,
                               "17", "fedora")
Ejemplo n.º 28
0
def setUpModule():
    global test_server, model

    utils.patch_auth()
    test_server = utils.run_server(test_mode=True)
Ejemplo n.º 29
0
def setUpModule():
    global test_server, model

    utils.patch_auth()
    test_server = utils.run_server(test_mode=True)
Ejemplo n.º 30
0
def setup_server(environment='development'):
    global test_server, model

    patch_auth()
    test_server = run_server(test_mode=True, environment=environment)
Ejemplo n.º 31
0
def setUpModule():
    global test_server, model, tmpfile

    utils.patch_auth()
    tmpfile = tempfile.mktemp()
    test_server = utils.run_server(test_mode=True)
Ejemplo n.º 32
0
def setUpModule():
    global test_server, model, tmpfile

    utils.patch_auth()
    tmpfile = tempfile.mktemp()
    test_server = utils.run_server(test_mode=True)