import com.microsoft.azure.documentdb.ConnectionPolicy; //导入依赖的package包/类
@Before
public void setUp() throws DocumentClientException {

    asyncClient = new AsyncDocumentClient.Builder()
            .withServiceEndpoint(TestConfigurations.HOST)
            .withMasterKey(TestConfigurations.MASTER_KEY)
            .withConnectionPolicy(ConnectionPolicy.GetDefault())
            .withConsistencyLevel(ConsistencyLevel.Session)
            .build();

    // Clean up before setting up
    this.cleanUpGeneratedDatabases();

    databaseDefinition = new Database();
    databaseDefinition.setId(DATABASE_ID);
    
    collectionDefinition = new DocumentCollection();
    collectionDefinition.setId(UUID.randomUUID().toString());
}
 

import com.microsoft.azure.documentdb.ConnectionPolicy; //导入依赖的package包/类
@BeforeClass(groups = { "simple" }, timeOut = SETUP_TIMEOUT)
public void beforeClass() {
    // set up the client
    
    client = new AsyncDocumentClient.Builder()
        .withServiceEndpoint(TestConfigurations.HOST)
        .withMasterKey(TestConfigurations.MASTER_KEY)
        .withConnectionPolicy(ConnectionPolicy.GetDefault())
        .withConsistencyLevel(ConsistencyLevel.Session).build();

    Database databaseDefinition = new Database();
    databaseDefinition.setId(DATABASE_ID);
    
    try {
        client.deleteDatabase(Utils.getDatabaseLink(databaseDefinition, true), null).toBlocking().single();
    } catch (Exception e) {
       // ignore failure if it doesn't exist
    }
    
    database = client.createDatabase(databaseDefinition, null).toBlocking().single().getResource();
}
 

import com.microsoft.azure.documentdb.ConnectionPolicy; //导入依赖的package包/类
@BeforeClass(groups = { "simple" }, timeOut = SETUP_TIMEOUT)
public void beforeClass() {
    // set up the client        
    client = new AsyncDocumentClient.Builder()
            .withServiceEndpoint(TestConfigurations.HOST)
            .withMasterKey(TestConfigurations.MASTER_KEY)
            .withConnectionPolicy(ConnectionPolicy.GetDefault())
            .withConsistencyLevel(ConsistencyLevel.Session)
            .build();
    registerSpyProxy();

    Database databaseDefinition = new Database();
    databaseDefinition.setId(DATABASE_ID);

    try {
        client.deleteDatabase(Utils.getDatabaseLink(databaseDefinition, true), null).toBlocking().single();
    } catch (Exception e) {
        // ignore failure if it doesn't exist
    }

    database = client.createDatabase(databaseDefinition, null).toBlocking().single().getResource();
    collection = client.createCollection(database.getSelfLink(), getCollectionDefinition(), null).toBlocking().single().getResource();
}
 

import com.microsoft.azure.documentdb.ConnectionPolicy; //导入依赖的package包/类
@Test(groups = { "simple" }, timeOut = TIMEOUT)
public void createDocument() throws Exception {
    
    AsyncDocumentClient newClient = new AsyncDocumentClient.Builder()
            .withServiceEndpoint(TestConfigurations.HOST)
            .withMasterKey(TestConfigurations.MASTER_KEY)
            .withConnectionPolicy(ConnectionPolicy.GetDefault())
            .withConsistencyLevel(ConsistencyLevel.Session)
            .withWorkers(2, 1)
            .build();

    try {
        Document docDefinition = getDocumentDefinition();

        Observable<ResourceResponse<Document>> createObservable = newClient
                .createDocument(collection.getSelfLink(), docDefinition, null, false);

        ResourceResponseValidator<Document> validator = new ResourceResponseValidator.Builder<Document>()
                .withId(docDefinition.getId())
                .build();

        validateSuccess(createObservable, validator);
    } finally {
        newClient.close();
    }
}
 

