func NewLock(
logger lager.Logger,
consulClient consuladapter.Client,
lockKey string,
lockValue []byte,
clock clock.Clock,
retryInterval time.Duration,
lockTTL time.Duration,
) Lock {
lockMetricName := strings.Replace(lockKey, "/", "-", -1)
uuid, err := uuid.NewV4()
if err != nil {
logger.Fatal("create-uuid-failed", err)
}
session, err := NewSessionNoChecks(uuid.String(), lockTTL, consulClient)
if err != nil {
logger.Fatal("consul-session-failed", err)
}
return Lock{
consul: session,
key: lockKey,
value: lockValue,
clock: clock,
retryInterval: retryInterval,
logger: logger,
lockAcquiredMetric: metric.Metric("LockHeld." + lockMetricName),
lockUptimeMetric: metric.Duration("LockHeldDuration." + lockMetricName),
}
}
func sendUnmountDurationMetrics(logger lager.Logger, duration time.Duration, driverId string) {
err := volmanUnmountDuration.Send(duration)
if err != nil {
logger.Error("failed-to-send-volman-unmount-duration-metric", err)
}
m, ok := driverUnmountDurations[driverId]
if !ok {
m = metric.Duration("VolmanUnmountDurationFor" + driverId)
driverUnmountDurations[driverId] = m
}
err = m.Send(duration)
if err != nil {
logger.Error("failed-to-send-volman-unmount-duration-metric", err)
}
}
package middleware
import (
"net/http"
"time"
"code.cloudfoundry.org/lager"
"code.cloudfoundry.org/runtimeschema/metric"
)
const (
requestLatency = metric.Duration("RequestLatency")
requestCount = metric.Counter("RequestCount")
)
type LoggableHandlerFunc func(logger lager.Logger, w http.ResponseWriter, r *http.Request)
func LogWrap(logger, accessLogger lager.Logger, loggableHandlerFunc LoggableHandlerFunc) http.HandlerFunc {
lagerDataFromReq := func(r *http.Request) lager.Data {
return lager.Data{
"method": r.Method,
"request": r.URL.String(),
}
}
if accessLogger != nil {
return func(w http.ResponseWriter, r *http.Request) {
requestLog := logger.Session("request", lagerDataFromReq(r))
requestAccessLogger := accessLogger.Session("request", lagerDataFromReq(r))
requestAccessLogger.Info("serving")
"sync"
"sync/atomic"
"time"
"code.cloudfoundry.org/auctioneer"
"code.cloudfoundry.org/bbs/models"
"code.cloudfoundry.org/workpool"
"code.cloudfoundry.org/clock"
"code.cloudfoundry.org/lager"
"code.cloudfoundry.org/runtimeschema/metric"
)
const (
convergeLRPRunsCounter = metric.Counter("ConvergenceLRPRuns")
convergeLRPDuration = metric.Duration("ConvergenceLRPDuration")
malformedSchedulingInfosMetric = metric.Counter("ConvergenceLRPPreProcessingMalformedSchedulingInfos")
malformedRunInfosMetric = metric.Counter("ConvergenceLRPPreProcessingMalformedRunInfos")
actualLRPsDeleted = metric.Counter("ConvergenceLRPPreProcessingActualLRPsDeleted")
orphanedRunInfosMetric = metric.Counter("ConvergenceLRPPreProcessingOrphanedRunInfos")
desiredLRPs = metric.Metric("LRPsDesired")
claimedLRPs = metric.Metric("LRPsClaimed")
unclaimedLRPs = metric.Metric("LRPsUnclaimed")
runningLRPs = metric.Metric("LRPsRunning")
missingLRPs = metric.Metric("LRPsMissing")
extraLRPs = metric.Metric("LRPsExtra")
crashedActualLRPs = metric.Metric("CrashedActualLRPs")
package etcd
import (
"time"
"code.cloudfoundry.org/auctioneer"
"code.cloudfoundry.org/bbs/models"
"code.cloudfoundry.org/lager"
"code.cloudfoundry.org/runtimeschema/metric"
"code.cloudfoundry.org/workpool"
)
const (
convergeTaskRunsCounter = metric.Counter("ConvergenceTaskRuns")
convergeTaskDuration = metric.Duration("ConvergenceTaskDuration")
tasksKickedCounter = metric.Counter("ConvergenceTasksKicked")
tasksPrunedCounter = metric.Counter("ConvergenceTasksPruned")
pendingTasks = metric.Metric("TasksPending")
runningTasks = metric.Metric("TasksRunning")
completedTasks = metric.Metric("TasksCompleted")
resolvingTasks = metric.Metric("TasksResolving")
)
type compareAndSwappableTask struct {
OldIndex uint64
NewTask *models.Task
}
func (db *ETCDDB) ConvergeTasks(
"context"
"code.cloudfoundry.org/clock"
"code.cloudfoundry.org/lager"
"code.cloudfoundry.org/runtimeschema/metric"
"code.cloudfoundry.org/voldriver"
"code.cloudfoundry.org/voldriver/driverhttp"
"code.cloudfoundry.org/volman"
"github.com/tedsuo/ifrit/grouper"
"os"
)
const (
volmanMountErrorsCounter = metric.Counter("VolmanMountErrors")
volmanMountDuration = metric.Duration("VolmanMountDuration")
volmanUnmountErrorsCounter = metric.Counter("VolmanUnmountErrors")
volmanUnmountDuration = metric.Duration("VolmanUnmountDuration")
)
var (
driverMountDurations = map[string]metric.Duration{}
driverUnmountDurations = map[string]metric.Duration{}
)
type DriverConfig struct {
DriverPaths []string
SyncInterval time.Duration
}
func NewDriverConfig() DriverConfig {
"fmt"
"os"
"sort"
"time"
"code.cloudfoundry.org/bbs/db"
"code.cloudfoundry.org/bbs/db/etcd"
"code.cloudfoundry.org/bbs/encryption"
"code.cloudfoundry.org/bbs/models"
"code.cloudfoundry.org/clock"
"code.cloudfoundry.org/lager"
"code.cloudfoundry.org/runtimeschema/metric"
)
const (
migrationDuration = metric.Duration("MigrationDuration")
)
type Manager struct {
logger lager.Logger
etcdDB db.DB
storeClient etcd.StoreClient
sqlDB db.DB
rawSQLDB *sql.DB
cryptor encryption.Cryptor
migrations []Migration
migrationsDone chan<- struct{}
clock clock.Clock
databaseDriver string
}
package encryptor
import (
"errors"
"os"
"code.cloudfoundry.org/bbs/db"
"code.cloudfoundry.org/bbs/encryption"
"code.cloudfoundry.org/bbs/models"
"code.cloudfoundry.org/clock"
"code.cloudfoundry.org/lager"
"code.cloudfoundry.org/runtimeschema/metric"
)
const (
encryptionDuration = metric.Duration("EncryptionDuration")
)
type Encryptor struct {
logger lager.Logger
db db.EncryptionDB
keyManager encryption.KeyManager
cryptor encryption.Cryptor
clock clock.Clock
}
func New(
logger lager.Logger,
db db.EncryptionDB,
keyManager encryption.KeyManager,
cryptor encryption.Cryptor,