'This API will induce data loss for the specified partition. It will
trigger a call to the OnDataLossAsync API of the partition.
This API will induce data loss for the specified partition. It will
trigger a call to the OnDataLoss API of the partition.
Actual data loss will depend on the specified DataLossMode
PartialDataLoss - Only a quorum of replicas are removed and OnDataLoss
is triggered for the partition but actual data loss depends on the
presence of in-flight replication.
FullDataLoss - All replicas are removed hence all data is lost and
OnDataLoss is triggered.
This API should only be called with a stateful service as the target.
Calling this API with a system service as the target is not advised.
Note:  Once this API has been called, it cannot be reversed. Calling
CancelOperation will only stop execution and clean up internal system
state.
It will not restore data if the command has progressed far enough to
cause data loss.
Call the GetDataLossProgress API with the same OperationId to return
information on the operation started with this API.
:param service_id: The identity of the service. This is typically the
full name of the service without the \'fabric:\' URI scheme.
:type service_id: str
:param partition_id: The identity of the partition.
:type partition_id: str
:param operation_id: A GUID that identifies a call of this API.  This
is passed into the corresponding GetProgress API
:type operation_id: str
:param data_loss_mode: This enum is passed to the StartDataLoss API
to indicate what type of data loss to induce.
- Invalid - Reserved.  Do not pass into API.
- PartialDataLoss - PartialDataLoss option will cause a quorum of
replicas to go down, triggering an OnDataLoss event in the system
for the given partition.
- FullDataLoss - FullDataLoss option will drop all the replicas which
means that all the data will be lost.
. Possible values include: \'Invalid\', \'PartialDataLoss\',
\'FullDataLoss\'
:type data_loss_mode: str
:param timeout: The server timeout for performing the operation in
seconds. This specifies the time duration that the client is willing
to wait for the requested operation to complete. The default value
for this parameter is 60 seconds.
:type timeout: long
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`'

def start_data_loss(self, service_id, partition_id, operation_id, data_loss_mode, timeout=60, custom_headers=None, raw=False, **operation_config):

    api_version = '3.0'
    url = '/Faults/Services/{serviceId}/$/GetPartitions/{partitionId}/$/StartDataLoss'
    path_format_arguments = {'serviceId': self._serialize.url('service_id', service_id, 'str', skip_quote=True), 'partitionId': self._serialize.url('partition_id', partition_id, 'str', skip_quote=True)}
    url = self._client.format_url(url, **path_format_arguments)
    query_parameters = {}
    query_parameters['api-version'] = self._serialize.query('api_version', api_version, 'str')
    query_parameters['OperationId'] = self._serialize.query('operation_id', operation_id, 'str')
    query_parameters['DataLossMode'] = self._serialize.query('data_loss_mode', data_loss_mode, 'str')
    if (timeout is not None):
        query_parameters['timeout'] = self._serialize.query('timeout', timeout, 'long', maximum=4294967295, minimum=1)
    header_parameters = {}
    header_parameters['Content-Type'] = 'application/json;    charset=utf-8'
    if custom_headers:
        header_parameters.update(custom_headers)
    request = self._client.post(url, query_parameters)
    response = self._client.send(request, header_parameters, **operation_config)
    if (response.status_code not in [202]):
        raise models.FabricErrorException(self._deserialize, response)
    if raw:
        client_raw_response = ClientRawResponse(None, response)
        return client_raw_response
