Java Code Examples for com.google.common.base.Optional#absent()

@Override
public StoredProject map(int index, ResultSet r, StatementContext ctx)
        throws SQLException
{
    String name = r.getString("name");
    Optional<Instant> deletedAt = Optional.absent();
    if (r.wasNull()) {
        name = r.getString("deleted_name");
        deletedAt = Optional.of(getTimestampInstant(r, "deleted_at"));
    }
    return ImmutableStoredProject.builder()
        .id(r.getInt("id"))
        .name(name)
        .siteId(r.getInt("site_id"))
        .createdAt(getTimestampInstant(r, "created_at"))
        .deletedAt(deletedAt)
        .build();
}
 

@Override
protected Optional<List<M>> loadFromCache() {
    if(addresses.size() == 0) {
        return Optional.of( (List<M>) ImmutableList.<M>of() );
    }

    List<M> models = new ArrayList<>(addresses.size());
    for(String address: addresses) {
        M model = (M) cache.get(address);
        if(model == null) {
            // TODO better option than this?
            return Optional.absent();
        }
        models.add(model);
    }
    return Optional.of(models);
}
 

@Override
public Optional<String> getSecret(int projectId, String scope, String key)
{
    EncryptedSecret secret =
            tm.begin(() -> autoCommit((handle, dao) -> dao.getProjectSecret(siteId, projectId, scope, key)));

    if (secret == null) {
        return Optional.absent();
    }

    // TODO: look up crypto engine using name
    if (!crypto.getName().equals(secret.engine)) {
        throw new AssertionError(String.format(ENGLISH,
                    "Crypto engine mismatch. Expected '%s' but got '%s'",
                    secret.engine, crypto.getName()));
    }

    String decrypted = crypto.decryptSecret(secret.value);

    return Optional.of(decrypted);
}
 

private static Optional<AuthProvider> getAuthProvider(Configuration conf)
{
    Optional<String> authProvider = getInputNativeAuthProvider(conf);
    if (!authProvider.isPresent())
        return Optional.absent();

    return Optional.of(getClientAuthProvider(authProvider.get(), conf));
}
 

@Before
public void setup() throws Exception {
    dlServer = createDistributedLogServer(7001);
    Optional<String> serverSideRoutingFinagleName = Optional.absent();
    if (!clientSideRouting) {
        serverSideRoutingFinagleName =
                Optional.of("inet!" + DLSocketAddress.toString(dlServer.getAddress()));
    }
    dlClient = createDistributedLogClient("test", serverSideRoutingFinagleName);
}
 

private static Optional<ComponentMethodDescriptor> methodDescriptor(
    ComponentMethodKind kind, DeclaredType type, ExecutableElement componentMethod) {
  // ObjectGraph API doesn't allow passing qualifier as input, so ignore those methods.
  if (hasQualifier(componentMethod)) {
    return Optional.absent();
  }
  return Optional.<ComponentMethodDescriptor>of(new AutoValue_ComponentMethodDescriptor(kind, type, componentMethod.getSimpleName().toString()));
}
 

private Optional<String> findAndCompareNode(
        XmlElement otherElement,
        List<Node> otherElementChildren,
        XmlElement childNode) {

    Optional<String> message = Optional.absent();
    for (Node potentialNode : otherElementChildren) {
        if (potentialNode.getNodeType() == Node.ELEMENT_NODE) {
            XmlElement otherChildNode = new XmlElement((Element) potentialNode, mDocument);
            if (childNode.getType() == otherChildNode.getType()) {
                // check if this element uses a key.
                if (childNode.getType().getNodeKeyResolver().getKeyAttributesNames()
                        .isEmpty()) {
                    // no key... try all the other elements, if we find one equal, we are done.
                    message = childNode.compareTo(otherChildNode);
                    if (!message.isPresent()) {
                        return Optional.absent();
                    }
                } else {
                    // key...
                    if (childNode.getKey() == null) {
                        // other key MUST also be null.
                        if (otherChildNode.getKey() == null) {
                            return childNode.compareTo(otherChildNode);
                        }
                    } else {
                        if (childNode.getKey().equals(otherChildNode.getKey())) {
                            return childNode.compareTo(otherChildNode);
                        }
                    }
                }
            }
        }
    }
    return message.isPresent()
            ? message
            : Optional.of(String.format("Child %1$s not found in document %2$s",
                    childNode.getId(),
                    otherElement.printPosition()));
}
 

public static void main(String[] args)
    throws Exception {
  Options options = buildOptions();
  try {
    CommandLine cmd = new DefaultParser().parse(options, args);
    if (!cmd.hasOption(GobblinClusterConfigurationKeys.APPLICATION_NAME_OPTION_NAME) || !cmd
        .hasOption(GobblinClusterConfigurationKeys.HELIX_INSTANCE_NAME_OPTION_NAME)) {
      printUsage(options);
      System.exit(1);
    }

    logger.info(JvmUtils.getJvmInputArguments());

    String applicationName =
        cmd.getOptionValue(GobblinClusterConfigurationKeys.APPLICATION_NAME_OPTION_NAME);
    String helixInstanceName =
        cmd.getOptionValue(GobblinClusterConfigurationKeys.HELIX_INSTANCE_NAME_OPTION_NAME);

    GobblinTaskRunner gobblinWorkUnitRunner =
        new GobblinTaskRunner(applicationName, helixInstanceName, getApplicationId(),
            getTaskRunnerId(), ConfigFactory.load(), Optional.<Path>absent());
    gobblinWorkUnitRunner.start();
  } catch (ParseException pe) {
    printUsage(options);
    System.exit(1);
  }
}
 

