Example #1
0
 def setUp(self):
     super(TestAdmin, self).setUp()
     self.admin = AdminClient(self.conf)
     self.api = ObjectStorageApi(self.ns)
     self.account = "test_admin"
     self.container = "admin-" + random_str(4)
     self.api.container_create(self.account, self.container)
Example #2
0
    def __init__(self, tool, queue_workers, queue_reply):
        super(ContainerRepairerWorker, self).__init__(
            tool, queue_workers, queue_reply)

        self.rebuild_bases = true_value(self.tool.conf.get(
            'rebuild_bases', self.tool.DEFAULT_REBUILD_BASES))
        self.sync_bases = true_value(self.tool.conf.get(
            'sync_bases', self.tool.DEFAULT_SYNC_BASES))
        self.update_account = true_value(self.tool.conf.get(
            'update_account', self.tool.DEFAULT_UPDATE_ACCOUNT))

        self.admin_client = AdminClient(self.conf, logger=self.logger)
        self.container_client = ContainerClient(self.conf, logger=self.logger)
        self.meta2_database = Meta2Database(self.conf, logger=self.logger)
Example #3
0
class ContentRepairerWorker(ToolWorker):
    def __init__(self, tool, queue_workers, queue_reply):
        super(ContentRepairerWorker, self).__init__(tool, queue_workers,
                                                    queue_reply)

        self.admin_client = AdminClient(self.conf, logger=self.logger)
        self.meta2_database = Meta2Database(self.conf, logger=self.logger)

    def _process_item(self, item):
        namespace, container_id = item
        if namespace != self.tool.namespace:
            raise ValueError('Invalid namespace (actual=%s, expected=%s)' %
                             (namespace, self.tool.namespace))

        self.logger.debug('Rebuilding %s', self.tool.string_from_item(item))
        errors = list()
        for res in self.meta2_database.rebuild(container_id):
            if res['err']:
                errors.append('%s: %s' % (res['base'], res['err']))
        if errors:
            raise Exception(errors)

        data = self.admin_client.election_sync(service_type='meta2',
                                               cid=container_id)
        for host, info in data.items():
            if info['status']['status'] not in (200, 301):
                errors.append('%s (%d): %s' % (host, info['status']['status'],
                                               info['status']['message']))
        if errors:
            raise Exception(errors)
Example #4
0
class MetaRebuilderWorker(RebuilderWorker):
    def __init__(self, rebuilder, type_, max_attempts=5, **kwargs):
        super(MetaRebuilderWorker, self).__init__(rebuilder, **kwargs)
        self.type = type_
        self.max_attempts = max_attempts
        self.admin_client = AdminClient(self.conf, logger=self.logger)

    def _rebuild_one(self, cid, **kwargs):
        missing_base = False
        for attempts in range(self.max_attempts):
            try:
                if not missing_base:
                    # Check if the bases exist
                    info = self.admin_client.has_base(self.type, cid=cid)
                    for meta in info.values():
                        if meta['status']['status'] != 200:
                            missing_base = True
                            break

                if missing_base:
                    self.admin_client.election_leave(self.type, cid=cid)
                    # TODO(adu): use self.admin_client.election_sync
                    # Setting a property will trigger a database replication
                    properties = {'sys.last_rebuild': str(int(time.time()))}
                    self.admin_client.set_properties(self.type,
                                                     cid=cid,
                                                     properties=properties)
                break
            except Exception as err:
                if attempts < self.max_attempts - 1:
                    if isinstance(err, NotFound):
                        self.logger.warn('%s: %s', cid, err)
                        continue
                    if isinstance(err, OioTimeout) \
                            or isinstance(err, ServiceBusy):
                        self.logger.warn('%s: %s', cid, err)
                        time.sleep(attempts * 0.5)
                        continue
                self.logger.error('ERROR while rebuilding %s: %s', cid, err)
                sys.stdout.write(cid + '\n')
                break
