<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def handle(self, connection_id, message_content):
 """ The simplest authorization type will be Trust. If Trust authorization is enabled, the validator will trust the connection and approve any roles requested that are available on that endpoint. If the requester wishes to gain access to every role it has permission to access, it can request access to the role ALL, and the validator will respond with all available roles. If the permission verifier deems the connection to not have access to a role, the connection has not sent a ConnectionRequest or a the connection has already recieved a AuthorizationTrustResponse, an AuthorizatinViolation will be returned and the connection will be closed. """

        if self._network.get_connection_status(connection_id) != \
                ConnectionStatus.CONNECTION_REQUEST:
            LOGGER.debug("Connection's previous message was not a"
                         " ConnectionRequest, Remove connection to %s",
                         connection_id)
            violation = AuthorizationViolation(
                violation=RoleType.Value("NETWORK"))
            return HandlerResult(
                HandlerStatus.RETURN_AND_CLOSE,
                message_out=violation,
                message_type=validator_pb2.Message
                .AUTHORIZATION_VIOLATION)

        request = AuthorizationTrustRequest()
        request.ParseFromString(message_content)

        # Check that the connection's public key is allowed by the network role
        roles = self._network.roles
        for role in request.roles:
            if role == RoleType.Value("NETWORK") or role == \
                    RoleType.Value("ALL"):
                permitted = False
                if "network" in roles:
                    permitted = self._permission_verifier.check_network_role(
                        request.public_key)
                if not permitted:
                    violation = AuthorizationViolation(
                        violation=RoleType.Value("NETWORK"))
                    return HandlerResult(
                        HandlerStatus.RETURN_AND_CLOSE,
                        message_out=violation,
                        message_type=validator_pb2.Message
                        .AUTHORIZATION_VIOLATION)

        self._network.update_connection_public_key(connection_id,
                                                   request.public_key)

        if RoleType.Value("NETWORK") in request.roles:
            # Need to send ConnectionRequest to authorize ourself with the
            # connection if they initialized the connection
            try:
                is_outbound_connection = self._network.is_outbound_connection(
                    connection_id)
            except KeyError:
                # Connection has gone away, drop message
                return HandlerResult(HandlerStatus.DROP)

            if not is_outbound_connection:
                self._network.send_connect_request(connection_id)
            else:
                # If this is an outbound connection, authorization is complete
                # for both connections and peering can begin.
                self._gossip.connect_success(connection_id)

        auth_trust_response = AuthorizationTrustResponse(
            roles=[RoleType.Value("NETWORK")])

        LOGGER.debug("Connection: %s is approved", connection_id)

        self._network.update_connection_status(
            connection_id,
            ConnectionStatus.CONNECTED)

        return HandlerResult(
            HandlerStatus.RETURN,
            message_out=auth_trust_response,
            message_type=validator_pb2.Message.AUTHORIZATION_TRUST_RESPONSE)