import com.microsoft.azure.documentdb.ConnectionPolicy; //导入依赖的package包/类
@BeforeClass(groups = { "simple" }, timeOut = SETUP_TIMEOUT)
public void beforeClass() {
    // set up the client        
    client = new AsyncDocumentClient.Builder()
            .withServiceEndpoint(TestConfigurations.HOST)
            .withMasterKey(TestConfigurations.MASTER_KEY)
            .withConnectionPolicy(ConnectionPolicy.GetDefault())
            .withConsistencyLevel(ConsistencyLevel.Session)
            .build();
    
    Database databaseDefinition = new Database();
    databaseDefinition.setId(DATABASE_ID);
    
    try {
        client.deleteDatabase(Utils.getDatabaseLink(databaseDefinition, true), null).toBlocking().single();
    } catch (Exception e) {
       // ignore failure if it doesn't exist
    }
    
    database = client.createDatabase(databaseDefinition, null).toBlocking().single().getResource();
    collection = client.createCollection(database.getSelfLink(), getCollectionDefinition(), null).toBlocking().single().getResource();
}
 

import com.microsoft.azure.documentdb.ConnectionPolicy; //导入依赖的package包/类
@Before
public void setup() {
    mappingContext = new DocumentDbMappingContext();
    try {
        mappingContext.setInitialEntitySet(new EntityScanner(this.applicationContext)
                .scan(Persistent.class));
    } catch (ClassNotFoundException e) {
        throw new RuntimeException(e.getMessage());

    }
    dbConverter = new MappingDocumentDbConverter(mappingContext);
    documentClient = new DocumentClient(documentDbUri, documentDbKey,
            ConnectionPolicy.GetDefault(), ConsistencyLevel.Session);

    dbTemplate = new DocumentDbTemplate(documentClient, dbConverter, TEST_DB_NAME);

    dbTemplate.createCollectionIfNotExists(Person.class.getSimpleName(), null, null);
    dbTemplate.insert(Person.class.getSimpleName(), TEST_PERSON, null);
}
 

import com.microsoft.azure.documentdb.ConnectionPolicy; //导入依赖的package包/类
private DocumentClient createDocumentClient() {
    LOG.debug("createDocumentClient");
    final ConnectionPolicy policy = connectionPolicy == null ? ConnectionPolicy.GetDefault() : connectionPolicy;

    String userAgent = (policy.getUserAgentSuffix() == null ? "" : ";" + policy.getUserAgentSuffix()) +
            ";" + USER_AGENT_SUFFIX;

    if (properties.isAllowTelemetry() && GetHashMac.getHashMac() != null) {
        userAgent += ";" + GetHashMac.getHashMac();
    }
    policy.setUserAgentSuffix(userAgent);

    return new DocumentClient(properties.getUri(), properties.getKey(), policy,
            properties.getConsistencyLevel() == null ?
                    ConsistencyLevel.Session : properties.getConsistencyLevel());
}
 

import com.microsoft.azure.documentdb.ConnectionPolicy; //导入依赖的package包/类
@Test
public void canSetAllowTelemetryFalse() {
    PropertySettingUtil.setAllowTelemetryFalse();

    try (AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext()) {
        context.register(DocumentDBAutoConfiguration.class, ConnectionPolicyConfig.class);
        context.refresh();
        final DocumentClient documentClient = context.getBean(DocumentClient.class);

        final ConnectionPolicy connectionPolicy = documentClient.getConnectionPolicy();
        assertThat(connectionPolicy.getUserAgentSuffix()).contains(PropertySettingUtil.USER_AGENT_SUFFIX);
        assertThat(connectionPolicy.getUserAgentSuffix()).contains(
                PropertySettingUtil.DEFAULT_USER_AGENT_SUFFIX);
    }
    PropertySettingUtil.unsetAllowTelemetry();
}
 

