func initializeEtcdDB(
logger lager.Logger,
cryptor encryption.Cryptor,
storeClient etcddb.StoreClient,
cbClient taskworkpool.TaskCompletionClient,
serviceClient bbs.ServiceClient,
desiredLRPCreationMaxTime time.Duration,
) *etcddb.ETCDDB {
return etcddb.NewETCD(
format.ENCRYPTED_PROTO,
*convergenceWorkers,
*updateWorkers,
desiredLRPCreationMaxTime,
cryptor,
storeClient,
clock.NewClock(),
)
}
func initializeEtcdDB(
logger lager.Logger,
cryptor encryption.Cryptor,
storeClient etcddb.StoreClient,
cbClient taskworkpool.TaskCompletionClient,
serviceClient bbs.ServiceClient,
) *etcddb.ETCDDB {
return etcddb.NewETCD(
format.ENCRYPTED_PROTO,
*convergenceWorkers,
*updateWorkers,
cryptor,
storeClient,
initializeAuctioneerClient(logger),
serviceClient,
clock.NewClock(),
rep.NewClientFactory(cf_http.NewClient(), cf_http.NewClient()),
cbClient,
)
}
fakeAuctioneerClient = new(auctioneerfakes.FakeClient)
etcdRunner.Reset()
consulRunner.Reset()
consulSession = consulRunner.NewSession("a-session")
etcdClient := etcdRunner.Client()
etcdClient.SetConsistency(etcdclient.STRONG_CONSISTENCY)
storeClient = etcd.NewStoreClient(etcdClient)
fakeStoreClient = &fakes.FakeStoreClient{}
consulHelper = test_helpers.NewConsulHelper(consulSession)
serviceClient = bbs.NewServiceClient(consulSession, clock)
fakeTaskCompletionClient = new(faketaskworkpool.FakeTaskCompletionClient)
fakeRepClientFactory = new(repfakes.FakeClientFactory)
fakeRepClient = new(repfakes.FakeClient)
fakeRepClientFactory.CreateClientReturns(fakeRepClient)
etcdHelper = etcd_helpers.NewETCDHelper(format.ENCRYPTED_PROTO, cryptor, storeClient)
etcdDB = etcd.NewETCD(format.ENCRYPTED_PROTO, 100, 100, cryptor, storeClient, fakeAuctioneerClient, serviceClient, clock, fakeRepClientFactory, fakeTaskCompletionClient)
etcdDBWithFakeStore = etcd.NewETCD(format.ENCRYPTED_PROTO, 100, 100, cryptor, fakeStoreClient, fakeAuctioneerClient, serviceClient, clock, fakeRepClientFactory, fakeTaskCompletionClient)
})
func registerCell(cell models.CellPresence) {
var err error
jsonBytes, err := json.Marshal(cell)
Expect(err).NotTo(HaveOccurred())
_, err = consulSession.SetPresence(bbs.CellSchemaPath(cell.CellID), jsonBytes)
Expect(err).NotTo(HaveOccurred())
}
encoder = format.NewEncoder(cryptor)
encoded1, err := encoder.Encode(format.BASE64_ENCRYPTED, value1)
Expect(err).NotTo(HaveOccurred())
encoded2, err := encoder.Encode(format.LEGACY_UNENCODED, value2)
Expect(err).NotTo(HaveOccurred())
_, err = storeClient.Set(fmt.Sprintf("%s/my/key-1", etcd.V1SchemaRoot), encoded1, etcd.NO_TTL)
Expect(err).NotTo(HaveOccurred())
_, err = storeClient.Set(fmt.Sprintf("%s/my/nested/key-2", etcd.V1SchemaRoot), encoded2, etcd.NO_TTL)
Expect(err).NotTo(HaveOccurred())
cryptor = makeCryptor("new", "old")
etcdDB = etcd.NewETCD(format.ENCRYPTED_PROTO, 100, 100, DesiredLRPCreationTimeout, cryptor, storeClient, clock)
err = etcdDB.PerformEncryption(logger)
Expect(err).NotTo(HaveOccurred())
cryptor = makeCryptor("new")
encoder = format.NewEncoder(cryptor)
res, err := storeClient.Get(fmt.Sprintf("%s/my/key-1", etcd.V1SchemaRoot), false, false)
Expect(err).NotTo(HaveOccurred())
decrypted1, err := encoder.Decode([]byte(res.Node.Value))
Expect(err).NotTo(HaveOccurred())
Expect(decrypted1).To(Equal(value1))
res, err = storeClient.Get(fmt.Sprintf("%s/my/nested/key-2", etcd.V1SchemaRoot), false, false)
Expect(err).NotTo(HaveOccurred())
decrypted2, err := encoder.Decode([]byte(res.Node.Value))
)
logger = lagertest.NewTestLogger("test")
consulRunner.Start()
consulRunner.WaitUntilReady()
etcdRunner.Start()
})
var _ = AfterSuite(func() {
etcdRunner.Stop()
consulRunner.Stop()
})
var _ = BeforeEach(func() {
auctioneerClient = new(fakeauctioneer.FakeClient)
cellClient = new(fakecellhandlers.FakeClient)
etcdRunner.Reset()
consulRunner.Reset()
consulSession = consulRunner.NewSession("a-session")
etcdClient = etcdRunner.Client()
etcdClient.SetConsistency(etcdclient.STRONG_CONSISTENCY)
etcdHelper = etcd_helpers.NewETCDHelper(etcdClient)
consulHelper = consul_helpers.NewConsulHelper(consulSession)
cellDB = consul.NewConsul(consulSession)
etcdDB = etcd.NewETCD(etcdClient, auctioneerClient, cellClient, cellDB, clock)
})
db *etcddb.ETCDDB
logger *lagertest.TestLogger
)
BeforeEach(func() {
logger = lagertest.NewTestLogger("test")
encryptionKey, err := encryption.NewKey("label", "passphrase")
Expect(err).NotTo(HaveOccurred())
keyManager, err := encryption.NewKeyManager(encryptionKey, nil)
Expect(err).NotTo(HaveOccurred())
cryptor = encryption.NewCryptor(keyManager, rand.Reader)
serializer = format.NewSerializer(cryptor)
migration = migrations.NewTimeoutMilliseconds()
db = etcddb.NewETCD(format.ENCRYPTED_PROTO, 1, 1, 1*time.Minute, cryptor, storeClient, fakeClock)
})
It("appends itself to the migration list", func() {
Expect(migrations.Migrations).To(ContainElement(migration))
})
Describe("Version", func() {
It("returns the timestamp from which it was created", func() {
Expect(migration.Version()).To(BeEquivalentTo(1451635200))
})
})
Describe("Down", func() {
It("returns a not implemented error", func() {
Expect(migration.Down(logger)).To(HaveOccurred())
func TestEncryptor(t *testing.T) {
RegisterFailHandler(Fail)
RunSpecs(t, "Encryptor Suite")
}
var _ = BeforeSuite(func() {
etcdPort = 4001 + GinkgoParallelNode()
etcdUrl = fmt.Sprintf("http://127.0.0.1:%d", etcdPort)
etcdRunner = etcdstorerunner.NewETCDClusterRunner(etcdPort, 1, nil)
etcdRunner.Start()
})
var _ = AfterSuite(func() {
etcdRunner.Stop()
})
var _ = BeforeEach(func() {
etcdRunner.Reset()
etcdClient := etcdRunner.Client()
etcdClient.SetConsistency(etcdclient.STRONG_CONSISTENCY)
storeClient = etcd.NewStoreClient(etcdClient)
encryptionKey, err := encryption.NewKey("label", "passphrase")
Expect(err).NotTo(HaveOccurred())
keyManager, err := encryption.NewKeyManager(encryptionKey, nil)
Expect(err).NotTo(HaveOccurred())
cryptor := encryption.NewCryptor(keyManager, rand.Reader)
etcdDB = etcd.NewETCD(format.ENCRYPTED_PROTO, 100, 100, cryptor, storeClient, nil, nil, nil, nil, nil)
})
func main() {
cf_debug_server.AddFlags(flag.CommandLine)
cf_lager.AddFlags(flag.CommandLine)
etcdFlags := AddETCDFlags(flag.CommandLine)
flag.Parse()
cf_http.Initialize(*communicationTimeout)
logger, reconfigurableSink := cf_lager.New("bbs")
logger.Info("starting")
initializeDropsonde(logger)
etcdOptions, err := etcdFlags.Validate()
if err != nil {
logger.Fatal("etcd-validation-failed", err)
}
var etcdClient *etcdclient.Client
if etcdOptions.IsSSL {
etcdClient, err = etcdclient.NewTLSClient(etcdOptions.ClusterUrls, etcdOptions.CertFile, etcdOptions.KeyFile, etcdOptions.CAFile)
if err != nil {
logger.Fatal("failed-to-construct-etcd-tls-client", err)
}
} else {
etcdClient = etcdclient.NewClient(etcdOptions.ClusterUrls)
}
etcdClient.SetConsistency(etcdclient.STRONG_CONSISTENCY)
err = validateAuctioneerFlag()
if err != nil {
logger.Fatal("auctioneer-address-validation-failed", err)
}
auctioneerClient := auctionhandlers.NewClient(*auctioneerAddress)
consulSession := initializeConsul(logger)
consulDB := consuldb.NewConsul(consulSession)
cellClient := cellhandlers.NewClient()
db := etcddb.NewETCD(etcdClient, auctioneerClient, cellClient, consulDB, clock.NewClock())
hub := events.NewHub()
watcher := watcher.NewWatcher(
logger,
db,
hub,
clock.NewClock(),
bbsWatchRetryWaitDuration,
)
handler := handlers.New(logger, db, hub)
members := grouper.Members{
{"watcher", watcher},
{"server", http_server.New(*serverAddress, handler)},
{"hub-closer", closeHub(logger.Session("hub-closer"), hub)},
}
if dbgAddr := cf_debug_server.DebugAddress(flag.CommandLine); dbgAddr != "" {
members = append(grouper.Members{
{"debug-server", cf_debug_server.Runner(dbgAddr, reconfigurableSink)},
}, members...)
}
group := grouper.NewOrdered(os.Interrupt, members)
monitor := ifrit.Invoke(sigmon.New(group))
logger.Info("started")
err = <-monitor.Wait()
if err != nil {
logger.Error("exited-with-failure", err)
os.Exit(1)
}
logger.Info("exited")
}