def cli_cosmosdb_create(cmd,
client,
resource_group_name,
account_name,
locations=None,
tags=None,
kind=DatabaseAccountKind.global_document_db.value,
default_consistency_level=None,
max_staleness_prefix=100,
max_interval=5,
ip_range_filter=None,
enable_automatic_failover=None,
capabilities=None,
enable_virtual_network=None,
virtual_network_rules=None,
enable_multiple_write_locations=None,
disable_key_based_metadata_write_access=None):
"""Create a new Azure Cosmos DB database account."""
consistency_policy = None
if default_consistency_level is not None:
consistency_policy = ConsistencyPolicy(
default_consistency_level=default_consistency_level,
max_staleness_prefix=max_staleness_prefix,
max_interval_in_seconds=max_interval)
from azure.cli.core.commands.client_factory import get_mgmt_service_client
from azure.cli.core.profiles import ResourceType
resource_client = get_mgmt_service_client(
cmd.cli_ctx, ResourceType.MGMT_RESOURCE_RESOURCES)
rg = resource_client.resource_groups.get(resource_group_name)
resource_group_location = rg.location # pylint: disable=no-member
if not locations:
locations = []
locations.append(
Location(location_name=resource_group_location,
failover_priority=0,
is_zone_redundant=False))
params = DatabaseAccountCreateUpdateParameters(
location=resource_group_location,
locations=locations,
tags=tags,
kind=kind,
consistency_policy=consistency_policy,
ip_range_filter=ip_range_filter,
is_virtual_network_filter_enabled=enable_virtual_network,
enable_automatic_failover=enable_automatic_failover,
capabilities=capabilities,
virtual_network_rules=virtual_network_rules,
enable_multiple_write_locations=enable_multiple_write_locations,
disable_key_based_metadata_write_access=
disable_key_based_metadata_write_access)
async_docdb_create = client.create_or_update(resource_group_name,
account_name, params)
docdb_account = async_docdb_create.result()
docdb_account = client.get(resource_group_name, account_name) # Workaround
return docdb_account
def cli_cosmosdb_update(client,
resource_group_name,
account_name,
locations=None,
default_consistency_level=None,
max_staleness_prefix=None,
max_interval=None,
ip_range_filter=None,
enable_automatic_failover=None):
"""Update an existing Azure Cosmos DB database account. """
existing = client.get(resource_group_name, account_name)
update_consistency_policy = False
if max_interval is not None or \
max_staleness_prefix is not None or \
default_consistency_level is not None:
update_consistency_policy = True
if max_staleness_prefix is None:
max_staleness_prefix = existing.consistency_policy.max_staleness_prefix
if max_interval is None:
max_interval = existing.consistency_policy.max_interval_in_seconds
if default_consistency_level is None:
default_consistency_level = existing.consistency_policy.default_consistency_level
consistency_policy = None
if update_consistency_policy:
consistency_policy = ConsistencyPolicy(default_consistency_level,
max_staleness_prefix,
max_interval)
else:
consistency_policy = existing.consistency_policy
if not locations:
for loc in existing.read_locations:
locations.append(
Location(location_name=loc.location_name,
failover_priority=loc.failover_priority))
if ip_range_filter is None:
ip_range_filter = existing.ip_range_filter
if enable_automatic_failover is None:
enable_automatic_failover = existing.enable_automatic_failover
params = DatabaseAccountCreateUpdateParameters(
existing.location,
locations,
kind=existing.kind,
consistency_policy=consistency_policy,
ip_range_filter=ip_range_filter)
async_docdb_create = client.create_or_update(resource_group_name,
account_name, params)
docdb_account = async_docdb_create.result()
docdb_account = client.get(resource_group_name, account_name) # Workaround
return docdb_account
def __get_cosmosdb_steps(self, cmd, name, location):
from azure.mgmt.cosmosdb import CosmosDBManagementClient
from azure.cli.core.commands.client_factory import get_mgmt_service_client
steps = []
cosmosdb_client = get_mgmt_service_client(cmd.cli_ctx,
CosmosDBManagementClient)
from azure.mgmt.cosmosdb.models import (
DatabaseAccountCreateUpdateParameters, DatabaseAccountKind,
Location, ConsistencyPolicy)
server_params = {
'resource_group_name':
name,
'account_name':
name,
'params':
DatabaseAccountCreateUpdateParameters(
location=location,
locations=[
Location(location_name=location,
failover_priority=0,
is_zone_redundant=False)
],
kind=DatabaseAccountKind.mongo_db.value,
consistency_policy=ConsistencyPolicy(
default_consistency_level=1,
max_staleness_prefix=100,
max_interval_in_seconds=5))
}
steps.append(
DatabaseCreationStep(
'server', cosmosdb_client.database_accounts.create_or_update,
server_params))
database_params = {
'resource_group_name': name,
'account_name': name,
'database_name': name,
'resource': {
'id': name
},
'options': {}
}
steps.append(
DatabaseCreationStep(
'database', cosmosdb_client.mongo_db_resources.
create_update_mongo_db_database, database_params))
def retrieve_password():
result = cosmosdb_client.database_accounts.list_keys(
resource_group_name=name, account_name=name)
self.password = result.primary_master_key
steps.append(
DatabaseCreationStep('retrieve password', retrieve_password, None))
return steps
def cli_cosmosdb_network_rule_add(cmd,
client,
resource_group_name,
account_name,
subnet,
virtual_network=None,
ignore_missing_vnet_service_endpoint=False):
""" Adds a virtual network rule to an existing Cosmos DB database account """
subnet = _get_virtual_network_id(cmd, resource_group_name, subnet,
virtual_network)
existing = client.get(resource_group_name, account_name)
virtual_network_rules = []
rule_already_exists = False
for rule in existing.virtual_network_rules:
virtual_network_rules.append(
VirtualNetworkRule(id=rule.id,
ignore_missing_vnet_service_endpoint=rule.
ignore_missing_vnet_service_endpoint))
if rule.id == subnet:
rule_already_exists = True
logger.warning("The rule exists and will be overwritten")
if not rule_already_exists:
virtual_network_rules.append(
VirtualNetworkRule(id=subnet,
ignore_missing_vnet_service_endpoint=
ignore_missing_vnet_service_endpoint))
locations = []
for loc in existing.read_locations:
locations.append(
Location(location_name=loc.location_name,
failover_priority=loc.failover_priority,
is_zone_redundant=loc.is_zone_redundant))
params = DatabaseAccountCreateUpdateParameters(
location=existing.location,
locations=locations,
tags=existing.tags,
kind=existing.kind,
consistency_policy=existing.consistency_policy,
ip_range_filter=existing.ip_range_filter,
enable_automatic_failover=existing.enable_automatic_failover,
capabilities=existing.capabilities,
is_virtual_network_filter_enabled=True,
virtual_network_rules=virtual_network_rules,
enable_multiple_write_locations=existing.
enable_multiple_write_locations,
enable_cassandra_connector=existing.enable_cassandra_connector,
connector_offer=existing.connector_offer)
async_docdb_create = client.create_or_update(resource_group_name,
account_name, params)
docdb_account = async_docdb_create.result()
docdb_account = client.get(resource_group_name, account_name) # Workaround
return docdb_account
def cli_cosmosdb_network_rule_remove(cmd,
client,
resource_group_name,
account_name,
subnet,
virtual_network=None):
""" Adds a virtual network rule to an existing Cosmos DB database account """
subnet = _get_virtual_network_id(cmd, resource_group_name, subnet,
virtual_network)
existing = client.get(resource_group_name, account_name)
virtual_network_rules = []
rule_removed = False
for rule in existing.virtual_network_rules:
if rule.id != subnet:
virtual_network_rules.append(
VirtualNetworkRule(id=rule.id,
ignore_missing_vnet_service_endpoint=rule.
ignore_missing_vnet_service_endpoint))
else:
rule_removed = True
if not rule_removed:
raise CLIError("This rule does not exist for the Cosmos DB account")
locations = []
for loc in existing.read_locations:
locations.append(
Location(location_name=loc.location_name,
failover_priority=loc.failover_priority,
is_zone_redundant=loc.is_zone_redundant))
params = DatabaseAccountCreateUpdateParameters(
location=existing.location,
locations=locations,
tags=existing.tags,
kind=existing.kind,
consistency_policy=existing.consistency_policy,
ip_range_filter=existing.ip_range_filter,
enable_automatic_failover=existing.enable_automatic_failover,
capabilities=existing.capabilities,
is_virtual_network_filter_enabled=True,
virtual_network_rules=virtual_network_rules,
enable_multiple_write_locations=existing.
enable_multiple_write_locations)
async_docdb_create = client.create_or_update(resource_group_name,
account_name, params)
docdb_account = async_docdb_create.result()
docdb_account = client.get(resource_group_name, account_name) # Workaround
return docdb_account
def create_resource(self, name, **kwargs):
if self.is_live:
capabilities = Capability(name='EnableTable')
db_params = DatabaseAccountCreateUpdateParameters(
capabilities=[capabilities],
locations=[{'location_name': self.location}],
location=self.location,
)
self.client = self.create_mgmt_client(CosmosDBManagementClient)
group = self._get_resource_group(**kwargs)
cosmos_async_operation = self.client.database_accounts.begin_create_or_update(
group.name,
name,
db_params
)
self.resource = cosmos_async_operation.result()
cosmos_keys = self.client.database_accounts.list_keys(
group.name,
name
)
self.cosmos_key = cosmos_keys.primary_master_key
self.cosmos_account_name = name
self.test_class_instance.scrubber.register_name_pair(
name,
self.resource_moniker
)
self.primary_endpoint = 'https://{}.table.cosmos.azure.com:443/'.format(name)
else:
self.resource = StorageAccount(
location=self.location
)
self.resource.name = name
self.resource.id = name
self.primary_endpoint = 'https://{}.table.cosmos.azure.com:443/'.format(name)
self.cosmos_key = 'ZmFrZV9hY29jdW50X2tleQ=='
self.cosmos_account_name = name
return {
self.parameter_name: self.resource,
'{}_key'.format(self.parameter_name): self.cosmos_key,
'{}_cs'.format(self.parameter_name): ";".join([
"DefaultEndpointsProtocol=https",
"AccountName={}".format(self.cosmos_account_name),
"AccountKey={}".format(self.cosmos_key),
"TableEndpoint={}".format(self.primary_endpoint)
])
}
def server_creator():
params = DatabaseAccountCreateUpdateParameters(
location=location,
locations=[
Location(location_name=location,
failover_priority=0,
is_zone_redundant=False)
],
kind=DatabaseAccountKind.mongo_db.value,
consistency_policy=ConsistencyPolicy(
default_consistency_level=1,
max_staleness_prefix=100,
max_interval_in_seconds=5))
return cosmosdb_client.database_accounts.create_or_update(
name, name, params)
def cli_cosmosdb_create(cmd,
client,
resource_group_name,
account_name,
locations=None,
tags=None,
kind=DatabaseAccountKind.global_document_db.value,
default_consistency_level=None,
max_staleness_prefix=100,
max_interval=5,
ip_range_filter=None,
enable_automatic_failover=None,
capabilities=None):
"""Create a new Azure Cosmos DB database account."""
consistency_policy = None
if default_consistency_level is not None:
consistency_policy = ConsistencyPolicy(default_consistency_level,
max_staleness_prefix,
max_interval)
from azure.mgmt.resource import ResourceManagementClient
from azure.cli.core.commands.client_factory import get_mgmt_service_client
resource_client = get_mgmt_service_client(cmd.cli_ctx,
ResourceManagementClient)
rg = resource_client.resource_groups.get(resource_group_name)
resource_group_location = rg.location # pylint: disable=no-member
if not locations:
locations.append(
Location(location_name=resource_group_location,
failover_priority=0))
params = DatabaseAccountCreateUpdateParameters(
resource_group_location,
locations,
tags=tags,
kind=kind,
consistency_policy=consistency_policy,
ip_range_filter=ip_range_filter,
enable_automatic_failover=enable_automatic_failover,
capabilities=capabilities)
async_docdb_create = client.create_or_update(resource_group_name,
account_name, params)
docdb_account = async_docdb_create.result()
docdb_account = client.get(resource_group_name, account_name) # Workaround
return docdb_account
def setup_cosmosdb(cosmosdb_client, database_account_name):
log.info("Creating CosmosDB")
mongo = cosmosdb_client.database_accounts.create_or_update(
Azure.resource_group,
database_account_name,
DatabaseAccountCreateUpdateParameters(
location=Azure.location,
locations=[Location(location_name=Azure.location)],
kind=DatabaseAccountKind.mongo_db
),
database_account_offer_type=DatabaseAccountOfferType.standard
).result()
log.info("Fetching CosmosDB connection details")
keys = cosmosdb_client.database_accounts.list_keys(Azure.resource_group, database_account_name)
connection_strings = cosmosdb_client.database_accounts.list_connection_strings(Azure.resource_group, database_account_name).connection_strings
connection_string = head(cs for cs in connection_strings if cs.description == "Primary MongoDB Connection String").connection_string
return mongo, keys, connection_string
def cli_cosmosdb_update(client,
resource_group_name,
account_name,
locations=None,
tags=None,
default_consistency_level=None,
max_staleness_prefix=None,
max_interval=None,
ip_range_filter=None,
enable_automatic_failover=None,
capabilities=None,
enable_virtual_network=None,
virtual_network_rules=None):
"""Update an existing Azure Cosmos DB database account. """
existing = client.get(resource_group_name, account_name)
# Workaround until PATCH support for all properties
# pylint: disable=too-many-boolean-expressions
if capabilities is not None:
if locations or \
default_consistency_level is not None or \
max_staleness_prefix is not None or \
max_interval is not None or \
ip_range_filter is not None or \
enable_automatic_failover is not None or \
enable_virtual_network is not None or \
virtual_network_rules is not None:
raise CLIError(
"Cannot set capabilities and update properties at the same time. {0}"
.format(locations))
else:
async_docdb_create = client.patch(resource_group_name,
account_name,
tags=tags,
capabilities=capabilities)
docdb_account = async_docdb_create.result()
docdb_account = client.get(resource_group_name, account_name)
return docdb_account
# Workaround until PATCH support for all properties
# pylint: disable=too-many-boolean-expressions
if tags is not None:
if not locations and \
default_consistency_level is None and \
max_staleness_prefix is None and \
max_interval is None and \
ip_range_filter is None and \
enable_automatic_failover is None and \
enable_virtual_network is None and \
virtual_network_rules is None:
async_docdb_create = client.patch(resource_group_name,
account_name,
tags=tags,
capabilities=capabilities)
docdb_account = async_docdb_create.result()
docdb_account = client.get(resource_group_name, account_name)
return docdb_account
update_consistency_policy = False
if max_interval is not None or \
max_staleness_prefix is not None or \
default_consistency_level is not None:
update_consistency_policy = True
if max_staleness_prefix is None:
max_staleness_prefix = existing.consistency_policy.max_staleness_prefix
if max_interval is None:
max_interval = existing.consistency_policy.max_interval_in_seconds
if default_consistency_level is None:
default_consistency_level = existing.consistency_policy.default_consistency_level
consistency_policy = None
if update_consistency_policy:
consistency_policy = ConsistencyPolicy(
default_consistency_level=default_consistency_level,
max_staleness_prefix=max_staleness_prefix,
max_interval_in_seconds=max_interval)
else:
consistency_policy = existing.consistency_policy
if not locations:
for loc in existing.read_locations:
locations.append(
Location(location_name=loc.location_name,
failover_priority=loc.failover_priority))
if ip_range_filter is None:
ip_range_filter = existing.ip_range_filter
if enable_automatic_failover is None:
enable_automatic_failover = existing.enable_automatic_failover
if enable_virtual_network is None:
enable_virtual_network = existing.is_virtual_network_filter_enabled
if virtual_network_rules is None:
virtual_network_rules = existing.virtual_network_rules
if tags is None:
tags = existing.tags
params = DatabaseAccountCreateUpdateParameters(
location=existing.location,
locations=locations,
tags=tags,
kind=existing.kind,
consistency_policy=consistency_policy,
ip_range_filter=ip_range_filter,
enable_automatic_failover=enable_automatic_failover,
capabilities=existing.capabilities,
is_virtual_network_filter_enabled=enable_virtual_network,
virtual_network_rules=virtual_network_rules)
async_docdb_create = client.create_or_update(resource_group_name,
account_name, params)
docdb_account = async_docdb_create.result()
docdb_account = client.get(resource_group_name, account_name) # Workaround
return docdb_account
def __get_cosmosdb_steps(self, cmd, name, location):
from azure.mgmt.cosmosdb import CosmosDBManagementClient
from azure.mgmt.cosmosdb.models import Capability
from azure.cli.core.commands.client_factory import get_mgmt_service_client
steps = []
cosmosdb_client = get_mgmt_service_client(cmd.cli_ctx,
CosmosDBManagementClient)
from azure.mgmt.cosmosdb.models import (
DatabaseAccountCreateUpdateParameters, DatabaseAccountKind,
Location, MongoDBDatabaseCreateUpdateParameters)
server_params = {
'resource_group_name':
name,
'account_name':
name,
'create_update_parameters':
DatabaseAccountCreateUpdateParameters(
location=location,
locations=[
Location(location_name=location,
failover_priority=0,
is_zone_redundant=False)
],
kind=DatabaseAccountKind.mongo_db.value,
capabilities=[
Capability(name='EnableMongo'),
Capability(name='EnableServerless'),
Capability(name='DisableRateLimitingResponses')
],
tags={'CosmosAccountType': 'Non-Production'})
}
steps.append(
DatabaseCreationStep(
'server', cosmosdb_client.database_accounts.create_or_update,
server_params))
database_params = {
'resource_group_name':
name,
'account_name':
name,
'database_name':
name,
'create_update_mongo_db_database_parameters':
MongoDBDatabaseCreateUpdateParameters(resource={'id': name},
options={})
}
steps.append(
DatabaseCreationStep(
'database', cosmosdb_client.mongo_db_resources.
create_update_mongo_db_database, database_params))
def retrieve_password():
result = cosmosdb_client.database_accounts.list_keys(
resource_group_name=name, account_name=name)
self.password = result.primary_master_key
steps.append(
DatabaseCreationStep('retrieve password', retrieve_password, None))
return steps