import com.microsoft.azure.documentdb.ConnectionPolicy; //导入依赖的package包/类
public DocumentDBRecordWriter(Configuration conf, String host, String key, String dbName, String[] collNames,
        int outputStringPrecision, boolean upsert, String offerType) throws IOException {
    try {
        ConnectionPolicy policy = ConnectionPolicy.GetDefault();
        policy.setUserAgentSuffix(DocumentDBConnectorUtil.UserAgentSuffix);
        DocumentClient client = new DocumentClient(host, key, policy,
                ConsistencyLevel.Session);

        Database db = DocumentDBConnectorUtil.GetDatabase(client, dbName);
        this.collections = new DocumentCollection[collNames.length];
        this.sprocs = new StoredProcedure[collNames.length];
        for (int i = 0; i < collNames.length; i++) {
            this.collections[i] =  DocumentDBConnectorUtil.getOrCreateOutputCollection(client, db.getSelfLink(), collNames[i],
                    outputStringPrecision, offerType);
            this.sprocs[i] = DocumentDBConnectorUtil.CreateBulkImportStoredProcedure(client, this.collections[i].getSelfLink());
        }
        
        this.client = client;
        this.enableUpsert = upsert;
        this.cachedDocs = new LinkedList<Document>();
    } catch (Exception e) {
        e.printStackTrace();
        throw new IOException(e);
    }
}
 

import com.microsoft.azure.documentdb.ConnectionPolicy; //导入依赖的package包/类
@Before
public void setUp() throws DocumentClientException {

    // sets up the requirements for each test
    
    asyncClient = new AsyncDocumentClient.Builder()
            .withServiceEndpoint(TestConfigurations.HOST)
            .withMasterKey(TestConfigurations.MASTER_KEY)
            .withConnectionPolicy(ConnectionPolicy.GetDefault())
            .withConsistencyLevel(ConsistencyLevel.Session)
            .build();
    // Clean up the database.
    this.cleanUpGeneratedDatabases();

    Database databaseDefinition = new Database();
    databaseDefinition.setId(DATABASE_ID);

    DocumentCollection collectionDefinition = new DocumentCollection();
    collectionDefinition.setId(UUID.randomUUID().toString());

    // create database
    ResourceResponse<Database> databaseCreationResponse = asyncClient.createDatabase(databaseDefinition, null)
            .toBlocking().single();
    
    // create collection
    createdCollection = asyncClient
            .createCollection(databaseCreationResponse.getResource().getSelfLink(), collectionDefinition, null)
            .toBlocking().single().getResource();
}
 

import com.microsoft.azure.documentdb.ConnectionPolicy; //导入依赖的package包/类
@Before
public void setUp() throws DocumentClientException {

    asyncClient = new AsyncDocumentClient.Builder()
            .withServiceEndpoint(TestConfigurations.HOST)
            .withMasterKey(TestConfigurations.MASTER_KEY)
            .withConnectionPolicy(ConnectionPolicy.GetDefault())
            .withConsistencyLevel(ConsistencyLevel.Session)
            .build();
    
    // Clean up the database.
    this.cleanUpGeneratedDatabases();

    Database databaseDefinition = new Database();
    databaseDefinition.setId(DATABASE_ID);

    DocumentCollection collectionDefinition = new DocumentCollection();
    collectionDefinition.setId(UUID.randomUUID().toString());

    // create database
    ResourceResponse<Database> databaseCreationResponse = asyncClient.createDatabase(databaseDefinition, null)
            .toBlocking().single();

    createdDatabase = databaseCreationResponse.getResource();
    
    // create collection
    createdCollection = asyncClient
            .createCollection(databaseCreationResponse.getResource().getSelfLink(), collectionDefinition, null)
            .toBlocking().single().getResource();

    numberOfDocuments = 20;
    // add documents
    for (int i = 0; i < numberOfDocuments; i++) {
        Document doc = new Document(String.format("{ 'id': 'loc%d', 'counter': %d}", i, i));
        asyncClient.createDocument(createdCollection.getSelfLink(), doc, null, true).toBlocking().single();
    }
}
 

