func main() {
flag.Parse()
ctx := base.Context{Insecure: *insecure, Certs: *certs, User: *user}
httpClient, err := ctx.GetHTTPClient()
if err != nil {
panic(err)
}
startTime := time.Now()
file := filepath.Join(*outputDir, fmt.Sprintf("monitor.%s", strings.Replace(
startTime.Format(time.RFC3339), ":", "_", -1)))
log.Infof("Logging cluster status to: %s.\n", file)
w, err := os.Create(file)
if err != nil {
panic(err)
}
defer w.Close()
url := fmt.Sprintf("%s://%s/%s", ctx.HTTPRequestScheme(), *addr, *endpoint)
log.Infof("Cluster Status URL: %s\n", url)
for range time.Tick(*interval) {
resp, found := request(url, httpClient)
if !found {
log.Warningf("Could not get cluster status. Time since monitor started %s.", time.Since(startTime))
break
}
log.Infof("Got cluster status.")
fmt.Fprintf(w, "%s\n", resp)
}
}
// newStatusServer allocates and returns a statusServer.
func newStatusServer(
db *client.DB,
gossip *gossip.Gossip,
metricSource json.Marshaler,
ctx *base.Context,
rpcCtx *rpc.Context,
stores *storage.Stores,
) *statusServer {
// Create an http client with a timeout
httpClient, err := ctx.GetHTTPClient()
if err != nil {
log.Error(err)
return nil
}
server := &statusServer{
db: db,
gossip: gossip,
metricSource: metricSource,
router: httprouter.New(),
rpcCtx: rpcCtx,
proxyClient: httpClient,
stores: stores,
}
server.router.GET(statusLogFilesListPattern, server.handleLogFilesList)
server.router.GET(statusLogFilePattern, server.handleLogFile)
server.router.GET(statusLogsPattern, server.handleLogs)
// TODO(tschottdorf): significant overlap with /debug/pprof/goroutine,
// except that this one allows querying by NodeID.
server.router.GET(statusStacksPattern, server.handleStacks)
server.router.GET(statusMetricsPattern, server.handleMetrics)
return server
}
// makeTestHTTPSession constructs a new testHTTPSession. The session will
// instantiate a client using the based base context. All HTTP requests from the
// session will be sent to the given baseUrl.
//
// baseUrl should be specified *without* a request scheme (i.e. "http://"); the
// request scheme will be used from the context.
//
// If an error occurs in HTTP layer during any session operation, a Fatal method
// will be called on the supplied t.Tester.
func makeTestHTTPSession(t *testing.T, ctx *base.Context, baseURL string) testHTTPSession {
client, err := ctx.GetHTTPClient()
if err != nil {
t.Fatalf("error creating client: %s", err)
}
return testHTTPSession{
client: client,
baseURL: ctx.HTTPRequestScheme() + "://" + baseURL,
}
}
// NewTestHTTPSession constructs a new TestHTTPSession. The session will
// instantiate a client using the based base context. All HTTP requests from the
// session will be sent to the given baseUrl.
//
// baseUrl should be specified *without* a request scheme (i.e. "http://"); the
// request scheme will be used from the context.
//
// If an error occurs in HTTP layer during any session operation, a Fatal method
// will be called on the supplied t.Tester.
func NewTestHTTPSession(t util.Tester, ctx *base.Context, baseURL string) *TestHTTPSession {
client, err := ctx.GetHTTPClient()
if err != nil {
t.Fatalf("error creating client: %s", err)
}
return &TestHTTPSession{
t: t,
client: client,
baseURL: ctx.RequestScheme() + "://" + baseURL,
}
}
func newStatusMonitor(context *base.Context, addr string) (*statusMonitor, error) {
monitor := &statusMonitor{
addr: addr,
}
var err error
monitor.httpClient, err = context.GetHTTPClient()
if err != nil {
return nil, err
}
monitor.url = fmt.Sprintf("%s://%s/%s", context.HTTPRequestScheme(), monitor.addr, urlPath)
return monitor, nil
}
// newHTTPSender returns a new instance of httpSender.
func newHTTPSender(server string, ctx *base.Context, retryOpts retry.Options) (*httpSender, error) {
sender := &httpSender{
server: server,
context: ctx,
retryOpts: retryOpts,
}
var err error
sender.client, err = ctx.GetHTTPClient()
if err != nil {
return nil, err
}
return sender, nil
}
// newHTTPSender returns a new instance of httpSender.
func newHTTPSender(server string, ctx *base.Context, retryOpts retry.Options) (*httpSender, error) {
// Ensure that the context returns an HTTPClient.
if _, err := ctx.GetHTTPClient(); err != nil {
return nil, err
}
return &httpSender{
ctx: client.PostContext{
Server: server,
Endpoint: Endpoint,
Context: ctx,
RetryOpts: retryOpts,
},
}, nil
}
// newRPCSender returns a new instance of rpcSender.
func newRPCSender(server string, context *base.Context, retryOpts retry.Options) (*rpcSender, error) {
addr, err := net.ResolveTCPAddr("tcp", server)
if err != nil {
return nil, err
}
tlsConfig, err := context.GetClientTLSConfig()
if err != nil {
return nil, err
}
conn, err := codec.TLSDialHTTP(addr.Network(), addr.String(), base.NetworkTimeout, tlsConfig)
if err != nil {
return nil, err
}
client := rpc.NewClientWithCodec(codec.NewClientCodec(conn))
return &rpcSender{
user: context.User,
client: client,
retryOpts: retryOpts,
}, nil
}
func createTestClientForUser(t *testing.T, stopper *stop.Stopper, addr, user string) *client.DB {
var ctx base.Context
ctx.InitDefaults()
ctx.User = user
ctx.SSLCA = filepath.Join(security.EmbeddedCertsDir, security.EmbeddedCACert)
ctx.SSLCert = filepath.Join(security.EmbeddedCertsDir, fmt.Sprintf("%s.crt", user))
ctx.SSLCertKey = filepath.Join(security.EmbeddedCertsDir, fmt.Sprintf("%s.key", user))
sender, err := client.NewSender(rpc.NewContext(&ctx, nil, stopper), addr)
if err != nil {
t.Fatal(err)
}
return client.NewDB(sender)
}
// newRPCSender returns a new instance of rpcSender.
func newRPCSender(server string, context *base.Context, retryOpts retry.Options, stopper *stop.Stopper) (*rpcSender, error) {
addr, err := net.ResolveTCPAddr("tcp", server)
if err != nil {
return nil, err
}
if context.Insecure {
log.Warning("running in insecure mode, this is strongly discouraged. See --insecure and --certs.")
} else {
if _, err := context.GetClientTLSConfig(); err != nil {
return nil, err
}
}
ctx := rpc.NewContext(context, hlc.NewClock(hlc.UnixNano), stopper)
client := rpc.NewClient(addr, ctx)
return &rpcSender{
client: client,
retryOpts: retryOpts,
}, nil
}
func fillCertPaths(context *base.Context, user string) {
context.SSLCA = filepath.Join(security.EmbeddedCertsDir, security.EmbeddedCACert)
context.SSLCAKey = filepath.Join(security.EmbeddedCertsDir, security.EmbeddedCAKey)
context.SSLCert = filepath.Join(security.EmbeddedCertsDir, fmt.Sprintf("%s.crt", user))
context.SSLCertKey = filepath.Join(security.EmbeddedCertsDir, fmt.Sprintf("%s.key", user))
}