public SelectBetweenTimeBasedPolicy(Config conf) {

    this(conf.hasPath(TIME_BASED_SELECTION_MIN_LOOK_BACK_TIME_KEY) ? Optional.of(getLookBackPeriod(conf
        .getString(TIME_BASED_SELECTION_MIN_LOOK_BACK_TIME_KEY))) : Optional.<Period> absent(), conf
        .hasPath(TIME_BASED_SELECTION_MAX_LOOK_BACK_TIME_KEY) ? Optional.of(getLookBackPeriod(conf
        .getString(TIME_BASED_SELECTION_MAX_LOOK_BACK_TIME_KEY))) : Optional.<Period> absent());

  }
 

public Optional<PropertyResolver> create (Optional<JavaMethod> method) {
    if (method.isPresent()) {
        PropertyResolver propertyResolver = new MethodPropertyResolver(method.get(), argumentsConverter);
        return Optional.of(propertyResolver);
    }

    return Optional.absent();
}
 

/**
 * @since 0.9.0
 * @deprecated since 0.9.0 (only added as aid until the deprecated {@link #getTemplate()} is deleted)
 */
@Deprecated
protected Optional<Template> getOptionalTemplate() {
    if (_template == null) {
        _template = Optional.absent();
    }
    return _template;
}
 

@Override
public Optional<PropertyResolver> select(Request request) {
    if (request.getRightExpression() instanceof VariableExpression) {
        String identifier = ((VariableExpression) request.getRightExpression()).getIdentifier();
        JavaClass javaClass = classManager.metadata(request.getLeftValue().getClass());
        Optional<JavaMethod> method = propertyMethodFinder.find(javaClass, identifier, Collections.emptyList());
        return methodPropertyResolverFactory.create(method);
    }
    return Optional.absent();
}
 

static Optional<Credential> getCredential() {
    final boolean auth = Boolean.valueOf(Env.option("MESOS_AUTHENTICATE").or("false"));
    if (auth){
        LOGGER.info("Enabling authentication for the framework");

        final String principal = Env.get("DEFAULT_PRINCIPAL");
        final Optional<String> secret = Env.option("DEFAULT_SECRET");

        return Optional.of(ProtoUtils.getCredential(principal, secret));
    } else {
        return Optional.absent();
    }
}
 

@Override
public Optional<IncrementalResultExporter> build(final Context context) throws IncrementalExporterFactoryException, ConfigurationException {
    final KafkaBindingSetExporterParameters exportParams = new KafkaBindingSetExporterParameters(context.getObserverConfiguration().toMap());
    if (exportParams.getUseKafkaBindingSetExporter()) {
        log.info("Exporter is enabled.");
        // Setup Kafka connection
        final KafkaProducer<String, VisibilityBindingSet> producer = new KafkaProducer<>(exportParams.listAllConfig());
        // Create the exporter
        final IncrementalBindingSetExporter exporter = new KafkaBindingSetExporter(producer);
        return Optional.of(exporter);
    } else {
        return Optional.absent();
    }
}
 

/**
 * Will return all the queries needed to have a backup table partition pointing to the original partition data location
 */
public static List<String> getBackupQueries(PurgeableHivePartitionDataset dataset) {
  List<String> queries = new ArrayList<>();
  queries.add(getUseDbQuery(dataset.getDbName()));
  queries.add(getCreateTableQuery(dataset.getCompleteBackupTableName(), dataset.getDbName(), dataset.getTableName(),
      dataset.getBackupTableLocation()));
  Optional<String> fileFormat = Optional.absent();
  if (dataset.getSpecifyPartitionFormat()) {
    fileFormat = dataset.getFileFormat();
  }
  queries.add(
      getAddPartitionQuery(dataset.getBackupTableName(), PartitionUtils.getPartitionSpecString(dataset.getSpec()),
          fileFormat, Optional.fromNullable(dataset.getOriginalPartitionLocation())));
  return queries;
}
 

/** Constructor with no logging */
public Orchestrator(Config config, Optional<TopologyCatalog> topologyCatalog) {
  this(config, topologyCatalog, Optional.<DagManager>absent(), Optional.<Logger>absent());
}
 

/**
 * Read blob content and cache result in repository in case the same blob 
 * content is requested again. 
 * 
 * We made this method thread-safe as we are using ForkJoinPool to calculate 
 * diffs of multiple blob changes concurrently, and this method will be 
 * accessed concurrently in that special case.
 * 
 * @param blobIdent
 * 			ident of the blob
 * @return
 * 			blob of specified blob ident
 * @throws
 * 			ObjectNotFoundException if blob of specified ident can not be found in repository 
 * 			
 */