import com.microsoft.azure.documentdb.ConnectionPolicy; //导入依赖的package包/类
public RxGatewayStoreModel(ConnectionPolicy connectionPolicy,
        ConsistencyLevel consistencyLevel,
        QueryCompatibilityMode queryCompatibilityMode,
        String masterKey,
        Map<String, String> resourceTokens,
        UserAgentContainer userAgentContainer,
        EndpointManager globalEndpointManager,
        HttpClient<ByteBuf, ByteBuf> httpClient) {
    this.defaultHeaders = new HashMap<String, String>();
    this.defaultHeaders.put(HttpConstants.HttpHeaders.CACHE_CONTROL,
            "no-cache");
    this.defaultHeaders.put(HttpConstants.HttpHeaders.VERSION,
            HttpConstants.Versions.CURRENT_VERSION);

    if (userAgentContainer == null) {
        userAgentContainer = new UserAgentContainer();
    }

    this.defaultHeaders.put(HttpConstants.HttpHeaders.USER_AGENT, userAgentContainer.getUserAgent());

    if (consistencyLevel != null) {
        this.defaultHeaders.put(HttpConstants.HttpHeaders.CONSISTENCY_LEVEL,
                consistencyLevel.toString());
    }

    this.globalEndpointManager = globalEndpointManager;
    this.queryCompatibilityMode = queryCompatibilityMode;

    this.httpClient = httpClient;
}
 

import com.microsoft.azure.documentdb.ConnectionPolicy; //导入依赖的package包/类
static protected AsyncDocumentClient.Builder createGatewayRxDocumentClient() {
    ConnectionPolicy connectionPolicy = new ConnectionPolicy();
    connectionPolicy.setConnectionMode(ConnectionMode.Gateway);
    return new AsyncDocumentClient.Builder()
            .withServiceEndpoint(TestConfigurations.HOST)
            .withMasterKey(TestConfigurations.MASTER_KEY)
            .withConnectionPolicy(connectionPolicy)
            .withConsistencyLevel(ConsistencyLevel.Session);
}
 

import com.microsoft.azure.documentdb.ConnectionPolicy; //导入依赖的package包/类
static protected AsyncDocumentClient.Builder createDirectHttpsRxDocumentClient() {
    ConnectionPolicy connectionPolicy = new ConnectionPolicy();
    connectionPolicy.setConnectionMode(ConnectionMode.DirectHttps);
    return new AsyncDocumentClient.Builder()
            .withServiceEndpoint(TestConfigurations.HOST)
            .withMasterKey(TestConfigurations.MASTER_KEY)
            .withConnectionPolicy(connectionPolicy)
            .withConsistencyLevel(ConsistencyLevel.Session);
}
 

import com.microsoft.azure.documentdb.ConnectionPolicy; //导入依赖的package包/类
static protected AsyncDocumentClient.Builder createRxWrapperDocumentClient() {

        return new AsyncDocumentClient.Builder() {
            /* (non-Javadoc)
             * @see com.microsoft.azure.documentdb.rx.AsyncDocumentClient.Builder#build()
             */
            @Override
            public AsyncDocumentClient build() {
                return new RxWrapperDocumentClientImpl(new DocumentClient(TestConfigurations.HOST,
                        TestConfigurations.MASTER_KEY, ConnectionPolicy.GetDefault(), ConsistencyLevel.Session));
            }
        };
    }
 

import com.microsoft.azure.documentdb.ConnectionPolicy; //导入依赖的package包/类
@Test(groups = { "simple" }, timeOut = TIMEOUT, expectedExceptions = { IllegalArgumentException.class })
public void invalidBuilder() throws Exception {
    
    ConnectionPolicy cp = new ConnectionPolicy();
    cp.setConnectionMode(ConnectionMode.DirectHttps);
    new AsyncDocumentClient.Builder()
            .withServiceEndpoint(TestConfigurations.HOST)
            .withMasterKey(TestConfigurations.MASTER_KEY)
            .withConnectionPolicy(ConnectionPolicy.GetDefault())
            .withConsistencyLevel(ConsistencyLevel.Session)
            .withWorkers(2, 1)
            .withConnectionPolicy(cp).build();
}
 

