Examples with ExportTable org.apache.accumulo.manager.tableOps.tableExport.ExportTable used on opensource projects

Example 1 with ExportTable

use of org.apache.accumulo.manager.tableOps.tableExport.ExportTable in project accumulo by apache.

the class FateServiceHandler method executeFateOperation.

@Override
public void executeFateOperation(TInfo tinfo, TCredentials c, long opid, FateOperation op, List<ByteBuffer> arguments, Map<String, String> options, boolean autoCleanup) throws ThriftSecurityException, ThriftTableOperationException {
    authenticate(c);
    String goalMessage = op.toString() + " ";
    switch(op) {
        case NAMESPACE_CREATE:
            {
                TableOperation tableOp = TableOperation.CREATE;
                validateArgumentCount(arguments, tableOp, 1);
                String namespace = validateName(arguments.get(0), tableOp, NEW_NAMESPACE_NAME);
                if (!manager.security.canCreateNamespace(c))
                    throw new ThriftSecurityException(c.getPrincipal(), SecurityErrorCode.PERMISSION_DENIED);
                goalMessage += "Create " + namespace + " namespace.";
                manager.fate.seedTransaction(opid, new TraceRepo<>(new CreateNamespace(c.getPrincipal(), namespace, options)), autoCleanup, goalMessage);
                break;
            }
        case NAMESPACE_RENAME:
            {
                TableOperation tableOp = TableOperation.RENAME;
                validateArgumentCount(arguments, tableOp, 2);
                String oldName = validateName(arguments.get(0), tableOp, EXISTING_NAMESPACE_NAME.and(NOT_BUILTIN_NAMESPACE));
                String newName = validateName(arguments.get(1), tableOp, NEW_NAMESPACE_NAME);
                NamespaceId namespaceId = ClientServiceHandler.checkNamespaceId(manager.getContext(), oldName, tableOp);
                if (!manager.security.canRenameNamespace(c, namespaceId))
                    throw new ThriftSecurityException(c.getPrincipal(), SecurityErrorCode.PERMISSION_DENIED);
                goalMessage += "Rename " + oldName + " namespace to " + newName;
                manager.fate.seedTransaction(opid, new TraceRepo<>(new RenameNamespace(namespaceId, oldName, newName)), autoCleanup, goalMessage);
                break;
            }
        case NAMESPACE_DELETE:
            {
                TableOperation tableOp = TableOperation.DELETE;
                validateArgumentCount(arguments, tableOp, 1);
                String namespace = validateName(arguments.get(0), tableOp, EXISTING_NAMESPACE_NAME.and(NOT_BUILTIN_NAMESPACE));
                NamespaceId namespaceId = ClientServiceHandler.checkNamespaceId(manager.getContext(), namespace, tableOp);
                if (!manager.security.canDeleteNamespace(c, namespaceId))
                    throw new ThriftSecurityException(c.getPrincipal(), SecurityErrorCode.PERMISSION_DENIED);
                goalMessage += "Delete namespace Id: " + namespaceId;
                manager.fate.seedTransaction(opid, new TraceRepo<>(new DeleteNamespace(namespaceId)), autoCleanup, goalMessage);
                break;
            }
        case TABLE_CREATE:
            {
                TableOperation tableOp = TableOperation.CREATE;
                // offset where split data begins in arguments list
                int SPLIT_OFFSET = 4;
                if (arguments.size() < SPLIT_OFFSET) {
                    throw new ThriftTableOperationException(null, null, tableOp, TableOperationExceptionType.OTHER, "Expected at least " + SPLIT_OFFSET + " arguments, saw :" + arguments.size());
                }
                String tableName = validateName(arguments.get(0), tableOp, NEW_TABLE_NAME.and(NOT_BUILTIN_TABLE));
                TimeType timeType = TimeType.valueOf(ByteBufferUtil.toString(arguments.get(1)));
                InitialTableState initialTableState = InitialTableState.valueOf(ByteBufferUtil.toString(arguments.get(2)));
                int splitCount = Integer.parseInt(ByteBufferUtil.toString(arguments.get(3)));
                validateArgumentCount(arguments, tableOp, SPLIT_OFFSET + splitCount);
                Path splitsPath = null;
                Path splitsDirsPath = null;
                if (splitCount > 0) {
                    try {
                        Path tmpDir = mkTempDir(opid);
                        splitsPath = new Path(tmpDir, "splits");
                        splitsDirsPath = new Path(tmpDir, "splitsDirs");
                        writeSplitsToFile(splitsPath, arguments, splitCount, SPLIT_OFFSET);
                    } catch (IOException e) {
                        throw new ThriftTableOperationException(null, tableName, tableOp, TableOperationExceptionType.OTHER, "Exception thrown while writing splits to file system");
                    }
                }
                NamespaceId namespaceId;
                try {
                    namespaceId = Namespaces.getNamespaceId(manager.getContext(), TableNameUtil.qualify(tableName).getFirst());
                } catch (NamespaceNotFoundException e) {
                    throw new ThriftTableOperationException(null, tableName, tableOp, TableOperationExceptionType.NAMESPACE_NOTFOUND, "");
                }
                if (!manager.security.canCreateTable(c, tableName, namespaceId))
                    throw new ThriftSecurityException(c.getPrincipal(), SecurityErrorCode.PERMISSION_DENIED);
                for (Map.Entry<String, String> entry : options.entrySet()) {
                    if (!Property.isTablePropertyValid(entry.getKey(), entry.getValue())) {
                        throw new ThriftTableOperationException(null, tableName, tableOp, TableOperationExceptionType.OTHER, "Property or value not valid " + entry.getKey() + "=" + entry.getValue());
                    }
                }
                goalMessage += "Create table " + tableName + " " + initialTableState + " with " + splitCount + " splits.";
                manager.fate.seedTransaction(opid, new TraceRepo<>(new CreateTable(c.getPrincipal(), tableName, timeType, options, splitsPath, splitCount, splitsDirsPath, initialTableState, namespaceId)), autoCleanup, goalMessage);
                break;
            }
        case TABLE_RENAME:
            {
                TableOperation tableOp = TableOperation.RENAME;
                validateArgumentCount(arguments, tableOp, 2);
                String oldTableName = validateName(arguments.get(0), tableOp, EXISTING_TABLE_NAME.and(NOT_BUILTIN_TABLE));
                String newTableName = validateName(arguments.get(1), tableOp, NEW_TABLE_NAME.and(sameNamespaceAs(oldTableName)));
                TableId tableId = ClientServiceHandler.checkTableId(manager.getContext(), oldTableName, tableOp);
                NamespaceId namespaceId = getNamespaceIdFromTableId(tableOp, tableId);
                final boolean canRename;
                try {
                    canRename = manager.security.canRenameTable(c, tableId, oldTableName, newTableName, namespaceId);
                } catch (ThriftSecurityException e) {
                    throwIfTableMissingSecurityException(e, tableId, oldTableName, TableOperation.RENAME);
                    throw e;
                }
                if (!canRename)
                    throw new ThriftSecurityException(c.getPrincipal(), SecurityErrorCode.PERMISSION_DENIED);
                goalMessage += "Rename table " + oldTableName + "(" + tableId + ") to " + oldTableName;
                try {
                    manager.fate.seedTransaction(opid, new TraceRepo<>(new RenameTable(namespaceId, tableId, oldTableName, newTableName)), autoCleanup, goalMessage);
                } catch (NamespaceNotFoundException e) {
                    throw new ThriftTableOperationException(null, oldTableName, tableOp, TableOperationExceptionType.NAMESPACE_NOTFOUND, "");
                }
                break;
            }
        case TABLE_CLONE:
            {
                TableOperation tableOp = TableOperation.CLONE;
                validateArgumentCount(arguments, tableOp, 3);
                TableId srcTableId = validateTableIdArgument(arguments.get(0), tableOp, CAN_CLONE_TABLE);
                String tableName = validateName(arguments.get(1), tableOp, NEW_TABLE_NAME.and(NOT_BUILTIN_TABLE));
                boolean keepOffline = false;
                if (arguments.get(2) != null) {
                    keepOffline = Boolean.parseBoolean(ByteBufferUtil.toString(arguments.get(2)));
                }
                NamespaceId namespaceId;
                try {
                    namespaceId = Namespaces.getNamespaceId(manager.getContext(), TableNameUtil.qualify(tableName).getFirst());
                } catch (NamespaceNotFoundException e) {
                    // shouldn't happen, but possible once cloning between namespaces is supported
                    throw new ThriftTableOperationException(null, tableName, tableOp, TableOperationExceptionType.NAMESPACE_NOTFOUND, "");
                }
                final boolean canCloneTable;
                try {
                    canCloneTable = manager.security.canCloneTable(c, srcTableId, tableName, namespaceId, namespaceId);
                } catch (ThriftSecurityException e) {
                    throwIfTableMissingSecurityException(e, srcTableId, null, TableOperation.CLONE);
                    throw e;
                }
                if (!canCloneTable)
                    throw new ThriftSecurityException(c.getPrincipal(), SecurityErrorCode.PERMISSION_DENIED);
                Map<String, String> propertiesToSet = new HashMap<>();
                Set<String> propertiesToExclude = new HashSet<>();
                for (Entry<String, String> entry : options.entrySet()) {
                    if (entry.getKey().startsWith(TableOperationsImpl.CLONE_EXCLUDE_PREFIX)) {
                        propertiesToExclude.add(entry.getKey().substring(TableOperationsImpl.CLONE_EXCLUDE_PREFIX.length()));
                        continue;
                    }
                    if (!Property.isTablePropertyValid(entry.getKey(), entry.getValue())) {
                        throw new ThriftTableOperationException(null, tableName, tableOp, TableOperationExceptionType.OTHER, "Property or value not valid " + entry.getKey() + "=" + entry.getValue());
                    }
                    propertiesToSet.put(entry.getKey(), entry.getValue());
                }
                goalMessage += "Clone table " + srcTableId + " to " + tableName;
                if (keepOffline)
                    goalMessage += " and keep offline.";
                manager.fate.seedTransaction(opid, new TraceRepo<>(new CloneTable(c.getPrincipal(), namespaceId, srcTableId, tableName, propertiesToSet, propertiesToExclude, keepOffline)), autoCleanup, goalMessage);
                break;
            }
        case TABLE_DELETE:
            {
                TableOperation tableOp = TableOperation.DELETE;
                validateArgumentCount(arguments, tableOp, 1);
                String tableName = validateName(arguments.get(0), tableOp, EXISTING_TABLE_NAME.and(NOT_BUILTIN_TABLE));
                final TableId tableId = ClientServiceHandler.checkTableId(manager.getContext(), tableName, tableOp);
                NamespaceId namespaceId = getNamespaceIdFromTableId(tableOp, tableId);
                final boolean canDeleteTable;
                try {
                    canDeleteTable = manager.security.canDeleteTable(c, tableId, namespaceId);
                } catch (ThriftSecurityException e) {
                    throwIfTableMissingSecurityException(e, tableId, tableName, TableOperation.DELETE);
                    throw e;
                }
                if (!canDeleteTable)
                    throw new ThriftSecurityException(c.getPrincipal(), SecurityErrorCode.PERMISSION_DENIED);
                goalMessage += "Delete table " + tableName + "(" + tableId + ")";
                manager.fate.seedTransaction(opid, new TraceRepo<>(new PreDeleteTable(namespaceId, tableId)), autoCleanup, goalMessage);
                break;
            }
        case TABLE_ONLINE:
            {
                TableOperation tableOp = TableOperation.ONLINE;
                validateArgumentCount(arguments, tableOp, 1);
                final var tableId = validateTableIdArgument(arguments.get(0), tableOp, NOT_ROOT_TABLE_ID);
                NamespaceId namespaceId = getNamespaceIdFromTableId(tableOp, tableId);
                final boolean canOnlineOfflineTable;
                try {
                    canOnlineOfflineTable = manager.security.canOnlineOfflineTable(c, tableId, op, namespaceId);
                } catch (ThriftSecurityException e) {
                    throwIfTableMissingSecurityException(e, tableId, null, TableOperation.ONLINE);
                    throw e;
                }
                if (!canOnlineOfflineTable)
                    throw new ThriftSecurityException(c.getPrincipal(), SecurityErrorCode.PERMISSION_DENIED);
                goalMessage += "Online table " + tableId;
                manager.fate.seedTransaction(opid, new TraceRepo<>(new ChangeTableState(namespaceId, tableId, tableOp)), autoCleanup, goalMessage);
                break;
            }
        case TABLE_OFFLINE:
            {
                TableOperation tableOp = TableOperation.OFFLINE;
                validateArgumentCount(arguments, tableOp, 1);
                final var tableId = validateTableIdArgument(arguments.get(0), tableOp, NOT_ROOT_TABLE_ID);
                NamespaceId namespaceId = getNamespaceIdFromTableId(tableOp, tableId);
                final boolean canOnlineOfflineTable;
                try {
                    canOnlineOfflineTable = manager.security.canOnlineOfflineTable(c, tableId, op, namespaceId);
                } catch (ThriftSecurityException e) {
                    throwIfTableMissingSecurityException(e, tableId, null, TableOperation.OFFLINE);
                    throw e;
                }
                if (!canOnlineOfflineTable)
                    throw new ThriftSecurityException(c.getPrincipal(), SecurityErrorCode.PERMISSION_DENIED);
                goalMessage += "Offline table " + tableId;
                manager.fate.seedTransaction(opid, new TraceRepo<>(new ChangeTableState(namespaceId, tableId, tableOp)), autoCleanup, goalMessage);
                break;
            }
        case TABLE_MERGE:
            {
                TableOperation tableOp = TableOperation.MERGE;
                validateArgumentCount(arguments, tableOp, 3);
                String tableName = validateName(arguments.get(0), tableOp, EXISTING_TABLE_NAME);
                Text startRow = ByteBufferUtil.toText(arguments.get(1));
                Text endRow = ByteBufferUtil.toText(arguments.get(2));
                final TableId tableId = ClientServiceHandler.checkTableId(manager.getContext(), tableName, tableOp);
                NamespaceId namespaceId = getNamespaceIdFromTableId(tableOp, tableId);
                final boolean canMerge;
                try {
                    canMerge = manager.security.canMerge(c, tableId, namespaceId);
                } catch (ThriftSecurityException e) {
                    throwIfTableMissingSecurityException(e, tableId, tableName, TableOperation.MERGE);
                    throw e;
                }
                if (!canMerge)
                    throw new ThriftSecurityException(c.getPrincipal(), SecurityErrorCode.PERMISSION_DENIED);
                Manager.log.debug("Creating merge op: {} {} {}", tableId, startRow, endRow);
                goalMessage += "Merge table " + tableName + "(" + tableId + ") splits from " + startRow + " to " + endRow;
                manager.fate.seedTransaction(opid, new TraceRepo<>(new TableRangeOp(MergeInfo.Operation.MERGE, namespaceId, tableId, startRow, endRow)), autoCleanup, goalMessage);
                break;
            }
        case TABLE_DELETE_RANGE:
            {
                TableOperation tableOp = TableOperation.DELETE_RANGE;
                validateArgumentCount(arguments, tableOp, 3);
                String tableName = validateName(arguments.get(0), tableOp, EXISTING_TABLE_NAME.and(NOT_METADATA_TABLE));
                Text startRow = ByteBufferUtil.toText(arguments.get(1));
                Text endRow = ByteBufferUtil.toText(arguments.get(2));
                final TableId tableId = ClientServiceHandler.checkTableId(manager.getContext(), tableName, tableOp);
                NamespaceId namespaceId = getNamespaceIdFromTableId(tableOp, tableId);
                final boolean canDeleteRange;
                try {
                    canDeleteRange = manager.security.canDeleteRange(c, tableId, tableName, startRow, endRow, namespaceId);
                } catch (ThriftSecurityException e) {
                    throwIfTableMissingSecurityException(e, tableId, tableName, TableOperation.DELETE_RANGE);
                    throw e;
                }
                if (!canDeleteRange)
                    throw new ThriftSecurityException(c.getPrincipal(), SecurityErrorCode.PERMISSION_DENIED);
                goalMessage += "Delete table " + tableName + "(" + tableId + ") range " + startRow + " to " + endRow;
                manager.fate.seedTransaction(opid, new TraceRepo<>(new TableRangeOp(MergeInfo.Operation.DELETE, namespaceId, tableId, startRow, endRow)), autoCleanup, goalMessage);
                break;
            }
        case TABLE_BULK_IMPORT:
            {
                TableOperation tableOp = TableOperation.BULK_IMPORT;
                validateArgumentCount(arguments, tableOp, 4);
                String tableName = validateName(arguments.get(0), tableOp, EXISTING_TABLE_NAME.and(NOT_BUILTIN_TABLE));
                String dir = ByteBufferUtil.toString(arguments.get(1));
                String failDir = ByteBufferUtil.toString(arguments.get(2));
                boolean setTime = Boolean.parseBoolean(ByteBufferUtil.toString(arguments.get(3)));
                final TableId tableId = ClientServiceHandler.checkTableId(manager.getContext(), tableName, tableOp);
                NamespaceId namespaceId = getNamespaceIdFromTableId(tableOp, tableId);
                final boolean canBulkImport;
                try {
                    canBulkImport = manager.security.canBulkImport(c, tableId, tableName, dir, failDir, namespaceId);
                } catch (ThriftSecurityException e) {
                    throwIfTableMissingSecurityException(e, tableId, tableName, TableOperation.BULK_IMPORT);
                    throw e;
                }
                if (!canBulkImport)
                    throw new ThriftSecurityException(c.getPrincipal(), SecurityErrorCode.PERMISSION_DENIED);
                manager.updateBulkImportStatus(dir, BulkImportState.INITIAL);
                goalMessage += "Bulk import " + dir + " to " + tableName + "(" + tableId + ") failing to " + failDir;
                manager.fate.seedTransaction(opid, new TraceRepo<>(new org.apache.accumulo.manager.tableOps.bulkVer1.BulkImport(tableId, dir, failDir, setTime)), autoCleanup, goalMessage);
                break;
            }
        case TABLE_COMPACT:
            {
                TableOperation tableOp = TableOperation.COMPACT;
                validateArgumentCount(arguments, tableOp, 2);
                TableId tableId = validateTableIdArgument(arguments.get(0), tableOp, null);
                CompactionConfig compactionConfig = UserCompactionUtils.decodeCompactionConfig(ByteBufferUtil.toBytes(arguments.get(1)));
                NamespaceId namespaceId = getNamespaceIdFromTableId(tableOp, tableId);
                final boolean canCompact;
                try {
                    canCompact = manager.security.canCompact(c, tableId, namespaceId);
                } catch (ThriftSecurityException e) {
                    throwIfTableMissingSecurityException(e, tableId, null, TableOperation.COMPACT);
                    throw e;
                }
                if (!canCompact)
                    throw new ThriftSecurityException(c.getPrincipal(), SecurityErrorCode.PERMISSION_DENIED);
                goalMessage += "Compact table (" + tableId + ") with config " + compactionConfig;
                manager.fate.seedTransaction(opid, new TraceRepo<>(new CompactRange(namespaceId, tableId, compactionConfig)), autoCleanup, goalMessage);
                break;
            }
        case TABLE_CANCEL_COMPACT:
            {
                TableOperation tableOp = TableOperation.COMPACT_CANCEL;
                validateArgumentCount(arguments, tableOp, 1);
                TableId tableId = validateTableIdArgument(arguments.get(0), tableOp, null);
                NamespaceId namespaceId = getNamespaceIdFromTableId(tableOp, tableId);
                final boolean canCancelCompact;
                try {
                    canCancelCompact = manager.security.canCompact(c, tableId, namespaceId);
                } catch (ThriftSecurityException e) {
                    throwIfTableMissingSecurityException(e, tableId, null, TableOperation.COMPACT_CANCEL);
                    throw e;
                }
                if (!canCancelCompact)
                    throw new ThriftSecurityException(c.getPrincipal(), SecurityErrorCode.PERMISSION_DENIED);
                goalMessage += "Cancel compaction of table (" + tableId + ")";
                manager.fate.seedTransaction(opid, new TraceRepo<>(new CancelCompactions(namespaceId, tableId)), autoCleanup, goalMessage);
                break;
            }
        case TABLE_IMPORT:
            {
                TableOperation tableOp = TableOperation.IMPORT;
                // offset where table list begins
                int IMPORT_DIR_OFFSET = 2;
                if (arguments.size() < IMPORT_DIR_OFFSET) {
                    throw new ThriftTableOperationException(null, null, tableOp, TableOperationExceptionType.OTHER, "Expected at least " + IMPORT_DIR_OFFSET + "arguments, sar :" + arguments.size());
                }
                String tableName = validateName(arguments.get(0), tableOp, NEW_TABLE_NAME.and(NOT_BUILTIN_TABLE));
                List<ByteBuffer> exportDirArgs = arguments.stream().skip(1).collect(Collectors.toList());
                Set<String> exportDirs = ByteBufferUtil.toStringSet(exportDirArgs);
                NamespaceId namespaceId;
                try {
                    namespaceId = Namespaces.getNamespaceId(manager.getContext(), TableNameUtil.qualify(tableName).getFirst());
                } catch (NamespaceNotFoundException e) {
                    throw new ThriftTableOperationException(null, tableName, tableOp, TableOperationExceptionType.NAMESPACE_NOTFOUND, "");
                }
                final boolean canImport;
                try {
                    canImport = manager.security.canImport(c, tableName, exportDirs, namespaceId);
                } catch (ThriftSecurityException e) {
                    throwIfTableMissingSecurityException(e, null, tableName, TableOperation.IMPORT);
                    throw e;
                }
                if (!canImport)
                    throw new ThriftSecurityException(c.getPrincipal(), SecurityErrorCode.PERMISSION_DENIED);
                goalMessage += "Import table with new name: " + tableName + " from " + exportDirs;
                manager.fate.seedTransaction(opid, new TraceRepo<>(new ImportTable(c.getPrincipal(), tableName, exportDirs, namespaceId)), autoCleanup, goalMessage);
                break;
            }
        case TABLE_EXPORT:
            {
                TableOperation tableOp = TableOperation.EXPORT;
                validateArgumentCount(arguments, tableOp, 2);
                String tableName = validateName(arguments.get(0), tableOp, EXISTING_TABLE_NAME.and(NOT_BUILTIN_TABLE));
                String exportDir = ByteBufferUtil.toString(arguments.get(1));
                TableId tableId = ClientServiceHandler.checkTableId(manager.getContext(), tableName, tableOp);
                NamespaceId namespaceId = getNamespaceIdFromTableId(tableOp, tableId);
                final boolean canExport;
                try {
                    canExport = manager.security.canExport(c, tableId, tableName, exportDir, namespaceId);
                } catch (ThriftSecurityException e) {
                    throwIfTableMissingSecurityException(e, tableId, tableName, TableOperation.EXPORT);
                    throw e;
                }
                if (!canExport)
                    throw new ThriftSecurityException(c.getPrincipal(), SecurityErrorCode.PERMISSION_DENIED);
                goalMessage += "Export table " + tableName + "(" + tableId + ") to " + exportDir;
                manager.fate.seedTransaction(opid, new TraceRepo<>(new ExportTable(namespaceId, tableName, tableId, exportDir)), autoCleanup, goalMessage);
                break;
            }
        case TABLE_BULK_IMPORT2:
            TableOperation tableOp = TableOperation.BULK_IMPORT;
            validateArgumentCount(arguments, tableOp, 3);
            final var tableId = validateTableIdArgument(arguments.get(0), tableOp, NOT_ROOT_TABLE_ID);
            String dir = ByteBufferUtil.toString(arguments.get(1));
            boolean setTime = Boolean.parseBoolean(ByteBufferUtil.toString(arguments.get(2)));
            NamespaceId namespaceId = getNamespaceIdFromTableId(tableOp, tableId);
            final boolean canBulkImport;
            String tableName;
            try {
                tableName = manager.getContext().getTableName(tableId);
                canBulkImport = manager.security.canBulkImport(c, tableId, tableName, dir, null, namespaceId);
            } catch (ThriftSecurityException e) {
                throwIfTableMissingSecurityException(e, tableId, "", TableOperation.BULK_IMPORT);
                throw e;
            } catch (TableNotFoundException e) {
                throw new ThriftTableOperationException(tableId.canonical(), null, TableOperation.BULK_IMPORT, TableOperationExceptionType.NOTFOUND, "Table no longer exists");
            }
            if (!canBulkImport)
                throw new ThriftSecurityException(c.getPrincipal(), SecurityErrorCode.PERMISSION_DENIED);
            manager.updateBulkImportStatus(dir, BulkImportState.INITIAL);
            goalMessage += "Bulk import (v2)  " + dir + " to " + tableName + "(" + tableId + ")";
            manager.fate.seedTransaction(opid, new TraceRepo<>(new PrepBulkImport(tableId, dir, setTime)), autoCleanup, goalMessage);
            break;
        default:
            throw new UnsupportedOperationException();
    }
}