@Nullable
public Blob getBlob(BlobIdent blobIdent, boolean mustExist) {
	Preconditions.checkArgument(blobIdent.revision!=null && blobIdent.path!=null && blobIdent.mode!=null, 
			"Revision, path and mode of ident param should be specified");
	
	Optional<Blob> blob = getBlobCache().get(blobIdent);
	if (blob == null) {
		try (RevWalk revWalk = new RevWalk(getRepository())) {
			ObjectId revId = getObjectId(blobIdent.revision, mustExist);		
			if (revId != null) {
				RevCommit commit = GitUtils.parseCommit(revWalk, revId);
				if (commit != null) {
					RevTree revTree = commit.getTree();
					TreeWalk treeWalk = TreeWalk.forPath(getRepository(), blobIdent.path, revTree);
					if (treeWalk != null) {
						ObjectId blobId = treeWalk.getObjectId(0);
						if (blobIdent.isGitLink()) {
							String url = getSubmodules(blobIdent.revision).get(blobIdent.path);
							if (url == null) {
								if (mustExist)
									throw new ObjectNotFoundException("Unable to find submodule '" + blobIdent.path + "' in .gitmodules");
								else
									blob = Optional.absent();
							} else {
								String hash = blobId.name();
								blob = Optional.of(new Blob(blobIdent, blobId, new Submodule(url, hash).toString().getBytes()));
							}
						} else if (blobIdent.isTree()) {
							throw new NotFileException("Path '" + blobIdent.path + "' is a tree");
						} else {
							blob = Optional.of(new Blob(blobIdent, blobId, treeWalk.getObjectReader()));
						}
					} 
				} 				
			} 
			if (blob == null) {
				if (mustExist)
					throw new ObjectNotFoundException("Unable to find blob ident: " + blobIdent);
				else 
					blob = Optional.absent();
			}
			getBlobCache().put(blobIdent, blob);
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
	}
	return blob.orNull();
}
 

default Optional<DirectDownloadHandle> getDirectDownloadHandle(String key)
{
    return Optional.absent();
}
 

@Test public void testStateTransitionsSuccess() throws TimeoutException, InterruptedException {
  final Logger log = LoggerFactory.getLogger(getClass().getSimpleName() + ".testStateTransitionsSuccess");
  JobSpec js1 = JobSpec.builder("gobblin:/testStateTransitionsSuccess/job1")
      .withConfig(ConfigFactory.empty()
          .withValue(ConfigurationKeys.JOB_NAME_KEY, ConfigValueFactory.fromAnyRef("myJob")))
      .build();
  JobExecution je1 = JobExecutionUpdatable.createFromJobSpec(js1);

  final JobExecutionStateListener listener = mock(JobExecutionStateListener.class);

  final JobExecutionState jes1 =
      new JobExecutionState(js1, je1, Optional.<JobExecutionStateListener>absent());

  // Current state is null
  assertFailedStateTransition(jes1, RunningState.RUNNING);
  assertFailedStateTransition(jes1, RunningState.COMMITTED);
  assertFailedStateTransition(jes1, RunningState.SUCCESSFUL);
  assertFailedStateTransition(jes1, RunningState.FAILED);
  assertFailedStateTransition(jes1, RunningState.RUNNING);
  assertFailedStateTransition(jes1, RunningState.CANCELLED);

  assertTransition(jes1, listener, null, RunningState.PENDING, log);

  // Current state is PENDING
  assertFailedStateTransition(jes1, RunningState.PENDING);
  assertFailedStateTransition(jes1, RunningState.COMMITTED);
  assertFailedStateTransition(jes1, RunningState.SUCCESSFUL);

  assertTransition(jes1, listener, RunningState.PENDING, RunningState.RUNNING, log);

  // Current state is RUNNING
  assertFailedStateTransition(jes1, RunningState.PENDING);
  assertFailedStateTransition(jes1, RunningState.COMMITTED);
  assertFailedStateTransition(jes1, RunningState.RUNNING);

  assertTransition(jes1, listener, RunningState.RUNNING, RunningState.SUCCESSFUL, log);

  // Current state is SUCCESSFUL
  assertFailedStateTransition(jes1, RunningState.PENDING);
  assertFailedStateTransition(jes1, RunningState.RUNNING);
  assertFailedStateTransition(jes1, RunningState.SUCCESSFUL);

  assertTransition(jes1, listener, RunningState.SUCCESSFUL, RunningState.COMMITTED, log);

  // Current state is COMMITTED (final)
  assertFailedStateTransition(jes1, RunningState.RUNNING);
  assertFailedStateTransition(jes1, RunningState.COMMITTED);
  assertFailedStateTransition(jes1, RunningState.SUCCESSFUL);
  assertFailedStateTransition(jes1, RunningState.FAILED);
  assertFailedStateTransition(jes1, RunningState.RUNNING);
  assertFailedStateTransition(jes1, RunningState.CANCELLED);
}
 

public QuartzJobSpecScheduler(Logger log, Config cfg) {
  this(Optional.of(log), cfg, Optional.<SchedulerService>absent());
}