// Run starts listening for RPC and HTTP requests,
// and blocks until it the process gets a signal.
// It may also listen on a secure port, or on a unix socket.
func Run() {
onRunHooks.Fire()
ServeRPC()
l, err := proc.Listen(fmt.Sprintf("%v", *Port))
if err != nil {
log.Fatal(err)
}
host, err := netutil.FullyQualifiedHostname()
if err != nil {
host, err = os.Hostname()
if err != nil {
log.Fatalf("os.Hostname() failed: %v", err)
}
}
ListeningURL = url.URL{
Scheme: "http",
Host: fmt.Sprintf("%v:%v", host, *Port),
Path: "/",
}
go http.Serve(l, nil)
serveSecurePort()
serveSocketFile()
proc.Wait()
l.Close()
log.Info("Entering lameduck mode")
go onTermHooks.Fire()
time.Sleep(*LameduckPeriod)
log.Info("Shutting down")
Close()
}
// Run starts listening for RPC and HTTP requests,
// and blocks until it the process gets a signal.
func Run(port int) {
populateListeningURL()
onRunHooks.Fire()
ServeRPC()
l, err := proc.Listen(fmt.Sprintf("%v", port))
if err != nil {
log.Fatal(err)
}
go http.Serve(l, nil)
proc.Wait()
l.Close()
startTime := time.Now()
log.Infof("Entering lameduck mode for at least %v", *lameduckPeriod)
log.Infof("Firing asynchronous OnTerm hooks")
go onTermHooks.Fire()
fireOnTermSyncHooks(*onTermTimeout)
if remain := *lameduckPeriod - time.Since(startTime); remain > 0 {
log.Infof("Sleeping an extra %v after OnTermSync to finish lameduck period", remain)
time.Sleep(remain)
}
log.Info("Shutting down gracefully")
Close()
}
// Run starts listening for RPC and HTTP requests,
// and blocks until it the process gets a signal.
// It may also listen on a secure port, or on a unix socket.
func Run() {
onRunHooks.Fire()
ServeRPC()
l, err := proc.Listen(fmt.Sprintf("%v", *Port))
if err != nil {
log.Fatal(err)
}
host, err := netutil.FullyQualifiedHostname()
if err != nil {
host, err = os.Hostname()
if err != nil {
log.Fatalf("os.Hostname() failed: %v", err)
}
}
ListeningURL = url.URL{
Scheme: "http",
Host: fmt.Sprintf("%v:%v", host, *Port),
Path: "/",
}
go http.Serve(l, nil)
serveSecurePort()
serveSocketFile()
proc.Wait()
l.Close()
Close()
}
// RunSecure is like Run, but it additionally listens for RPC and HTTP
// requests using TLS on securePort, using the passed certificate,
// key, and CA certificate.
func RunSecure(port int, securePort int, cert, key, caCert string) {
onRunHooks.Fire()
ServeRPC()
l, err := proc.Listen(fmt.Sprintf("%v", port))
if err != nil {
log.Fatal(err)
}
host, err := netutil.FullyQualifiedHostname()
if err != nil {
host, err = os.Hostname()
if err != nil {
log.Fatalf("os.Hostname() failed: %v", err)
}
}
ListeningURL = url.URL{
Scheme: "http",
Host: fmt.Sprintf("%v:%v", host, port),
Path: "/",
}
go http.Serve(l, nil)
if securePort != 0 {
log.Infof("listening on secure port %v", securePort)
SecureServe(fmt.Sprintf(":%d", securePort), cert, key, caCert)
}
proc.Wait()
l.Close()
Close()
}
// RunSecure is like Run, but it additionally listens for RPC and HTTP
// requests using TLS on securePort, using the passed certificate,
// key, and CA certificate.
func RunSecure(port int, securePort int, cert, key, caCert string) {
onRunHooks.Fire()
ServeRPC()
l, err := proc.Listen(fmt.Sprintf("%v", port))
if err != nil {
log.Fatal(err)
}
go http.Serve(l, nil)
if securePort != 0 {
log.Infof("listening on secure port %v", securePort)
SecureServe(fmt.Sprintf(":%d", securePort), cert, key, caCert)
}
proc.Wait()
Close()
}
// Run starts listening for RPC and HTTP requests,
// and blocks until it the process gets a signal.
func Run(port int) {
populateListeningURL()
onRunHooks.Fire()
ServeRPC()
l, err := proc.Listen(fmt.Sprintf("%v", port))
if err != nil {
log.Fatal(err)
}
go http.Serve(l, nil)
proc.Wait()
l.Close()
log.Infof("Entering lameduck mode for %v", *lameduckPeriod)
go onTermHooks.Fire()
time.Sleep(*lameduckPeriod)
log.Info("Shutting down")
Close()
}
func main() {
dbConfigsFile, dbCredentialsFile := dbconfigs.RegisterCommonFlags()
flag.Parse()
servenv.Init()
defer servenv.Close()
tabletAlias := vttablet.TabletParamToTabletAlias(*tabletPath)
if *mycnfFile == "" {
*mycnfFile = mysqlctl.MycnfFile(tabletAlias.Uid)
}
mycnf, err := mysqlctl.ReadMycnf(*mycnfFile)
if err != nil {
log.Fatalf("mycnf read failed: %v", err)
}
dbcfgs, err := dbconfigs.Init(mycnf.SocketFile, *dbConfigsFile, *dbCredentialsFile)
if err != nil {
log.Warning(err)
}
ts.InitQueryService()
mysqlctl.RegisterUpdateStreamService(mycnf)
// Depends on both query and updateStream.
ts.RegisterCacheInvalidator()
// Depends on both query and updateStream.
if err := vttablet.InitAgent(tabletAlias, dbcfgs, mycnf, *dbConfigsFile, *dbCredentialsFile, *port, *securePort, *mycnfFile, *overridesFile); err != nil {
log.Fatal(err)
}
servenv.ServeRPC()
vttablet.HttpHandleSnapshots(mycnf, tabletAlias.Uid)
l, err := proc.Listen(fmt.Sprintf("%v", *port))
if err != nil {
log.Fatal(err)
}
go http.Serve(l, nil)
if *securePort != 0 {
log.Infof("listening on secure port %v", *securePort)
vttablet.SecureServe(fmt.Sprintf(":%d", *securePort), *cert, *key, *caCert)
}
log.Infof("started vttablet %v", *port)
s := proc.Wait()
// A SIGUSR1 means that we're restarting
if s == syscall.SIGUSR1 {
// Give some time for the other process
// to pick up the listeners
log.Info("Exiting on SIGUSR1")
time.Sleep(5 * time.Millisecond)
ts.DisallowQueries(true)
} else {
log.Info("Exiting on SIGTERM")
ts.DisallowQueries(false)
}
mysqlctl.DisableUpdateStreamService()
topo.CloseServers()
vttablet.CloseAgent()
}