text:
import uuid
from msrest.pipeline import ClientRawResponse
from msrestazure.azure_exceptions import CloudError
from msrest.exceptions import DeserializationError
from msrestazure.azure_operation import AzureOperationPoller

from .. import models

class VirtualNetworkGatewaysOperations(object):
    """VirtualNetworkGatewaysOperations operations.

    :param client: Client for service requests.
    :param config: Configuration of service client.
    :param serializer: An object model serializer.
    :param deserializer: An objec model deserializer.
    :ivar api_version: Client API version. Constant value: "2017-10-01".
    """

    models = models

    def __init__(self, client, config, serializer, deserializer):

        self._client = client
        self._serialize = serializer
        self._deserialize = deserializer
        self.api_version = "2017-10-01"

        self.config = config

    def _create_or_update_initial(
            self, resource_group_name, virtual_network_gateway_name, parameters, custom_headers=None, raw=False, **operation_config):
        # Construct URL
        url = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}'
        path_format_arguments = {
            'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
            'virtualNetworkGatewayName': self._serialize.url("virtual_network_gateway_name", virtual_network_gateway_name, 'str'),
            'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
        }
        url = self._client.format_url(url, **path_format_arguments)

        # Construct parameters
        query_parameters = {}
        query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')

        # Construct headers
        header_parameters = {}
        header_parameters['Content-Type'] = 'application/json; charset=utf-8'
        if self.config.generate_client_request_id:
            header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
        if custom_headers:
            header_parameters.update(custom_headers)
        if self.config.accept_language is not None:
            header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

        # Construct body
        body_content = self._serialize.body(parameters, 'VirtualNetworkGateway')

        # Construct and send request
        request = self._client.put(url, query_parameters)
        response = self._client.send(
            request, header_parameters, body_content, stream=False, **operation_config)

        if response.status_code not in [200, 201]:
            exp = CloudError(response)
            exp.request_id = response.headers.get('x-ms-request-id')
            raise exp

        deserialized = None

        if response.status_code == 200:
            deserialized = self._deserialize('VirtualNetworkGateway', response)
        if response.status_code == 201:
            deserialized = self._deserialize('VirtualNetworkGateway', response)

        if raw:
            client_raw_response = ClientRawResponse(deserialized, response)
            return client_raw_response

        return deserialized

    def create_or_update(
            self, resource_group_name, virtual_network_gateway_name, parameters, custom_headers=None, raw=False, **operation_config):
        """Creates or updates a virtual network gateway in the specified resource
        group.

        :param resource_group_name: The name of the resource group.
        :type resource_group_name: str
        :param virtual_network_gateway_name: The name of the virtual network
         gateway.
        :type virtual_network_gateway_name: str
        :param parameters: Parameters supplied to create or update virtual
         network gateway operation.
        :type parameters:
         ~azure.mgmt.network.v2017_10_01.models.VirtualNetworkGateway
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :return: An instance of AzureOperationPoller that returns
         VirtualNetworkGateway or ClientRawResponse if raw=true
        :rtype:
         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_10_01.models.VirtualNetworkGateway]
         or ~msrest.pipeline.ClientRawResponse
        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
        """
        raw_result = self._create_or_update_initial(
            resource_group_name=resource_group_name,
            virtual_network_gateway_name=virtual_network_gateway_name,
            parameters=parameters,
            custom_headers=custom_headers,
            raw=True,
            **operation_config
        )
        if raw:
            return raw_result

        # Construct and send request
        def long_running_send():
            return raw_result.response

        def get_long_running_status(status_link, headers=None):

            request = self._client.get(status_link)
            if headers:
                request.headers.update(headers)
            header_parameters = {}
            header_parameters['x-ms-client-request-id'] = raw_result.response.request.headers['x-ms-client-request-id']
            return self._client.send(
                request, header_parameters, stream=False, **operation_config)

        def get_long_running_output(response):

            if response.status_code not in [200, 201]:
                exp = CloudError(response)
                exp.request_id = response.headers.get('x-ms-request-id')
                raise exp

            deserialized = self._deserialize('VirtualNetworkGateway', response)

            if raw:
                client_raw_response = ClientRawResponse(deserialized, response)
                return client_raw_response

            return deserialized

        long_running_operation_timeout = operation_config.get(
            'long_running_operation_timeout',
            self.config.long_running_operation_timeout)
        return AzureOperationPoller(
            long_running_send, get_long_running_output,
            get_long_running_status, long_running_operation_timeout)

    def get(
            self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, **operation_config):
        """Gets the specified virtual network gateway by resource group.

        :param resource_group_name: The name of the resource group.
        :type resource_group_name: str
        :param virtual_network_gateway_name: The name of the virtual network
         gateway.
        :type virtual_network_gateway_name: str
        :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>`.
        :return: VirtualNetworkGateway or ClientRawResponse if raw=true
        :rtype: ~azure.mgmt.network.v2017_10_01.models.VirtualNetworkGateway
         or ~msrest.pipeline.ClientRawResponse
        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
        """
        # Construct URL
        url = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}'
        path_format_arguments = {
            'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
            'virtualNetworkGatewayName': self._serialize.url("virtual_network_gateway_name", virtual_network_gateway_name, 'str'),
            'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
        }
        url = self._client.format_url(url, **path_format_arguments)

        # Construct parameters
        query_parameters = {}
        query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')

        # Construct headers
        header_parameters = {}
        header_parameters['Content-Type'] = 'application/json; charset=utf-8'
        if self.config.generate_client_request_id:
            header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
        if custom_headers:
            header_parameters.update(custom_headers)
        if self.config.accept_language is not None:
            header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

        # Construct and send request
        request = self._client.get(url, query_parameters)
        response = self._client.send(request, header_parameters, stream=False, **operation_config)

        if response.status_code not in [200]:
            exp = CloudError(response)
            exp.request_id = response.headers.get('x-ms-request-id')
            raise exp

        deserialized = None

        if response.status_code == 200:
            deserialized = self._deserialize('VirtualNetworkGateway', response)

        if raw:
            client_raw_response = ClientRawResponse(deserialized, response)
            return client_raw_response

        return deserialized

    def _delete_initial(
            self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, **operation_config):
        # Construct URL
        url = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}'
        path_format_arguments = {
            'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
            'virtualNetworkGatewayName': self._serialize.url("virtual_network_gateway_name", virtual_network_gateway_name, 'str'),
            'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
        }
        url = self._client.format_url(url, **path_format_arguments)

        # Construct parameters
        query_parameters = {}
        query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')

        # Construct headers
        header_parameters = {}
        header_parameters['Content-Type'] = 'application/json; charset=utf-8'
        if self.config.generate_client_request_id:
            header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
        if custom_headers:
            header_parameters.update(custom_headers)
        if self.config.accept_language is not None:
            header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

        # Construct and send request
        request = self._client.delete(url, query_parameters)
        response = self._client.send(request, header_parameters, stream=False, **operation_config)

        if response.status_code not in [200, 202, 204]:
            exp = CloudError(response)
            exp.request_id = response.headers.get('x-ms-request-id')
            raise exp

        if raw:
            client_raw_response = ClientRawResponse(None, response)
            return client_raw_response

    def delete(
            self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, **operation_config):
        """Deletes the specified virtual network gateway.

        :param resource_group_name: The name of the resource group.
        :type resource_group_name: str
        :param virtual_network_gateway_name: The name of the virtual network
         gateway.
        :type virtual_network_gateway_name: str
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :return: An instance of AzureOperationPoller that returns None or
         ClientRawResponse if raw=true
        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or
         ~msrest.pipeline.ClientRawResponse
        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
        """
        raw_result = self._delete_initial(
            resource_group_name=resource_group_name,
            virtual_network_gateway_name=virtual_network_gateway_name,
            custom_headers=custom_headers,
            raw=True,
            **operation_config
        )
        if raw:
            return raw_result

        # Construct and send request
        def long_running_send():
            return raw_result.response

        def get_long_running_status(status_link, headers=None):

            request = self._client.get(status_link)
            if headers:
                request.headers.update(headers)
            header_parameters = {}
            header_parameters['x-ms-client-request-id'] = raw_result.response.request.headers['x-ms-client-request-id']
            return self._client.send(
                request, header_parameters, stream=False, **operation_config)

        def get_long_running_output(response):

            if response.status_code not in [200, 202, 204]:
                exp = CloudError(response)
                exp.request_id = response.headers.get('x-ms-request-id')
                raise exp

            if raw:
                client_raw_response = ClientRawResponse(None, response)
                return client_raw_response

        long_running_operation_timeout = operation_config.get(
            'long_running_operation_timeout',
            self.config.long_running_operation_timeout)
        return AzureOperationPoller(
            long_running_send, get_long_running_output,
            get_long_running_status, long_running_operation_timeout)

    def _update_tags_initial(
            self, resource_group_name, virtual_network_gateway_name, tags=None, custom_headers=None, raw=False, **operation_config):
        parameters = models.TagsObject(tags=tags)

        # Construct URL
        url = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}'
        path_format_arguments = {
            'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
            'virtualNetworkGatewayName': self._serialize.url("virtual_network_gateway_name", virtual_network_gateway_name, 'str'),
            'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
        }
        url = self._client.format_url(url, **path_format_arguments)

        # Construct parameters
        query_parameters = {}
        query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')

        # Construct headers
        header_parameters = {}
        header_parameters['Content-Type'] = 'application/json; charset=utf-8'
        if self.config.generate_client_request_id:
            header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
        if custom_headers:
            header_parameters.update(custom_headers)
        if self.config.accept_language is not None:
            header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

        # Construct body
        body_content = self._serialize.body(parameters, 'TagsObject')

        # Construct and send request
        request = self._client.patch(url, query_parameters)
        response = self._client.send(
            request, header_parameters, body_content, stream=False, **operation_config)

        if response.status_code not in [200]:
            exp = CloudError(response)
            exp.request_id = response.headers.get('x-ms-request-id')
            raise exp

        deserialized = None

        if response.status_code == 200:
            deserialized = self._deserialize('VirtualNetworkGateway', response)

        if raw:
            client_raw_response = ClientRawResponse(deserialized, response)
            return client_raw_response

        return deserialized

    def update_tags(
            self, resource_group_name, virtual_network_gateway_name, tags=None, custom_headers=None, raw=False, **operation_config):
        """Updates a virtual network gateway tags.

        :param resource_group_name: The name of the resource group.
        :type resource_group_name: str
        :param virtual_network_gateway_name: The name of the virtual network
         gateway.
        :type virtual_network_gateway_name: str
        :param tags: Resource tags.
        :type tags: dict[str, str]
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :return: An instance of AzureOperationPoller that returns
         VirtualNetworkGateway or ClientRawResponse if raw=true
        :rtype:
         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_10_01.models.VirtualNetworkGateway]
         or ~msrest.pipeline.ClientRawResponse
        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
        """
        raw_result = self._update_tags_initial(
            resource_group_name=resource_group_name,
            virtual_network_gateway_name=virtual_network_gateway_name,
            tags=tags,
            custom_headers=custom_headers,
            raw=True,
            **operation_config
        )
        if raw:
            return raw_result

        # Construct and send request
        def long_running_send():
            return raw_result.response

        def get_long_running_status(status_link, headers=None):

            request = self._client.get(status_link)
            if headers:
                request.headers.update(headers)
            header_parameters = {}
            header_parameters['x-ms-client-request-id'] = raw_result.response.request.headers['x-ms-client-request-id']
            return self._client.send(
                request, header_parameters, stream=False, **operation_config)

        def get_long_running_output(response):

            if response.status_code not in [200]:
                exp = CloudError(response)
                exp.request_id = response.headers.get('x-ms-request-id')
                raise exp

            deserialized = self._deserialize('VirtualNetworkGateway', response)

            if raw:
                client_raw_response = ClientRawResponse(deserialized, response)
                return client_raw_response

            return deserialized

        long_running_operation_timeout = operation_config.get(
            'long_running_operation_timeout',
            self.config.long_running_operation_timeout)
        return AzureOperationPoller(
            long_running_send, get_long_running_output,
            get_long_running_status, long_running_operation_timeout)

    def list(
            self, resource_group_name, custom_headers=None, raw=False, **operation_config):
        """Gets all virtual network gateways by resource group.

        :param resource_group_name: The name of the resource group.
        :type resource_group_name: str
        :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>`.
        :return: An iterator like instance of VirtualNetworkGateway
        :rtype:
         ~azure.mgmt.network.v2017_10_01.models.VirtualNetworkGatewayPaged[~azure.mgmt.network.v2017_10_01.models.VirtualNetworkGateway]
        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
        """
        def internal_paging(next_link=None, raw=False):

            if not next_link:
                # Construct URL
                url = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways'
                path_format_arguments = {
                    'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
                    'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
                }
                url = self._client.format_url(url, **path_format_arguments)

                # Construct parameters
                query_parameters = {}
                query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')

            else:
                url = next_link
                query_parameters = {}

            # Construct headers
            header_parameters = {}
            header_parameters['Content-Type'] = 'application/json; charset=utf-8'
            if self.config.generate_client_request_id:
                header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
            if custom_headers:
                header_parameters.update(custom_headers)
            if self.config.accept_language is not None:
                header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

            # Construct and send request
            request = self._client.get(url, query_parameters)
            response = self._client.send(
                request, header_parameters, stream=False, **operation_config)

            if response.status_code not in [200]:
                exp = CloudError(response)
                exp.request_id = response.headers.get('x-ms-request-id')
                raise exp

            return response

        # Deserialize response
        deserialized = models.VirtualNetworkGatewayPaged(internal_paging, self._deserialize.dependencies)

        if raw:
            header_dict = {}
            client_raw_response = models.VirtualNetworkGatewayPaged(internal_paging, self._deserialize.dependencies, header_dict)
            return client_raw_response

        return deserialized

    def list_connections(
            self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, **operation_config):
        """Gets all the connections in a virtual network gateway.

        :param resource_group_name: The name of the resource group.
        :type resource_group_name: str
        :param virtual_network_gateway_name: The name of the virtual network
         gateway.
        :type virtual_network_gateway_name: str
        :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>`.
        :return: An iterator like instance of
         VirtualNetworkGatewayConnectionListEntity
        :rtype:
         ~azure.mgmt.network.v2017_10_01.models.VirtualNetworkGatewayConnectionListEntityPaged[~azure.mgmt.network.v2017_10_01.models.VirtualNetworkGatewayConnectionListEntity]
        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
        """
        def internal_paging(next_link=None, raw=False):

            if not next_link:
                # Construct URL
                url = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/connections'
                path_format_arguments = {
                    'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
                    'virtualNetworkGatewayName': self._serialize.url("virtual_network_gateway_name", virtual_network_gateway_name, 'str'),
                    'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
                }
                url = self._client.format_url(url, **path_format_arguments)

                # Construct parameters
                query_parameters = {}
                query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')

            else:
                url = next_link
                query_parameters = {}

            # Construct headers
            header_parameters = {}
            header_parameters['Content-Type'] = 'application/json; charset=utf-8'
            if self.config.generate_client_request_id:
                header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
            if custom_headers:
                header_parameters.update(custom_headers)
            if self.config.accept_language is not None:
                header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

            # Construct and send request
            request = self._client.get(url, query_parameters)
            response = self._client.send(
                request, header_parameters, stream=False, **operation_config)

            if response.status_code not in [200]:
                exp = CloudError(response)
                exp.request_id = response.headers.get('x-ms-request-id')
                raise exp

            return response

        # Deserialize response
        deserialized = models.VirtualNetworkGatewayConnectionListEntityPaged(internal_paging, self._deserialize.dependencies)

        if raw:
            header_dict = {}
            client_raw_response = models.VirtualNetworkGatewayConnectionListEntityPaged(internal_paging, self._deserialize.dependencies, header_dict)
            return client_raw_response

        return deserialized

    def _reset_initial(
            self, resource_group_name, virtual_network_gateway_name, gateway_vip=None, custom_headers=None, raw=False, **operation_config):
        # Construct URL
        url = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/reset'
        path_format_arguments = {
            'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
            'virtualNetworkGatewayName': self._serialize.url("virtual_network_gateway_name", virtual_network_gateway_name, 'str'),
            'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
        }
        url = self._client.format_url(url, **path_format_arguments)

        # Construct parameters
        query_parameters = {}
        if gateway_vip is not None:
            query_parameters['gatewayVip'] = self._serialize.query("gateway_vip", gateway_vip, 'str')
        query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')

        # Construct headers
        header_parameters = {}
        header_parameters['Content-Type'] = 'application/json; charset=utf-8'
        if self.config.generate_client_request_id:
            header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
        if custom_headers:
            header_parameters.update(custom_headers)
        if self.config.accept_language is not None:
            header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

        # Construct and send request
        request = self._client.post(url, query_parameters)
        response = self._client.send(request, header_parameters, stream=False, **operation_config)

        if response.status_code not in [200, 202]:
            exp = CloudError(response)
            exp.request_id = response.headers.get('x-ms-request-id')
            raise exp

        deserialized = None

        if response.status_code == 200:
            deserialized = self._deserialize('VirtualNetworkGateway', response)

        if raw:
            client_raw_response = ClientRawResponse(deserialized, response)
            return client_raw_response

        return deserialized

    def reset(
            self, resource_group_name, virtual_network_gateway_name, gateway_vip=None, custom_headers=None, raw=False, **operation_config):
        """Resets the primary of the virtual network gateway in the specified
        resource group.

        :param resource_group_name: The name of the resource group.
        :type resource_group_name: str
        :param virtual_network_gateway_name: The name of the virtual network
         gateway.
        :type virtual_network_gateway_name: str
        :param gateway_vip: Virtual network gateway vip address supplied to
         the begin reset of the active-active feature enabled gateway.
        :type gateway_vip: str
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :return: An instance of AzureOperationPoller that returns
         VirtualNetworkGateway or ClientRawResponse if raw=true
        :rtype:
         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_10_01.models.VirtualNetworkGateway]
         or ~msrest.pipeline.ClientRawResponse
        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
        """
        raw_result = self._reset_initial(
            resource_group_name=resource_group_name,
            virtual_network_gateway_name=virtual_network_gateway_name,
            gateway_vip=gateway_vip,
            custom_headers=custom_headers,
            raw=True,
            **operation_config
        )
        if raw:
            return raw_result

        # Construct and send request
        def long_running_send():
            return raw_result.response

        def get_long_running_status(status_link, headers=None):

            request = self._client.get(status_link)
            if headers:
                request.headers.update(headers)
            header_parameters = {}
            header_parameters['x-ms-client-request-id'] = raw_result.response.request.headers['x-ms-client-request-id']
            return self._client.send(
                request, header_parameters, stream=False, **operation_config)

        def get_long_running_output(response):

            if response.status_code not in [200, 202]:
                exp = CloudError(response)
                exp.request_id = response.headers.get('x-ms-request-id')
                raise exp

            deserialized = self._deserialize('VirtualNetworkGateway', response)

            if raw:
                client_raw_response = ClientRawResponse(deserialized, response)
                return client_raw_response

            return deserialized

        long_running_operation_timeout = operation_config.get(
            'long_running_operation_timeout',
            self.config.long_running_operation_timeout)
        return AzureOperationPoller(
            long_running_send, get_long_running_output,
            get_long_running_status, long_running_operation_timeout)

    def _generatevpnclientpackage_initial(
            self, resource_group_name, virtual_network_gateway_name, parameters, custom_headers=None, raw=False, **operation_config):
        # Construct URL
        url = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/generatevpnclientpackage'
        path_format_arguments = {
            'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
            'virtualNetworkGatewayName': self._serialize.url("virtual_network_gateway_name", virtual_network_gateway_name, 'str'),
            'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
        }
        url = self._client.format_url(url, **path_format_arguments)

        # Construct parameters
        query_parameters = {}
        query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')

        # Construct headers
        header_parameters = {}
        header_parameters['Content-Type'] = 'application/json; charset=utf-8'
        if self.config.generate_client_request_id:
            header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
        if custom_headers:
            header_parameters.update(custom_headers)
        if self.config.accept_language is not None:
            header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

        # Construct body
        body_content = self._serialize.body(parameters, 'VpnClientParameters')

        # Construct and send request
        request = self._client.post(url, query_parameters)
        response = self._client.send(
            request, header_parameters, body_content, stream=False, **operation_config)

        if response.status_code not in [200]:
            exp = CloudError(response)
            exp.request_id = response.headers.get('x-ms-request-id')
            raise exp

        deserialized = None

        if response.status_code == 200:
            deserialized = self._deserialize('str', response)

        if raw:
            client_raw_response = ClientRawResponse(deserialized, response)
            return client_raw_response

        return deserialized

    def generatevpnclientpackage(
            self, resource_group_name, virtual_network_gateway_name, parameters, custom_headers=None, raw=False, **operation_config):
        """Generates VPN client package for P2S client of the virtual network
        gateway in the specified resource group.

        :param resource_group_name: The name of the resource group.
        :type resource_group_name: str
        :param virtual_network_gateway_name: The name of the virtual network
         gateway.
        :type virtual_network_gateway_name: str
        :param parameters: Parameters supplied to the generate virtual network
         gateway VPN client package operation.
        :type parameters:
         ~azure.mgmt.network.v2017_10_01.models.VpnClientParameters
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :return: An instance of AzureOperationPoller that returns str or
         ClientRawResponse if raw=true
        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[str] or
         ~msrest.pipeline.ClientRawResponse
        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
        """
        raw_result = self._generatevpnclientpackage_initial(
            resource_group_name=resource_group_name,
            virtual_network_gateway_name=virtual_network_gateway_name,
            parameters=parameters,
            custom_headers=custom_headers,
            raw=True,
            **operation_config
        )
        if raw:
            return raw_result

        # Construct and send request
        def long_running_send():
            return raw_result.response

        def get_long_running_status(status_link, headers=None):

            request = self._client.get(status_link)
            if headers:
                request.headers.update(headers)
            header_parameters = {}
            header_parameters['x-ms-client-request-id'] = raw_result.response.request.headers['x-ms-client-request-id']
            return self._client.send(
                request, header_parameters, stream=False, **operation_config)

        def get_long_running_output(response):

            if response.status_code not in [200]:
                exp = CloudError(response)
                exp.request_id = response.headers.get('x-ms-request-id')
                raise exp

            deserialized = self._deserialize('str', response)

            if raw:
                client_raw_response = ClientRawResponse(deserialized, response)
                return client_raw_response

            return deserialized

        long_running_operation_timeout = operation_config.get(
            'long_running_operation_timeout',
            self.config.long_running_operation_timeout)
        return AzureOperationPoller(
            long_running_send, get_long_running_output,
            get_long_running_status, long_running_operation_timeout)

    def _generate_vpn_profile_initial(
            self, resource_group_name, virtual_network_gateway_name, parameters, custom_headers=None, raw=False, **operation_config):
        # Construct URL
        url = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/generatevpnprofile'
        path_format_arguments = {
            'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
            'virtualNetworkGatewayName': self._serialize.url("virtual_network_gateway_name", virtual_network_gateway_name, 'str'),
            'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
        }
        url = self._client.format_url(url, **path_format_arguments)

        # Construct parameters
        query_parameters = {}
        query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')

        # Construct headers
        header_parameters = {}
        header_parameters['Content-Type'] = 'application/json; charset=utf-8'
        if self.config.generate_client_request_id:
            header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
        if custom_headers:
            header_parameters.update(custom_headers)
        if self.config.accept_language is not None:
            header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

        # Construct body
        body_content = self._serialize.body(parameters, 'VpnClientParameters')

        # Construct and send request
        request = self._client.post(url, query_parameters)
        response = self._client.send(
            request, header_parameters, body_content, stream=False, **operation_config)

        if response.status_code not in [200, 202]:
            exp = CloudError(response)
            exp.request_id = response.headers.get('x-ms-request-id')
            raise exp

        deserialized = None

        if response.status_code == 200:
            deserialized = self._deserialize('str', response)

        if raw:
            client_raw_response = ClientRawResponse(deserialized, response)
            return client_raw_response

        return deserialized

    def generate_vpn_profile(
            self, resource_group_name, virtual_network_gateway_name, parameters, custom_headers=None, raw=False, **operation_config):
        """Generates VPN profile for P2S client of the virtual network gateway in
        the specified resource group. Used for IKEV2 and radius based
        authentication.

        :param resource_group_name: The name of the resource group.
        :type resource_group_name: str
        :param virtual_network_gateway_name: The name of the virtual network
         gateway.
        :type virtual_network_gateway_name: str
        :param parameters: Parameters supplied to the generate virtual network
         gateway VPN client package operation.
        :type parameters:
         ~azure.mgmt.network.v2017_10_01.models.VpnClientParameters
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :return: An instance of AzureOperationPoller that returns str or
         ClientRawResponse if raw=true
        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[str] or
         ~msrest.pipeline.ClientRawResponse
        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
        """
        raw_result = self._generate_vpn_profile_initial(
            resource_group_name=resource_group_name,
            virtual_network_gateway_name=virtual_network_gateway_name,
            parameters=parameters,
            custom_headers=custom_headers,
            raw=True,
            **operation_config
        )
        if raw:
            return raw_result

        # Construct and send request
        def long_running_send():
            return raw_result.response

        def get_long_running_status(status_link, headers=None):

            request = self._client.get(status_link)
            if headers:
                request.headers.update(headers)
            header_parameters = {}
            header_parameters['x-ms-client-request-id'] = raw_result.response.request.headers['x-ms-client-request-id']
            return self._client.send(
                request, header_parameters, stream=False, **operation_config)

        def get_long_running_output(response):

            if response.status_code not in [200, 202]:
                exp = CloudError(response)
                exp.request_id = response.headers.get('x-ms-request-id')
                raise exp

            deserialized = self._deserialize('str', response)

            if raw:
                client_raw_response = ClientRawResponse(deserialized, response)
                return client_raw_response

            return deserialized

        long_running_operation_timeout = operation_config.get(
            'long_running_operation_timeout',
            self.config.long_running_operation_timeout)
        return AzureOperationPoller(
            long_running_send, get_long_running_output,
            get_long_running_status, long_running_operation_timeout)

    def _get_vpn_profile_package_url_initial(
            self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, **operation_config):
        # Construct URL
        url = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/getvpnprofilepackageurl'
        path_format_arguments = {
            'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
            'virtualNetworkGatewayName': self._serialize.url("virtual_network_gateway_name", virtual_network_gateway_name, 'str'),
            'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
        }
        url = self._client.format_url(url, **path_format_arguments)

        # Construct parameters
        query_parameters = {}
        query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')

        # Construct headers
        header_parameters = {}
        header_parameters['Content-Type'] = 'application/json; charset=utf-8'
        if self.config.generate_client_request_id:
            header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
        if custom_headers:
            header_parameters.update(custom_headers)
        if self.config.accept_language is not None:
            header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

        # Construct and send request
        request = self._client.post(url, query_parameters)
        response = self._client.send(request, header_parameters, stream=False, **operation_config)

        if response.status_code not in [200, 202]:
            exp = CloudError(response)
            exp.request_id = response.headers.get('x-ms-request-id')
            raise exp

        deserialized = None

        if response.status_code == 200:
            deserialized = self._deserialize('str', response)

        if raw:
            client_raw_response = ClientRawResponse(deserialized, response)
            return client_raw_response

        return deserialized

    def get_vpn_profile_package_url(
            self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, **operation_config):
        """Gets pre-generated VPN profile for P2S client of the virtual network
        gateway in the specified resource group. The profile needs to be
        generated first using generateVpnProfile.

        :param resource_group_name: The name of the resource group.
        :type resource_group_name: str
        :param virtual_network_gateway_name: The name of the virtual network
         gateway.
        :type virtual_network_gateway_name: str
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :return: An instance of AzureOperationPoller that returns str or
         ClientRawResponse if raw=true
        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[str] or
         ~msrest.pipeline.ClientRawResponse
        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
        """
        raw_result = self._get_vpn_profile_package_url_initial(
            resource_group_name=resource_group_name,
            virtual_network_gateway_name=virtual_network_gateway_name,
            custom_headers=custom_headers,
            raw=True,
            **operation_config
        )
        if raw:
            return raw_result

        # Construct and send request
        def long_running_send():
            return raw_result.response

        def get_long_running_status(status_link, headers=None):

            request = self._client.get(status_link)
            if headers:
                request.headers.update(headers)
            header_parameters = {}
            header_parameters['x-ms-client-request-id'] = raw_result.response.request.headers['x-ms-client-request-id']
            return self._client.send(
                request, header_parameters, stream=False, **operation_config)

        def get_long_running_output(response):

            if response.status_code not in [200, 202]:
                exp = CloudError(response)
                exp.request_id = response.headers.get('x-ms-request-id')
                raise exp

            deserialized = self._deserialize('str', response)

            if raw:
                client_raw_response = ClientRawResponse(deserialized, response)
                return client_raw_response

            return deserialized

        long_running_operation_timeout = operation_config.get(
            'long_running_operation_timeout',
            self.config.long_running_operation_timeout)
        return AzureOperationPoller(
            long_running_send, get_long_running_output,
            get_long_running_status, long_running_operation_timeout)

    def _get_bgp_peer_status_initial(
            self, resource_group_name, virtual_network_gateway_name, peer=None, custom_headers=None, raw=False, **operation_config):
        # Construct URL
        url = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/getBgpPeerStatus'
        path_format_arguments = {
            'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
            'virtualNetworkGatewayName': self._serialize.url("virtual_network_gateway_name", virtual_network_gateway_name, 'str'),
            'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
        }
        url = self._client.format_url(url, **path_format_arguments)

        # Construct parameters
        query_parameters = {}
        if peer is not None:
            query_parameters['peer'] = self._serialize.query("peer", peer, 'str')
        query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')

        # Construct headers
        header_parameters = {}
        header_parameters['Content-Type'] = 'application/json; charset=utf-8'
        if self.config.generate_client_request_id:
            header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
        if custom_headers:
            header_parameters.update(custom_headers)
        if self.config.accept_language is not None:
            header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

        # Construct and send request
        request = self._client.post(url, query_parameters)
        response = self._client.send(request, header_parameters, stream=False, **operation_config)

        if response.status_code not in [200, 202]:
            exp = CloudError(response)
            exp.request_id = response.headers.get('x-ms-request-id')
            raise exp

        deserialized = None

        if response.status_code == 200:
            deserialized = self._deserialize('BgpPeerStatusListResult', response)

        if raw:
            client_raw_response = ClientRawResponse(deserialized, response)
            return client_raw_response

        return deserialized

    def get_bgp_peer_status(
            self, resource_group_name, virtual_network_gateway_name, peer=None, custom_headers=None, raw=False, **operation_config):
        """The GetBgpPeerStatus operation retrieves the status of all BGP peers.

        :param resource_group_name: The name of the resource group.
        :type resource_group_name: str
        :param virtual_network_gateway_name: The name of the virtual network
         gateway.
        :type virtual_network_gateway_name: str
        :param peer: The IP address of the peer to retrieve the status of.
        :type peer: str
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :return: An instance of AzureOperationPoller that returns
         BgpPeerStatusListResult or ClientRawResponse if raw=true
        :rtype:
         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_10_01.models.BgpPeerStatusListResult]
         or ~msrest.pipeline.ClientRawResponse
        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
        """
        raw_result = self._get_bgp_peer_status_initial(
            resource_group_name=resource_group_name,
            virtual_network_gateway_name=virtual_network_gateway_name,
            peer=peer,
            custom_headers=custom_headers,
            raw=True,
            **operation_config
        )
        if raw:
            return raw_result

        # Construct and send request
        def long_running_send():
            return raw_result.response

        def get_long_running_status(status_link, headers=None):

            request = self._client.get(status_link)
            if headers:
                request.headers.update(headers)
            header_parameters = {}
            header_parameters['x-ms-client-request-id'] = raw_result.response.request.headers['x-ms-client-request-id']
            return self._client.send(
                request, header_parameters, stream=False, **operation_config)

        def get_long_running_output(response):

            if response.status_code not in [200, 202]:
                exp = CloudError(response)
                exp.request_id = response.headers.get('x-ms-request-id')
                raise exp

            deserialized = self._deserialize('BgpPeerStatusListResult', response)

            if raw:
                client_raw_response = ClientRawResponse(deserialized, response)
                return client_raw_response

            return deserialized

        long_running_operation_timeout = operation_config.get(
            'long_running_operation_timeout',
            self.config.long_running_operation_timeout)
        return AzureOperationPoller(
            long_running_send, get_long_running_output,
            get_long_running_status, long_running_operation_timeout)

    def supported_vpn_devices(
            self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, **operation_config):
        """Gets a xml format representation for supported vpn devices.

        :param resource_group_name: The name of the resource group.
        :type resource_group_name: str
        :param virtual_network_gateway_name: The name of the virtual network
         gateway.
        :type virtual_network_gateway_name: str
        :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>`.
        :return: str or ClientRawResponse if raw=true
        :rtype: str or ~msrest.pipeline.ClientRawResponse
        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
        """
        # Construct URL
        url = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/supportedvpndevices'
        path_format_arguments = {
            'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
            'virtualNetworkGatewayName': self._serialize.url("virtual_network_gateway_name", virtual_network_gateway_name, 'str'),
            'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
        }
        url = self._client.format_url(url, **path_format_arguments)

        # Construct parameters
        query_parameters = {}
        query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')

        # Construct headers
        header_parameters = {}
        header_parameters['Content-Type'] = 'application/json; charset=utf-8'
        if self.config.generate_client_request_id:
            header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
        if custom_headers:
            header_parameters.update(custom_headers)
        if self.config.accept_language is not None:
            header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

        # Construct and send request
        request = self._client.post(url, query_parameters)
        response = self._client.send(request, header_parameters, stream=False, **operation_config)

        if response.status_code not in [200]:
            exp = CloudError(response)
            exp.request_id = response.headers.get('x-ms-request-id')
            raise exp

        deserialized = None

        if response.status_code == 200:
            deserialized = self._deserialize('str', response)

        if raw:
            client_raw_response = ClientRawResponse(deserialized, response)
            return client_raw_response

        return deserialized

    def _get_learned_routes_initial(
            self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, **operation_config):
        # Construct URL
        url = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/getLearnedRoutes'
        path_format_arguments = {
            'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
            'virtualNetworkGatewayName': self._serialize.url("virtual_network_gateway_name", virtual_network_gateway_name, 'str'),
            'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
        }
        url = self._client.format_url(url, **path_format_arguments)

        # Construct parameters
        query_parameters = {}
        query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')

        # Construct headers
        header_parameters = {}
        header_parameters['Content-Type'] = 'application/json; charset=utf-8'
        if self.config.generate_client_request_id:
            header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
        if custom_headers:
            header_parameters.update(custom_headers)
        if self.config.accept_language is not None:
            header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

        # Construct and send request
        request = self._client.post(url, query_parameters)
        response = self._client.send(request, header_parameters, stream=False, **operation_config)

        if response.status_code not in [200, 202]:
            exp = CloudError(response)
            exp.request_id = response.headers.get('x-ms-request-id')
            raise exp

        deserialized = None

        if response.status_code == 200:
            deserialized = self._deserialize('GatewayRouteListResult', response)

        if raw:
            client_raw_response = ClientRawResponse(deserialized, response)
            return client_raw_response

        return deserialized

    def get_learned_routes(
            self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, **operation_config):
        """This operation retrieves a list of routes the virtual network gateway
        has learned, including routes learned from BGP peers.

        :param resource_group_name: The name of the resource group.
        :type resource_group_name: str
        :param virtual_network_gateway_name: The name of the virtual network
         gateway.
        :type virtual_network_gateway_name: str
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :return: An instance of AzureOperationPoller that returns
         GatewayRouteListResult or ClientRawResponse if raw=true
        :rtype:
         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_10_01.models.GatewayRouteListResult]
         or ~msrest.pipeline.ClientRawResponse
        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
        """
        raw_result = self._get_learned_routes_initial(
            resource_group_name=resource_group_name,
            virtual_network_gateway_name=virtual_network_gateway_name,
            custom_headers=custom_headers,
            raw=True,
            **operation_config
        )
        if raw:
            return raw_result

        # Construct and send request
        def long_running_send():
            return raw_result.response

        def get_long_running_status(status_link, headers=None):

            request = self._client.get(status_link)
            if headers:
                request.headers.update(headers)
            header_parameters = {}
            header_parameters['x-ms-client-request-id'] = raw_result.response.request.headers['x-ms-client-request-id']
            return self._client.send(
                request, header_parameters, stream=False, **operation_config)

        def get_long_running_output(response):

            if response.status_code not in [200, 202]:
                exp = CloudError(response)
                exp.request_id = response.headers.get('x-ms-request-id')
                raise exp

            deserialized = self._deserialize('GatewayRouteListResult', response)

            if raw:
                client_raw_response = ClientRawResponse(deserialized, response)
                return client_raw_response

            return deserialized

        long_running_operation_timeout = operation_config.get(
            'long_running_operation_timeout',
            self.config.long_running_operation_timeout)
        return AzureOperationPoller(
            long_running_send, get_long_running_output,
            get_long_running_status, long_running_operation_timeout)

    def _get_advertised_routes_initial(
            self, resource_group_name, virtual_network_gateway_name, peer, custom_headers=None, raw=False, **operation_config):
        # Construct URL
        url = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/getAdvertisedRoutes'
        path_format_arguments = {
            'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
            'virtualNetworkGatewayName': self._serialize.url("virtual_network_gateway_name", virtual_network_gateway_name, 'str'),
            'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
        }
        url = self._client.format_url(url, **path_format_arguments)

        # Construct parameters
        query_parameters = {}
        query_parameters['peer'] = self._serialize.query("peer", peer, 'str')
        query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')

        # Construct headers
        header_parameters = {}
        header_parameters['Content-Type'] = 'application/json; charset=utf-8'
        if self.config.generate_client_request_id:
            header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
        if custom_headers:
            header_parameters.update(custom_headers)
        if self.config.accept_language is not None:
            header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

        # Construct and send request
        request = self._client.post(url, query_parameters)
        response = self._client.send(request, header_parameters, stream=False, **operation_config)

        if response.status_code not in [200, 202]:
            exp = CloudError(response)
            exp.request_id = response.headers.get('x-ms-request-id')
            raise exp

        deserialized = None

        if response.status_code == 200:
            deserialized = self._deserialize('GatewayRouteListResult', response)

        if raw:
            client_raw_response = ClientRawResponse(deserialized, response)
            return client_raw_response

        return deserialized

    def get_advertised_routes(
            self, resource_group_name, virtual_network_gateway_name, peer, custom_headers=None, raw=False, **operation_config):
        """This operation retrieves a list of routes the virtual network gateway
        is advertising to the specified peer.

        :param resource_group_name: The name of the resource group.
        :type resource_group_name: str
        :param virtual_network_gateway_name: The name of the virtual network
         gateway.
        :type virtual_network_gateway_name: str
        :param peer: The IP address of the peer
        :type peer: str
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :return: An instance of AzureOperationPoller that returns
         GatewayRouteListResult or ClientRawResponse if raw=true
        :rtype:
         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_10_01.models.GatewayRouteListResult]
         or ~msrest.pipeline.ClientRawResponse
        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
        """
        raw_result = self._get_advertised_routes_initial(
            resource_group_name=resource_group_name,
            virtual_network_gateway_name=virtual_network_gateway_name,
            peer=peer,
            custom_headers=custom_headers,
            raw=True,
            **operation_config
        )
        if raw:
            return raw_result

        # Construct and send request
        def long_running_send():
            return raw_result.response

        def get_long_running_status(status_link, headers=None):

            request = self._client.get(status_link)
            if headers:
                request.headers.update(headers)
            header_parameters = {}
            header_parameters['x-ms-client-request-id'] = raw_result.response.request.headers['x-ms-client-request-id']
            return self._client.send(
                request, header_parameters, stream=False, **operation_config)

        def get_long_running_output(response):

            if response.status_code not in [200, 202]:
                exp = CloudError(response)
                exp.request_id = response.headers.get('x-ms-request-id')
                raise exp

            deserialized = self._deserialize('GatewayRouteListResult', response)

            if raw:
                client_raw_response = ClientRawResponse(deserialized, response)
                return client_raw_response

            return deserialized

        long_running_operation_timeout = operation_config.get(
            'long_running_operation_timeout',
            self.config.long_running_operation_timeout)
        return AzureOperationPoller(
            long_running_send, get_long_running_output,
            get_long_running_status, long_running_operation_timeout)

    def vpn_device_configuration_script(
            self, resource_group_name, virtual_network_gateway_connection_name, parameters, custom_headers=None, raw=False, **operation_config):
        """Gets a xml format representation for vpn device configuration script.

        :param resource_group_name: The name of the resource group.
        :type resource_group_name: str
        :param virtual_network_gateway_connection_name: The name of the
         virtual network gateway connection for which the configuration script
         is generated.
        :type virtual_network_gateway_connection_name: str
        :param parameters: Parameters supplied to the generate vpn device
         script operation.
        :type parameters:
         ~azure.mgmt.network.v2017_10_01.models.VpnDeviceScriptParameters
        :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>`.
        :return: str or ClientRawResponse if raw=true
        :rtype: str or ~msrest.pipeline.ClientRawResponse
        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
        """
        # Construct URL
        url = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/connections/{virtualNetworkGatewayConnectionName}/vpndeviceconfigurationscript'
        path_format_arguments = {
            'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
            'virtualNetworkGatewayConnectionName': self._serialize.url("virtual_network_gateway_connection_name", virtual_network_gateway_connection_name, 'str'),
            'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
        }
        url = self._client.format_url(url, **path_format_arguments)

        # Construct parameters
        query_parameters = {}
        query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')

        # Construct headers
        header_parameters = {}
        header_parameters['Content-Type'] = 'application/json; charset=utf-8'
        if self.config.generate_client_request_id:
            header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
        if custom_headers:
            header_parameters.update(custom_headers)
        if self.config.accept_language is not None:
            header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

        # Construct body
        body_content = self._serialize.body(parameters, 'VpnDeviceScriptParameters')

        # Construct and send request
        request = self._client.post(url, query_parameters)
        response = self._client.send(
            request, header_parameters, body_content, stream=False, **operation_config)

        if response.status_code not in [200]:
            exp = CloudError(response)
            exp.request_id = response.headers.get('x-ms-request-id')
            raise exp

        deserialized = None

        if response.status_code == 200:
            deserialized = self._deserialize('str', response)

        if raw:
            client_raw_response = ClientRawResponse(deserialized, response)
            return client_raw_response

        return deserialized


