func (e *BtEngine) newMetaInfoClient() (pb.MetaInfoClient, error) {
	rsv, err := endpoint.NewResolverGroup("eagleclient")
	if err != nil {
		return nil, err
	}
	rsv.SetEndpoints(e.seeders)

	name := fmt.Sprintf("eagleclient-%s", picker.RoundrobinBalanced.String())
	balancer.RegisterBuilder(balancer.Config{
		Policy: picker.RoundrobinBalanced,
		Name:   name,
		Logger: zap.NewExample(),
	})
	conn, err := grpc.Dial(fmt.Sprintf("endpoint://eagleclient/"), grpc.WithInsecure(), grpc.WithBalancerName(name))
	if err != nil {
		return nil, fmt.Errorf("failed to dial seeder: %s", err)
	}
	return pb.NewMetaInfoClient(conn), nil
}

// GetMetaData get torrent of layer
func (s *Seeder) GetMetaInfo(ctx context.Context, metaInfoReq *pb.MetaInfoRequest) (*pb.MetaInfoReply, error) {
	log.Debugf("Access: %s", metaInfoReq.Url)
	digest := metaInfoReq.Url[strings.LastIndex(metaInfoReq.Url, "/")+1:]
	id := distdigests.Digest(digest).Encoded()
	log.Debugf("Start to get metadata of layer %s", id)
	err := s.getMetaDataSync(metaInfoReq.Url, id)
	if err != nil {
		return nil, fmt.Errorf("Get metainfo from origin failed: %v", err)
	}
	torrentFile := s.storage.GetTorrentFilePath(id)
	content, err := s.storage.Download(torrentFile)
	if err != nil {
		return nil, fmt.Errorf("Download metainfo file failed: %v", err)
	}
	return &pb.MetaInfoReply{Metainfo: content}, nil
}

// Storage defines an interface for accessing blobs on a remote storage backend.
//
// Implementations of Storage must be thread-safe, since they are cached and
// used concurrently by Manager.
type Storage interface {
	// Create creates torrent with meta info
	CreateWithMetaInfo(name string, info *metainfo.MetaInfo) error

	// Stat is useful when we need to quickly know if a blob exists (and maybe
	// some basic information about it), without downloading the entire blob,
	// which may be very large.
	Stat(name string) (*FileInfo, error)

	// Upload uploads data into name.
	Upload(name string, data []byte) error

	// Download downloads name into dst. All implementations should return
	// backenderrors.ErrBlobNotFound when the blob was not found.
	Download(name string) ([]byte, error)

	// Delete removes relevant name
	Delete(name string) error

	// List lists entries whose names start with prefix.
	List(prefix string) ([]*FileInfo, error)

	// GetFilePath returns data path
	GetFilePath(id string) string

	// GetTorrentFilePath returns torrent path
	GetTorrentFilePath(id string) string

	// GetDataDir returns directory of data
	GetDataDir() string

	// GetTorrentDir returns directory of torrent
	GetTorrentDir() string
}

// EvictCallback is used to get a callback when a cache entry is evicted
type EvictCallback func(string)

type LruCache struct {
	sync.RWMutex
	limitSize   int64
	currentSize int64
	evictList   *list.List
	items       map[string]*list.Element
	onEvict     EvictCallback
}

// Entry is used to hold a value in the evictList
type entry struct {
	key   string
	value Entry
}

type Entry struct {
	Done      chan struct{}
	Completed bool
	Size      int64
}

package main

import "github.com/duyanghao/eagle/proxy/cmd"

func main() {
	cmd.Run(cmd.ParseFlags())
}

func Run(flags *Flags) {
	// create config
	log.Infof("Start to load config %s ...", flags.ConfigFile)
	config, err := LoadConfig(flags.ConfigFile)
	if err != nil {
		log.Fatalf("Failed to load config: %v", err)
	}
	log.Infof("Load config %s successfully", flags.ConfigFile)

	// set log level
	if config.ProxyCfg.Verbose {
		log.SetLevel(log.DebugLevel)
	} else {
		log.SetLevel(log.InfoLevel)
	}

	// start eagleClient
	log.Infof("Start eagleClient ...")
	c := &eagleclient.Config{
		EnableUpload:      true,
		EnableSeeding:     true,
		IncomingPort:      config.ClientCfg.Port,
		DownloadTimeout:   time.Duration(config.ClientCfg.DownloadTimeout),
		UploadRateLimit:   ratelimiter.RateConvert(config.ClientCfg.UploadRateLimit),
		DownloadRateLimit: ratelimiter.RateConvert(config.ClientCfg.DownloadRateLimit),
		CacheLimitSize:    ratelimiter.RateConvert(config.ClientCfg.LimitSize),
	}
	eagleClient := eagleclient.NewBtEngine(config.ClientCfg.RootDirectory, config.ClientCfg.Trackers, config.ClientCfg.Seeders, c)
	proxyRoundTripper := transport.NewProxyRoundTripper(eagleClient, config.ProxyCfg.Rules)
	err = proxyRoundTripper.P2PClient.Run()
	if err != nil {
		log.Fatal("Start eagleClient failure: %v", err)
	}
	log.Infof("Start eagleClient successfully ...")

	// init routes
	routes.InitMux()

	// start proxy
	log.Infof("Launch proxy on port: %d", config.ProxyCfg.Port)
	if config.ProxyCfg.CertFile != "" && config.ProxyCfg.KeyFile != "" {
		err = http.ListenAndServeTLS(fmt.Sprintf(":%d", config.ProxyCfg.Port), config.ProxyCfg.CertFile, config.ProxyCfg.KeyFile, nil)
	} else {
		err = http.ListenAndServe(fmt.Sprintf(":%d", config.ProxyCfg.Port), nil)
	}
	if err != nil {
		log.Fatal(err)
	}
}