Asserts bulkheads by ensuring that the rate of requests to other dests is kept when slow_dest is slow
        :param source the source service name
        :param dependencies list of dependency names of source
        :param slow_dest the name of the dependency that independence is being tested for
        :param rate number of requests per second that should occur to each dependency
        :return:

def check_bulkhead(self, source, dependencies, slow_dest, rate):
        """
	Asserts bulkheads by ensuring that the rate of requests to other dests is kept when slow_dest is slow
        :param source the source service name
        :param dependencies list of dependency names of source
        :param slow_dest the name of the dependency that independence is being tested for
        :param rate number of requests per second that should occur to each dependency
        :return:
        """
        #Remove slow dest
        dependencies.remove(slow_dest)


        s =str(float(1)/float(rate))
        max_spacing = _parse_duration(s+'s')

           
        
        for dest in dependencies:
            data = self._es.search(body={
                "size": max_query_results,
                "query": {
                    "filtered": {
                        "query": {
                            "match_all": {}
                        },
                        "filter": {
                            "bool": {
                                "must": [
                                    {"term": {"msg": "Request"}},
                                    {"term": {"source": source}},
                                    {"term": {"dest": dest}},
                                    {"term": {"testid": self._id}}
                                ]
                            }
                        }
                    }
                }
            })

            if self.debug:
                pprint.pprint(data)

            result = True
            errormsg = ""
            if not self._check_non_zero_results(data):
                result = False
                errormsg = "No log entries found"
                return GremlinTestResult(result, errormsg)

            req_seq = _get_by("source", source, data["hits"]["hits"])
            req_seq.sort(key=lambda x: isodate.parse_datetime(x['_source']["ts"]))

            last_request = isodate.parse_datetime(req_seq[0]['_source']["ts"])

            for req in req_seq:
                req_spacing = isodate.parse_datetime(req['_source']["ts"]) - last_request
                last_request = isodate.parse_datetime(req['_source']["ts"])
                if self.debug:
                    print "spacing", req_spacing, max_spacing
                if req_spacing > max_spacing:

                    errormsg = "{} -> {} - new request was issued at ({}s) but max spacing should be ({}s)".format(source,
                                                                                                                     dest,
                                                                                                                     req_spacing,
                                                                                                                     max_spacing) 
                    result = False
                    return GremlinTestResult(result, errormsg)                
                

                

        return GremlinTestResult(result, errormsg)