Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [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 | |
| 17 | package common |
| 18 | |
Zdravko Bozakov | 3ddb245 | 2019-11-29 14:33:41 +0100 | [diff] [blame] | 19 | import ( |
| 20 | "flag" |
| 21 | "fmt" |
| 22 | "io/ioutil" |
| 23 | "net" |
Matteo Scandolo | f65e687 | 2020-04-15 15:18:43 -0700 | [diff] [blame] | 24 | "strings" |
Shrey Baid | 64cda47 | 2020-04-24 18:58:18 +0530 | [diff] [blame] | 25 | |
Matteo Scandolo | 4a03626 | 2020-08-17 15:56:13 -0700 | [diff] [blame] | 26 | "github.com/imdario/mergo" |
Shrey Baid | 64cda47 | 2020-04-24 18:58:18 +0530 | [diff] [blame] | 27 | log "github.com/sirupsen/logrus" |
Matteo Scandolo | 4a03626 | 2020-08-17 15:56:13 -0700 | [diff] [blame] | 28 | "gopkg.in/yaml.v2" |
Matteo Scandolo | f65e687 | 2020-04-15 15:18:43 -0700 | [diff] [blame] | 29 | ) |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 30 | |
Matteo Scandolo | f65e687 | 2020-04-15 15:18:43 -0700 | [diff] [blame] | 31 | var tagAllocationValues = []string{ |
| 32 | "unknown", |
| 33 | "shared", |
| 34 | "unique", |
| 35 | } |
| 36 | |
| 37 | type TagAllocation int |
| 38 | |
| 39 | func (t TagAllocation) String() string { |
| 40 | return tagAllocationValues[t] |
| 41 | } |
| 42 | |
| 43 | func tagAllocationFromString(s string) (TagAllocation, error) { |
| 44 | for i, v := range tagAllocationValues { |
Matteo Scandolo | 4a03626 | 2020-08-17 15:56:13 -0700 | [diff] [blame] | 45 | if v == strings.TrimSpace(s) { |
Matteo Scandolo | f65e687 | 2020-04-15 15:18:43 -0700 | [diff] [blame] | 46 | return TagAllocation(i), nil |
| 47 | } |
| 48 | } |
| 49 | log.WithFields(log.Fields{ |
| 50 | "ValidValues": strings.Join(tagAllocationValues[1:], ", "), |
| 51 | }).Errorf("%s-is-not-a-valid-tag-allocation", s) |
Shrey Baid | 688b424 | 2020-07-10 20:40:10 +0530 | [diff] [blame] | 52 | return TagAllocation(0), fmt.Errorf("%s-is-not-a-valid-tag-allocation", s) |
Matteo Scandolo | f65e687 | 2020-04-15 15:18:43 -0700 | [diff] [blame] | 53 | } |
| 54 | |
| 55 | const ( |
| 56 | _ TagAllocation = iota |
| 57 | TagAllocationShared |
| 58 | TagAllocationUnique |
| 59 | ) |
| 60 | |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 61 | type BBRCliOptions struct { |
Matteo Scandolo | 4a03626 | 2020-08-17 15:56:13 -0700 | [diff] [blame] | 62 | *GlobalConfig |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 63 | BBSimIp string |
| 64 | BBSimPort string |
| 65 | BBSimApiPort string |
Matteo Scandolo | f5c537e | 2019-10-28 16:45:57 -0700 | [diff] [blame] | 66 | LogFile string |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 67 | } |
| 68 | |
Matteo Scandolo | 4a03626 | 2020-08-17 15:56:13 -0700 | [diff] [blame] | 69 | type GlobalConfig struct { |
Zdravko Bozakov | 3ddb245 | 2019-11-29 14:33:41 +0100 | [diff] [blame] | 70 | BBSim BBSimConfig |
| 71 | Olt OltConfig |
| 72 | BBR BBRConfig |
| 73 | } |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 74 | |
Zdravko Bozakov | 3ddb245 | 2019-11-29 14:33:41 +0100 | [diff] [blame] | 75 | type OltConfig struct { |
| 76 | Model string `yaml:"model"` |
| 77 | Vendor string `yaml:"vendor"` |
| 78 | HardwareVersion string `yaml:"hardware_version"` |
| 79 | FirmwareVersion string `yaml:"firmware_version"` |
| 80 | DeviceId string `yaml:"device_id"` |
| 81 | DeviceSerialNumber string `yaml:"device_serial_number"` |
| 82 | PonPorts uint32 `yaml:"pon_ports"` |
| 83 | NniPorts uint32 `yaml:"nni_ports"` |
| 84 | OnusPonPort uint32 `yaml:"onus_per_port"` |
| 85 | Technology string `yaml:"technology"` |
| 86 | ID int `yaml:"id"` |
| 87 | OltRebootDelay int `yaml:"reboot_delay"` |
Shrey Baid | 688b424 | 2020-07-10 20:40:10 +0530 | [diff] [blame] | 88 | PortStatsInterval int `yaml:"port_stats_interval"` |
Zdravko Bozakov | 3ddb245 | 2019-11-29 14:33:41 +0100 | [diff] [blame] | 89 | } |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 90 | |
Zdravko Bozakov | 3ddb245 | 2019-11-29 14:33:41 +0100 | [diff] [blame] | 91 | type BBSimConfig struct { |
Matteo Scandolo | 4a03626 | 2020-08-17 15:56:13 -0700 | [diff] [blame] | 92 | ConfigFile string |
| 93 | ServiceConfigFile string |
| 94 | DhcpRetry bool `yaml:"dhcp_retry"` |
| 95 | AuthRetry bool `yaml:"auth_retry"` |
| 96 | LogLevel string `yaml:"log_level"` |
| 97 | LogCaller bool `yaml:"log_caller"` |
| 98 | Delay int `yaml:"delay"` |
| 99 | CpuProfile *string `yaml:"cpu_profile"` |
| 100 | OpenOltAddress string `yaml:"openolt_address"` |
| 101 | ApiAddress string `yaml:"api_address"` |
| 102 | RestApiAddress string `yaml:"rest_api_address"` |
| 103 | LegacyApiAddress string `yaml:"legacy_api_address"` |
| 104 | LegacyRestApiAddress string `yaml:"legacy_rest_api_address"` |
| 105 | SadisRestAddress string `yaml:"sadis_rest_address"` |
| 106 | SadisServer bool `yaml:"sadis_server"` |
| 107 | KafkaAddress string `yaml:"kafka_address"` |
| 108 | Events bool `yaml:"enable_events"` |
| 109 | ControlledActivation string `yaml:"controlled_activation"` |
| 110 | EnablePerf bool `yaml:"enable_perf"` |
| 111 | KafkaEventTopic string `yaml:"kafka_event_topic"` |
Zdravko Bozakov | 3ddb245 | 2019-11-29 14:33:41 +0100 | [diff] [blame] | 112 | } |
Matteo Scandolo | c114709 | 2019-10-29 09:38:33 -0700 | [diff] [blame] | 113 | |
Zdravko Bozakov | 3ddb245 | 2019-11-29 14:33:41 +0100 | [diff] [blame] | 114 | type BBRConfig struct { |
| 115 | Log string `yaml:"log"` |
| 116 | LogLevel string `yaml:"log_level"` |
| 117 | LogCaller bool `yaml:"log_caller"` |
| 118 | } |
| 119 | |
Matteo Scandolo | 4a03626 | 2020-08-17 15:56:13 -0700 | [diff] [blame] | 120 | type ServiceYaml struct { |
| 121 | Name string |
| 122 | CTag int `yaml:"c_tag"` |
| 123 | STag int `yaml:"s_tag"` |
| 124 | NeedsEapol bool `yaml:"needs_eapol"` |
| 125 | NeedsDchp bool `yaml:"needs_dhcp"` |
| 126 | NeedsIgmp bool `yaml:"needs_igmp"` |
| 127 | CTagAllocation string `yaml:"c_tag_allocation"` |
| 128 | STagAllocation string `yaml:"s_tag_allocation"` |
| 129 | TechnologyProfileID int `yaml:"tp_id"` |
| 130 | UniTagMatch int `yaml:"uni_tag_match"` |
| 131 | ConfigureMacAddress bool `yaml:"configure_mac_address"` |
| 132 | UsPonCTagPriority int `yaml:"us_pon_c_tag_priority"` |
| 133 | UsPonSTagPriority int `yaml:"us_pon_s_tag_priority"` |
| 134 | DsPonCTagPriority int `yaml:"ds_pon_c_tag_priority"` |
| 135 | DsPonSTagPriority int `yaml:"ds_pon_s_tag_priority"` |
| 136 | } |
| 137 | type YamlServiceConfig struct { |
| 138 | Workflow string |
| 139 | Services []ServiceYaml `yaml:"services,flow"` |
Zdravko Bozakov | 3ddb245 | 2019-11-29 14:33:41 +0100 | [diff] [blame] | 140 | } |
| 141 | |
Matteo Scandolo | 4a03626 | 2020-08-17 15:56:13 -0700 | [diff] [blame] | 142 | func (cfg *YamlServiceConfig) String() string { |
| 143 | str := fmt.Sprintf("[workflow: %s, Services: ", cfg.Workflow) |
Zdravko Bozakov | 3ddb245 | 2019-11-29 14:33:41 +0100 | [diff] [blame] | 144 | |
Matteo Scandolo | 4a03626 | 2020-08-17 15:56:13 -0700 | [diff] [blame] | 145 | for _, s := range cfg.Services { |
| 146 | str = fmt.Sprintf("%s[", str) |
| 147 | str = fmt.Sprintf("%sname=%s, c_tag=%d, s_tag=%d, ", |
| 148 | str, s.Name, s.CTag, s.STag) |
| 149 | str = fmt.Sprintf("%sc_tag_allocation=%s, s_tag_allocation=%s, ", |
| 150 | str, s.CTagAllocation, s.STagAllocation) |
| 151 | str = fmt.Sprintf("%sneeds_eapol=%t, needs_dhcp=%t, needs_igmp=%t", |
| 152 | str, s.NeedsEapol, s.NeedsDchp, s.NeedsIgmp) |
| 153 | str = fmt.Sprintf("%stp_id=%d, uni_tag_match=%d", |
| 154 | str, s.TechnologyProfileID, s.UniTagMatch) |
| 155 | str = fmt.Sprintf("%s]", str) |
| 156 | } |
| 157 | str = fmt.Sprintf("%s]", str) |
| 158 | return str |
| 159 | } |
| 160 | |
| 161 | var ( |
| 162 | Config *GlobalConfig |
| 163 | Services []ServiceYaml |
| 164 | ) |
| 165 | |
| 166 | // Load the BBSim configuration. This is a combination of CLI parameters and YAML files |
| 167 | // We proceed in this order: |
| 168 | // - Read CLI parameters |
| 169 | // - Using those we read the yaml files (config and services) |
| 170 | // - we merge the configuration (CLI has priority over yaml files) |
| 171 | func LoadConfig() { |
| 172 | |
| 173 | Config = getDefaultOps() |
| 174 | |
| 175 | cliConf := readCliParams() |
| 176 | |
| 177 | yamlConf, err := loadBBSimConf(cliConf.BBSim.ConfigFile) |
| 178 | |
| 179 | if err != nil { |
| 180 | log.WithFields(log.Fields{ |
| 181 | "file": cliConf.BBSim.ConfigFile, |
| 182 | "err": err, |
| 183 | }).Fatal("Can't read config file") |
| 184 | } |
| 185 | |
| 186 | // merging Yaml and Default Values |
| 187 | if err := mergo.Merge(Config, yamlConf, mergo.WithOverride); err != nil { |
| 188 | log.WithFields(log.Fields{ |
| 189 | "err": err, |
| 190 | }).Fatal("Can't merge YAML and Config") |
| 191 | } |
| 192 | |
| 193 | // merging CLI values on top of the yaml ones |
| 194 | if err := mergo.Merge(Config, cliConf, mergo.WithOverride); err != nil { |
| 195 | log.WithFields(log.Fields{ |
| 196 | "err": err, |
| 197 | }).Fatal("Can't merge CLI and Config") |
| 198 | } |
| 199 | |
| 200 | services, err := loadBBSimServices(Config.BBSim.ServiceConfigFile) |
| 201 | |
| 202 | if err != nil { |
| 203 | log.WithFields(log.Fields{ |
| 204 | "file": Config.BBSim.ServiceConfigFile, |
| 205 | "err": err, |
| 206 | }).Fatal("Can't read services file") |
| 207 | } |
| 208 | |
| 209 | Services = services |
| 210 | |
| 211 | } |
| 212 | |
| 213 | func readCliParams() *GlobalConfig { |
| 214 | |
| 215 | conf := GlobalConfig{} |
| 216 | |
| 217 | configFile := flag.String("config", conf.BBSim.ConfigFile, "Configuration file path") |
| 218 | servicesFile := flag.String("services", conf.BBSim.ServiceConfigFile, "Service Configuration file path") |
| 219 | |
| 220 | olt_id := flag.Int("olt_id", conf.Olt.ID, "OLT device ID") |
| 221 | nni := flag.Int("nni", int(conf.Olt.NniPorts), "Number of NNI ports per OLT device to be emulated") |
| 222 | pon := flag.Int("pon", int(conf.Olt.PonPorts), "Number of PON ports per OLT device to be emulated") |
| 223 | onu := flag.Int("onu", int(conf.Olt.OnusPonPort), "Number of ONU devices per PON port to be emulated") |
| 224 | |
| 225 | openolt_address := flag.String("openolt_address", conf.BBSim.OpenOltAddress, "IP address:port") |
| 226 | api_address := flag.String("api_address", conf.BBSim.ApiAddress, "IP address:port") |
| 227 | rest_api_address := flag.String("rest_api_address", conf.BBSim.RestApiAddress, "IP address:port") |
| 228 | |
| 229 | profileCpu := flag.String("cpuprofile", "", "write cpu profile to file") |
| 230 | |
| 231 | logLevel := flag.String("logLevel", conf.BBSim.LogLevel, "Set the log level (trace, debug, info, warn, error)") |
| 232 | logCaller := flag.Bool("logCaller", conf.BBSim.LogCaller, "Whether to print the caller filename or not") |
| 233 | |
| 234 | delay := flag.Int("delay", conf.BBSim.Delay, "The delay between ONU DISCOVERY batches in milliseconds (1 ONU per each PON PORT at a time") |
| 235 | |
| 236 | controlledActivation := flag.String("ca", conf.BBSim.ControlledActivation, "Set the mode for controlled activation of PON ports and ONUs") |
| 237 | enablePerf := flag.Bool("enableperf", conf.BBSim.EnablePerf, "Setting this flag will cause BBSim to not store data like traffic schedulers, flows of ONUs etc..") |
| 238 | enableEvents := flag.Bool("enableEvents", conf.BBSim.Events, "Enable sending BBSim events on configured kafka server") |
| 239 | kafkaAddress := flag.String("kafkaAddress", conf.BBSim.KafkaAddress, "IP:Port for kafka") |
| 240 | kafkaEventTopic := flag.String("kafkaEventTopic", conf.BBSim.KafkaEventTopic, "Ability to configure the topic on which BBSim publishes events on Kafka") |
| 241 | dhcpRetry := flag.Bool("dhcpRetry", conf.BBSim.DhcpRetry, "Set this flag if BBSim should retry DHCP upon failure until success") |
| 242 | authRetry := flag.Bool("authRetry", conf.BBSim.AuthRetry, "Set this flag if BBSim should retry EAPOL (Authentication) upon failure until success") |
| 243 | flag.Parse() |
| 244 | |
| 245 | conf.Olt.ID = int(*olt_id) |
| 246 | conf.Olt.NniPorts = uint32(*nni) |
| 247 | conf.Olt.PonPorts = uint32(*pon) |
| 248 | conf.Olt.OnusPonPort = uint32(*onu) |
| 249 | conf.BBSim.ConfigFile = *configFile |
| 250 | conf.BBSim.ServiceConfigFile = *servicesFile |
| 251 | conf.BBSim.CpuProfile = profileCpu |
| 252 | conf.BBSim.LogLevel = *logLevel |
| 253 | conf.BBSim.LogCaller = *logCaller |
| 254 | conf.BBSim.Delay = *delay |
| 255 | conf.BBSim.ControlledActivation = *controlledActivation |
| 256 | conf.BBSim.EnablePerf = *enablePerf |
| 257 | conf.BBSim.Events = *enableEvents |
| 258 | conf.BBSim.KafkaAddress = *kafkaAddress |
| 259 | conf.BBSim.OpenOltAddress = *openolt_address |
| 260 | conf.BBSim.ApiAddress = *api_address |
| 261 | conf.BBSim.RestApiAddress = *rest_api_address |
| 262 | conf.BBSim.KafkaEventTopic = *kafkaEventTopic |
| 263 | conf.BBSim.AuthRetry = *authRetry |
| 264 | conf.BBSim.DhcpRetry = *dhcpRetry |
| 265 | |
| 266 | // update device id if not set |
| 267 | if conf.Olt.DeviceId == "" { |
| 268 | conf.Olt.DeviceId = net.HardwareAddr{0xA, 0xA, 0xA, 0xA, 0xA, byte(conf.Olt.ID)}.String() |
| 269 | } |
| 270 | |
| 271 | return &conf |
| 272 | } |
| 273 | |
| 274 | func getDefaultOps() *GlobalConfig { |
| 275 | |
| 276 | c := &GlobalConfig{ |
Zdravko Bozakov | 3ddb245 | 2019-11-29 14:33:41 +0100 | [diff] [blame] | 277 | BBSimConfig{ |
Matteo Scandolo | 4a03626 | 2020-08-17 15:56:13 -0700 | [diff] [blame] | 278 | ConfigFile: "configs/bbsim.yaml", |
| 279 | ServiceConfigFile: "configs/att-services.yaml", |
Zdravko Bozakov | 3ddb245 | 2019-11-29 14:33:41 +0100 | [diff] [blame] | 280 | LogLevel: "debug", |
| 281 | LogCaller: false, |
| 282 | Delay: 200, |
Zdravko Bozakov | 958d81c | 2019-12-13 22:09:48 +0100 | [diff] [blame] | 283 | OpenOltAddress: ":50060", |
| 284 | ApiAddress: ":50070", |
| 285 | RestApiAddress: ":50071", |
| 286 | LegacyApiAddress: ":50072", |
| 287 | LegacyRestApiAddress: ":50073", |
| 288 | SadisRestAddress: ":50074", |
| 289 | SadisServer: true, |
Pragya Arya | 324337e | 2020-02-20 14:35:08 +0530 | [diff] [blame] | 290 | KafkaAddress: ":9092", |
| 291 | Events: false, |
Pragya Arya | 2225f20 | 2020-01-29 18:05:01 +0530 | [diff] [blame] | 292 | ControlledActivation: "default", |
Anand S Katti | 0954135 | 2020-01-29 15:54:01 +0530 | [diff] [blame] | 293 | EnablePerf: false, |
Shrey Baid | 64cda47 | 2020-04-24 18:58:18 +0530 | [diff] [blame] | 294 | KafkaEventTopic: "", |
Shrey Baid | f8abccc | 2020-06-15 19:41:22 +0530 | [diff] [blame] | 295 | DhcpRetry: false, |
| 296 | AuthRetry: false, |
Zdravko Bozakov | 3ddb245 | 2019-11-29 14:33:41 +0100 | [diff] [blame] | 297 | }, |
| 298 | OltConfig{ |
| 299 | Vendor: "BBSim", |
| 300 | Model: "asfvolt16", |
| 301 | HardwareVersion: "emulated", |
| 302 | FirmwareVersion: "", |
| 303 | DeviceSerialNumber: "BBSM00000001", |
| 304 | PonPorts: 1, |
| 305 | NniPorts: 1, |
| 306 | OnusPonPort: 1, |
| 307 | Technology: "XGS-PON", |
| 308 | ID: 0, |
| 309 | OltRebootDelay: 10, |
Pragya Arya | 996a089 | 2020-03-09 21:47:52 +0530 | [diff] [blame] | 310 | PortStatsInterval: 20, |
Zdravko Bozakov | 3ddb245 | 2019-11-29 14:33:41 +0100 | [diff] [blame] | 311 | }, |
| 312 | BBRConfig{ |
| 313 | LogLevel: "debug", |
| 314 | LogCaller: false, |
| 315 | }, |
| 316 | } |
| 317 | return c |
| 318 | } |
| 319 | |
| 320 | // LoadBBSimConf loads the BBSim configuration from a YAML file |
Matteo Scandolo | 4a03626 | 2020-08-17 15:56:13 -0700 | [diff] [blame] | 321 | func loadBBSimConf(filename string) (*GlobalConfig, error) { |
Zdravko Bozakov | 3ddb245 | 2019-11-29 14:33:41 +0100 | [diff] [blame] | 322 | yamlConfig := getDefaultOps() |
| 323 | |
| 324 | yamlFile, err := ioutil.ReadFile(filename) |
| 325 | if err != nil { |
Matteo Scandolo | 4a03626 | 2020-08-17 15:56:13 -0700 | [diff] [blame] | 326 | log.WithFields(log.Fields{ |
| 327 | "err": err, |
| 328 | "filename": filename, |
| 329 | }).Error("Cannot load BBSim configuration file. Using defaults.") |
Zdravko Bozakov | 3ddb245 | 2019-11-29 14:33:41 +0100 | [diff] [blame] | 330 | return yamlConfig, nil |
| 331 | } |
| 332 | |
| 333 | err = yaml.Unmarshal(yamlFile, yamlConfig) |
| 334 | if err != nil { |
Matteo Scandolo | 4a03626 | 2020-08-17 15:56:13 -0700 | [diff] [blame] | 335 | return nil, err |
Zdravko Bozakov | 3ddb245 | 2019-11-29 14:33:41 +0100 | [diff] [blame] | 336 | } |
| 337 | |
| 338 | return yamlConfig, nil |
| 339 | } |
| 340 | |
Matteo Scandolo | 4a03626 | 2020-08-17 15:56:13 -0700 | [diff] [blame] | 341 | // LoadBBSimServices parses a file describing the services that need to be created for each UNI |
| 342 | func loadBBSimServices(filename string) ([]ServiceYaml, error) { |
Zdravko Bozakov | 3ddb245 | 2019-11-29 14:33:41 +0100 | [diff] [blame] | 343 | |
Matteo Scandolo | 4a03626 | 2020-08-17 15:56:13 -0700 | [diff] [blame] | 344 | yamlServiceCfg := YamlServiceConfig{} |
Zdravko Bozakov | 3ddb245 | 2019-11-29 14:33:41 +0100 | [diff] [blame] | 345 | |
Matteo Scandolo | 4a03626 | 2020-08-17 15:56:13 -0700 | [diff] [blame] | 346 | yamlFile, err := ioutil.ReadFile(filename) |
Matteo Scandolo | f65e687 | 2020-04-15 15:18:43 -0700 | [diff] [blame] | 347 | if err != nil { |
Matteo Scandolo | 4a03626 | 2020-08-17 15:56:13 -0700 | [diff] [blame] | 348 | return nil, err |
Matteo Scandolo | f65e687 | 2020-04-15 15:18:43 -0700 | [diff] [blame] | 349 | } |
| 350 | |
Matteo Scandolo | 4a03626 | 2020-08-17 15:56:13 -0700 | [diff] [blame] | 351 | err = yaml.Unmarshal([]byte(yamlFile), &yamlServiceCfg) |
Matteo Scandolo | f65e687 | 2020-04-15 15:18:43 -0700 | [diff] [blame] | 352 | if err != nil { |
Matteo Scandolo | 4a03626 | 2020-08-17 15:56:13 -0700 | [diff] [blame] | 353 | return nil, err |
Matteo Scandolo | f65e687 | 2020-04-15 15:18:43 -0700 | [diff] [blame] | 354 | } |
| 355 | |
Matteo Scandolo | 4a03626 | 2020-08-17 15:56:13 -0700 | [diff] [blame] | 356 | for _, service := range yamlServiceCfg.Services { |
| 357 | |
| 358 | if service.CTagAllocation == "" || service.STagAllocation == "" { |
| 359 | log.Fatal("c_tag_allocation and s_tag_allocation are mandatory fields") |
| 360 | } |
| 361 | |
| 362 | if _, err := tagAllocationFromString(string(service.CTagAllocation)); err != nil { |
| 363 | log.WithFields(log.Fields{ |
| 364 | "err": err, |
| 365 | }).Fatal("c_tag_allocation is not valid") |
| 366 | } |
Matteo Scandolo | f65e687 | 2020-04-15 15:18:43 -0700 | [diff] [blame] | 367 | } |
| 368 | |
Matteo Scandolo | 4a03626 | 2020-08-17 15:56:13 -0700 | [diff] [blame] | 369 | log.WithFields(log.Fields{ |
| 370 | "services": yamlServiceCfg.String(), |
| 371 | }).Debug("BBSim services description correctly loaded") |
| 372 | return yamlServiceCfg.Services, nil |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 373 | } |
| 374 | |
Matteo Scandolo | 4a03626 | 2020-08-17 15:56:13 -0700 | [diff] [blame] | 375 | // This is only used by BBR |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 376 | func GetBBROpts() BBRCliOptions { |
| 377 | |
Matteo Scandolo | 4a03626 | 2020-08-17 15:56:13 -0700 | [diff] [blame] | 378 | LoadConfig() |
| 379 | |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 380 | bbsimIp := flag.String("bbsimIp", "127.0.0.1", "BBSim IP") |
| 381 | bbsimPort := flag.String("bbsimPort", "50060", "BBSim Port") |
| 382 | bbsimApiPort := flag.String("bbsimApiPort", "50070", "BBSim API Port") |
Matteo Scandolo | f5c537e | 2019-10-28 16:45:57 -0700 | [diff] [blame] | 383 | logFile := flag.String("logfile", "", "Log to a file") |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 384 | |
Matteo Scandolo | 4a03626 | 2020-08-17 15:56:13 -0700 | [diff] [blame] | 385 | flag.Parse() |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 386 | |
| 387 | bbrOptions := BBRCliOptions{ |
Matteo Scandolo | 4a03626 | 2020-08-17 15:56:13 -0700 | [diff] [blame] | 388 | Config, |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 389 | *bbsimIp, |
| 390 | *bbsimPort, |
| 391 | *bbsimApiPort, |
Matteo Scandolo | f5c537e | 2019-10-28 16:45:57 -0700 | [diff] [blame] | 392 | *logFile, |
Matteo Scandolo | 40e067f | 2019-10-16 16:59:41 -0700 | [diff] [blame] | 393 | } |
| 394 | |
| 395 | return bbrOptions |
| 396 | } |