import com.microsoft.azure.documentdb.ConnectionPolicy; //导入依赖的package包/类
public DocumentDbFactory(String host, String key, boolean isBiEnabled) {
    Assert.hasText(host, "host must not be empty!");
    Assert.hasText(key, "key must not be empty!");

    final ConnectionPolicy policy = ConnectionPolicy.GetDefault();

    String userAgent = ";" + USER_AGENT_SUFFIX;
    if (isBiEnabled && GetHashMac.getHashMac() != null) {
        userAgent += ";" + GetHashMac.getHashMac();
    }
    policy.setUserAgentSuffix(userAgent);

    documentClient = new DocumentClient(host, key, policy, ConsistencyLevel.Session);
}
 

import com.microsoft.azure.documentdb.ConnectionPolicy; //导入依赖的package包/类
public DocumentDBAutoConfiguration(DocumentDBProperties properties,
                                   ObjectProvider<ConnectionPolicy> connectionPolicyObjectProvider,
                                   ApplicationContext applicationContext) {
    this.properties = properties;
    this.connectionPolicy = connectionPolicyObjectProvider.getIfAvailable();
    this.applicationContext = applicationContext;
}
 

import com.microsoft.azure.documentdb.ConnectionPolicy; //导入依赖的package包/类
@Test
public void canSetAllPropertiesToDocumentClient() {
    try (AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext()) {
        context.register(DocumentDBAutoConfiguration.class);
        context.refresh();
        final DocumentClient documentClient = context.getBean(DocumentClient.class);

        // No way to verify the setting of key value and ConsistencyLevel.
        final URI uri = documentClient.getServiceEndpoint();
        assertThat(uri.toString()).isEqualTo(PropertySettingUtil.URI);

        assertThat(documentClient.getConnectionPolicy()).isEqualTo(ConnectionPolicy.GetDefault());
    }
}
 

import com.microsoft.azure.documentdb.ConnectionPolicy; //导入依赖的package包/类
@Test
public void canSetConnectionPolicyToDocumentClient() {
    try (AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext()) {
        context.register(DocumentDBAutoConfiguration.class, ConnectionPolicyConfig.class);
        context.refresh();
        final DocumentClient documentClient = context.getBean(DocumentClient.class);

        final ConnectionPolicy connectionPolicy = documentClient.getConnectionPolicy();
        assertThat(connectionPolicy.getRequestTimeout()).isEqualTo(PropertySettingUtil.REQUEST_TIMEOUT);
        assertThat(connectionPolicy.getMediaRequestTimeout()).
                isEqualTo(PropertySettingUtil.MEDIA_REQUEST_TIMEOUT);
        assertThat(connectionPolicy.getConnectionMode()).isEqualTo(PropertySettingUtil.CONNECTION_MODE);
        assertThat(connectionPolicy.getMediaReadMode()).isEqualTo(PropertySettingUtil.MEDIA_READ_MODE);
        assertThat(connectionPolicy.getMaxPoolSize()).isEqualTo(PropertySettingUtil.MAX_POOL_SIZE);
        assertThat(connectionPolicy.getIdleConnectionTimeout()).
                isEqualTo(PropertySettingUtil.IDLE_CONNECTION_TIMEOUT);
        assertThat(connectionPolicy.getUserAgentSuffix()).contains(PropertySettingUtil.USER_AGENT_SUFFIX);
        assertThat(connectionPolicy.getUserAgentSuffix()).contains(PropertySettingUtil.DEFAULT_USER_AGENT_SUFFIX);
        assertThat(connectionPolicy.getRetryOptions().getMaxRetryAttemptsOnThrottledRequests()).
                isEqualTo(PropertySettingUtil.RETRY_OPTIONS_MAX_RETRY_ATTEMPTS_ON_THROTTLED_REQUESTS);
        assertThat(connectionPolicy.getRetryOptions().getMaxRetryWaitTimeInSeconds()).
                isEqualTo(PropertySettingUtil.RETRY_OPTIONS_MAX_RETRY_WAIT_TIME_IN_SECONDS);
        assertThat(connectionPolicy.getEnableEndpointDiscovery()).
                isEqualTo(PropertySettingUtil.ENABLE_ENDPOINT_DISCOVERY);
        assertThat(connectionPolicy.getPreferredLocations().toString()).
                isEqualTo(PropertySettingUtil.PREFERRED_LOCATIONS.toString());
    }
}