use of io.cdap.cdap.common.NamespaceAlreadyExistsException in project cdap by caskdata.
the class AbstractNamespaceClient method create.
@Override
public void create(NamespaceMeta metadata) throws Exception {
URL url = resolve(String.format("namespaces/%s", metadata.getName()));
HttpResponse response = execute(HttpRequest.put(url).withBody(GSON.toJson(metadata)).build());
String responseBody = response.getResponseBodyAsString();
if (response.getResponseCode() == HttpURLConnection.HTTP_OK) {
if (responseBody.equals(String.format("Namespace '%s' already exists.", metadata.getName()))) {
throw new NamespaceAlreadyExistsException(metadata.getNamespaceId());
}
return;
}
if (response.getResponseCode() == HttpURLConnection.HTTP_BAD_REQUEST) {
throw new BadRequestException("Bad request: " + responseBody);
}
throw new IOException(String.format("Cannot create namespace %s. Reason: %s", metadata.getName(), responseBody));
}
use of io.cdap.cdap.common.NamespaceAlreadyExistsException in project cdap by caskdata.
the class DefaultNamespaceCreator method execute.
@Override
public void execute(EmptyArguments arguments) throws FileAlreadyExistsException {
try {
if (!namespaceAdmin.exists(NamespaceId.DEFAULT)) {
namespaceAdmin.create(NamespaceMeta.DEFAULT);
LOG.info("Successfully created namespace '{}'.", NamespaceMeta.DEFAULT);
}
} catch (FileAlreadyExistsException e) {
// avoid retrying if its a FileAlreadyExistsException
throw e;
} catch (NamespaceAlreadyExistsException e) {
// default namespace already exists, move on
} catch (Exception e) {
// the default namespace is valid so any exception here is transient and should be retried.
throw new RetryableException(e);
}
}
use of io.cdap.cdap.common.NamespaceAlreadyExistsException in project cdap by caskdata.
the class InMemoryNamespaceAdmin method create.
@Override
public synchronized void create(NamespaceMeta metadata) throws Exception {
NamespaceId id = new NamespaceId(metadata.getName());
NamespaceMeta existing = namespaces.putIfAbsent(id, metadata);
if (existing != null) {
throw new NamespaceAlreadyExistsException(id);
}
}
use of io.cdap.cdap.common.NamespaceAlreadyExistsException in project cdap by caskdata.
the class DefaultNamespaceAdmin method create.
/**
* Creates a new namespace
*
* @param metadata the {@link NamespaceMeta} for the new namespace to be created
* @throws NamespaceAlreadyExistsException if the specified namespace already exists
*/
@Override
public synchronized void create(final NamespaceMeta metadata) throws Exception {
// TODO: CDAP-1427 - This should be transactional, but we don't support transactions on files yet
Preconditions.checkArgument(metadata != null, "Namespace metadata should not be null.");
NamespaceId namespace = metadata.getNamespaceId();
if (exists(namespace)) {
throw new NamespaceAlreadyExistsException(namespace);
}
// need to enforce on the principal id if impersonation is involved
String ownerPrincipal = metadata.getConfig().getPrincipal();
Principal requestingUser = authenticationContext.getPrincipal();
if (ownerPrincipal != null) {
accessEnforcer.enforce(new KerberosPrincipalId(ownerPrincipal), requestingUser, AccessPermission.SET_OWNER);
}
accessEnforcer.enforce(namespace, requestingUser, StandardPermission.CREATE);
// If this namespace has custom mapping then validate the given custom mapping
if (hasCustomMapping(metadata)) {
validateCustomMapping(metadata);
}
// check that the user has configured either both or none of the following configuration: principal and keytab URI
boolean hasValidKerberosConf = false;
if (metadata.getConfig() != null) {
String configuredPrincipal = metadata.getConfig().getPrincipal();
String configuredKeytabURI = metadata.getConfig().getKeytabURI();
if ((!Strings.isNullOrEmpty(configuredPrincipal) && Strings.isNullOrEmpty(configuredKeytabURI)) || (Strings.isNullOrEmpty(configuredPrincipal) && !Strings.isNullOrEmpty(configuredKeytabURI))) {
throw new BadRequestException(String.format("Either both or none of the following two configurations must be configured. " + "Configured principal: %s, Configured keytabURI: %s", configuredPrincipal, configuredKeytabURI));
}
hasValidKerberosConf = true;
}
// check that if explore as principal is explicitly set to false then user has kerberos configuration
if (!metadata.getConfig().isExploreAsPrincipal() && !hasValidKerberosConf) {
throw new BadRequestException(String.format("No kerberos principal or keytab-uri was provided while '%s' was set to true.", NamespaceConfig.EXPLORE_AS_PRINCIPAL));
}
// store the meta first in the namespace store because namespacedLocationFactory needs to look up location
// mapping from namespace config
nsStore.create(metadata);
try {
UserGroupInformation ugi;
if (NamespaceId.DEFAULT.equals(namespace)) {
ugi = UserGroupInformation.getCurrentUser();
} else {
ugi = impersonator.getUGI(namespace);
}
ImpersonationUtils.doAs(ugi, (Callable<Void>) () -> {
storageProviderNamespaceAdmin.get().create(metadata);
return null;
});
// if needed, run master environment specific logic
MasterEnvironment masterEnv = MasterEnvironments.getMasterEnvironment();
if (masterEnv != null) {
masterEnv.onNamespaceCreation(namespace.getNamespace(), metadata.getConfig().getConfigs());
}
} catch (Throwable t) {
LOG.error(String.format("Failed to create namespace '%s'", namespace.getNamespace()), t);
// failed to create namespace in underlying storage so delete the namespace meta stored in the store earlier
deleteNamespaceMeta(metadata.getNamespaceId());
throw new NamespaceCannotBeCreatedException(namespace, t);
}
emitNamespaceCountMetric();
LOG.info("Namespace {} created with meta {}", metadata.getNamespaceId(), metadata);
}
use of io.cdap.cdap.common.NamespaceAlreadyExistsException in project cdap by caskdata.
the class DefaultNamespaceAdminTest method testNamespaces.
@Test
public void testNamespaces() throws Exception {
String namespace = "namespace";
NamespaceId namespaceId = new NamespaceId(namespace);
NamespaceMeta.Builder builder = new NamespaceMeta.Builder();
int initialCount = namespaceAdmin.list().size();
// TEST_NAMESPACE_META1 is already created in AppFabricTestBase#beforeClass
Assert.assertTrue(namespaceAdmin.exists(new NamespaceId(TEST_NAMESPACE1)));
// It should be present in cache too
Assert.assertNotNull(getFromCache(new NamespaceId(TEST_NAMESPACE1)));
try {
namespaceAdmin.create(TEST_NAMESPACE_META1);
Assert.fail("Should not create duplicate namespace.");
} catch (NamespaceAlreadyExistsException e) {
Assert.assertEquals(TEST_NAMESPACE_META1.getNamespaceId(), e.getId());
}
// "random" namespace should not exist
try {
namespaceAdmin.get(new NamespaceId("random"));
Assert.fail("Namespace 'random' should not exist.");
} catch (NamespaceNotFoundException e) {
Assert.assertEquals(new NamespaceId("random"), e.getId());
}
try {
namespaceAdmin.create(null);
Assert.fail("Namespace with null metadata should fail.");
} catch (IllegalArgumentException e) {
Assert.assertEquals("Namespace metadata should not be null.", e.getMessage());
}
Assert.assertEquals(initialCount, namespaceAdmin.list().size());
Assert.assertFalse(namespaceAdmin.exists(new NamespaceId(namespace)));
try {
namespaceAdmin.create(builder.build());
Assert.fail("Namespace with no name should fail");
} catch (IllegalArgumentException e) {
Assert.assertEquals("Namespace id cannot be null.", e.getMessage());
}
Assert.assertEquals(initialCount, namespaceAdmin.list().size());
Assert.assertFalse(namespaceAdmin.exists(namespaceId));
// namespace with default fields
namespaceAdmin.create(builder.setName(namespace).build());
Assert.assertEquals(initialCount + 1, namespaceAdmin.list().size());
Assert.assertTrue(namespaceAdmin.exists(namespaceId));
// it should be loaded in cache too since exists calls get
Assert.assertNotNull(getFromCache(namespaceId));
try {
NamespaceMeta namespaceMeta = namespaceAdmin.get(namespaceId);
Assert.assertEquals(namespaceId.getNamespace(), namespaceMeta.getName());
Assert.assertEquals("", namespaceMeta.getDescription());
namespaceAdmin.delete(namespaceId);
// it should be deleted from the cache too
Assert.assertNull(getFromCache(namespaceId));
} catch (NotFoundException e) {
Assert.fail(String.format("Namespace '%s' should be found since it was just created.", namespaceId.getNamespace()));
}
namespaceAdmin.create(builder.setDescription("describes " + namespace).build());
Assert.assertEquals(initialCount + 1, namespaceAdmin.list().size());
Assert.assertTrue(namespaceAdmin.exists(namespaceId));
try {
NamespaceMeta namespaceMeta = namespaceAdmin.get(namespaceId);
// it should be loaded in cache too
Assert.assertNotNull(getFromCache(namespaceId));
Assert.assertEquals(namespaceId.getNamespace(), namespaceMeta.getName());
Assert.assertEquals("describes " + namespaceId.getNamespace(), namespaceMeta.getDescription());
namespaceAdmin.delete(namespaceId);
// it should be deleted from the cache
Assert.assertNull(getFromCache(namespaceId));
} catch (NotFoundException e) {
Assert.fail(String.format("Namespace '%s' should be found since it was just created.", namespaceId.getNamespace()));
}
// Verify NotFoundException's contents as well, instead of just checking namespaceService.exists = false
verifyNotFound(namespaceId);
}
Aggregations