In this information center we visit an educational exhibit on the origin and the most important features of the Natural Park Cabo de Gata.
March, April and May From 10h to 15h.
Easter week, First fortnight June and last fortnight September From 10h to 17h.
This informative building is adjacent to the lighthouse of Cabo de Gata and the Gazebo of Sirens' reef. It offers tours, to others of leaflets, maps, information on activities, schedules, etc..
October, November and December Holidays.
Address: Avenida de San José 27, San José, Níjar.
Tour of the Natural Park Cabo de Gata, offering maps, marked routes, information on hotels and other entertainment activities. It also has to store where andou can buand souvenirs, maps, books, pictures, etc..
Another tour desk on the beach of San José.
This small information booth found in the road that crosses the Pozo de Los Frailes, and that leads to San Jose. It is next to an old waterwheel Arab heritage that was used to draw water.
Address: Street Terrera de Mágina , s/n La Isleta del Moro.
This tourist information desk is located in the town of La Isleta del Moro , next to to gazebo. Next to this house begins the path that leads from the Isleta until Escullos, is to walk of less than an hour running through beaches and cliffs of great beauty. Here is to pdf document on the Isleta-Escullos route.
Januarand, February, October and November Open in holidays. Rest of days Closed.
Address: Road AL-4200, between La Isleta del Moro and Rodalquilar.
This information point next to the viewpoint of the Amatista , from which are lovely views from the cliffs of Cabo de Gata Natural Park. This viewpoint provides tourist information and the posiblilidad to buy souvenirs.
This building, called House of Volcanoes, apart from receiving informacióny souvenirs, visit an exhibition. It through audiovisual, information panels and photographs can learn more about the geology of the park. As to retrospective on the golden age of Rodalquilar, when the gold mines exploited.
Next door is the Albardinal garden, to botanical garden where you can see to variety of plant species.
Address: From road N-341 (to Carboneras), take road AL-5106.
The information kiosk is located next to the viewpoint of the Punta de los Muertos with spectacular views of this part of the coast of Almeria. Fromsde information point there is to road that goes down has the Playa de Los Muertos, one of the most beautiful beaches in Spain.
At this point, also begins to path that runs from the tip of Los Muertos to Agua Amarga, through the hill Mesa Roldán. Here you can download to PDF with the route Los Muertos - Agua Amarga.


