/**
* Writes driver configuration to disk.
*
* @param jobFolder The folder in which the job is staged.
* @param jobId id of the job to be submitted
* @param clientRemoteId The client remote id
* @return the configuration
* @throws IOException
*/
public Configuration writeConfiguration(
final File jobFolder, final String jobId, final String clientRemoteId) throws IOException {
final File driverFolder = new File(jobFolder, PreparedDriverFolderLauncher.DRIVER_FOLDER_NAME);
final Configuration driverConfiguration1 =
driverConfigurationProvider.getDriverConfiguration(
jobFolder.toURI(),
clientRemoteId,
jobId,
Constants.DRIVER_CONFIGURATION_WITH_HTTP_AND_NAMESERVER);
final ConfigurationBuilder configurationBuilder =
Tang.Factory.getTang().newConfigurationBuilder();
for (final ConfigurationProvider configurationProvider : this.configurationProviders) {
configurationBuilder.addConfiguration(configurationProvider.getConfiguration());
}
final Configuration providedConfigurations = configurationBuilder.build();
final Configuration driverConfiguration =
Configurations.merge(
driverConfiguration1,
Tang.Factory.getTang()
.newConfigurationBuilder()
.bindNamedParameter(JobSubmissionDirectory.class, driverFolder.toString())
.build(),
providedConfigurations);
final File driverConfigurationFile =
new File(driverFolder, fileNames.getDriverConfigurationPath());
configurationSerializer.toFile(driverConfiguration, driverConfigurationFile);
return driverConfiguration;
}
public void validatePlan() throws IOException, BindException, InjectionException {
final Tang t = Tang.Factory.getTang();
// TODO Use the AvroClassHierarchySerializer
final ClassHierarchyProto.Node root;
try (final InputStream chin = new FileInputStream(this.ch)) {
root = ClassHierarchyProto.Node.parseFrom(chin);
}
final ClassHierarchy classHierarchy = new ProtocolBufferClassHierarchy(root);
final ConfigurationBuilder cb = t.newConfigurationBuilder(classHierarchy);
if (!inConfig.canRead()) {
throw new IOException("Cannot read input config file: " + inConfig);
}
ConfigurationFile.addConfiguration(cb, inConfig);
if (target != null) {
final Injector i = t.newInjector(cb.build());
final InjectionPlan<?> ip = i.getInjectionPlan(target);
if (!ip.isInjectable()) {
throw new InjectionException(target + " is not injectable: " + ip.toCantInjectString());
}
}
ConfigurationFile.writeConfigurationFile(cb.build(), outConfig);
// Injector i = t.newInjector(cb.build());
// InjectionPlan<?> ip = i.getInjectionPlan(target);
// try (final OutputStream ipout = new FileOutputStream(injectionPlan)) {
// new ProtocolBufferInjectionPlan().serialize(ip).writeTo(ipout);
// }
}
@Override
public T withProperties(Properties properties) {
super.withProperties(properties);
if (properties.containsKey("betamax.proxyHost")) {
proxyHost(properties.getProperty("betamax.proxyHost"));
}
if (properties.containsKey("betamax.proxyPort")) {
proxyPort(TypedProperties.getInteger(properties, "betamax.proxyPort"));
}
if (properties.containsKey("betamax.proxyTimeoutSeconds")) {
proxyTimeoutSeconds(TypedProperties.getInteger(properties, "betamax.proxyTimeoutSeconds"));
}
if (properties.containsKey("betamax.requestBufferSize")) {
requestBufferSize(TypedProperties.getInteger(properties, "betamax.requestBufferSize"));
}
if (properties.containsKey("betamax.sslEnabled")) {
sslEnabled(TypedProperties.getBoolean(properties, "betamax.sslEnabled"));
}
return self();
}
@Override
public ConfigurationRuleBuilder otherwise(Operation operation) {
for (ConfigurationRuleBuilderInterceptor interceptor : interceptors) {
operation = interceptor.otherwise(operation);
}
wrapped.addOtherwiseRule(rule).when(Not.any(rule)).perform(operation);
return this;
}
private boolean maybeSet(
final ConfigurationBuilder builder, final String property, final String env) {
String value = System.getenv(env);
if (value != null) {
log.debug("Environment variable: {}={}", env, value);
builder.set(property, value);
return true;
}
return false;
}
@Override
public ConfigurationRuleBuilderOtherwise otherwise(Operation operation, Operation... operations) {
List<Operation> list = new LinkedList<Operation>();
list.add(operation);
list.addAll(Arrays.asList(operations));
for (ConfigurationRuleBuilderInterceptor interceptor : interceptors) {
list = interceptor.otherwise(list);
}
wrapped
.addOtherwiseRule(rule)
.when(Not.any(rule))
.perform(Perform.all(list.toArray(new Operation[list.size()])));
return this;
}
public static void main(String[] args) {
printWelcomeMessage();
CliWrapper cliWrapper = new CliWrapper();
CommandLine commandLine = null;
try {
commandLine = cliWrapper.parse(args);
} catch (ParseException e) {
printUsage(cliWrapper);
System.out.println(e.getMessage());
System.exit(1);
}
Configuration configuration =
ConfigurationBuilder.initFromFile(
commandLine.getOptionValue(CliOption.CONF.getCommandLineParam()));
configuration.updateWithCliOptions(commandLine);
ConnectorFacade facade = getConnectorFacade(configuration);
new Engine(facade, facade, configuration).run();
}
@Override
public ConfigurationBuilder balancingStrategy(String balancingStrategy) {
return builder.balancingStrategy(balancingStrategy);
}
@Override
public ExecutorFactoryConfigurationBuilder asyncExecutorFactory() {
return builder.asyncExecutorFactory();
}
@Override
public ConfigurationBuilder pingOnStartup(boolean pingOnStartup) {
return builder.pingOnStartup(pingOnStartup);
}
@Override
public ConfigurationBuilder forceReturnValues(boolean forceReturnValues) {
return builder.forceReturnValues(forceReturnValues);
}
@Override
public ConfigurationBuilder consistentHashImpl(
int version, Class<? extends ConsistentHash> consistentHashClass) {
return builder.consistentHashImpl(version, consistentHashClass);
}
@Override
public ConnectionPoolConfigurationBuilder connectionPool() {
return builder.connectionPool();
}
@Override
public ConfigurationBuilder transportFactory(Class<? extends TransportFactory> transportFactory) {
return builder.transportFactory(transportFactory);
}
@Override
public ConfigurationBuilder transportFactory(String transportFactory) {
return builder.transportFactory(transportFactory);
}
@Override
public ConfigurationBuilder tcpNoDelay(boolean tcpNoDelay) {
return builder.tcpNoDelay(tcpNoDelay);
}
@Override
public SslConfigurationBuilder ssl() {
return builder.ssl();
}
@Override
public ConfigurationBuilder socketTimeout(int socketTimeout) {
return builder.socketTimeout(socketTimeout);
}
@Override
public ConfigurationBuilder protocolVersion(String protocolVersion) {
return builder.protocolVersion(protocolVersion);
}
@Override
public ConfigurationBuilder balancingStrategy(
Class<? extends RequestBalancingStrategy> balancingStrategy) {
return builder.balancingStrategy(balancingStrategy);
}
@Override
public ConfigurationBuilder classLoader(ClassLoader classLoader) {
return builder.classLoader(classLoader);
}
@Override
public ConfigurationBuilder valueSizeEstimate(int valueSizeEstimate) {
return builder.valueSizeEstimate(valueSizeEstimate);
}
@Override
public ConfigurationBuilder connectionTimeout(int connectionTimeout) {
return builder.connectionTimeout(connectionTimeout);
}
@Override
public ConfigurationBuilder withProperties(Properties properties) {
return builder.withProperties(properties);
}
@Override
public ConfigurationBuilder consistentHashImpl(int version, String consistentHashClass) {
return builder.consistentHashImpl(version, consistentHashClass);
}
@Override
public ServerConfigurationBuilder addServer() {
return builder.addServer();
}
@Override
public ConfigurationBuilder keySizeEstimate(int keySizeEstimate) {
return builder.keySizeEstimate(keySizeEstimate);
}
@Override
public ConfigurationBuilder addServers(String servers) {
return builder.addServers(servers);
}
@Override
public Configuration build() {
return builder.build();
}
@Override
public ConfigurationBuilder marshaller(Marshaller marshaller) {
return builder.marshaller(marshaller);
}
