/** * Sets the connector information needed to communicate with Accumulo in this job. * * <p><b>WARNING:</b> Some tokens, when serialized, divulge sensitive information in the * configuration as a means to pass the token to MapReduce tasks. This information is BASE64 * encoded to provide a charset safe conversion to a string, but this conversion is not intended * to be secure. {@link PasswordToken} is one example that is insecure in this way; however {@link * DelegationToken}s, acquired using {@link * SecurityOperations#getDelegationToken(DelegationTokenConfig)}, is not subject to this concern. * * @param job the Hadoop job instance to be configured * @param principal a valid Accumulo user name (user must have Table.CREATE permission if {@link * #setCreateTables(Job, boolean)} is set to true) * @param token the user's password * @since 1.5.0 */ public static void setConnectorInfo(Job job, String principal, AuthenticationToken token) throws AccumuloSecurityException { if (token instanceof KerberosToken) { log.info("Received KerberosToken, attempting to fetch DelegationToken"); try { Instance instance = getInstance(job); Connector conn = instance.getConnector(principal, token); token = conn.securityOperations().getDelegationToken(new DelegationTokenConfig()); } catch (Exception e) { log.warn( "Failed to automatically obtain DelegationToken, Mappers/Reducers will likely fail to communicate with Accumulo", e); } } // DelegationTokens can be passed securely from user to task without serializing insecurely in // the configuration if (token instanceof DelegationTokenImpl) { DelegationTokenImpl delegationToken = (DelegationTokenImpl) token; // Convert it into a Hadoop Token AuthenticationTokenIdentifier identifier = delegationToken.getIdentifier(); Token<AuthenticationTokenIdentifier> hadoopToken = new Token<>( identifier.getBytes(), delegationToken.getPassword(), identifier.getKind(), delegationToken.getServiceName()); // Add the Hadoop Token to the Job so it gets serialized and passed along. job.getCredentials().addToken(hadoopToken.getService(), hadoopToken); } OutputConfigurator.setConnectorInfo(CLASS, job.getConfiguration(), principal, token); }
/** * Sets the directive to create new tables, as necessary. Table names can only be alpha-numeric * and underscores. * * <p>By default, this feature is <b>disabled</b>. * * @param job the Hadoop job instance to be configured * @param enableFeature the feature is enabled if true, disabled otherwise * @since 1.5.0 */ public static void setCreateTables(Job job, boolean enableFeature) { OutputConfigurator.setCreateTables(CLASS, job.getConfiguration(), enableFeature); }
/** * Gets the {@link BatchWriterConfig} settings. * * @param context the Hadoop context for the configured job * @return the configuration object * @since 1.5.0 * @see #setBatchWriterOptions(Job, BatchWriterConfig) */ protected static BatchWriterConfig getBatchWriterOptions(JobContext context) { return OutputConfigurator.getBatchWriterOptions(CLASS, context.getConfiguration()); }
/** * Sets the configuration for for the job's {@link BatchWriter} instances. If not set, a new * {@link BatchWriterConfig}, with sensible built-in defaults is used. Setting the configuration * multiple times overwrites any previous configuration. * * @param job the Hadoop job instance to be configured * @param bwConfig the configuration for the {@link BatchWriter} * @since 1.5.0 */ public static void setBatchWriterOptions(Job job, BatchWriterConfig bwConfig) { OutputConfigurator.setBatchWriterOptions(CLASS, job.getConfiguration(), bwConfig); }
/** * Gets the default table name from the configuration. * * @param context the Hadoop context for the configured job * @return the default table name * @since 1.5.0 * @see #setDefaultTableName(Job, String) */ protected static String getDefaultTableName(JobContext context) { return OutputConfigurator.getDefaultTableName(CLASS, context.getConfiguration()); }
/** * Sets the default table name to use if one emits a null in place of a table name for a given * mutation. Table names can only be alpha-numeric and underscores. * * @param job the Hadoop job instance to be configured * @param tableName the table to use when the tablename is null in the write call * @since 1.5.0 */ public static void setDefaultTableName(Job job, String tableName) { OutputConfigurator.setDefaultTableName(CLASS, job.getConfiguration(), tableName); }
/** * Sets the connector information needed to communicate with Accumulo in this job. * * <p>Stores the password in a file in HDFS and pulls that into the Distributed Cache in an * attempt to be more secure than storing it in the Configuration. * * @param job the Hadoop job instance to be configured * @param principal a valid Accumulo user name (user must have Table.CREATE permission if {@link * #setCreateTables(Job, boolean)} is set to true) * @param tokenFile the path to the token file * @since 1.6.0 */ public static void setConnectorInfo(Job job, String principal, String tokenFile) throws AccumuloSecurityException { OutputConfigurator.setConnectorInfo(CLASS, job.getConfiguration(), principal, tokenFile); }
/** * Determines whether this feature is enabled. * * @param context the Hadoop context for the configured job * @return true if the feature is enabled, false otherwise * @since 1.5.0 * @see #setSimulationMode(Job, boolean) */ protected static Boolean getSimulationMode(JobContext context) { return OutputConfigurator.getSimulationMode(CLASS, context.getConfiguration()); }
/** * Initializes an Accumulo {@link Instance} based on the configuration. * * @param context the Hadoop context for the configured job * @return an Accumulo instance * @since 1.5.0 * @see #setZooKeeperInstance(Job, ClientConfiguration) */ protected static Instance getInstance(JobContext context) { return OutputConfigurator.getInstance(CLASS, context.getConfiguration()); }
/** * Configures a {@link org.apache.accumulo.core.client.mock.MockInstance} for this job. * * @param job the Hadoop job instance to be configured * @param instanceName the Accumulo instance name * @since 1.5.0 */ @Deprecated public static void setMockInstance(Job job, String instanceName) { OutputConfigurator.setMockInstance(CLASS, job.getConfiguration(), instanceName); }
/** * Configures a {@link ZooKeeperInstance} for this job. * * @param job the Hadoop job instance to be configured * @param clientConfig client configuration for specifying connection timeouts, SSL connection * options, etc. * @since 1.6.0 */ public static void setZooKeeperInstance(Job job, ClientConfiguration clientConfig) { OutputConfigurator.setZooKeeperInstance(CLASS, job.getConfiguration(), clientConfig); }
/** * Gets the authenticated token from either the specified token file or directly from the * configuration, whichever was used when the job was configured. * * @param context the Hadoop context for the configured job * @return the principal's authentication token * @since 1.6.0 * @see #setConnectorInfo(Job, String, AuthenticationToken) * @see #setConnectorInfo(Job, String, String) */ protected static AuthenticationToken getAuthenticationToken(JobContext context) { AuthenticationToken token = OutputConfigurator.getAuthenticationToken(CLASS, context.getConfiguration()); return ConfiguratorBase.unwrapAuthenticationToken(context, token); }
/** * Gets the user name from the configuration. * * @param context the Hadoop context for the configured job * @return the user name * @since 1.5.0 * @see #setConnectorInfo(Job, String, AuthenticationToken) */ protected static String getPrincipal(JobContext context) { return OutputConfigurator.getPrincipal(CLASS, context.getConfiguration()); }
/** * Determines if the connector has been configured. * * @param context the Hadoop context for the configured job * @return true if the connector has been configured, false otherwise * @since 1.5.0 * @see #setConnectorInfo(Job, String, AuthenticationToken) */ protected static Boolean isConnectorInfoSet(JobContext context) { return OutputConfigurator.isConnectorInfoSet(CLASS, context.getConfiguration()); }
/** * Determines whether tables are permitted to be created as needed. * * @param context the Hadoop context for the configured job * @return true if the feature is disabled, false otherwise * @since 1.5.0 * @see #setCreateTables(Job, boolean) */ protected static Boolean canCreateTables(JobContext context) { return OutputConfigurator.canCreateTables(CLASS, context.getConfiguration()); }
/** * Sets the directive to use simulation mode for this job. In simulation mode, no output is * produced. This is useful for testing. * * <p>By default, this feature is <b>disabled</b>. * * @param job the Hadoop job instance to be configured * @param enableFeature the feature is enabled if true, disabled otherwise * @since 1.5.0 */ public static void setSimulationMode(Job job, boolean enableFeature) { OutputConfigurator.setSimulationMode(CLASS, job.getConfiguration(), enableFeature); }
/** * Sets the log level for this job. * * @param job the Hadoop job instance to be configured * @param level the logging level * @since 1.5.0 */ public static void setLogLevel(Job job, Level level) { OutputConfigurator.setLogLevel(CLASS, job.getConfiguration(), level); }
/** * Set all the initial parameters needed in this class for connectivity out to Accumulo. * * @param context */ private void initialize(JobContext context) { // Configuration conf){ Configuration conf = context.getConfiguration(); try { // output zoom level log.info("Working from zoom level = " + zoomLevel); if (zoomLevel == -1) { zoomLevel = Integer.parseInt(conf.get(MrGeoAccumuloConstants.MRGEO_ACC_KEY_ZOOMLEVEL)); } table = conf.get(MrGeoAccumuloConstants.MRGEO_ACC_KEY_OUTPUT_TABLE); username = conf.get(MrGeoAccumuloConstants.MRGEO_ACC_KEY_USER); instanceName = conf.get(MrGeoAccumuloConstants.MRGEO_ACC_KEY_INSTANCE); zooKeepers = conf.get(MrGeoAccumuloConstants.MRGEO_ACC_KEY_ZOOKEEPERS); String pl = conf.get(MrGeoConstants.MRGEO_PROTECTION_LEVEL); if (pl != null) { colViz = new ColumnVisibility(pl); } else if (colViz == null) { vizStr = conf.get(MrGeoAccumuloConstants.MRGEO_ACC_KEY_VIZ); if (vizStr == null) { colViz = new ColumnVisibility(); } else { colViz = new ColumnVisibility(vizStr); } } password = conf.get(MrGeoAccumuloConstants.MRGEO_ACC_KEY_PASSWORD); String isEnc = conf.get(MrGeoAccumuloConstants.MRGEO_ACC_KEY_PWENCODED64, "false"); if (isEnc.equalsIgnoreCase("true")) { password = Base64Utils.decodeToString(password); } if (_innerFormat != null) { return; } _innerFormat = AccumuloOutputFormat.class.newInstance(); AuthenticationToken token = new PasswordToken(password.getBytes()); // log.info("Setting output with: u = " + username); // log.info("Setting output with: p = " + password); // log.info("Setting output with: i = " + instanceName); // log.info("Setting output with: z = " + zooKeepers); boolean connSet = ConfiguratorBase.isConnectorInfoSet(AccumuloOutputFormat.class, conf); if (!connSet) { // job not always available - do it how Accumulo does it OutputConfigurator.setConnectorInfo(AccumuloOutputFormat.class, conf, username, token); ClientConfiguration cc = ClientConfiguration.loadDefault().withInstance(instanceName); cc.setProperty(ClientProperty.INSTANCE_ZK_HOST, zooKeepers); OutputConfigurator.setZooKeeperInstance(AccumuloOutputFormat.class, conf, cc); OutputConfigurator.setDefaultTableName(AccumuloOutputFormat.class, conf, table); OutputConfigurator.setCreateTables(AccumuloOutputFormat.class, conf, true); outputInfoSet = true; } } catch (InstantiationException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalAccessException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (AccumuloSecurityException ase) { ase.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } // end initialize
/** * Gets the log level from this configuration. * * @param context the Hadoop context for the configured job * @return the log level * @since 1.5.0 * @see #setLogLevel(Job, Level) */ protected static Level getLogLevel(JobContext context) { return OutputConfigurator.getLogLevel(CLASS, context.getConfiguration()); }