// NewFinder returns a new Finder instance. func NewFinder(docker *dockerapi.Client, as *aerospike.Client) *Finder { return &Finder{ docker: docker, as: as, logger: leverutil.GetLogger(PackageName, "Finder"), } }
// NewLeverResource returns a new instance of LeverResource. func NewLeverResource( leverEnv, leverService, instanceID, leverResource, levResResourceID, levResSessionID, instanceAddr string, conns *scale.GRPCPool, onCloseFun OnCloseFun) (*LeverResource, error) { expiryDur := ResourceExpiryTimeFlag.Get() logger := leverutil.GetLogger(PackageName, "leverresource").WithFields( "leverEnv", leverEnv, "leverService", leverService, "leverInstanceID", instanceID, "leverResource", leverResource, ) resource := &LeverResource{ leverEnv: leverEnv, leverService: leverService, leverResource: leverResource, levResResource: scale.ExistingResource( leverutil.ServiceFlag.Get(), levResResourceID, levResSessionID), instanceAddr: instanceAddr, conns: conns, sessionKAB: scale.NewSessionKeepAliveBuffer( levResSessionID, expiryDur), expiryDur: expiryDur, onCloseFun: onCloseFun, logger: logger, } resource.expiryTimer = time.AfterFunc(expiryDur, resource.onExpired) go resource.monitorResourceLock(levResResourceID) resource.construct() return resource, nil }
// NewLeverInstance returns a new instance of LeverInstance. func NewLeverInstance( info *InstanceInfo, instanceAddr string, proxyInAddr string, conns *scale.GRPCPool, docker *dockerapi.Client, onCloseFun OnCloseFun) *LeverInstance { expiryDur := InstanceExpiryTimeFlag.Get() logger := leverutil.GetLogger(PackageName, "leverinstance").WithFields( "leverEnv", info.Environment, "leverService", info.Service, "leverInstanceID", info.InstanceID, ) instance := &LeverInstance{ leverEnv: info.Environment, instanceID: info.InstanceID, leverService: info.Service, containerID: info.ContainerID, servingID: info.ServingID, instanceAddr: instanceAddr, conns: conns, docker: docker, expiryDur: expiryDur, onCloseFun: onCloseFun, logger: logger, leverResources: make(map[string]*LeverResource), } instance.expiryTimer = time.AfterFunc(expiryDur, instance.onExpired) instance.registerAsService(proxyInAddr) go instance.monitorContainer() if info.LevInstResourceID != "" { // This instance has a resource + session associated with it. Manage // its lifecycle. instance.levInstResource = scale.ExistingResource( leverutil.ServiceFlag.Get(), info.LevInstResourceID, info.LevInstSessionID) instance.sessionKAB = scale.NewSessionKeepAliveBuffer( info.LevInstSessionID, expiryDur) go instance.monitorInstanceLock(info.LevInstResourceID) } return instance }
// NewManager returns a new Manager. func NewManager( grpcServer *grpc.Server, grpcPool *scale.GRPCPool, docker *dockerapi.Client, grpcAddr string, proxyInAddr string) ( manager *Manager, err error) { manager = &Manager{ grpcPool: grpcPool, docker: docker, proxyInAddr: proxyInAddr, environments: make(map[string]*envEntry), servingIDs: make(map[string]map[string]struct{}), logger: leverutil.GetLogger(PackageName, "Manager"), } RegisterManagerServer(grpcServer, manager) managerInstanceID := InstanceIDFlag.Get() serviceTTL := 30 * time.Second err = scale.RegisterServiceLocal( ManagerService, managerInstanceID, grpcAddr, serviceTTL) if err != nil { return nil, err } manager.serviceSKA = scale.NewServiceSelfKeepAlive( managerInstanceID, serviceTTL/2) err = manager.registerManagerResource(grpcAddr) if err != nil { return nil, err } // TODO: This is a workaround for docker's bug where a network connect // causes active connections to be closed. This prevents the admin // env's network from being created at request time, causing that // request to fail (and client to retry). adminEntry, err := manager.getEnvironment(core.AdminEnvFlag.Get()) if err != nil { manager.logger.WithFields("err", err).Warning( "Admin env workaround failed") } adminEntry.envLock.Unlock() return manager, nil }
// NewLeverProxy creates a new instance of LeverProxy. func NewLeverProxy( manager *hostman.Manager, finder *Finder, ownIPv4 string, grpcPool *scale.GRPCPool) ( *LeverProxy, error) { client, err := http2stream.NewHTTP2Client( ConnectionConnectTimeoutFlag.Get(), ConnectionExpiryFlag.Get()) if err != nil { return nil, err } proxy := &LeverProxy{ outServer: http2stream.NewHTTP2Server(), inServer: http2stream.NewHTTP2Server(), extServer: http2stream.NewHTTP2Server(), client: client, manager: manager, finder: finder, ownIPv4: ownIPv4, grpcPool: grpcPool, outListeners: make(map[string]net.Listener), logger: leverutil.GetLogger(PackageName, "LeverProxy"), } proxy.inLogger = proxy.logger.WithFields("listener", "in") proxy.outLogger = proxy.logger.WithFields("listener", "out") proxy.extLogger = proxy.logger.WithFields("listener", "ext") if !DisableProxyExtFlag.Get() { err = proxy.serveExt() if err != nil { return nil, err } } if !DisableProxyInOutFlag.Get() { err = proxy.serveIn() if err != nil { return nil, err } } return proxy, nil }
"github.com/leveros/leveros/core" "github.com/leveros/leveros/host" "github.com/leveros/leveros/leverutil" ) // PackageName is the name of this package. const PackageName = "apiserver" var ( // ListenPortFlag is the port the API server should listen on. ListenPortFlag = config.DeclareString(PackageName, "listenPort", "3503") // DisableAPIServerFlag disables the creation of an HTTP API server. DisableAPIServerFlag = config.DeclareBool(PackageName, "disableAPIServer") ) var logger = leverutil.GetLogger(PackageName, "Server") const maxNonChanRequestSize = 512 * 1024 // 512 KiB var bufferedReaderPool = &sync.Pool{ New: func() interface{} { return bufio.NewReaderSize(nil, maxNonChanRequestSize) }, } var bufferPool = &sync.Pool{ New: func() interface{} { return make([]byte, maxNonChanRequestSize) }, }
DockerLocalFlag = config.DeclareString( PackageName, "dockerLocal", "unix:///var/run/docker.sock") // LeverCodeHostDirFlag is the location on the host (outside docker) of the // mounted customer code directory, containing all code from all // environments and services. LeverCodeHostDirFlag = config.DeclareString( PackageName, "leverCodeHostDir", "/tmp/leveros/custcodetree") // DisableRemoveContainerFlag causes Lever containers to not be // removed (on errors, on exit etc). DisableRemoveContainerFlag = config.DeclareBool( PackageName, "disableRemoveContainer") ) var logger = leverutil.GetLogger(PackageName, "dockerutil") var ( ownContainerIDOnce sync.Once ownContainerID = "" ) // HostCodeDirPath returns the path on the docker host that the code for a given // service version is found at. func HostCodeDirPath(environment, service string, codeVersion int64) string { return filepath.Join( LeverCodeHostDirFlag.Get(), environment, service, strconv.Itoa(int(codeVersion))) } // CodeDirPath returns the path within the docker container that the code
"github.com/leveros/leveros/scale" "github.com/leveros/leveros/store" "google.golang.org/grpc" ) // PackageName is the name of this package. const PackageName = cmd.PackageName + ".leveroshost" var ( // Version is the version of Lever OS. This variable is set at build time. Version string // GitHash is the git hash of Lever OS. This variable is set at build time. GitHash string ) var logger = leverutil.GetLogger(PackageName, "main") var ( // InternalGRPCListenPortFlag is the port to listen to for internal GRPC // connections. InternalGRPCListenPortFlag = config.DeclareString( PackageName, "internalGRPCListenPort", "3501") // ExternalIPFlag is the host's external IP address. ExternalIPFlag = config.DeclareString( PackageName, "externalIP", "127.0.0.1") ) func main() { config.Initialize() leverutil.UpdateLoggingSettings()
package systemtest import ( "github.com/leveros/leveros/leverutil" ) // PackageName is the name of this package. const PackageName = "systemtest" var logger = leverutil.GetLogger(PackageName, "test")
package http2stream import ( "net" "sync" "github.com/leveros/leveros/leverutil" ) var ( serverLogger = leverutil.GetLogger(PackageName, "server") ) // StreamHandler is a function that handles incoming streams. type StreamHandler func(stream *HTTP2Stream) // HTTP2Server represents a HTTP2 server which listens for connections. type HTTP2Server struct { lock sync.Mutex listeners map[net.Listener]bool conns map[*http2Connection]bool } // NewHTTP2Server returns a new instance of HTTP2Server. func NewHTTP2Server() *HTTP2Server { return &HTTP2Server{ listeners: make(map[net.Listener]bool), conns: make(map[*http2Connection]bool), } }
// http2MaxFrameLen specifies the max length of a HTTP2 frame. http2MaxFrameLen = 16384 // 16KiB frame // http2IOBufSize specifies the buffer size for sending frames. http2IOBufSize = 32 * 1024 // The default value of flow control window size in HTTP2 spec. defaultWindowSize = 65535 // 64KiB // The initial window size for flow control. initialWindowSize = defaultWindowSize // for an RPC initialConnWindowSize = defaultWindowSize * 16 // for a connection contentType = "application/grpc" ) var ( connectionLogger = leverutil.GetLogger(PackageName, "connection") ) type connectionState uint8 const ( stateReachable = iota stateClosing ) var ( clientPreface = []byte(http2.ClientPreface) ) type http2Connection struct { isServer bool
package store import ( "github.com/leveros/leveros/leverutil" ) // PackageName is the name of this package. const PackageName = "store" var logger = leverutil.GetLogger(PackageName, "store")
package http2stream import ( "net" "time" "github.com/leveros/leveros/leverutil" ) var clientLogger = leverutil.GetLogger(PackageName, "client") // HTTP2Client represents a collection of client HTTP2 connections. // The structure manages a connection pool internally. type HTTP2Client struct { conns *leverutil.Cache } // NewHTTP2Client creates a new HTTP2Client. func NewHTTP2Client( connectionConnectTimeout time.Duration, connectionExpiry time.Duration) (*HTTP2Client, error) { client := new(HTTP2Client) client.conns = leverutil.NewCache( connectionExpiry, func(addr string) (interface{}, error) { clientLogger.WithFields("addr", addr).Debug("New connection") netConn, err := net.DialTimeout( "tcp", addr, connectionConnectTimeout) if err != nil { return nil, err }
package fleettracker import ( "math" "sync" "sync/atomic" "time" consulapi "github.com/hashicorp/consul/api" "github.com/leveros/leveros/config" "github.com/leveros/leveros/leverutil" "github.com/leveros/leveros/scale" ) var trackerLogger = leverutil.GetLogger(PackageName, "loadtracker") var ( // TickNumEventsFlag is the number of events that the load tracker aims to // put in a tick length. Yet, due to {Min,Max}TickPeriodFlag, the number of // events may vary. TickNumEventsFlag = config.DeclareInt(PackageName, "tickNumEvents", 16) // MinTickPeriodFlag is the minimum time between load tracker ticks. MinTickPeriodFlag = config.DeclareDuration( PackageName, "minTickPeriod", 250*time.Millisecond) // MaxTickPeriodFlag is the maximum time between load tracker // ticks. Note: The period may still be longer than this if no events at all // come up for a while. MaxTickPeriodFlag = config.DeclareDuration( PackageName, "maxTickPeriod", 15*time.Second) // StatsExpPeriodFlag is the amount of time stats are taken into // consideration. This value is used for the computation of alpha in EWMA.
dockerapi "github.com/fsouza/go-dockerclient" consulapi "github.com/hashicorp/consul/api" "github.com/leveros/leveros/config" "github.com/leveros/leveros/core" "github.com/leveros/leveros/dockerutil" "github.com/leveros/leveros/hostman" "github.com/leveros/leveros/leverutil" "github.com/leveros/leveros/scale" "golang.org/x/net/context" "google.golang.org/grpc" ) // PackageName is the name of this package. const PackageName = "fleettracker" var logger = leverutil.GetLogger(PackageName, "fleettracker") // FleetTrackerService is the name of the fleettracker internal service. const FleetTrackerService = "fleettracker" var ( // InstanceIDFlag is the instance ID of the fleettracker. Note: This is a // different instance ID than leverutil.InstanceIDFlag because they serve // different things. InstanceIDFlag = config.DeclareString( PackageName, "instanceID", leverutil.RandomID()) // TTLFlag is the time after a service expires in fleettracker. If no RPC // event comes up during this span of time for a Lever service, fleettracker // stops keeping track of its stats (it is assumed all its instances // have expired anyway). TTLFlag = config.DeclareDuration(PackageName, "ttl", 20*time.Minute)
import ( "encoding/json" "fmt" "net/url" "strconv" "strings" "time" consulapi "github.com/hashicorp/consul/api" "github.com/leveros/leveros/config" "github.com/leveros/leveros/leverutil" "github.com/miekg/dns" ) var ( discoveryLogger = leverutil.GetLogger(PackageName, "discovery") ) var ( // DNSServerFlag is the DNS server address in format <ip>:<port>. Used for // service discovery. DNSServerFlag = config.DeclareString( PackageName, "dnsServer", "leverosconsul:8600") ) // ErrServiceNotFound is an error that is returned when a service with provided // name is not found. var ErrServiceNotFound = fmt.Errorf("Service not found") const ( consulResourcePrefix = "res/"