Example #5
0
class ContainerRepairerWorker(ToolWorker):

    def __init__(self, tool, queue_workers, queue_reply):
        super(ContainerRepairerWorker, self).__init__(
            tool, queue_workers, queue_reply)

        self.rebuild_bases = true_value(self.tool.conf.get(
            'rebuild_bases', self.tool.DEFAULT_REBUILD_BASES))
        self.sync_bases = true_value(self.tool.conf.get(
            'sync_bases', self.tool.DEFAULT_SYNC_BASES))
        self.update_account = true_value(self.tool.conf.get(
            'update_account', self.tool.DEFAULT_UPDATE_ACCOUNT))

        self.admin_client = AdminClient(self.conf, logger=self.logger)
        self.container_client = ContainerClient(self.conf, logger=self.logger)
        self.meta2_database = Meta2Database(self.conf, logger=self.logger)

    def _process_item(self, item):
        namespace, account, container = item
        if namespace != self.tool.namespace:
            raise ValueError('Invalid namespace (actual=%s, expected=%s)' % (
                namespace, self.tool.namespace))

        errors = list()

        if self.rebuild_bases:
            cid = cid_from_name(account, container)
            for res in self.meta2_database.rebuild(cid):
                if res['err']:
                    errors.append('%s: %s' % (res['base'], res['err']))
            if errors:
                raise Exception(errors)

        if self.sync_bases:
            data = self.admin_client.election_sync(
                service_type='meta2', account=account, reference=container)
            for host, info in data.items():
                if info['status']['status'] not in (200, 301):
                    errors.append('%s (%d): %s' % (
                        host, info['status']['status'],
                        info['status']['message']))
            if errors:
                raise Exception(errors)

        if self.update_account:
            self.container_client.container_touch(
                account=account, reference=container)
Example #6
0
 def admin(self):
     if not self._admin:
         self._admin = AdminClient(self.conf)
     return self._admin
Example #7
0
    def __init__(self, tool, queue_workers, queue_reply):
        super(ContentRepairerWorker, self).__init__(tool, queue_workers,
                                                    queue_reply)

        self.admin_client = AdminClient(self.conf, logger=self.logger)
        self.meta2_database = Meta2Database(self.conf, logger=self.logger)
Example #8
0
 def admin(self):
     """Get a client for admin operations (especially sqliterepo)."""
     if not self._admin:
         from oio.directory.admin import AdminClient
         self._admin = AdminClient(self.conf, pool_manager=self.http_pool)
     return self._admin
Example #9
0
class TestAdmin(BaseTestCase):
    def setUp(self):
        super(TestAdmin, self).setUp()
        self.admin = AdminClient(self.conf)
        self.api = ObjectStorageApi(self.ns)
        self.account = "test_admin"
        self.container = "admin-" + random_str(4)
        self.api.container_create(self.account, self.container)

    def tearDown(self):
        super(TestAdmin, self).tearDown()
        try:
            self.api.container_delete(self.account, self.container)
        except Exception:
            pass

    def test_election_leave_service_id(self):
        status = self.admin.election_status("meta2",
                                            account=self.account,
                                            reference=self.container)
        peers = status["peers"]
        service_id = peers.keys()[random.randrange(len(peers))]
        election = self.admin.election_leave("meta2",
                                             account=self.account,
                                             reference=self.container,
                                             service_id=service_id)
        self.assertEqual(1, len(election))
        self.assertEqual(200, election[service_id]["status"]["status"])

    def test_election_leave_serveral_service_ids(self):
        status = self.admin.election_status("meta2",
                                            account=self.account,
                                            reference=self.container)
        peers = status["peers"]
        if len(peers) < 2:
            self.skipTest('Can only run in a replicated environment')
        service_ids = peers.keys()[:2]
        election = self.admin.election_leave("meta2",
                                             account=self.account,
                                             reference=self.container,
                                             service_id=service_ids)
        self.assertEquals(2, len(election))
        self.assertEquals(200, election[service_ids[0]]["status"]["status"])
        self.assertEquals(200, election[service_ids[1]]["status"]["status"])

    def test_has_base(self):
        info = self.admin.has_base('meta2',
                                   account=self.account,
                                   reference=self.container)
        for peer, meta in info.iteritems():
            self.assertEqual(200, meta['status']['status'])

        peer = info.keys()[0]
        peer_loc = info[peer]['body']
        self.assertTrue(os.path.isfile(peer_loc))
        os.remove(peer_loc)

        info = self.admin.has_base('meta2',
                                   account=self.account,
                                   reference=self.container)
        self.assertNotEquals(200, info[peer]['status']['status'])
        del info[peer]
        for peer, meta in info.iteritems():
            self.assertEqual(200, meta['status']['status'])
Example #10
0
 def admin(self):
     if self._admin_client is None:
         from oio.directory.admin import AdminClient
         self._admin_client = AdminClient(self.client_conf,
                                          pool_manager=self.pool_manager)
     return self._admin_client
Example #11
0
 def __init__(self, rebuilder, type_, max_attempts=5, **kwargs):
     super(MetaRebuilderWorker, self).__init__(rebuilder, **kwargs)
     self.type = type_
     self.max_attempts = max_attempts
     self.admin_client = AdminClient(self.conf, logger=self.logger)
Example #12
0
def make_client(instance):
    endpoint = instance.get_endpoint('election')
    client = AdminClient({"namespace": instance.namespace}, endpoint=endpoint)
    return client