khenaidoo | b920354 | 2018-09-17 22:56:37 -0400 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2018-present Open Networking Foundation |
| 3 | |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | package core |
| 17 | |
| 18 | import ( |
| 19 | "context" |
sbarbari | 17d7e22 | 2019-11-05 10:02:29 -0500 | [diff] [blame^] | 20 | "github.com/opencord/voltha-go/db/model" |
khenaidoo | b920354 | 2018-09-17 22:56:37 -0400 | [diff] [blame] | 21 | "github.com/opencord/voltha-go/rw_core/config" |
sbarbari | 17d7e22 | 2019-11-05 10:02:29 -0500 | [diff] [blame^] | 22 | "github.com/opencord/voltha-lib-go/v2/pkg/db" |
Scott Baker | 807addd | 2019-10-24 15:16:21 -0700 | [diff] [blame] | 23 | "github.com/opencord/voltha-lib-go/v2/pkg/db/kvstore" |
Scott Baker | 807addd | 2019-10-24 15:16:21 -0700 | [diff] [blame] | 24 | grpcserver "github.com/opencord/voltha-lib-go/v2/pkg/grpc" |
| 25 | "github.com/opencord/voltha-lib-go/v2/pkg/kafka" |
| 26 | "github.com/opencord/voltha-lib-go/v2/pkg/log" |
| 27 | "github.com/opencord/voltha-lib-go/v2/pkg/probe" |
Scott Baker | 555307d | 2019-11-04 08:58:01 -0800 | [diff] [blame] | 28 | "github.com/opencord/voltha-protos/v2/go/voltha" |
khenaidoo | b920354 | 2018-09-17 22:56:37 -0400 | [diff] [blame] | 29 | "google.golang.org/grpc" |
khenaidoo | b324421 | 2019-08-27 14:32:27 -0400 | [diff] [blame] | 30 | "google.golang.org/grpc/codes" |
| 31 | "google.golang.org/grpc/status" |
| 32 | "time" |
khenaidoo | b920354 | 2018-09-17 22:56:37 -0400 | [diff] [blame] | 33 | ) |
| 34 | |
| 35 | type Core struct { |
| 36 | instanceId string |
| 37 | deviceMgr *DeviceManager |
| 38 | logicalDeviceMgr *LogicalDeviceManager |
| 39 | grpcServer *grpcserver.GrpcServer |
Richard Jankowski | dbab94a | 2018-12-06 16:20:25 -0500 | [diff] [blame] | 40 | grpcNBIAPIHandler *APIHandler |
khenaidoo | 2c6a099 | 2019-04-29 13:46:56 -0400 | [diff] [blame] | 41 | adapterMgr *AdapterManager |
khenaidoo | b920354 | 2018-09-17 22:56:37 -0400 | [diff] [blame] | 42 | config *config.RWCoreFlags |
khenaidoo | 43c8212 | 2018-11-22 18:38:28 -0500 | [diff] [blame] | 43 | kmp *kafka.InterContainerProxy |
khenaidoo | 92e62c5 | 2018-10-03 14:02:54 -0400 | [diff] [blame] | 44 | clusterDataRoot model.Root |
| 45 | localDataRoot model.Root |
khenaidoo | b920354 | 2018-09-17 22:56:37 -0400 | [diff] [blame] | 46 | clusterDataProxy *model.Proxy |
| 47 | localDataProxy *model.Proxy |
| 48 | exitChannel chan int |
Richard Jankowski | e4d7766 | 2018-10-17 13:53:21 -0400 | [diff] [blame] | 49 | kvClient kvstore.Client |
khenaidoo | 43c8212 | 2018-11-22 18:38:28 -0500 | [diff] [blame] | 50 | kafkaClient kafka.Client |
khenaidoo | 2c6a099 | 2019-04-29 13:46:56 -0400 | [diff] [blame] | 51 | deviceOwnership *DeviceOwnership |
khenaidoo | b920354 | 2018-09-17 22:56:37 -0400 | [diff] [blame] | 52 | } |
| 53 | |
| 54 | func init() { |
| 55 | log.AddPackage(log.JSON, log.WarnLevel, nil) |
| 56 | } |
| 57 | |
khenaidoo | 43c8212 | 2018-11-22 18:38:28 -0500 | [diff] [blame] | 58 | func NewCore(id string, cf *config.RWCoreFlags, kvClient kvstore.Client, kafkaClient kafka.Client) *Core { |
khenaidoo | b920354 | 2018-09-17 22:56:37 -0400 | [diff] [blame] | 59 | var core Core |
| 60 | core.instanceId = id |
| 61 | core.exitChannel = make(chan int, 1) |
| 62 | core.config = cf |
Richard Jankowski | e4d7766 | 2018-10-17 13:53:21 -0400 | [diff] [blame] | 63 | core.kvClient = kvClient |
khenaidoo | 43c8212 | 2018-11-22 18:38:28 -0500 | [diff] [blame] | 64 | core.kafkaClient = kafkaClient |
Richard Jankowski | e4d7766 | 2018-10-17 13:53:21 -0400 | [diff] [blame] | 65 | |
| 66 | // Setup the KV store |
sbarbari | 17d7e22 | 2019-11-05 10:02:29 -0500 | [diff] [blame^] | 67 | backend := db.Backend{ |
khenaidoo | 7ccedd5 | 2018-12-14 16:48:54 -0500 | [diff] [blame] | 68 | Client: kvClient, |
| 69 | StoreType: cf.KVStoreType, |
| 70 | Host: cf.KVStoreHost, |
| 71 | Port: cf.KVStorePort, |
| 72 | Timeout: cf.KVStoreTimeout, |
khenaidoo | 9cdc1a6 | 2019-01-24 21:57:40 -0500 | [diff] [blame] | 73 | PathPrefix: cf.KVStoreDataPrefix} |
khenaidoo | 7ccedd5 | 2018-12-14 16:48:54 -0500 | [diff] [blame] | 74 | core.clusterDataRoot = model.NewRoot(&voltha.Voltha{}, &backend) |
| 75 | core.localDataRoot = model.NewRoot(&voltha.CoreInstance{}, &backend) |
Stephane Barbarie | ef6650d | 2019-07-18 12:15:09 -0400 | [diff] [blame] | 76 | core.clusterDataProxy = core.clusterDataRoot.CreateProxy(context.Background(), "/", false) |
| 77 | core.localDataProxy = core.localDataRoot.CreateProxy(context.Background(), "/", false) |
khenaidoo | b920354 | 2018-09-17 22:56:37 -0400 | [diff] [blame] | 78 | return &core |
| 79 | } |
| 80 | |
| 81 | func (core *Core) Start(ctx context.Context) { |
David K. Bainbridge | b4a9ab0 | 2019-09-20 15:12:16 -0700 | [diff] [blame] | 82 | |
| 83 | // If the context has a probe then fetch it and register our services |
| 84 | var p *probe.Probe |
| 85 | if value := ctx.Value(probe.ProbeContextKey); value != nil { |
| 86 | if _, ok := value.(*probe.Probe); ok { |
| 87 | p = value.(*probe.Probe) |
| 88 | p.RegisterService( |
| 89 | "message-bus", |
| 90 | "kv-store", |
| 91 | "device-manager", |
| 92 | "logical-device-manager", |
| 93 | "adapter-manager", |
| 94 | "grpc-service", |
| 95 | ) |
| 96 | } |
| 97 | } |
| 98 | |
khenaidoo | b324421 | 2019-08-27 14:32:27 -0400 | [diff] [blame] | 99 | log.Info("starting-core-services", log.Fields{"coreId": core.instanceId}) |
| 100 | |
| 101 | // Wait until connection to KV Store is up |
| 102 | if err := core.waitUntilKVStoreReachableOrMaxTries(ctx, core.config.MaxConnectionRetries, core.config.ConnectionRetryInterval); err != nil { |
| 103 | log.Fatal("Unable-to-connect-to-KV-store") |
| 104 | } |
David K. Bainbridge | b4a9ab0 | 2019-09-20 15:12:16 -0700 | [diff] [blame] | 105 | if p != nil { |
| 106 | p.UpdateStatus("kv-store", probe.ServiceStatusRunning) |
| 107 | } |
khenaidoo | b324421 | 2019-08-27 14:32:27 -0400 | [diff] [blame] | 108 | |
| 109 | if err := core.waitUntilKafkaMessagingProxyIsUpOrMaxTries(ctx, core.config.MaxConnectionRetries, core.config.ConnectionRetryInterval); err != nil { |
khenaidoo | 9cdc1a6 | 2019-01-24 21:57:40 -0500 | [diff] [blame] | 110 | log.Fatal("Failure-starting-kafkaMessagingProxy") |
| 111 | } |
David K. Bainbridge | b4a9ab0 | 2019-09-20 15:12:16 -0700 | [diff] [blame] | 112 | if p != nil { |
| 113 | p.UpdateStatus("message-bus", probe.ServiceStatusRunning) |
| 114 | } |
khenaidoo | b324421 | 2019-08-27 14:32:27 -0400 | [diff] [blame] | 115 | |
khenaidoo | 631fe54 | 2019-05-31 15:44:43 -0400 | [diff] [blame] | 116 | log.Debugw("values", log.Fields{"kmp": core.kmp}) |
Richard Jankowski | 199fd86 | 2019-03-18 14:49:51 -0400 | [diff] [blame] | 117 | core.deviceMgr = newDeviceManager(core) |
khenaidoo | ba6b6c4 | 2019-08-02 09:11:56 -0400 | [diff] [blame] | 118 | core.adapterMgr = newAdapterManager(core.clusterDataProxy, core.instanceId, core.deviceMgr) |
| 119 | core.deviceMgr.adapterMgr = core.adapterMgr |
khenaidoo | 2c6a099 | 2019-04-29 13:46:56 -0400 | [diff] [blame] | 120 | core.logicalDeviceMgr = newLogicalDeviceManager(core, core.deviceMgr, core.kmp, core.clusterDataProxy, core.config.DefaultCoreTimeout) |
khenaidoo | 54e0ddf | 2019-02-27 16:21:33 -0500 | [diff] [blame] | 121 | |
| 122 | if err := core.registerAdapterRequestHandlers(ctx, core.instanceId, core.deviceMgr, core.logicalDeviceMgr, core.adapterMgr, core.clusterDataProxy, core.localDataProxy); err != nil { |
khenaidoo | 9cdc1a6 | 2019-01-24 21:57:40 -0500 | [diff] [blame] | 123 | log.Fatal("Failure-registering-adapterRequestHandler") |
| 124 | } |
khenaidoo | b324421 | 2019-08-27 14:32:27 -0400 | [diff] [blame] | 125 | |
khenaidoo | b920354 | 2018-09-17 22:56:37 -0400 | [diff] [blame] | 126 | go core.startDeviceManager(ctx) |
| 127 | go core.startLogicalDeviceManager(ctx) |
| 128 | go core.startGRPCService(ctx) |
khenaidoo | 21d5115 | 2019-02-01 13:48:37 -0500 | [diff] [blame] | 129 | go core.startAdapterManager(ctx) |
khenaidoo | b920354 | 2018-09-17 22:56:37 -0400 | [diff] [blame] | 130 | |
khenaidoo | 1ce37ad | 2019-03-24 22:07:24 -0400 | [diff] [blame] | 131 | // Setup device ownership context |
| 132 | core.deviceOwnership = NewDeviceOwnership(core.instanceId, core.kvClient, core.deviceMgr, core.logicalDeviceMgr, |
| 133 | "service/voltha/owns_device", 10) |
| 134 | |
khenaidoo | b324421 | 2019-08-27 14:32:27 -0400 | [diff] [blame] | 135 | log.Info("core-services-started") |
khenaidoo | b920354 | 2018-09-17 22:56:37 -0400 | [diff] [blame] | 136 | } |
| 137 | |
| 138 | func (core *Core) Stop(ctx context.Context) { |
khenaidoo | 1937407 | 2018-12-11 11:05:15 -0500 | [diff] [blame] | 139 | log.Info("stopping-adaptercore") |
David Bainbridge | f794fc5 | 2019-10-03 22:37:12 +0000 | [diff] [blame] | 140 | if core.exitChannel != nil { |
| 141 | core.exitChannel <- 1 |
| 142 | } |
khenaidoo | 43c8212 | 2018-11-22 18:38:28 -0500 | [diff] [blame] | 143 | // Stop all the started services |
David Bainbridge | f794fc5 | 2019-10-03 22:37:12 +0000 | [diff] [blame] | 144 | if core.grpcServer != nil { |
| 145 | core.grpcServer.Stop() |
| 146 | } |
| 147 | if core.logicalDeviceMgr != nil { |
| 148 | core.logicalDeviceMgr.stop(ctx) |
| 149 | } |
| 150 | if core.deviceMgr != nil { |
| 151 | core.deviceMgr.stop(ctx) |
| 152 | } |
| 153 | if core.kmp != nil { |
| 154 | core.kmp.Stop() |
| 155 | } |
khenaidoo | 1937407 | 2018-12-11 11:05:15 -0500 | [diff] [blame] | 156 | log.Info("adaptercore-stopped") |
khenaidoo | b920354 | 2018-09-17 22:56:37 -0400 | [diff] [blame] | 157 | } |
| 158 | |
khenaidoo | 631fe54 | 2019-05-31 15:44:43 -0400 | [diff] [blame] | 159 | //startGRPCService creates the grpc service handlers, registers it to the grpc server and starts the server |
khenaidoo | b920354 | 2018-09-17 22:56:37 -0400 | [diff] [blame] | 160 | func (core *Core) startGRPCService(ctx context.Context) { |
| 161 | // create an insecure gserver server |
| 162 | core.grpcServer = grpcserver.NewGrpcServer(core.config.GrpcHost, core.config.GrpcPort, nil, false) |
| 163 | log.Info("grpc-server-created") |
| 164 | |
khenaidoo | 54e0ddf | 2019-02-27 16:21:33 -0500 | [diff] [blame] | 165 | core.grpcNBIAPIHandler = NewAPIHandler(core) |
Richard Jankowski | 46464e9 | 2019-03-05 11:53:55 -0500 | [diff] [blame] | 166 | log.Infow("grpc-handler", log.Fields{"core_binding_key": core.config.CoreBindingKey}) |
Richard Jankowski | dbab94a | 2018-12-06 16:20:25 -0500 | [diff] [blame] | 167 | core.logicalDeviceMgr.setGrpcNbiHandler(core.grpcNBIAPIHandler) |
khenaidoo | b920354 | 2018-09-17 22:56:37 -0400 | [diff] [blame] | 168 | // Create a function to register the core GRPC service with the GRPC server |
| 169 | f := func(gs *grpc.Server) { |
| 170 | voltha.RegisterVolthaServiceServer( |
| 171 | gs, |
Richard Jankowski | dbab94a | 2018-12-06 16:20:25 -0500 | [diff] [blame] | 172 | core.grpcNBIAPIHandler, |
khenaidoo | b920354 | 2018-09-17 22:56:37 -0400 | [diff] [blame] | 173 | ) |
| 174 | } |
| 175 | |
| 176 | core.grpcServer.AddService(f) |
| 177 | log.Info("grpc-service-added") |
| 178 | |
David K. Bainbridge | b4a9ab0 | 2019-09-20 15:12:16 -0700 | [diff] [blame] | 179 | /* |
| 180 | * Start the GRPC server |
| 181 | * |
| 182 | * This is a bit sub-optimal here as the grpcServer.Start call does not return (blocks) |
| 183 | * until something fails, but we want to send a "start" status update. As written this |
| 184 | * means that we are actually sending the "start" status update before the server is |
| 185 | * started, which means it is possible that the status is "running" before it actually is. |
| 186 | * |
| 187 | * This means that there is a small window in which the core could return its status as |
| 188 | * ready, when it really isn't. |
| 189 | */ |
| 190 | probe.UpdateStatusFromContext(ctx, "grpc-service", probe.ServiceStatusRunning) |
khenaidoo | b920354 | 2018-09-17 22:56:37 -0400 | [diff] [blame] | 191 | log.Info("grpc-server-started") |
David K. Bainbridge | b4a9ab0 | 2019-09-20 15:12:16 -0700 | [diff] [blame] | 192 | core.grpcServer.Start(context.Background()) |
| 193 | probe.UpdateStatusFromContext(ctx, "grpc-service", probe.ServiceStatusStopped) |
khenaidoo | b920354 | 2018-09-17 22:56:37 -0400 | [diff] [blame] | 194 | } |
| 195 | |
khenaidoo | b324421 | 2019-08-27 14:32:27 -0400 | [diff] [blame] | 196 | func (core *Core) waitUntilKafkaMessagingProxyIsUpOrMaxTries(ctx context.Context, maxRetries int, retryInterval int) error { |
khenaidoo | b920354 | 2018-09-17 22:56:37 -0400 | [diff] [blame] | 197 | log.Infow("starting-kafka-messaging-proxy", log.Fields{"host": core.config.KafkaAdapterHost, |
| 198 | "port": core.config.KafkaAdapterPort, "topic": core.config.CoreTopic}) |
| 199 | var err error |
khenaidoo | 43c8212 | 2018-11-22 18:38:28 -0500 | [diff] [blame] | 200 | if core.kmp, err = kafka.NewInterContainerProxy( |
| 201 | kafka.InterContainerHost(core.config.KafkaAdapterHost), |
| 202 | kafka.InterContainerPort(core.config.KafkaAdapterPort), |
| 203 | kafka.MsgClient(core.kafkaClient), |
khenaidoo | 7923270 | 2018-12-04 11:00:41 -0500 | [diff] [blame] | 204 | kafka.DefaultTopic(&kafka.Topic{Name: core.config.CoreTopic}), |
| 205 | kafka.DeviceDiscoveryTopic(&kafka.Topic{Name: core.config.AffinityRouterTopic})); err != nil { |
khenaidoo | b920354 | 2018-09-17 22:56:37 -0400 | [diff] [blame] | 206 | log.Errorw("fail-to-create-kafka-proxy", log.Fields{"error": err}) |
| 207 | return err |
| 208 | } |
khenaidoo | b324421 | 2019-08-27 14:32:27 -0400 | [diff] [blame] | 209 | count := 0 |
| 210 | for { |
| 211 | if err = core.kmp.Start(); err != nil { |
| 212 | log.Infow("error-starting-kafka-messaging-proxy", log.Fields{"error": err}) |
| 213 | if maxRetries != -1 { |
| 214 | if count >= maxRetries { |
| 215 | return err |
| 216 | } |
| 217 | } |
| 218 | count += 1 |
| 219 | log.Infow("retry-starting-kafka-messaging-proxy", log.Fields{"retryCount": count, "maxRetries": maxRetries, "retryInterval": retryInterval}) |
| 220 | // Take a nap before retrying |
| 221 | time.Sleep(time.Duration(retryInterval) * time.Second) |
| 222 | } else { |
| 223 | break |
| 224 | } |
khenaidoo | b920354 | 2018-09-17 22:56:37 -0400 | [diff] [blame] | 225 | } |
khenaidoo | b920354 | 2018-09-17 22:56:37 -0400 | [diff] [blame] | 226 | log.Info("kafka-messaging-proxy-created") |
| 227 | return nil |
| 228 | } |
| 229 | |
khenaidoo | b324421 | 2019-08-27 14:32:27 -0400 | [diff] [blame] | 230 | // waitUntilKVStoreReachableOrMaxTries will wait until it can connect to a KV store or until maxtries has been reached |
| 231 | func (core *Core) waitUntilKVStoreReachableOrMaxTries(ctx context.Context, maxRetries int, retryInterval int) error { |
| 232 | log.Infow("verifying-KV-store-connectivity", log.Fields{"host": core.config.KVStoreHost, |
| 233 | "port": core.config.KVStorePort, "retries": maxRetries, "retryInterval": retryInterval}) |
| 234 | // Get timeout in seconds with 1 second set as minimum |
| 235 | timeout := int(core.config.DefaultCoreTimeout / 1000) |
| 236 | if timeout < 1 { |
| 237 | timeout = 1 |
| 238 | } |
| 239 | count := 0 |
| 240 | for { |
| 241 | if !core.kvClient.IsConnectionUp(timeout) { |
| 242 | log.Info("KV-store-unreachable") |
| 243 | if maxRetries != -1 { |
| 244 | if count >= maxRetries { |
| 245 | return status.Error(codes.Unavailable, "kv store unreachable") |
| 246 | } |
| 247 | } |
| 248 | count += 1 |
| 249 | // Take a nap before retrying |
| 250 | time.Sleep(time.Duration(retryInterval) * time.Second) |
| 251 | log.Infow("retry-KV-store-connectivity", log.Fields{"retryCount": count, "maxRetries": maxRetries, "retryInterval": retryInterval}) |
| 252 | |
| 253 | } else { |
| 254 | break |
| 255 | } |
| 256 | } |
| 257 | log.Info("KV-store-reachable") |
| 258 | return nil |
| 259 | } |
| 260 | |
khenaidoo | 54e0ddf | 2019-02-27 16:21:33 -0500 | [diff] [blame] | 261 | func (core *Core) registerAdapterRequestHandlers(ctx context.Context, coreInstanceId string, dMgr *DeviceManager, |
khenaidoo | 297cd25 | 2019-02-07 22:10:23 -0500 | [diff] [blame] | 262 | ldMgr *LogicalDeviceManager, aMgr *AdapterManager, cdProxy *model.Proxy, ldProxy *model.Proxy, |
khenaidoo | 54e0ddf | 2019-02-27 16:21:33 -0500 | [diff] [blame] | 263 | ) error { |
Richard Jankowski | 199fd86 | 2019-03-18 14:49:51 -0400 | [diff] [blame] | 264 | requestProxy := NewAdapterRequestHandlerProxy(core, coreInstanceId, dMgr, ldMgr, aMgr, cdProxy, ldProxy, |
khenaidoo | 297cd25 | 2019-02-07 22:10:23 -0500 | [diff] [blame] | 265 | core.config.InCompetingMode, core.config.LongRunningRequestTimeout, core.config.DefaultRequestTimeout) |
khenaidoo | b920354 | 2018-09-17 22:56:37 -0400 | [diff] [blame] | 266 | |
khenaidoo | 54e0ddf | 2019-02-27 16:21:33 -0500 | [diff] [blame] | 267 | // Register the broadcast topic to handle any core-bound broadcast requests |
| 268 | if err := core.kmp.SubscribeWithRequestHandlerInterface(kafka.Topic{Name: core.config.CoreTopic}, requestProxy); err != nil { |
| 269 | log.Fatalw("Failed-registering-broadcast-handler", log.Fields{"topic": core.config.CoreTopic}) |
| 270 | return err |
| 271 | } |
| 272 | |
Kent Hagerman | a6d0c36 | 2019-07-30 12:50:21 -0400 | [diff] [blame] | 273 | // Register the core-pair topic to handle core-bound requests destined to the core pair |
| 274 | if err := core.kmp.SubscribeWithDefaultRequestHandler(kafka.Topic{Name: core.config.CorePairTopic}, kafka.OffsetNewest); err != nil { |
| 275 | log.Fatalw("Failed-registering-pair-handler", log.Fields{"topic": core.config.CorePairTopic}) |
| 276 | return err |
| 277 | } |
| 278 | |
khenaidoo | 54e0ddf | 2019-02-27 16:21:33 -0500 | [diff] [blame] | 279 | log.Info("request-handler-registered") |
khenaidoo | b920354 | 2018-09-17 22:56:37 -0400 | [diff] [blame] | 280 | return nil |
| 281 | } |
| 282 | |
| 283 | func (core *Core) startDeviceManager(ctx context.Context) { |
khenaidoo | 21d5115 | 2019-02-01 13:48:37 -0500 | [diff] [blame] | 284 | log.Info("DeviceManager-Starting...") |
khenaidoo | 4d4802d | 2018-10-04 21:59:49 -0400 | [diff] [blame] | 285 | core.deviceMgr.start(ctx, core.logicalDeviceMgr) |
khenaidoo | 21d5115 | 2019-02-01 13:48:37 -0500 | [diff] [blame] | 286 | log.Info("DeviceManager-Started") |
khenaidoo | b920354 | 2018-09-17 22:56:37 -0400 | [diff] [blame] | 287 | } |
| 288 | |
| 289 | func (core *Core) startLogicalDeviceManager(ctx context.Context) { |
khenaidoo | 21d5115 | 2019-02-01 13:48:37 -0500 | [diff] [blame] | 290 | log.Info("Logical-DeviceManager-Starting...") |
khenaidoo | 4d4802d | 2018-10-04 21:59:49 -0400 | [diff] [blame] | 291 | core.logicalDeviceMgr.start(ctx) |
khenaidoo | 21d5115 | 2019-02-01 13:48:37 -0500 | [diff] [blame] | 292 | log.Info("Logical-DeviceManager-Started") |
khenaidoo | b920354 | 2018-09-17 22:56:37 -0400 | [diff] [blame] | 293 | } |
khenaidoo | 21d5115 | 2019-02-01 13:48:37 -0500 | [diff] [blame] | 294 | |
| 295 | func (core *Core) startAdapterManager(ctx context.Context) { |
| 296 | log.Info("Adapter-Manager-Starting...") |
| 297 | core.adapterMgr.start(ctx) |
| 298 | log.Info("Adapter-Manager-Started") |
William Kurkian | daa6bb2 | 2019-03-07 12:26:28 -0500 | [diff] [blame] | 299 | } |