func doTestProxy(t *testing.T, origin *httptest.Server, server *httptest.Server, disableKeepAlives bool) {
u, _ := url.Parse(server.URL)
client := &http.Client{Transport: &http.Transport{
Dial: func(network, addr string) (net.Conn, error) {
conn, err := net.Dial("tcp", u.Host)
if err == nil {
initReq, reqErr := http.NewRequest("GET", fmt.Sprintf("http://%v", addr), nil)
if reqErr != nil {
return nil, fmt.Errorf("Unable to construct initial request: %v", reqErr)
}
initReq.Header.Set(XLanternPersistent, "true")
writeErr := initReq.Write(conn)
if writeErr != nil {
return nil, fmt.Errorf("Unable to write initial request: %v", writeErr)
}
}
return conn, err
},
DisableKeepAlives: disableKeepAlives,
}}
// Do a simple GET
if !testGet(t, client, origin) {
return
}
// Do another GET to test keepalive functionality
if !testGet(t, client, origin) {
return
}
// Forcibly close client connections and make sure we can still proxy
origin.CloseClientConnections()
testGet(t, client, origin)
}
func (t *WebRuleTest) TestHandleHttpFailures(c *C) {
var s *httptest.Server
s = httptest.NewServer(
http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
s.CloseClientConnections()
}))
r := NewWebRule(
"test rule",
s.URL,
"cats",
"dogs")
sane, triggered := r.TestTriggered()
c.Check(sane, Equals, false)
c.Check(triggered, Equals, false)
}
logger *lagertest.TestLogger
token *fake_token.FakeToken
server *httptest.Server
)
BeforeEach(func() {
token = &fake_token.FakeToken{}
database = &fake_db.FakeDB{}
logger = lagertest.NewTestLogger("event-handler-test")
handler = *handlers.NewEventStreamHandler(token, database, logger)
})
AfterEach(func(done Done) {
if server != nil {
go func() {
server.CloseClientConnections()
server.Close()
close(done)
}()
} else {
close(done)
}
})
Describe(".EventStream", func() {
var (
response *http.Response
eventStreamDone chan struct{}
)
BeforeEach(func() {
func TestSuperviceRetrieLimit0(t *testing.T) {
buf.Reset()
var wg sync.WaitGroup
var server *httptest.Server
var counter int
var h http.HandlerFunc = func(w http.ResponseWriter, r *http.Request) {
if counter > 0 {
server.CloseClientConnections()
}
fmt.Fprintln(w, "Hello")
counter++
}
server = httptest.NewServer(h)
defer server.Close()
log_s := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Header.Get("User-agent") != "epazote" {
t.Error("Expecting User-agent: epazote")
}
decoder := json.NewDecoder(r.Body)
var i map[string]interface{}
err := decoder.Decode(&i)
if err != nil {
t.Error(err)
}
// check exit
if i["exit"].(float64) != 0 {
t.Errorf("Expecting: 0 got: %v", i["exit"])
}
// check retries
if _, ok := i["retries"]; ok {
t.Errorf("retries key found")
}
// check url
if _, ok := i["url"]; !ok {
t.Error("URL key not found")
}
// check output
if i["status"].(float64) != 200 {
t.Errorf("Expecting status: %d got: %v", 200, i["status"])
}
wg.Done()
}))
defer log_s.Close()
s := make(Services)
s["s 1"] = &Service{
Name: "s 1",
URL: server.URL,
RetryLimit: 0,
RetryInterval: 1,
ReadLimit: 1024,
Log: log_s.URL,
Expect: Expect{
Status: 200,
},
}
ez := &Epazote{
Services: s,
}
wg.Add(1)
ez.Supervice(s["s 1"])()
wg.Wait()
rc := s["s 1"].retryCount
if rc != 0 {
t.Errorf("Expecting retryCount = 0 got: %d", rc)
}
}
// server.CloseClientConnections not workng on golang 1.6
func TestSuperviceRetrie(t *testing.T) {
buf.Reset()
var wg sync.WaitGroup
var server *httptest.Server
var counter int
var h http.HandlerFunc = func(w http.ResponseWriter, r *http.Request) {
if counter <= 1 {
server.CloseClientConnections()
}
w.Header().Set("X-Abc", "xyz")
fmt.Fprintln(w, "Hello, molcajete.org")
counter++
}
server = httptest.NewServer(h)
defer server.Close()
log_s := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Header.Get("User-agent") != "epazote" {
t.Error("Expecting User-agent: epazote")
}
decoder := json.NewDecoder(r.Body)
var i map[string]interface{}
err := decoder.Decode(&i)
if err != nil {
t.Error(err)
}
// check exit
if i["exit"].(float64) != 0 {
t.Errorf("Expecting: 0 got: %v", i["exit"])
}
// check because
e := "Body regex match: molcajete"
if i["because"] != e {
t.Errorf("Expecting: %q, got: %v", e, i["because"])
}
// check retries
if i["retries"].(float64) != 2 {
t.Errorf("Expecting: 2 got: %v", i["retries"])
}
// check url
if _, ok := i["url"]; !ok {
t.Error("URL key not found")
}
// check output
if i["status"].(float64) != 200 {
t.Errorf("Expecting status: %d got: %v", 200, i["status"])
}
wg.Done()
}))
defer log_s.Close()
s := make(Services)
re := regexp.MustCompile(`molcajete`)
s["s 1"] = &Service{
Name: "s 1",
URL: server.URL,
RetryLimit: 3,
ReadLimit: 17,
Log: log_s.URL,
Expect: Expect{
Status: 200,
Header: map[string]string{
"X-Abc": "xyz",
},
Body: "molcajete",
body: re,
},
}
ez := &Epazote{
Services: s,
}
wg.Add(1)
ez.Supervice(s["s 1"])()
wg.Wait()
// 1 try, 2 tries
rc := s["s 1"].retryCount
if rc != 2 {
t.Errorf("Expecting retryCount = 2 got: %d", rc)
}
if counter != 3 {
t.Errorf("Expecting 3 got: %v", counter)
}
}
consulClient = consuladapter.NewConsulClient(client)
presenceTTL = 6 * time.Second
})
Context("for longer than the MonitorRetries * MonitorRetryTime", func() {
It("drops its presence", func() {
// Serve 500's to simulate a leader election. We know that we need
// to serve more than lockTTL / 2 500's to lose the lock.
for i := 0; i < 4; i++ {
Eventually(serveFiveHundreds).Should(BeSent(struct{}{}))
}
// Close the existing connection with consul so that the
// lock monitor is forced to retry. This is because consul
// performs a blocking query until the lock index is changed.
fmt.Printf("Closing Blocking Connections")
fakeConsul.CloseClientConnections()
Eventually(logger, 7*time.Second).Should(Say("presence-lost"))
Consistently(presenceProcess.Wait()).ShouldNot(Receive())
})
})
Context("for less than the MonitorRetries * MonitorRetryTime", func() {
It("does not lose the lock", func() {
// Serve 500's to simulate a leader election. We know that if we
// serve less than lockTTL / 2 500's, we will not lose the lock.
for i := 0; i < 2; i++ {
Eventually(serveFiveHundreds).Should(BeSent(struct{}{}))
}
// Close the existing connection with consul so that the
// lock monitor is forced to retry. This is because consul
var matchServer *httptest.Server
var matchServerHost string
var _ = BeforeSuite(func() {
match.PhaseDuration = 50 * time.Millisecond
SetDefaultEventuallyTimeout(2 * time.Second)
})
var _ = BeforeEach(func() {
server.ClearMatches()
matchServer = httptest.NewServer(server.NewMatchHandler())
matchServerHost = serverHost(*matchServer)
})
var _ = AfterEach(func() {
matchServer.CloseClientConnections()
matchServer.Close()
})
func serverHost(s httptest.Server) string {
u, err := url.Parse(s.URL)
if err != nil {
log.Fatalln("Could not get server host from server url:", s.URL, err)
}
return u.Host
}
func matchURL(host, matchID, playerID string) string {
return fmt.Sprintf("ws://%s/match/%s/ws?player=%s", host, matchID, playerID)
}