text:
World Affairs Forum
China Learns the Hard Way That Money Can't Buy You Love
Thread starter Viet
BY SALVATORE BABONES | OCTOBER 14, 2020, 5:15 AM
Chinese Premier Lie Keqiang and Australian then-Prime Minister Malcolm Turnbull during a state visit in Sydney on Mar. 25, 2017. DAVID GRAY/AFP VIA GETTY IMAGES
China has long had Australia in its sights, and money is its favored weapon. China accounts for roughly a third of Australia's export earnings. Until recently, it was also a big investor in Australia.
Chinese international students occupy 10 percent of all university places in Australia, and Beijing has funded Confucius Institutes at 13 of Australia's 37 public universities. China-linked donors fundseveral Australian think tanks advancing China-friendly policies.
Nearly every major public institution in Australia has a "China strategy." China's presence looms even larger in Australia's much smaller neighbor, New Zealand. If there's one region of the (notionally) Western world where China has staked its claim to the future, it's in the Antipodes.
Yet the proportion of Australians who hold a favorable view of China has plummeted from 64 percent to just 15 percent over the last three years, according to a Pew Global Attitudes poll released last week. (New Zealand wasn't surveyed.) The proportion of Australians who view China unfavorably has risen to 81 percent, with only 3 percent undecided.
Australia's changing mood on China is part of a global shift, but it's the most extreme reversal among the 12 countries Pew regularly surveys and started before the coronavirus. Despite a widespread and long-standing perception in Australia that its economic future depends on China, it turns out that—at least when it comes to public diplomacy—money can't buy you love.
China has certainly spent the money. Australian ethics professor Clive Hamilton's 2018 book Silent Invasion traced the many paths through which Chinese and China-linked money has informed and potentially influenced Australia's public debates, from massive donations to political parties to the takeover of local Chinese-language media to luxury junkets for journalists and politiciansto visit China.
The controversial China-born and based businessman (and Australian citizen) Chau Chak Wing has given tens of millions of dollars to Australian universities—and has made a series of donations to patriotic Australian causes like veterans' charities and the Australian War Memorial. A confidant of Chinese President Xi Jinping, he has fought—and won—repeated lawsuitsagainst Australian media that accused him of bribery and spying for China.
The proportion of Australians who hold a favorable view of China has plummeted from 64 percent to just 15 percent over the last three years.
On an even larger scale, between 2016 and 2018 at least eight Chinese state-owned and state-linked firms poured investment into the Australian state of Victoria, which then officially signed onto China's Belt and Road Initiative in defiance of the national government's warnings against doing so.
Victoria's state premier, Daniel Andrews, attended China's flagship Belt and Road forums in Beijing in both 2017 and 2019, one of the few leaders below central government level to be invited. Australia's national government did not participate. Perhaps coincidentally—and perhaps not—when China slapped tariffs and restrictions on Australian agricultural exports earlier this year, products from Victoria were largely unaffected.
Whether or not they were influenced by Chinese inducements, by 2018 many leading members of Australia's political class were heeding China's call for the country to pursue an "independent" foreign policy, meaning free from its historical alliance with the United States. Former Prime Ministers Paul Keating (in office 1991-1996) and the late Malcolm Fraser (1975-1983) actually recommended that Australia withdraw from its U.S. alliance, while the late Bob Hawke (1983-1991) made a lucrative second career out of lobbying for Beijing.
A senior senator and former government minister even criticized a government-funded think tank, the Australian Strategic Policy Institute, for accepting a research grant from the U.S. State Department. Pro-China, anti-American viewpoints had become eminently respectable in Australia.
Meanwhile, the Australian public continued to support the country's alignment with the United States and express skepticism about its burgeoning links with China.
Between 2008 and 2020, public support for the U.S. alliance never dipped below 70 percent, according to the Australian Lowy Institute Poll. The majority of respondents consistently believed that the Australian government was allowing too much investment from China. And despite the personal unpopularity of U.S. President Donald Trump, the majority of Australians continue to trust the United States to "act responsibly in the world," compared to just 23 percent who say the same about China.
As Abraham Lincoln never said, "You can fool all of the people some of the time and some of the people all of the time, but you can't fool all of the people all of the time." If Hamilton's Silent Invasion got people talking about Chinese influence in Australia in 2018, a real turning point came in 2019 when U.S. Secretary of State Mike Pompeo warned Australians: "You can sell your soul for a pile of soybeans, or you can protect your people." Of course, Australia doesn't actually sell soybeans, but Pompeo's point hit home, resonating with an Australian public that was already wary about Chinese influence undermining their country's institutions.
Had China simply run its public diplomacy through a competent corporate communications firm, it might have avoided a breakdown in relations.
Then came the coronavirus. As in many other countries, China's early misinformation about the pathogen dealt a serious blow to its credibility in Australia. But we should not overestimate the effects of the pandemic on Australia's attitudes toward China. Relying on World Health Organization advice, the country's chief medical officer even expressed confidence in China's ability to prevent the international spread of the virus, while a leading Victorian state politician praised China's lockdown response. The coronavirus has been a disaster for the world, but it didn't have to be a disaster for China's international relations.
But that was before China lashed out, in response to a call by Australian Prime Minister Scott Morrison and Foreign Secretary Marise Payne for an international inquiry into the world's handling of the coronavirus. Never mind that the inquiry would be conducted by the China-dominated World Health Organization, or that China itself ended up signing the resolution to authorize the inquiry. China's embassy in Australia complained that "Australian politicians are keen to parrot what those Americans have asserted and simply follow them in staging political attacks on China." The Foreign Ministry in Beijing went much further, saying thatAustralia was "highly irresponsible to resort to politically motivated suspicion and accusation" and advising Australia "to put aside ideological bias and political games." And as China's deputy head of mission in Canberra explained, Australia's call for an investigation "hurts the feelings of the Chinese people … all of a sudden, they heard this shocking news of a proposal coming from Australia, which is supposed to be a good friend of China."
Taken aback by Australia's apparent insensitivity to the "feelings of the Chinese people," China's own diplomats seemed strangely unconcerned about the effects their own comments might have on the feelings of the Australian people. Despite China's extraordinary access to Australian politicians and public life, its diplomats proved either unable to comprehend the dynamics of democratic decision-making or unwilling to bend to its demands.
Had China simply run its public diplomacy through a competent corporate communications firm, it might have avoided anything worse than a brief coronavirus pause in its march through Australia's institutions.
Now that China has turned itself into an international pariah, the gravy train that has fattened so many Western wallets will grind to a halt.
Few countries have soured more rapidly against China than Australia, as decades of influence-building by Beijing come to naught.
foreignpolicy.com
kankan326
China will be the first ever non-White country that becomes world dominant power since Industrial Revolution. Australians don't want to trade their White superiority complex for money. They simply don't.
beijingwalker
We still do business with Aussies, what love does China need from Australia? Fighting wars for China?
Their current PM is a right wing zealous Christian, replace him and relations will get better. The CIA probably put him in power there.
Zsari
Viet said:
Rather Australia will learn it the hard way, don't bite the hands that feeds you.
Titanium100
kankan326 said:
Are you for real? Seems like the history you know is only from the 18s and 19s.
There have been multiple Islamic Dynasties ruling the world and not to forget the Mongols and ancient Egypt and Bablyonian empire.
Angry: 1
Titanium100 said:
"Since industrial revolutions....." Read his reply again.
"Oderint, dum metuant" - Roman Emperor Caligula
It means let them hate as long as they fear.
FairAndUnbiased
Australia doesn't need to love China, they just need to act in a way that fulfills Chinese interests or be punished for not doing so.
peagle
The lesson isn't that money cant buy love. The lesson is that the whites will always prefer white, no matter how good you are to them, that is the lesson. Individually they are a lovely bunch, but nationally, its a different picture.
Pick your friends wisely and you will have a secure future. Because for them if you are not white then their relationship with you is always transactional, and not a bond.
Look at Turkey, it bent over backwards so it could join the European Union, but they would not accept them, because the Turks are not pure whites and also Muslims.
Place Of Space
Money can buy a whore.
Haha: 2
thewayoftheworld
Australia was never going to side with an Asian power against their Anglo brother. Anglo-American have serious superiority complex that allows them reason their crimes against humanity and genocide of native population around the world.
China should arm the Aborigines against their struggle for independent from racist Anglo.
redtom
In a corrupt country, it is better to give money to the politicians the state than to give money to the state.
How many countries' politicians own a lot of property in the US?
How many countries have their media controlled by the US?
How many people get their news through social media in the US?
Since Australians feel they have to support American foreign policy at the cost of their lives, we don't care .
But also a warning to other countries: are you willing to die for the US?
hualushui
Three years of negative media reports have brainwashed the entire country. How can you say that you think independently?
TheTruth
China is learning it doesn't need the love of Indians and their white masters.
PM Narendra Modi Interview: 'Khan Market gang hasn't created my image, 45 years of tapasya has…
Andhadhun
A Week In Xinjiang's Absolute Surveillance State
Tresbon
What it's like to work in a Chinese mega-factory, according to a student who spent 6 weeks there
Hamartia Antidote
Ashraf Ghani: The Theorist in the Palace
President Duterte Of The Philippines For Dummies (good read)
JayMandan
chauism
France offers India a huge package of 36 more Rafales, 6 A330 MRTT & 100 Panthers
Latest: Oracle
How Pakistan lost $6 billion on a gold mine
China Focus: Tibet basically eliminates absolute poverty
Latest: beijingwalker
JF-17 Block-3 -- Updates, News & Discussion
Latest: AsifIjaz
Latest: surya kiran
Featured Pakistan: When Agents Ruled – a glimpse of Spying, Espionage and Security Breaches
Pakistan's Internal Security
Pakistan's Service Rifle (G-3, Type-56) Replacement Competition 2016.
Karandaaz Launches Data Portal on Financial Indicators
Latest: Morpheus
PM for fast-tracking establishment of border markets along Afghan, Iran bordering areas
Latest: ghazi52
Infrastructure & Development
Pakistan Export Updates
Latest: Gomig-21
Many PLA units move the camps to higher locations in 2020, new military tractors put in use for high mountain terrains
Latest: Itachi
Indian, French Rafale fighters kickstart Desert Knight wargames
Latest: khansaheeb
Historical photo and video
Latest: vostok
Russian Defence Forum
Indian and Chinese Armour Face to Face Just Few Meters From the LAC
Latest: FOOLS_NIGHTMARE

redpajama_set_name: RedPajamaCommonCrawl


Hainan has been declared as a World Longevity Island by the International Expert Committee on Population Aging and Longevity (ISCPAL).
Alongside South Korea's Jeju Island, Hainan was named one of the world's two longevity islands thanks to its outstanding natural environment and social welfare system. The committee decided to honor the province after conducting field research in 17 towns and counties in 2013.
Hainan trumpets a record of more than 1,900 centenarians, and about 1.2 million residents above the age of 60 by the end of 2013, amounting for about 13.36 percent of its total population, according to the the provincial committee on aging. By 2015, the number of octogenarians is expected to reach 170,000.


NikaFriend . VoluptuousDoll. XtreamLeonard. LoraBlu.
kayahottValeryMelonsCherrieDollmissalice3 .AaronSweetestAmandaMintBeautyHikariKloePunishGame .KinkyKarmenHeavenScentCOCKAmaliaLewisKingChris1 .Linda2NicoleRachellAdamsWetLips4Y0u2latinpigeons .MaiyCapricornusChloeCrystal1WildSeductiveTS .EleEvansAnnaHotusaAlexaMorrenoMarselolalala .AaronSweetestaronandrandyValeryMelonswelldamn23 .JamesCarsonAmaliaLewisoszitestDONOVAN11INCHS .AmyLingAmandaMintHotMellicentaxxxgeoxxx .ValeryMelonsCurvyChicBarbaraisabellle19isabellle19 .SweetCockyGuyX2tsCOCKFIGHTINGMarselolalalaHotMellicenta .
SophiaHotLove2tsCOCKFIGHTINGDANNYVIDALEroticEbony21 .SophiaHotLoveDirtylatina666EasternTemptressLinda2Nicole .CHRISANDJEANEasternTemptressKingChris1isabellle19 .ByankaKDDONOVAN11INCHS1WildSeductiveTSwelldamn23 .WelcomingRobinKingChris1GabiyAliceNN .HeavenScentCOCKSmileyGellyEroticEbony21LoraBlu .EleEvansoszitestsoswitchymalibuhot19 .ByankaKD1WildSeductiveTSBustyPamXtreamLeonard .AsianTSJASTINEWetLips4Y0uHOTLALAINEByankaKD .samjulesEleEvanssamjulesWildCOCKDRIVERS .SweetEve69NadiaKissLoraBluBeautyHikari .


Furniture — This furniture, is one of the 18 designs published under the gallery: Styles Of Barn Doors For Homes Interior. In the next page, we have the barn doors for homes interior inspiring worthy interior sliding barn door white amazing interior best [ ... ]. While in	the previous page, we have the barn doors for homes interior inspiring fine interior sliding barn doors for homes the custom [ ... ].


text:
<!DOCTYPE html>

    <meta charset="utf-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />

    <title>Transient - gudhakesa</title>

    <meta name="HandheldFriendly" content="True">
    <meta name="MobileOptimized" content="320">
    <meta name="apple-mobile-web-app-capable" content="yes">
    <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent">
    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">

    <meta name="description" content="">

    <meta name="twitter:card" content="summary">
    <meta name="twitter:title" content="Transient">
    <meta name="twitter:description" content="">

    <meta property="og:type" content="article">
    <meta property="og:title" content="Transient">
    <meta property="og:description" content="">

    <link href="/favicon.ico" rel="shortcut icon" type="image/x-icon">
    <link href="/apple-touch-icon-precomposed.png" rel="apple-touch-icon">

    <link rel="stylesheet" type="text/css" href="//gudhakesa.com/themes/uno/assets/css/uno.css?v=1517448627259" />

    <link rel="canonical" href="http://gudhakesa.com/2011/11/21/Transient.html" />
    <meta name="referrer" content="origin" />

    <meta property="og:site_name" content="gudhakesa" />
    <meta property="og:type" content="website" />
    <meta property="og:title" content="Transient" />
    <meta property="og:description" content="" />
    <meta property="og:url" content="http://gudhakesa.com/2011/11/21/Transient.html" />
    <meta property="article:tag" content="pictures" />

    <meta name="twitter:card" content="summary" />
    <meta name="twitter:title" content="Transient" />
    <meta name="twitter:description" content="" />
    <meta name="twitter:url" content="http://gudhakesa.com/2011/11/21/Transient.html" />

    <meta name="generator" content="HubPress" />
    <link rel="alternate" type="application/rss+xml" title="gudhakesa" href="http://gudhakesa.com/rss/" />

gudhakesa

                words,
                pictures,
                and me

Words

Pictures

About

                      Twitter

                      Instagram

                      Flickr

                      Email

        <time datetime="21 Nov 2011" class="post-meta__date date">21 Nov 2011</time> • on pictures
         by Mahendra Gudhakesa

Transient

                 Next Post →
                © 2018. All rights reserved.
                Proudly published with Hubpress

redpajama_set_name: RedPajamaGithub


text:
class CreateDynamicRadioButtons < ActiveRecord::Migration
  def self.up
    create_table :dynamic_radio_buttons do |t|
      t.timestamps
      t.integer :default_item_id
      t.boolean :combine_option_groups
      t.string :missing_value_error
    end
  end

  def self.down
    drop_table :dynamic_radio_buttons
  end
end


It looks like Victoria and David Beckham have a budding pop star on their hands. The talented couple's 11-year-old son, Cruz Beckham, just recorded a cover of Justin Bieber and Cody Simpson's "Home to Mama," and his young voice sounds so good on the mellow track.
Proud big brother Brooklyn Beckham posted the link to Instagram with a picture of Cruz playing guitar by the fireplace. "Check out my little brother singing with @codysimpson and #justinbieber," he wrote on Instagram.
In the song, posted to his SoundCloud account, Cruz harmonizes on the chorus and showcases an angelic voice. His soft soprano tone sounds adorable next to the pop stars' vocals, and he can definitely carry a tune.
This isn't the first time we've gotten to hear the talented preteen sing: Mum and Dad have shared clips to Instagram of their "little man" showing off his passion. He's sung Anna Kendrick's hit "Cups," covered "Hope" by Twista, and even danced to "Pony" for the camera.
We have a feeling this little guy has a long, fruitful career ahead of him.


In the sixth-season finale, Byron must decide if he wants to propose to one of his final ladies-in-waiting or walk away from both. But before a decision is given, it's off to pick engagement rings just in case. Chris Harrison hosts.


I was introduced to the medicinal qualities of marijuana by fellow Vietnam-era veterans, after I sustained injuries that left myself wheelchair-bound and subject to chronic pain. I know what it' s like to be without an effective, reliable way to manage the pain and maintain an active life.
Because of the ever-increasing popularity, demand and success of the Medicine Man Superior Strains, I created in-collective signage to insure that patients are provided with superior products for medicinal use without interfering with one's active lifestyle.
It is for these reasons, I personally make sure that all Grand Daddy Purp (GDP) strains, seed lots, equipment, manuals and supplies are priced to be affordable. For me, it' s not about owning Lear Jets and a Rolls Royces, it' s about helping people find relief for their medical conditions at a fair price.
As you browse our offerings, I know you' ll find fair prices and outstanding values.


We are now in the closing hours of 2011. One of the aspects of life today (and I am sure it will be true in 2012 as well) is that we rely so much on experts to address the various questions we face. Health issue? See a doctor, and if (s)he does not know, you can get a referral to a specialist. Computer problem? You find either a hardware or a software expert to help you. In almost any area of life we turn to experts for advice and help. This usually works out, but sometimes blindly following experts can lead us into a worse predicament. Witness our ongoing global economic crisis – instigated first by the 'experts' running US financial institutions, and more recently by the 'experts' who configured and managed the Eurozone. It is interesting that there are thousands of expert economists who make a living giving us economic advice … and maybe about a dozen of them saw the economic disaster coming.
So it pays to have practical and common-sense checks to test against the advice of experts. This is all the more true when it comes to claims and statements by 'experts' when it comes to the Bible. Bart Ehrman is one such New Testament scholar who has gained much notoriety for his public attacks on the gospel. The title of one of his books, Misquoting Jesus: The Story Behind Who Changed the Bible and Why (2005) tells us what he thinks of the reliability of the text of the Bible. And since he is one of these 'experts' who are we to argue? For many, just reading the title of his book closes the case for them.
But New Year's Eve 2011 is a last-minute reminder of a common-sense and reasoned test for the reliability of the Bible. For 2011 is the 400th anniversary of the publication of the Authorized King James Bible. Yes, this translation that has so shaped the English language through modern history is on the verge of passing its 4th centennial!
The timeline figure below from time of Jesus until today shows the extent of the time period in which the 24000 manuscripts of the New Testament that are extant (i.e. in existence today) were being copied (the thick white bar labelled '24000 NT MSSs'). Extant copies are dated starting from 125 AD and continue until about 1250 AD. This is what we covered in Session 3. No one – Bart Ehrman included – disputes this.
Our next figure shows the manuscript source for the venerable King James Version (KJV). It was a 16th century scholar named Erasmus who first produced a Greek text from which the KJV was translated. But where did Erasmus get his Greek text? As you can see from the red oval it was from a few very late Greek manuscripts, dated well into the 2nd millennium, from which Erasmus obtained his text (called the Textus Receptus or Received Text) and from which the KJV was developed. No one disputes this – Bart Ehrman included. In fact, his book is an easy-to-read description of how this transpired.
The reason that Erasmus used just a handful of very late manuscripts for his Greek Edition was that in 1515 AD no others were on hand. He used the best he could find. But since 1515 AD thousands more have been discovered (which is why we now have 24000 manuscripts catalogued) and many much earlier, even preceding Constantine (325 AD).
Our third figure shows, with this modern catalogue of manuscripts to draw from, the manuscript source for present-day translations (like NIV, ESV, NLT etc.). They draw from the earliest and best manuscripts that scholarship and archaeology today provides, and which were unavailable to the translators of the KJV in 1611. Again, this was covered in Session 3, and as with our other points, no one today – Ehrman included – disputes this.
To put it in another way – the translators of the KJV used (by today's scholarly standards) the latest and least reliable manuscripts (their source manuscripts were later than 1000 AD). And today we know we are very close to the original text with an extremely high standard (see session 3) because of the much earlier texts that were discovered after the making of the KJV. So these advances give us a superb common-sense and practical way to test the reliability of the New Testament. We simply need to ask the question: What teaching or belief changes took place when gospel followers went from the KJV (the least reliable) to the modern versions (the most reliable)? Was the person and work of Jesus, the historical events portrayed, or teachings outlined in the epistles 'adjusted' in some way? For example, was there anything even remotely close to an adjustment on the order of a Da Vinci Code? No! In point of fact nothing changed! Today you can find gospel followers worldwide – some using the KJV and others using a modern translation – and no difference in their understanding or following of the gospel come as a result of their divergent translations.
Our fourth figure illustrates this schematically. We know (in step 1) that what is purported to be 'very different' by scholars such as Ehrman is in reality a small difference since the KJV teaches the same thing as the modern translations. So therefore (in step 2) we know that what is now a smaller difference between our current textual base and the originals must be small indeed. We have a solid textual base and can confidently say (Ehrman notwithstanding) that the Bible has not changed.
The same test is available for the Old Testament. In 1611 the only practical Hebrew text for the Old Testament was the Masoretic text dated at around 900 AD. The most modern translations of the Old Testament can make use of the Dead Sea Scrolls dated at 100 BC. (We look at the Old Testament in the 2nd video of Session 3). And you will find no 'adjustment' in the history and teachings between the KJV and these modern translations. They tell the same account.
Ehrman's book title aside, and despite his intent to denigrate the textual reliability of the Bible, his own account of the textual development of the KJV, and a common-sense check for any 'adjustments' in teaching or belief stemming from the KJV to a modern translation reveals the hollowness of his claim. Sometimes it pays to not to blindly accept 'expert' opinion by faith like so many do today. Common-sense reasoning from the verifiable facts on-hand is the safest way to go. On the passing of the 400th anniversary of the KJV It is a good reminder that it provides us with a dataset with which we can consider the gospel in just such a way.
Author RagnarPosted on 31/12/2011 Categories 3. Assessing 'The Book' - Considering the Textual Reliability of the Bible, UncategorizedTags Bart Ehrman, bart ehrman and misquoting Jesus, Bible Manuscripts, Bible reliability, Consider the Gospel, Erasmus, has bible changed, Is the Bible reliable, is the bible true, King Jams Version, KJV, misquoting Jesus, Textus Receptus, who changed the bible?