def is_response_valid_initial_check(self, response):
        if( not header_keys['MAGIC_NUM_1'] in response 
            or not header_keys['MAGIC_NUM_2'] in response 
            or response[header_keys['MAGIC_NUM_1']] != MAGIC_NUMBER_1
            or response[header_keys['MAGIC_NUM_2']] != MAGIC_NUMBER_2 ):
            raise MalformedRequestException("Magic Numbers Set Incorrectly")

        if( not header_keys['OPCODE'] in response ):
            raise MalformedRequestException("Missing OPCODE in response")
    def process_response(self, response):
        if( response[header_keys['OPCODE']] == opcodes['FAILED_SUBSCRIBE_ACK'] ):
            print("subscribe_ack#failed")

            if( header_keys['ERROR_MESSAGE'] in response ):
                err_message = response[header_keys['ERROR_MESSAGE']]
            raise MalformedRequestException("Subscribe Failed from Server: {}".format(err_message))

        if( response[header_keys['OPCODE']] != opcodes['SUCCESSFUL_SUBSCRIBE_ACK'] ):
            raise MalformedRequestException("SUBSCRIBE_ACK expected in response")

        print("subscribe_ack#successful")

        self.state_completed = True
    def transition_to_state(self, state ):
        with self.state_lock:
            if( not self.curr_state is None and not self.curr_state.state_transition_permitted() ):
                raise MalformedRequestException("Invalid state change")

            self.curr_state = state
            self.curr_state.start_state()
    def process_response(self, response):
        if( response[header_keys['OPCODE']] != opcodes['LOGOUT_ACK'] ):
            raise MalformedRequestException("LOGOUT_ACK expected in response")

        # Reset the token
        messaging_system.client.token_holder.token = None

        print("logout_ack#successful")

        self.state_completed = True
    def process_response(self, response):
        if (response[header_keys['OPCODE']] == opcodes['FAILED_LOGIN_ACK']):
            print("login_ack#failed")

            if (header_keys['ERROR_MESSAGE'] in response):
                err_message = response[header_keys['ERROR_MESSAGE']]
            raise MalformedRequestException(
                "Login Failed from Server: {}".format(err_message))

        if (response[header_keys['OPCODE']] !=
                opcodes['SUCCESSFUL_LOGIN_ACK']):
            raise MalformedRequestException("LOGIN_ACK expected in response")

        if (not header_keys['TOKEN'] in response):
            raise MalformedRequestException("TOKEN expected in response")

        # Get and store token in global module
        token = response[header_keys['TOKEN']]
        messaging_system.client.token_holder.token = token

        print("login_ack#successful")

        self.state_completed = True
    def process_response(self, response):
        if (response[header_keys['OPCODE']] == opcodes['RETRIEVE_ACK']):
            retrieved_message = response[header_keys['MESSAGE']]
            from_username = response[header_keys['FROM_USERNAME']]

            print("{from_username} : {retrieved_message}".format(
                from_username=from_username,
                retrieved_message=retrieved_message))
        elif (response[header_keys['OPCODE']] == opcodes['END_OF_RETRIEVE_ACK']
              ):
            self.state_completed = True
        else:
            raise MalformedRequestException(
                "RETRIEVE_ACK expected in response")
    def handle_forwarding(self, response):
        if (response[header_keys['OPCODE']] != opcodes['FORWARD']):
            return False

        if (not header_keys['FROM_USERNAME'] in response
                or not header_keys['MESSAGE'] in response):
            raise MalformedRequestException(
                "Missing FROM_USERNAME or MESSAGE in forward packet")

        from_username = response[header_keys['FROM_USERNAME']]
        message = response[header_keys['MESSAGE']]
        print("{from_username} : {message}".format(from_username=from_username,
                                                   message=message))

        return True
    def process_response(self, response):
        with self.state_lock:
            if( self.curr_state is None ):
                raise MalformedRequestException("Cannot process response from an empty state")

            self.curr_state.process_response(response)