func (cp *CachePool) startMemcache() {
cp.cmd = exec.Command(cp.commandLine[0], cp.commandLine[1:]...)
if err := cp.cmd.Start(); err != nil {
panic(NewTabletError(FATAL, "can't start memcache: %v", err))
}
attempts := 0
for {
time.Sleep(50 * time.Millisecond)
c, err := memcache.Connect(cp.port)
if err != nil {
attempts++
if attempts >= 30 {
cp.cmd.Process.Kill()
// FIXME(sougou): Throw proper error if we can recover
log.Fatal("Can't connect to memcache")
}
continue
}
if _, err = c.Set("health", 0, 0, []byte("ok")); err != nil {
panic(NewTabletError(FATAL, "can't communicate with memcache: %v", err))
}
c.Close()
break
}
}
func (cp *CachePool) startMemcache() {
if strings.Contains(cp.port, "/") {
_ = os.Remove(cp.port)
}
commandLine := cp.rowCacheConfig.GetSubprocessFlags()
cp.cmd = exec.Command(commandLine[0], commandLine[1:]...)
if err := cp.cmd.Start(); err != nil {
panic(NewTabletError(FATAL, "can't start memcache: %v", err))
}
attempts := 0
for {
time.Sleep(100 * time.Millisecond)
c, err := memcache.Connect(cp.port, 30*time.Millisecond)
if err != nil {
attempts++
if attempts >= 50 {
cp.cmd.Process.Kill()
// Avoid zombies
go cp.cmd.Wait()
// FIXME(sougou): Throw proper error if we can recover
log.Fatal("Can't connect to memcache")
}
continue
}
if _, err = c.Set("health", 0, 0, []byte("ok")); err != nil {
panic(NewTabletError(FATAL, "can't communicate with memcache: %v", err))
}
c.Close()
break
}
}
func (m *MemcacheConnPool) connect() {
if c, err := memcache.Connect(m.server, DefaultTimeout); err != nil {
m.idle <- connectResult{conn: c, err: err}
} else {
m.ReleaseConn(c, nil)
}
}
func CacheCreator(dbconfig dbconfigs.DBConfig) CreateCacheFunc {
if dbconfig.Memcache == "" {
relog.Info("rowcache not enabled")
return nil
}
relog.Info("rowcache is enabled")
return func() (*memcache.Connection, error) {
return memcache.Connect(dbconfig.Memcache)
}
}
func (cp *CachePool) Open() {
if len(cp.commandLine) == 0 {
log.Infof("rowcache not enabled")
return
}
cp.startMemcache()
log.Infof("rowcache is enabled")
f := func() (pools.Resource, error) {
c, err := memcache.Connect(cp.port)
if err != nil {
return nil, err
}
return &Cache{c, cp}, nil
}
cp.pool = pools.NewResourcePool(f, cp.capacity, cp.capacity, cp.idleTimeout)
}
func (cp *CachePool) Open() {
if cp.rowCacheConfig.Binary == "" {
panic(NewTabletError(FATAL, "rowcache binary not specified"))
}
cp.startMemcache()
log.Infof("rowcache is enabled")
f := func() (pools.Resource, error) {
return memcache.Connect(cp.port, 10*time.Second)
}
cp.mu.Lock()
defer cp.mu.Unlock()
cp.pool = pools.NewResourcePool(f, cp.capacity, cp.capacity, cp.idleTimeout)
if cp.memcacheStats != nil {
cp.memcacheStats.Open()
}
}
func (cp *CachePool) Open() {
if cp.rowCacheConfig.Binary == "" {
log.Infof("rowcache not enabled")
return
}
cp.startMemcache()
log.Infof("rowcache is enabled")
f := func() (pools.Resource, error) {
c, err := memcache.Connect(cp.port)
if err != nil {
return nil, err
}
return &Cache{c, cp}, nil
}
cp.mu.Lock()
defer cp.mu.Unlock()
cp.pool = pools.NewResourcePool(f, cp.capacity, cp.capacity, cp.idleTimeout)
if cp.memcacheStats != nil {
cp.memcacheStats.Open()
}
}
func (cp *CachePool) startMemcache() {
cp.cmd = exec.Command(cp.commandLine[0], cp.commandLine[1:]...)
if err := cp.cmd.Start(); err != nil {
panic(NewTabletError(FATAL, "can't start memcache: %v", err))
}
attempts := 0
for {
time.Sleep(50 * time.Millisecond)
c, err := memcache.Connect(cp.port)
if err != nil {
attempts++
if attempts >= 8 {
panic(NewTabletError(FATAL, "can't connect to memcache"))
}
continue
}
if _, err = c.Set("health", 0, 0, []byte("ok")); err != nil {
panic(NewTabletError(FATAL, "can't communicate with memcache: %v", err))
}
c.Close()
break
}
}
// NewMemcache connect memcached server
func NewMemcache(address string, dialTimeout time.Duration) (*Memcache, error) {
var err error
mc := Memcache{}
mc.conn, err = youtubeMemcache.Connect(address, dialTimeout)
return &mc, err
}