func (s *TestSuite) TestDialTimeout(t *C) {
/**
* This test simulates a dial timeout by listening on a port that does nothing.
* The TCP connection completes, but the TLS handshake times out because the
* little goroutine below does nothing after net.Listen() (normally code would
* net.Accept() after listening). To simulate a lower-level dial timeout would
* require a very low-level handling of the network socket: having the port open
* but not completing the TCP syn-syn+ack-ack handshake; this is too complicate,
* so breaking the TLS handshake is close enough.
*/
addr := "localhost:9443"
url := "wss://" + addr + "/"
links := map[string]string{"agent": url}
api := mock.NewAPI("http://localhost", url, "apikey", "uuid", links)
wss, err := client.NewWebsocketClient(s.logger, api, "agent", nil)
t.Assert(err, IsNil)
doneChan := make(chan bool, 1)
go func() {
l, err := net.Listen("tcp", addr)
if err != nil {
log.Fatal(err)
}
defer l.Close()
<-doneChan
}()
time.Sleep(1 * time.Second)
err = wss.ConnectOnce(2)
t.Check(err, NotNil)
doneChan <- true
}
func (s *ManagerTestSuite) SetUpSuite(t *C) {
s.logChan = make(chan *proto.LogEntry, 10)
s.logger = pct.NewLogger(s.logChan, "sysconfig-manager-test")
s.mockMonitor = mock.NewSysconfigMonitor()
s.factory = mock.NewSysconfigMonitorFactory([]sysconfig.Monitor{s.mockMonitor})
s.tickChan = make(chan time.Time)
s.dataChan = make(chan interface{}, 1)
s.spool = mock.NewSpooler(s.dataChan)
var err error
s.tmpDir, err = ioutil.TempDir("/tmp", "agent-test")
t.Assert(err, IsNil)
if err := pct.Basedir.Init(s.tmpDir); err != nil {
t.Fatal(err)
}
s.configDir = pct.Basedir.Dir("config")
links := map[string]string{
"agent": "http://localhost/agent",
"instances": "http://localhost/instances",
}
s.api = mock.NewAPI("http://localhost", "http://localhost", "123", "abc-123-def", links)
s.im = instance.NewRepo(pct.NewLogger(s.logChan, "im-test"), s.configDir, s.api)
}
func (s *ManagerTestSuite) SetUpSuite(t *C) {
s.dsn = os.Getenv("PCT_TEST_MYSQL_DSN")
if s.dsn == "" {
t.Fatal("PCT_TEST_MYSQL_DSN is not set")
}
s.logChan = make(chan *proto.LogEntry, 10)
s.logger = pct.NewLogger(s.logChan, query.SERVICE_NAME+"-manager-test")
var err error
s.tmpDir, err = ioutil.TempDir("/tmp", "agent-test")
t.Assert(err, IsNil)
if err := pct.Basedir.Init(s.tmpDir); err != nil {
t.Fatal(err)
}
s.configDir = pct.Basedir.Dir("config")
// Real instance repo
s.repo = instance.NewRepo(pct.NewLogger(s.logChan, "im-test"), s.configDir, s.api)
data, err := json.Marshal(&proto.MySQLInstance{
Hostname: "db1",
DSN: s.dsn,
})
t.Assert(err, IsNil)
s.repo.Add("mysql", 1, data, false)
s.mysqlInstance = proto.ServiceInstance{Service: "mysql", InstanceId: 1}
links := map[string]string{
"agent": "http://localhost/agent",
"instances": "http://localhost/instances",
}
s.api = mock.NewAPI("http://localhost", "http://localhost", "123", "abc-123-def", links)
}
func (s *UpdateTestSuite) SetUpSuite(t *C) {
var err error
s.tmpDir, err = ioutil.TempDir("/tmp", "percona-agent-test-pct-update")
t.Assert(err, IsNil)
s.logChan = make(chan *proto.LogEntry, 1000)
s.logger = pct.NewLogger(s.logChan, "qan-test")
links := map[string]string{
"agent": "http://localhost/agent",
"instances": "http://localhost/instances",
"update": "http://localhost/update",
}
s.api = mock.NewAPI("http://localhost", "http://localhost", "123", "abc-123-def", links)
test.CopyFile(test.RootDir+"/pct/fake-percona-agent-1.0.1.go", s.tmpDir)
cwd, err := os.Getwd()
t.Assert(err, IsNil)
defer os.Chdir(cwd)
err = os.Chdir(s.tmpDir)
t.Assert(err, IsNil)
out, err := exec.Command("go", "build", "fake-percona-agent-1.0.1.go").Output()
if err != nil {
t.Logf("%s", out)
t.Fatal(err)
}
s.bin, s.sig, err = test.Sign(filepath.Join(s.tmpDir, "fake-percona-agent-1.0.1"))
t.Assert(err, IsNil)
s.pubKey, err = ioutil.ReadFile(filepath.Join(test.RootDir, "pct", "key.pub"))
t.Assert(err, IsNil)
}
func (s *AgentTestSuite) SetUpTest(t *C) {
// Before each test, create an agent. Tests make change the agent,
// so this ensures each test starts with an agent with known values.
s.services = make(map[string]*mock.MockServiceManager)
s.services["qan"] = mock.NewMockServiceManager("qan", s.readyChan, s.traceChan)
s.services["mm"] = mock.NewMockServiceManager("mm", s.readyChan, s.traceChan)
links := map[string]string{
"agent": "http://localhost/agent",
"instances": "http://localhost/instances",
}
s.api = mock.NewAPI("http://localhost", s.config.ApiHostname, s.config.ApiKey, s.config.AgentUuid, links)
s.servicesMap = map[string]pct.ServiceManager{
"mm": s.services["mm"],
"qan": s.services["qan"],
}
s.agent = agent.NewAgent(s.config, s.logger, s.api, s.client, s.servicesMap)
// Run the agent.
s.agentRunning = true
go func() {
s.agent.Run()
s.doneChan <- true
}()
}
func (s *ManagerTestSuite) SetUpSuite(t *C) {
s.dsn = os.Getenv("PCT_TEST_MYSQL_DSN")
if s.dsn == "" {
t.Fatal("PCT_TEST_MYSQL_DSN is not set")
}
s.realmysql = mysql.NewConnection(s.dsn)
if err := s.realmysql.Connect(1); err != nil {
t.Fatal(err)
}
s.reset = []mysql.Query{
mysql.Query{Set: "SET GLOBAL slow_query_log=OFF"},
mysql.Query{Set: "SET GLOBAL long_query_time=10"},
}
s.nullmysql = mock.NewNullMySQL()
s.logChan = make(chan *proto.LogEntry, 1000)
s.logger = pct.NewLogger(s.logChan, "qan-test")
s.intervalChan = make(chan *qan.Interval, 1)
s.iter = mock.NewMockIntervalIter(s.intervalChan)
s.iterFactory = &mock.IntervalIterFactory{
Iters: []qan.IntervalIter{s.iter},
TickChans: make(map[qan.IntervalIter]chan time.Time),
}
s.dataChan = make(chan interface{}, 2)
s.spool = mock.NewSpooler(s.dataChan)
s.workerFactory = &qan.SlowLogWorkerFactory{}
var err error
s.tmpDir, err = ioutil.TempDir("/tmp", "agent-test")
t.Assert(err, IsNil)
if err := pct.Basedir.Init(s.tmpDir); err != nil {
t.Fatal(err)
}
s.configDir = pct.Basedir.Dir("config")
s.im = instance.NewRepo(pct.NewLogger(s.logChan, "im-test"), s.configDir, s.api)
data, err := json.Marshal(&proto.MySQLInstance{
Hostname: "db1",
DSN: s.dsn,
})
t.Assert(err, IsNil)
s.im.Add("mysql", 1, data, false)
s.mysqlInstance = proto.ServiceInstance{Service: "mysql", InstanceId: 1}
links := map[string]string{
"agent": "http://localhost/agent",
"instances": "http://localhost/instances",
}
s.api = mock.NewAPI("http://localhost", "http://localhost", "123", "abc-123-def", links)
}
func (s *TestSuite) SetUpSuite(t *C) {
s.logChan = make(chan *proto.LogEntry, 10)
s.logger = pct.NewLogger(s.logChan, "ws")
mock.SendChan = make(chan interface{}, 5)
mock.RecvChan = make(chan interface{}, 5)
s.server = new(mock.WebsocketServer)
go s.server.Run(ADDR, ENDPOINT)
time.Sleep(100 * time.Millisecond)
links := map[string]string{"agent": URL}
s.api = mock.NewAPI("http://localhost", ADDR, "apikey", "uuid", links)
}
func (s *RepoTestSuite) SetUpSuite(t *C) {
var err error
s.tmpDir, err = ioutil.TempDir("/tmp", "agent-test")
t.Assert(err, IsNil)
if err := pct.Basedir.Init(s.tmpDir); err != nil {
t.Fatal(err)
}
s.configDir = pct.Basedir.Dir("config")
s.logChan = make(chan *proto.LogEntry, 10)
s.logger = pct.NewLogger(s.logChan, "pct-it-test")
links := map[string]string{
"agent": "http://localhost/agent",
"instances": "http://localhost/instances",
}
s.api = mock.NewAPI("http://localhost", "http://localhost", "123", "abc-123-def", links)
}
func (s *ManagerTestSuite) SetUpSuite(t *C) {
s.logChan = make(chan *proto.LogEntry, 10)
s.logger = pct.NewLogger(s.logChan, "mm-manager-test")
s.tickChan = make(chan time.Time)
s.traceChan = make(chan string, 10)
s.dataChan = make(chan interface{}, 1)
s.spool = mock.NewSpooler(s.dataChan)
var err error
s.tmpDir, err = ioutil.TempDir("/tmp", "agent-test")
t.Assert(err, IsNil)
if err := pct.Basedir.Init(s.tmpDir); err != nil {
t.Fatal(err)
}
s.configDir = pct.Basedir.Dir("config")
s.im = instance.NewRepo(pct.NewLogger(s.logChan, "im"), s.configDir, s.api)
data, err := json.Marshal(&proto.MySQLInstance{
Hostname: "db1",
DSN: "user:host@tcp:(127.0.0.1:3306)",
})
t.Assert(err, IsNil)
s.im.Add("mysql", 1, data, false)
data, err = json.Marshal(&proto.ServerInstance{Hostname: "host1"})
t.Assert(err, IsNil)
s.im.Add("server", 1, data, false)
s.mysqlMonitor = mock.NewMmMonitor()
s.systemMonitor = mock.NewMmMonitor()
s.factory = mock.NewMmMonitorFactory(map[string]mm.Monitor{
"mysql-1": s.mysqlMonitor,
"server-1": s.systemMonitor,
})
links := map[string]string{
"agent": "http://localhost/agent",
"instances": "http://localhost/instances",
}
s.api = mock.NewAPI("http://localhost", "http://localhost", "123", "abc-123-def", links)
}
func (s *AnalyzerTestSuite) SetUpSuite(t *C) {
s.nullmysql = mock.NewNullMySQL()
s.logChan = make(chan *proto.LogEntry, 1000)
s.logger = pct.NewLogger(s.logChan, "qan-test")
s.intervalChan = make(chan *qan.Interval, 1)
s.iter = mock.NewIter(s.intervalChan)
s.dataChan = make(chan interface{}, 1)
s.spool = mock.NewSpooler(s.dataChan)
var err error
s.tmpDir, err = ioutil.TempDir("/tmp", "agent-test")
t.Assert(err, IsNil)
if err := pct.Basedir.Init(s.tmpDir); err != nil {
t.Fatal(err)
}
s.configDir = pct.Basedir.Dir("config")
s.im = instance.NewRepo(pct.NewLogger(s.logChan, "im-test"), s.configDir, s.api)
data, err := json.Marshal(&proto.MySQLInstance{
Hostname: "bm-cloud-db01",
Alias: "db01",
DSN: "user:pass@tcp/",
})
t.Assert(err, IsNil)
s.im.Add("mysql", 1, data, false)
s.mysqlInstance = proto.ServiceInstance{Service: "mysql", InstanceId: 1}
links := map[string]string{
"agent": "http://localhost/agent",
"instances": "http://localhost/instances",
}
s.api = mock.NewAPI("http://localhost", "http://localhost", "123", "abc-123-def", links)
s.restartChan = make(chan bool, 1)
}