Java WriteConcern.JOURNALED属性代码示例

/**
 * Prepares {@link WriteConcern} from given {@link WriteConcernEnum}
 *
 * @param writeConcernEnum  write concern provided in config.
 * @return  write concern for mongo client option.
 */
public static WriteConcern writeConcern(WriteConcernEnum writeConcernEnum) {
    switch (writeConcernEnum) {
        case MAJORITY:
            return WriteConcern.MAJORITY;

        case JOURNALED:
            return WriteConcern.JOURNALED;

        case ACKNOWLEDGED:
            return WriteConcern.ACKNOWLEDGED;

        case UNACKNOWLEDGED:
            return WriteConcern.UNACKNOWLEDGED;

        default:
            return null;
    }
}
 

private WriteConcern determineWriteConcern(String label) {
    switch (label.toLowerCase()) {
        case "acknowledged":
            return WriteConcern.ACKNOWLEDGED;
        case "unacknowledged":
            return WriteConcern.UNACKNOWLEDGED;
        case "journaled":
            return WriteConcern.JOURNALED;
        case "majority":
            return WriteConcern.MAJORITY;
        default:
            return WriteConcern.ACKNOWLEDGED;
    }
}
 

public WriteConcern toWriteConcern(Object obj, WriteConcern defaultValue) {
	if(obj instanceof WriteConcern) return (WriteConcern) obj;
	if(decision.isSimpleValue(obj)) {
		String str = caster.toString(obj,"");
		str=str.trim().toUpperCase();
		if("ACKNOWLEDGED".equals(str))
			return WriteConcern.ACKNOWLEDGED;
		else if("ACKNOWLEDGED".equals(str))
			return WriteConcern.FSYNC_SAFE;
		else if("FSYNC_SAFE".equals(str) || "FSYNCSAFE".equals(str))
			return WriteConcern.FSYNCED;
		else if("JOURNAL_SAFE".equals(str) || "JOURNALSAFE".equals(str))
			return WriteConcern.JOURNAL_SAFE;
		else if("JOURNALED".equals(str))
			return WriteConcern.JOURNALED;
		else if("MAJORITY".equals(str))
			return WriteConcern.MAJORITY;
		else if("NORMAL".equals(str))
			return WriteConcern.NORMAL;
		else if("REPLICA_ACKNOWLEDGED".equals(str) || "REPLICAACKNOWLEDGED".equals(str))
			return WriteConcern.REPLICA_ACKNOWLEDGED;
		else if("REPLICAS_SAFE".equals(str) || "REPLICASSAFE".equals(str))
			return WriteConcern.REPLICAS_SAFE;
		else if("SAFE".equals(str))
			return WriteConcern.SAFE;
		else if("UNACKNOWLEDGED".equals(str))
			return WriteConcern.UNACKNOWLEDGED;
	}
	return defaultValue;
}
 

@Test
public void testMongoClientOptions() {
    // GIVEN
    final Map<String, Object> properties = new HashMap<>();
    when(descriptor.getProperties()).thenReturn(properties);

    properties.put("eclipselink.nosql.property.mongo.db", "foo");

    // it looks like only the two options below are supported by EclipseLink

    final ReadPreference readPreference = ReadPreference.nearest();
    final WriteConcern writeConcern = WriteConcern.JOURNALED;

    properties.put("eclipselink.nosql.property.mongo.read-preference", readPreference.getName());
    properties.put("eclipselink.nosql.property.mongo.write-concern", "JOURNALED");

    final ConfigurationFactory factory = new ConfigurationFactoryImpl();

    // WHEN
    final Configuration configuration = factory.createConfiguration(descriptor);

    // THEN
    assertThat(configuration, notNullValue());

    final MongoClientOptions clientOptions = configuration.getClientOptions();
    assertThat(clientOptions, notNullValue());
    assertThat(clientOptions.getReadPreference(), equalTo(readPreference));
    assertThat(clientOptions.getWriteConcern(), equalTo(writeConcern));
}
 

@Test
public void testSimpleAndAdvancedWriteConcern() {
  WriteConcern expected = WriteConcern.JOURNALED;
  JsonObject config = new JsonObject();
  config.put("w", "majority");
  config.put("wtimeoutMS", 1);
  config.put("fsync", false);
  config.put("j", true);
  // this overwrites the other options
  config.put("writeConcern", "journaled");

  WriteConcern wc = new WriteConcernParser(null, config).writeConcern();
  assertNotNull(wc);
  assertEquals(expected, wc);
}
 

private void loadConfiguration()
    throws UnknownHostException
{
    configuration.refresh();
    MongoDBEntityStoreConfiguration config = configuration.get();

    // Combine hostname, port and nodes configuration properties
    // If no configuration, use 127.0.0.1:27017
    serverAddresses = new ArrayList<>();
    int port = config.port().get() == null ? 27017 : config.port().get();
    List<String> nodes = config.nodes().get();
    if( nodes.isEmpty() )
    {
        String hostname = config.hostname().get() == null ? "127.0.0.1" : config.hostname().get();
        serverAddresses.add( new ServerAddress( hostname, port ) );
    }
    else
    {
        if( config.hostname().get() != null && !config.hostname().get().isEmpty() )
        {
            serverAddresses.add( new ServerAddress( config.hostname().get(), port ) );
        }
        serverAddresses.addAll( nodes.stream()
                                     .map( this::parseNode )
                                     .collect( toList() )
                              );
    }

    // If database name not configured, set it to polygene:entitystore
    databaseName = config.database().get();
    if( databaseName == null )
    {
        databaseName = DEFAULT_DATABASE_NAME;
    }

    // If collection name not configured, set it to polygene:entitystore:entities
    collectionName = config.collection().get();
    if( collectionName == null )
    {
        collectionName = DEFAULT_COLLECTION_NAME;
    }

    // If write concern not configured, set it to normal
    switch( config.writeConcern().get() )
    {
    case W1:
        writeConcern = WriteConcern.W1;
        break;
    case W2:
        writeConcern = WriteConcern.W2;
        break;
    case W3:
        writeConcern = WriteConcern.W3;
        break;
    case UNACKNOWLEDGED:
        writeConcern = WriteConcern.UNACKNOWLEDGED;
        break;
    case JOURNALED:
        writeConcern = WriteConcern.JOURNALED;
        break;
    case MAJORITY:
        writeConcern = WriteConcern.MAJORITY;
        break;
    case ACKNOWLEDGED:
    default:
        writeConcern = WriteConcern.ACKNOWLEDGED;
    }

    // Username and password are defaulted to empty strings
    username = config.username().get();
    password = config.password().get().toCharArray();
}