blob: 7674182072ea1a33ed5b8c03b8fcc451a935dfa5 [file] [log] [blame]
Zsolt Harasztia133a452016-12-22 01:26:57 -08001#!/usr/bin/env python
2#
3# Copyright 2016 the original author or authors.
4#
5# Licensed under the Apache License, Version 2.0 (the "License");
6# you may not use this file except in compliance with the License.
7# You may obtain a copy of the License at
8#
9# http://www.apache.org/licenses/LICENSE-2.0
10#
11# Unless required by applicable law or agreed to in writing, software
12# distributed under the License is distributed on an "AS IS" BASIS,
13# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14# See the License for the specific language governing permissions and
15# limitations under the License.
16#
Zsolt Haraszti9b485fb2016-12-26 23:11:15 -080017import argparse
18import os
Zsolt Harasztia133a452016-12-22 01:26:57 -080019import readline
Stephane Barbarie4db8ca22017-04-24 10:30:20 -040020import sys
Zsolt Harasztid036b7e2016-12-23 15:36:01 -080021from optparse import make_option
Zsolt Haraszti80175202016-12-24 00:17:51 -080022from time import sleep, time
Zsolt Harasztid036b7e2016-12-23 15:36:01 -080023
Zsolt Harasztia133a452016-12-22 01:26:57 -080024import grpc
Zsolt Harasztid036b7e2016-12-23 15:36:01 -080025import requests
26from cmd2 import Cmd, options
Stephane Barbarie4db8ca22017-04-24 10:30:20 -040027from consul import Consul
Zsolt Harasztid036b7e2016-12-23 15:36:01 -080028from google.protobuf.empty_pb2 import Empty
Zsolt Harasztia133a452016-12-22 01:26:57 -080029from simplejson import dumps
30
Zsolt Harasztid036b7e2016-12-23 15:36:01 -080031from cli.device import DeviceCli
Nikolay Titov89004ec2017-06-19 18:22:42 -040032from cli.xpon import XponCli
Chip Boling69abce82018-06-18 09:56:23 -050033from cli.omci import OmciCli
Stephane Barbarie4db8ca22017-04-24 10:30:20 -040034from cli.alarm_filters import AlarmFiltersCli
Zsolt Harasztid036b7e2016-12-23 15:36:01 -080035from cli.logical_device import LogicalDeviceCli
Stephane Barbarie4db8ca22017-04-24 10:30:20 -040036from cli.table import print_pb_list_as_table
Zsolt Harasztid036b7e2016-12-23 15:36:01 -080037from voltha.core.flow_decomposer import *
Zsolt Harasztia133a452016-12-22 01:26:57 -080038from voltha.protos import third_party
39from voltha.protos import voltha_pb2
Zsolt Haraszti85f12852016-12-24 08:30:58 -080040from voltha.protos.openflow_13_pb2 import FlowTableUpdate, FlowGroupTableUpdate
Zsolt Harasztid036b7e2016-12-23 15:36:01 -080041
Zsolt Harasztia133a452016-12-22 01:26:57 -080042_ = third_party
Stephane Barbarie4db8ca22017-04-24 10:30:20 -040043from cli.utils import pb2dict
Zsolt Haraszti9b485fb2016-12-26 23:11:15 -080044
45defs = dict(
46 # config=os.environ.get('CONFIG', './cli.yml'),
47 consul=os.environ.get('CONSUL', 'localhost:8500'),
48 voltha_grpc_endpoint=os.environ.get('VOLTHA_GRPC_ENDPOINT',
49 'localhost:50055'),
50 voltha_sim_rest_endpoint=os.environ.get('VOLTHA_SIM_REST_ENDPOINT',
51 'localhost:18880'),
khenaidoo108f05c2017-07-06 11:15:29 -040052 global_request=os.environ.get('GLOBAL_REQUEST', False)
Zsolt Haraszti9b485fb2016-12-26 23:11:15 -080053)
54
Zsolt Harasztid036b7e2016-12-23 15:36:01 -080055banner = """\
Zsolt Haraszti313c4be2016-12-27 11:06:53 -080056 _ _ _ ___ _ ___
57__ _____| | |_| |_ __ _ / __| | |_ _|
58\ V / _ \ | _| ' \/ _` | | (__| |__ | |
59 \_/\___/_|\__|_||_\__,_| \___|____|___|
Zsolt Haraszti80175202016-12-24 00:17:51 -080060(to exit type quit or hit Ctrl-D)
Zsolt Harasztid036b7e2016-12-23 15:36:01 -080061"""
Zsolt Harasztia133a452016-12-22 01:26:57 -080062
Zsolt Harasztia133a452016-12-22 01:26:57 -080063
Stephane Barbarie4db8ca22017-04-24 10:30:20 -040064class VolthaCli(Cmd):
Zsolt Harasztia133a452016-12-22 01:26:57 -080065 prompt = 'voltha'
66 history_file_name = '.voltha_cli_history'
Zsolt Harasztid036b7e2016-12-23 15:36:01 -080067
68 # Settable CLI parameters
69 voltha_grpc = 'localhost:50055'
70 voltha_sim_rest = 'localhost:18880'
khenaidoo108f05c2017-07-06 11:15:29 -040071 global_request = False
Zsolt Harasztia133a452016-12-22 01:26:57 -080072 max_history_lines = 500
Zsolt Harasztid036b7e2016-12-23 15:36:01 -080073 default_device_id = None
74 default_logical_device_id = None
Zsolt Harasztia133a452016-12-22 01:26:57 -080075
76 Cmd.settable.update(dict(
Zsolt Harasztid036b7e2016-12-23 15:36:01 -080077 voltha_grpc='Voltha GRPC endpoint in form of <host>:<port>',
78 voltha_sim_rest='Voltha simulation back door for testing in form '
79 'of <host>:<port>',
80 max_history_lines='Maximum number of history lines stored across '
81 'sessions',
82 default_device_id='Device id used when no device id is specified',
83 default_logical_device_id='Logical device id used when no device id '
84 'is specified',
Zsolt Harasztia133a452016-12-22 01:26:57 -080085 ))
86
Zsolt Haraszti9b485fb2016-12-26 23:11:15 -080087 # cleanup of superfluous commands from cmd2
Zsolt Haraszti80175202016-12-24 00:17:51 -080088 del Cmd.do_cmdenvironment
Steve Crooks05f24522017-02-27 13:32:27 -050089 del Cmd.do_load
Zsolt Haraszti80175202016-12-24 00:17:51 -080090 del Cmd.do__relative_load
Zsolt Haraszti80175202016-12-24 00:17:51 -080091
khenaidoo108f05c2017-07-06 11:15:29 -040092 def __init__(self, voltha_grpc, voltha_sim_rest, global_request=False):
Zsolt Haraszti9b485fb2016-12-26 23:11:15 -080093 VolthaCli.voltha_grpc = voltha_grpc
94 VolthaCli.voltha_sim_rest = voltha_sim_rest
khenaidoo108f05c2017-07-06 11:15:29 -040095 VolthaCli.global_request = global_request
Zsolt Haraszti9b485fb2016-12-26 23:11:15 -080096 Cmd.__init__(self)
Zsolt Harasztia133a452016-12-22 01:26:57 -080097 self.prompt = '(' + self.colorize(
Zsolt Haraszti80175202016-12-24 00:17:51 -080098 self.colorize(self.prompt, 'blue'), 'bold') + ') '
Zsolt Harasztia133a452016-12-22 01:26:57 -080099 self.channel = None
khenaidoo108f05c2017-07-06 11:15:29 -0400100 self.stub = None
Zsolt Haraszti80175202016-12-24 00:17:51 -0800101 self.device_ids_cache = None
102 self.device_ids_cache_ts = time()
103 self.logical_device_ids_cache = None
104 self.logical_device_ids_cache_ts = time()
Zsolt Harasztia133a452016-12-22 01:26:57 -0800105
Zsolt Haraszti9b485fb2016-12-26 23:11:15 -0800106 # we override cmd2's method to avoid its optparse conflicting with our
107 # command line parsing
108 def cmdloop(self):
109 self._cmdloop()
110
Zsolt Harasztia133a452016-12-22 01:26:57 -0800111 def load_history(self):
112 """Load saved command history from local history file"""
113 try:
114 with file(self.history_file_name, 'r') as f:
115 for line in f.readlines():
116 stripped_line = line.strip()
117 self.history.append(stripped_line)
118 readline.add_history(stripped_line)
119 except IOError:
120 pass # ignore if file cannot be read
121
122 def save_history(self):
123 try:
Zsolt Haraszti80175202016-12-24 00:17:51 -0800124 with open(self.history_file_name, 'w') as f:
Zsolt Harasztia133a452016-12-22 01:26:57 -0800125 f.write('\n'.join(self.history[-self.max_history_lines:]))
Zsolt Haraszti80175202016-12-24 00:17:51 -0800126 except IOError as e:
127 self.perror('Could not save history in {}: {}'.format(
128 self.history_file_name, e))
Zsolt Harasztia133a452016-12-22 01:26:57 -0800129 else:
Zsolt Haraszti9b485fb2016-12-26 23:11:15 -0800130 self.poutput('History saved as {}'.format(
Zsolt Haraszti80175202016-12-24 00:17:51 -0800131 self.history_file_name))
132
133 def perror(self, errmsg, statement=None):
134 # Touch it up to make sure error is prefixed and colored
135 Cmd.perror(self, self.colorize('***ERROR: ', 'red') + errmsg,
136 statement)
Zsolt Harasztia133a452016-12-22 01:26:57 -0800137
138 def get_channel(self):
139 if self.channel is None:
140 self.channel = grpc.insecure_channel(self.voltha_grpc)
141 return self.channel
142
khenaidoo108f05c2017-07-06 11:15:29 -0400143 def get_stub(self):
144 if self.stub is None:
145 self.stub = \
146 voltha_pb2.VolthaGlobalServiceStub(self.get_channel()) \
147 if self.global_request else \
148 voltha_pb2.VolthaLocalServiceStub(self.get_channel())
149 return self.stub
150
Zsolt Haraszti80175202016-12-24 00:17:51 -0800151 # ~~~~~~~~~~~~~~~~~ ACTUAL COMMAND IMPLEMENTATIONS ~~~~~~~~~~~~~~~~~~~~~~~~
Zsolt Harasztid036b7e2016-12-23 15:36:01 -0800152
Zsolt Haraszti80175202016-12-24 00:17:51 -0800153 def do_reset_history(self, line):
Zsolt Harasztia133a452016-12-22 01:26:57 -0800154 """Reset CLI history"""
155 while self.history:
156 self.history.pop()
157
Zsolt Haraszti80175202016-12-24 00:17:51 -0800158 def do_launch(self, line):
Zsolt Harasztia133a452016-12-22 01:26:57 -0800159 """If Voltha is not running yet, launch it"""
Zsolt Haraszti80175202016-12-24 00:17:51 -0800160 raise NotImplementedError('not implemented yet')
Zsolt Harasztia133a452016-12-22 01:26:57 -0800161
Zsolt Haraszti80175202016-12-24 00:17:51 -0800162 def do_restart(self, line):
Zsolt Harasztia133a452016-12-22 01:26:57 -0800163 """Launch Voltha, but if it is already running, terminate it first"""
164 pass
165
Zsolt Haraszti80175202016-12-24 00:17:51 -0800166 def do_adapters(self, line):
167 """List loaded adapter"""
khenaidoo108f05c2017-07-06 11:15:29 -0400168 stub = self.get_stub()
Zsolt Haraszti80175202016-12-24 00:17:51 -0800169 res = stub.ListAdapters(Empty())
Sergio Slobodrian6e9fb692017-03-17 14:46:33 -0400170 omit_fields = {'config.log_level', 'logical_device_ids'}
Zsolt Haraszti85f12852016-12-24 08:30:58 -0800171 print_pb_list_as_table('Adapters:', res.items, omit_fields, self.poutput)
Zsolt Haraszti80175202016-12-24 00:17:51 -0800172
173 def get_devices(self):
khenaidoo108f05c2017-07-06 11:15:29 -0400174 stub = self.get_stub()
Zsolt Harasztia133a452016-12-22 01:26:57 -0800175 res = stub.ListDevices(Empty())
Zsolt Haraszti80175202016-12-24 00:17:51 -0800176 return res.items
Zsolt Harasztia133a452016-12-22 01:26:57 -0800177
Zsolt Haraszti80175202016-12-24 00:17:51 -0800178 def get_logical_devices(self):
khenaidoo108f05c2017-07-06 11:15:29 -0400179 stub = self.get_stub()
Zsolt Haraszti80175202016-12-24 00:17:51 -0800180 res = stub.ListLogicalDevices(Empty())
181 return res.items
182
183 def do_devices(self, line):
184 """List devices registered in Voltha"""
185 devices = self.get_devices()
186 omit_fields = {
187 'adapter',
188 'vendor',
189 'model',
190 'hardware_version',
ggowdru236bd952017-06-20 20:32:55 -0700191 'images',
Zsolt Haraszti80175202016-12-24 00:17:51 -0800192 'firmware_version',
Sergio Slobodriana95f99b2017-03-21 10:22:47 -0400193 'serial_number'
Zsolt Haraszti80175202016-12-24 00:17:51 -0800194 }
Zsolt Haraszti85f12852016-12-24 08:30:58 -0800195 print_pb_list_as_table('Devices:', devices, omit_fields, self.poutput)
Zsolt Haraszti80175202016-12-24 00:17:51 -0800196
197 def do_logical_devices(self, line):
Zsolt Harasztia133a452016-12-22 01:26:57 -0800198 """List logical devices in Voltha"""
khenaidoo108f05c2017-07-06 11:15:29 -0400199 stub = self.get_stub()
Zsolt Harasztia133a452016-12-22 01:26:57 -0800200 res = stub.ListLogicalDevices(Empty())
Zsolt Haraszti80175202016-12-24 00:17:51 -0800201 omit_fields = {
202 'desc.mfr_desc',
203 'desc.hw_desc',
204 'desc.sw_desc',
205 'desc.dp_desc',
206 'desc.serial_number',
Sergio Slobodriana95f99b2017-03-21 10:22:47 -0400207 'switch_features.capabilities'
Zsolt Haraszti80175202016-12-24 00:17:51 -0800208 }
Zsolt Haraszti85f12852016-12-24 08:30:58 -0800209 print_pb_list_as_table('Logical devices:', res.items, omit_fields,
210 self.poutput)
Zsolt Harasztia133a452016-12-22 01:26:57 -0800211
Zsolt Haraszti80175202016-12-24 00:17:51 -0800212 def do_device(self, line):
Zsolt Harasztia133a452016-12-22 01:26:57 -0800213 """Enter device level command mode"""
Zsolt Haraszti80175202016-12-24 00:17:51 -0800214 device_id = line.strip() or self.default_device_id
Zsolt Harasztid036b7e2016-12-23 15:36:01 -0800215 if not device_id:
216 raise Exception('<device-id> parameter needed')
Venkata Telu133b27d2018-06-12 14:22:28 -0500217 if device_id not in self.device_ids():
Venkata Telu35cc4722018-06-01 12:05:30 -0500218 self.poutput( self.colorize('Error: ', 'red') +
219 'There is no such device')
220 raise Exception('<device-id> is not a valid one')
khenaidoo108f05c2017-07-06 11:15:29 -0400221 sub = DeviceCli(device_id, self.get_stub)
Zsolt Harasztia133a452016-12-22 01:26:57 -0800222 sub.cmdloop()
223
Zsolt Haraszti80175202016-12-24 00:17:51 -0800224 def do_logical_device(self, line):
Zsolt Harasztia133a452016-12-22 01:26:57 -0800225 """Enter logical device level command mode"""
Zsolt Haraszti80175202016-12-24 00:17:51 -0800226 logical_device_id = line.strip() or self.default_logical_device_id
Zsolt Harasztid036b7e2016-12-23 15:36:01 -0800227 if not logical_device_id:
228 raise Exception('<logical-device-id> parameter needed')
Venkata Telu133b27d2018-06-12 14:22:28 -0500229 if logical_device_id not in self.logical_device_ids():
Venkata Telu35cc4722018-06-01 12:05:30 -0500230 self.poutput( self.colorize('Error: ', 'red') +
231 'There is no such device')
232 raise Exception('<logical-device-id> is not a valid one')
khenaidoo108f05c2017-07-06 11:15:29 -0400233 sub = LogicalDeviceCli(logical_device_id, self.get_stub)
Zsolt Harasztia133a452016-12-22 01:26:57 -0800234 sub.cmdloop()
235
Zsolt Haraszti80175202016-12-24 00:17:51 -0800236 def device_ids(self, force_refresh=False):
237 if force_refresh or self.device_ids is None or \
Stephane Barbarie4db8ca22017-04-24 10:30:20 -0400238 (time() - self.device_ids_cache_ts) > 1:
Zsolt Haraszti80175202016-12-24 00:17:51 -0800239 self.device_ids_cache = [d.id for d in self.get_devices()]
240 self.device_ids_cache_ts = time()
241 return self.device_ids_cache
242
243 def logical_device_ids(self, force_refresh=False):
244 if force_refresh or self.logical_device_ids is None or \
Stephane Barbarie4db8ca22017-04-24 10:30:20 -0400245 (time() - self.logical_device_ids_cache_ts) > 1:
Zsolt Haraszti80175202016-12-24 00:17:51 -0800246 self.logical_device_ids_cache = [d.id for d
247 in self.get_logical_devices()]
248 self.logical_device_ids_cache_ts = time()
249 return self.logical_device_ids_cache
250
251 def complete_device(self, text, line, begidx, endidx):
252 if not text:
253 completions = self.device_ids()[:]
254 else:
255 completions = [d for d in self.device_ids() if d.startswith(text)]
256 return completions
257
258 def complete_logical_device(self, text, line, begidx, endidx):
259 if not text:
260 completions = self.logical_device_ids()[:]
261 else:
262 completions = [d for d in self.logical_device_ids()
263 if d.startswith(text)]
264 return completions
265
Nikolay Titov89004ec2017-06-19 18:22:42 -0400266 def do_xpon(self, line):
267 """xpon <optional> [device_ID] - Enter xpon level command mode"""
268 device_id = line.strip()
Nikolay Titov3f0c9dd2017-07-17 17:37:25 -0400269 if device_id:
270 stub = self.get_stub()
271 try:
272 res = stub.GetDevice(voltha_pb2.ID(id=device_id))
273 except Exception:
Nikolay Titov176f1db2017-08-10 12:38:43 -0400274 self.poutput(
275 self.colorize('Error: ', 'red') + 'No device id ' +
276 self.colorize(device_id, 'blue') + ' is found')
Nikolay Titov3f0c9dd2017-07-17 17:37:25 -0400277 return
278 sub = XponCli(self.get_channel, device_id)
Nikolay Titov89004ec2017-06-19 18:22:42 -0400279 sub.cmdloop()
280
Chip Boling69abce82018-06-18 09:56:23 -0500281 def do_omci(self, line):
282 """omci <device_ID> - Enter OMCI level command mode"""
283
284 device_id = line.strip() or self.default_device_id
285 if not device_id:
286 raise Exception('<device-id> parameter needed')
287 sub = OmciCli(device_id, self.get_stub)
288 sub.cmdloop()
289
Zsolt Haraszti80175202016-12-24 00:17:51 -0800290 def do_pdb(self, line):
Zsolt Harasztia133a452016-12-22 01:26:57 -0800291 """Launch PDB debug prompt in CLI (for CLI development)"""
292 from pdb import set_trace
293 set_trace()
294
Jonathan Hartda93ac62018-05-01 11:25:29 -0700295 def do_version(self, line):
296 """Show the VOLTHA core version"""
297 stub = self.get_stub()
298 voltha = stub.GetVoltha(Empty())
299 self.poutput('{}'.format(voltha.version))
300
Zsolt Haraszti80175202016-12-24 00:17:51 -0800301 def do_health(self, line):
Zsolt Harasztia133a452016-12-22 01:26:57 -0800302 """Show connectivity status to Voltha status"""
303 stub = voltha_pb2.HealthServiceStub(self.get_channel())
304 res = stub.GetHealthStatus(Empty())
Zsolt Haraszti80175202016-12-24 00:17:51 -0800305 self.poutput(dumps(pb2dict(res), indent=4))
Zsolt Harasztia133a452016-12-22 01:26:57 -0800306
Zsolt Harasztid036b7e2016-12-23 15:36:01 -0800307 @options([
308 make_option('-t', '--device-type', action="store", dest='device_type',
Stephane Barbarie4db8ca22017-04-24 10:30:20 -0400309 help="Device type", default='simulated_olt'),
Zsolt Harasztid036b7e2016-12-23 15:36:01 -0800310 make_option('-m', '--mac-address', action='store', dest='mac_address',
311 default='00:0c:e2:31:40:00'),
312 make_option('-i', '--ip-address', action='store', dest='ip_address'),
Zsolt Haraszti656ecc62016-12-28 15:08:23 -0800313 make_option('-H', '--host_and_port', action='store',
314 dest='host_and_port'),
Zsolt Harasztid036b7e2016-12-23 15:36:01 -0800315 ])
Zsolt Haraszti80175202016-12-24 00:17:51 -0800316 def do_preprovision_olt(self, line, opts):
Zsolt Harasztid036b7e2016-12-23 15:36:01 -0800317 """Preprovision a new OLT with given device type"""
khenaidoo108f05c2017-07-06 11:15:29 -0400318 stub = self.get_stub()
Zsolt Harasztid036b7e2016-12-23 15:36:01 -0800319 kw = dict(type=opts.device_type)
Zsolt Haraszti656ecc62016-12-28 15:08:23 -0800320 if opts.host_and_port:
321 kw['host_and_port'] = opts.host_and_port
322 elif opts.ip_address:
Zsolt Harasztid036b7e2016-12-23 15:36:01 -0800323 kw['ipv4_address'] = opts.ip_address
324 elif opts.mac_address:
325 kw['mac_address'] = opts.mac_address
326 else:
327 raise Exception('Either IP address or Mac Address is needed')
Chip Boling90b224d2017-06-02 11:51:48 -0500328 # Pass any extra arguments past '--' to the device as custom arguments
329 kw['extra_args'] = line
330
Zsolt Harasztid036b7e2016-12-23 15:36:01 -0800331 device = voltha_pb2.Device(**kw)
332 device = stub.CreateDevice(device)
Zsolt Haraszti80175202016-12-24 00:17:51 -0800333 self.poutput('success (device id = {})'.format(device.id))
Zsolt Harasztid036b7e2016-12-23 15:36:01 -0800334 self.default_device_id = device.id
Zsolt Harasztia133a452016-12-22 01:26:57 -0800335
Khen Nursimulud068d812017-03-06 11:44:18 -0500336 def do_enable(self, line):
Zsolt Harasztid036b7e2016-12-23 15:36:01 -0800337 """
Khen Nursimulud068d812017-03-06 11:44:18 -0500338 Enable a device. If the <id> is not provided, it will be on the last
339 pre-provisioned device.
Zsolt Harasztid036b7e2016-12-23 15:36:01 -0800340 """
Zsolt Haraszti80175202016-12-24 00:17:51 -0800341 device_id = line or self.default_device_id
Khen Nursimulu29e75502017-03-07 17:26:50 -0500342 self.poutput('enabling {}'.format(device_id))
Khen Nursimuluc60afa12017-03-13 14:33:50 -0400343 try:
khenaidoo108f05c2017-07-06 11:15:29 -0400344 stub = self.get_stub()
Khen Nursimuluc60afa12017-03-13 14:33:50 -0400345 stub.EnableDevice(voltha_pb2.ID(id=device_id))
Zsolt Harasztia133a452016-12-22 01:26:57 -0800346
Khen Nursimuluc60afa12017-03-13 14:33:50 -0400347 while True:
348 device = stub.GetDevice(voltha_pb2.ID(id=device_id))
349 # If this is an OLT then acquire logical device id
350 if device.oper_status == voltha_pb2.OperStatus.ACTIVE:
351 if device.type.endswith('_olt'):
352 assert device.parent_id
353 self.default_logical_device_id = device.parent_id
354 self.poutput('success (logical device id = {})'.format(
355 self.default_logical_device_id))
356 else:
357 self.poutput('success (device id = {})'.format(device.id))
358 break
359 self.poutput('waiting for device to be enabled...')
360 sleep(.5)
Chip Boling69abce82018-06-18 09:56:23 -0500361 except Exception as e:
Khen Nursimuluc60afa12017-03-13 14:33:50 -0400362 self.poutput('Error enabling {}. Error:{}'.format(device_id, e))
Zsolt Harasztid036b7e2016-12-23 15:36:01 -0800363
Zsolt Haraszti50cae7d2017-01-08 22:27:07 -0800364 complete_activate_olt = complete_device
365
Khen Nursimulud068d812017-03-06 11:44:18 -0500366 def do_reboot(self, line):
367 """
368 Rebooting a device. ID of the device needs to be provided
369 """
370 device_id = line or self.default_device_id
371 self.poutput('rebooting {}'.format(device_id))
Khen Nursimuluc60afa12017-03-13 14:33:50 -0400372 try:
khenaidoo108f05c2017-07-06 11:15:29 -0400373 stub = self.get_stub()
Khen Nursimuluc60afa12017-03-13 14:33:50 -0400374 stub.RebootDevice(voltha_pb2.ID(id=device_id))
375 self.poutput('rebooted {}'.format(device_id))
ggowdru64d738a2018-05-10 07:08:06 -0700376 except Exception as e:
Khen Nursimuluc60afa12017-03-13 14:33:50 -0400377 self.poutput('Error rebooting {}. Error:{}'.format(device_id, e))
Khen Nursimulud068d812017-03-06 11:44:18 -0500378
sathishg5ae86222017-06-28 15:16:29 +0530379 def do_self_test(self, line):
380 """
381 Self Test a device. ID of the device needs to be provided
382 """
383 device_id = line or self.default_device_id
384 self.poutput('Self Testing {}'.format(device_id))
385 try:
khenaidoo108f05c2017-07-06 11:15:29 -0400386 stub = self.get_stub()
sathishg5ae86222017-06-28 15:16:29 +0530387 res = stub.SelfTest(voltha_pb2.ID(id=device_id))
388 self.poutput('Self Tested {}'.format(device_id))
389 self.poutput(dumps(pb2dict(res), indent=4))
ggowdru64d738a2018-05-10 07:08:06 -0700390 except Exception as e:
sathishg5ae86222017-06-28 15:16:29 +0530391 self.poutput('Error in self test {}. Error:{}'.format(device_id, e))
392
Khen Nursimulud068d812017-03-06 11:44:18 -0500393 def do_delete(self, line):
394 """
395 Deleting a device. ID of the device needs to be provided
396 """
397 device_id = line or self.default_device_id
398 self.poutput('deleting {}'.format(device_id))
Khen Nursimuluc60afa12017-03-13 14:33:50 -0400399 try:
khenaidoo108f05c2017-07-06 11:15:29 -0400400 stub = self.get_stub()
Khen Nursimuluc60afa12017-03-13 14:33:50 -0400401 stub.DeleteDevice(voltha_pb2.ID(id=device_id))
402 self.poutput('deleted {}'.format(device_id))
ggowdru64d738a2018-05-10 07:08:06 -0700403 except Exception as e:
Khen Nursimuluc60afa12017-03-13 14:33:50 -0400404 self.poutput('Error deleting {}. Error:{}'.format(device_id, e))
Khen Nursimulud068d812017-03-06 11:44:18 -0500405
406 def do_disable(self, line):
407 """
408 Disable a device. ID of the device needs to be provided
409 """
410 device_id = line
411 self.poutput('disabling {}'.format(device_id))
Khen Nursimuluc60afa12017-03-13 14:33:50 -0400412 try:
khenaidoo108f05c2017-07-06 11:15:29 -0400413 stub = self.get_stub()
Khen Nursimuluc60afa12017-03-13 14:33:50 -0400414 stub.DisableDevice(voltha_pb2.ID(id=device_id))
Khen Nursimulud068d812017-03-06 11:44:18 -0500415
Khen Nursimuluc60afa12017-03-13 14:33:50 -0400416 # Do device query and verify that the device admin status is
417 # DISABLED and Operational Status is unknown
418 device = stub.GetDevice(voltha_pb2.ID(id=device_id))
ggowdru64d738a2018-05-10 07:08:06 -0700419 if device.admin_state == voltha_pb2.AdminState.DISABLED:
Khen Nursimuluc60afa12017-03-13 14:33:50 -0400420 self.poutput('disabled successfully {}'.format(device_id))
421 else:
422 self.poutput('disabling failed {}. Admin State:{} '
423 'Operation State: {}'.format(device_id,
424 device.admin_state,
425 device.oper_status))
ggowdru64d738a2018-05-10 07:08:06 -0700426 except Exception as e:
Khen Nursimuluc60afa12017-03-13 14:33:50 -0400427 self.poutput('Error disabling {}. Error:{}'.format(device_id, e))
Khen Nursimulud068d812017-03-06 11:44:18 -0500428
Zsolt Haraszti50cae7d2017-01-08 22:27:07 -0800429 def do_test(self, line):
430 """Enter test mode, which makes a bunch on new commands available"""
khenaidoo108f05c2017-07-06 11:15:29 -0400431 sub = TestCli(self.history, self.voltha_grpc,
432 self.get_stub, self.voltha_sim_rest)
Zsolt Haraszti50cae7d2017-01-08 22:27:07 -0800433 sub.cmdloop()
434
Stephane Barbarie4db8ca22017-04-24 10:30:20 -0400435 def do_alarm_filters(self, line):
khenaidoo108f05c2017-07-06 11:15:29 -0400436 sub = AlarmFiltersCli(self.get_stub)
Stephane Barbarie4db8ca22017-04-24 10:30:20 -0400437 sub.cmdloop()
438
Zsolt Haraszti50cae7d2017-01-08 22:27:07 -0800439
440class TestCli(VolthaCli):
khenaidoo108f05c2017-07-06 11:15:29 -0400441 def __init__(self, history, voltha_grpc, get_stub, voltha_sim_rest):
Zsolt Haraszti50cae7d2017-01-08 22:27:07 -0800442 VolthaCli.__init__(self, voltha_grpc, voltha_sim_rest)
443 self.history = history
khenaidoo108f05c2017-07-06 11:15:29 -0400444 self.get_stub = get_stub
Zsolt Haraszti50cae7d2017-01-08 22:27:07 -0800445 self.prompt = '(' + self.colorize(self.colorize('test', 'cyan'),
Stephane Barbarie4db8ca22017-04-24 10:30:20 -0400446 'bold') + ') '
Zsolt Haraszti50cae7d2017-01-08 22:27:07 -0800447
448 def get_device(self, device_id, depth=0):
khenaidoo108f05c2017-07-06 11:15:29 -0400449 stub = self.get_stub()
Zsolt Haraszti50cae7d2017-01-08 22:27:07 -0800450 res = stub.GetDevice(voltha_pb2.ID(id=device_id),
Stephane Barbarie4db8ca22017-04-24 10:30:20 -0400451 metadata=(('get-depth', str(depth)),))
Zsolt Haraszti50cae7d2017-01-08 22:27:07 -0800452 return res
Zsolt Haraszti80175202016-12-24 00:17:51 -0800453
454 def do_arrive_onus(self, line):
Zsolt Harasztid036b7e2016-12-23 15:36:01 -0800455 """
Zsolt Haraszti85f12852016-12-24 08:30:58 -0800456 Simulate the arrival of ONUs (available only on simulated_olt)
Zsolt Harasztid036b7e2016-12-23 15:36:01 -0800457 """
Zsolt Haraszti80175202016-12-24 00:17:51 -0800458 device_id = line or self.default_device_id
Zsolt Haraszti85f12852016-12-24 08:30:58 -0800459
460 # verify that device is of type simulated_olt
461 device = self.get_device(device_id)
462 assert device.type == 'simulated_olt', (
463 'Cannot use it on this device type (only on simulated_olt type)')
464
Zsolt Harasztid036b7e2016-12-23 15:36:01 -0800465 requests.get('http://{}/devices/{}/detect_onus'.format(
466 self.voltha_sim_rest, device_id
467 ))
468
Zsolt Haraszti80175202016-12-24 00:17:51 -0800469 complete_arrive_onus = VolthaCli.complete_device
470
Zsolt Haraszti85f12852016-12-24 08:30:58 -0800471 def get_logical_ports(self, logical_device_id):
472 """
473 Return the NNI port number and the first usable UNI port of logical
474 device, and the vlan associated with the latter.
475 """
khenaidoo108f05c2017-07-06 11:15:29 -0400476 stub = self.get_stub()
Zsolt Haraszti85f12852016-12-24 08:30:58 -0800477 ports = stub.ListLogicalDevicePorts(
478 voltha_pb2.ID(id=logical_device_id)).items
Zsolt Harasztib9a5f752017-02-11 06:07:08 -0800479 nni = None
480 unis = []
Zsolt Haraszti85f12852016-12-24 08:30:58 -0800481 for port in ports:
Zsolt Harasztib9a5f752017-02-11 06:07:08 -0800482 if port.root_port:
483 assert nni is None, "There shall be only one root port"
Zsolt Haraszti85f12852016-12-24 08:30:58 -0800484 nni = port.ofp_port.port_no
Zsolt Harasztib9a5f752017-02-11 06:07:08 -0800485 else:
Zsolt Haraszti85f12852016-12-24 08:30:58 -0800486 uni = port.ofp_port.port_no
487 uni_device = self.get_device(port.device_id)
488 vlan = uni_device.vlan
Zsolt Harasztib9a5f752017-02-11 06:07:08 -0800489 unis.append((uni, vlan))
490
491 assert nni is not None, "No NNI port found"
492 assert unis, "Not a single UNI?"
493
494 return nni, unis
Zsolt Haraszti85f12852016-12-24 08:30:58 -0800495
Zsolt Haraszti80175202016-12-24 00:17:51 -0800496 def do_install_eapol_flow(self, line):
Zsolt Harasztid036b7e2016-12-23 15:36:01 -0800497 """
498 Install an EAPOL flow on the given logical device. If device is not
499 given, it will be applied to logical device of the last pre-provisioned
500 OLT device.
501 """
Zsolt Haraszti80175202016-12-24 00:17:51 -0800502 logical_device_id = line or self.default_logical_device_id
Zsolt Haraszti85f12852016-12-24 08:30:58 -0800503
504 # gather NNI and UNI port IDs
Zsolt Harasztib9a5f752017-02-11 06:07:08 -0800505 nni_port_no, unis = self.get_logical_ports(logical_device_id)
Zsolt Haraszti85f12852016-12-24 08:30:58 -0800506
507 # construct and push flow rule
khenaidoo108f05c2017-07-06 11:15:29 -0400508 stub = self.get_stub()
Zsolt Harasztib9a5f752017-02-11 06:07:08 -0800509 for uni_port_no, _ in unis:
510 update = FlowTableUpdate(
511 id=logical_device_id,
512 flow_mod=mk_simple_flow_mod(
513 priority=2000,
514 match_fields=[in_port(uni_port_no), eth_type(0x888e)],
515 actions=[
516 # push_vlan(0x8100),
517 # set_field(vlan_vid(4096 + 4000)),
518 output(ofp.OFPP_CONTROLLER)
519 ]
520 )
521 )
522 res = stub.UpdateLogicalDeviceFlowTable(update)
523 self.poutput('success for uni {} ({})'.format(uni_port_no, res))
Zsolt Harasztid036b7e2016-12-23 15:36:01 -0800524
Zsolt Haraszti80175202016-12-24 00:17:51 -0800525 complete_install_eapol_flow = VolthaCli.complete_logical_device
526
Zsolt Haraszti85f12852016-12-24 08:30:58 -0800527 def do_install_all_controller_bound_flows(self, line):
528 """
529 Install all flow rules for controller bound flows, including EAPOL,
530 IGMP and DHCP. If device is not given, it will be applied to logical
531 device of the last pre-provisioned OLT device.
532 """
533 logical_device_id = line or self.default_logical_device_id
534
535 # gather NNI and UNI port IDs
Zsolt Harasztib9a5f752017-02-11 06:07:08 -0800536 nni_port_no, unis = self.get_logical_ports(logical_device_id)
Zsolt Haraszti85f12852016-12-24 08:30:58 -0800537
538 # construct and push flow rules
khenaidoo108f05c2017-07-06 11:15:29 -0400539 stub = self.get_stub()
Zsolt Haraszti85f12852016-12-24 08:30:58 -0800540
Zsolt Harasztib9a5f752017-02-11 06:07:08 -0800541 for uni_port_no, _ in unis:
542 stub.UpdateLogicalDeviceFlowTable(FlowTableUpdate(
543 id=logical_device_id,
544 flow_mod=mk_simple_flow_mod(
545 priority=2000,
546 match_fields=[
547 in_port(uni_port_no),
548 eth_type(0x888e)
549 ],
550 actions=[output(ofp.OFPP_CONTROLLER)]
551 )
552 ))
553 stub.UpdateLogicalDeviceFlowTable(FlowTableUpdate(
554 id=logical_device_id,
555 flow_mod=mk_simple_flow_mod(
556 priority=1000,
557 match_fields=[
558 in_port(uni_port_no),
559 eth_type(0x800),
560 ip_proto(2)
561 ],
562 actions=[output(ofp.OFPP_CONTROLLER)]
563 )
564 ))
565 stub.UpdateLogicalDeviceFlowTable(FlowTableUpdate(
566 id=logical_device_id,
567 flow_mod=mk_simple_flow_mod(
568 priority=1000,
569 match_fields=[
570 in_port(uni_port_no),
571 eth_type(0x800),
572 ip_proto(17),
573 udp_dst(67)
574 ],
575 actions=[output(ofp.OFPP_CONTROLLER)]
576 )
577 ))
Zsolt Haraszti85f12852016-12-24 08:30:58 -0800578 self.poutput('success')
579
580 complete_install_all_controller_bound_flows = \
581 VolthaCli.complete_logical_device
582
583 def do_install_all_sample_flows(self, line):
584 """
585 Install all flows that are representative of the virtualized access
586 scenario in a PON network.
587 """
588 logical_device_id = line or self.default_logical_device_id
589
590 # gather NNI and UNI port IDs
Zsolt Harasztib9a5f752017-02-11 06:07:08 -0800591 nni_port_no, unis = self.get_logical_ports(logical_device_id)
Zsolt Haraszti85f12852016-12-24 08:30:58 -0800592
593 # construct and push flow rules
khenaidoo108f05c2017-07-06 11:15:29 -0400594 stub = self.get_stub()
Zsolt Haraszti85f12852016-12-24 08:30:58 -0800595
Zsolt Harasztib9a5f752017-02-11 06:07:08 -0800596 for uni_port_no, c_vid in unis:
Zsolt Harasztib9a5f752017-02-11 06:07:08 -0800597 # Controller-bound flows
598 stub.UpdateLogicalDeviceFlowTable(FlowTableUpdate(
599 id=logical_device_id,
600 flow_mod=mk_simple_flow_mod(
601 priority=2000,
602 match_fields=[in_port(uni_port_no), eth_type(0x888e)],
603 actions=[
604 # push_vlan(0x8100),
605 # set_field(vlan_vid(4096 + 4000)),
606 output(ofp.OFPP_CONTROLLER)
607 ]
608 )
609 ))
610 stub.UpdateLogicalDeviceFlowTable(FlowTableUpdate(
611 id=logical_device_id,
612 flow_mod=mk_simple_flow_mod(
613 priority=1000,
614 match_fields=[eth_type(0x800), ip_proto(2)],
615 actions=[output(ofp.OFPP_CONTROLLER)]
616 )
617 ))
618 stub.UpdateLogicalDeviceFlowTable(FlowTableUpdate(
619 id=logical_device_id,
620 flow_mod=mk_simple_flow_mod(
621 priority=1000,
622 match_fields=[eth_type(0x800), ip_proto(17), udp_dst(67)],
623 actions=[output(ofp.OFPP_CONTROLLER)]
624 )
625 ))
626
627 # Unicast flows:
628 # Downstream flow 1
629 stub.UpdateLogicalDeviceFlowTable(FlowTableUpdate(
630 id=logical_device_id,
631 flow_mod=mk_simple_flow_mod(
632 priority=500,
633 match_fields=[
634 in_port(nni_port_no),
635 vlan_vid(4096 + 1000),
636 metadata(c_vid) # here to mimic an ONOS artifact
637 ],
638 actions=[pop_vlan()],
639 next_table_id=1
640 )
641 ))
642 # Downstream flow 2
643 stub.UpdateLogicalDeviceFlowTable(FlowTableUpdate(
644 id=logical_device_id,
645 flow_mod=mk_simple_flow_mod(
646 priority=500,
647 table_id=1,
648 match_fields=[in_port(nni_port_no), vlan_vid(4096 + c_vid)],
649 actions=[set_field(vlan_vid(4096 + 0)), output(uni_port_no)]
650 )
651 ))
652 # Upstream flow 1 for 0-tagged case
653 stub.UpdateLogicalDeviceFlowTable(FlowTableUpdate(
654 id=logical_device_id,
655 flow_mod=mk_simple_flow_mod(
656 priority=500,
657 match_fields=[in_port(uni_port_no), vlan_vid(4096 + 0)],
658 actions=[set_field(vlan_vid(4096 + c_vid))],
659 next_table_id=1
660 )
661 ))
662 # Upstream flow 1 for untagged case
663 stub.UpdateLogicalDeviceFlowTable(FlowTableUpdate(
664 id=logical_device_id,
665 flow_mod=mk_simple_flow_mod(
666 priority=500,
667 match_fields=[in_port(uni_port_no), vlan_vid(0)],
668 actions=[push_vlan(0x8100), set_field(vlan_vid(4096 + c_vid))],
669 next_table_id=1
670 )
671 ))
672 # Upstream flow 2 for s-tag
673 stub.UpdateLogicalDeviceFlowTable(FlowTableUpdate(
674 id=logical_device_id,
675 flow_mod=mk_simple_flow_mod(
676 priority=500,
677 table_id=1,
678 match_fields=[in_port(uni_port_no), vlan_vid(4096 + c_vid)],
679 actions=[
680 push_vlan(0x8100),
681 set_field(vlan_vid(4096 + 1000)),
682 output(nni_port_no)
683 ]
684 )
685 ))
Zsolt Haraszti85f12852016-12-24 08:30:58 -0800686
687 # Push a few multicast flows
Zsolt Harasztib9a5f752017-02-11 06:07:08 -0800688 # 1st with one bucket for our uni 0
Zsolt Haraszti85f12852016-12-24 08:30:58 -0800689 stub.UpdateLogicalDeviceFlowGroupTable(FlowGroupTableUpdate(
690 id=logical_device_id,
691 group_mod=mk_multicast_group_mod(
692 group_id=1,
693 buckets=[
Zsolt Harasztib9a5f752017-02-11 06:07:08 -0800694 ofp.ofp_bucket(actions=[
695 pop_vlan(),
696 output(unis[0][0])
697 ])
Zsolt Haraszti85f12852016-12-24 08:30:58 -0800698 ]
699 )
700 ))
701 stub.UpdateLogicalDeviceFlowTable(FlowTableUpdate(
702 id=logical_device_id,
703 flow_mod=mk_simple_flow_mod(
704 priority=1000,
705 match_fields=[
706 in_port(nni_port_no),
707 eth_type(0x800),
708 vlan_vid(4096 + 140),
709 ipv4_dst(0xe4010101)
710 ],
711 actions=[group(1)]
712 )
713 ))
Zsolt Harasztib9a5f752017-02-11 06:07:08 -0800714
715 # 2nd with one bucket for uni 0 and 1
Zsolt Haraszti85f12852016-12-24 08:30:58 -0800716 stub.UpdateLogicalDeviceFlowGroupTable(FlowGroupTableUpdate(
717 id=logical_device_id,
718 group_mod=mk_multicast_group_mod(
719 group_id=2,
720 buckets=[
Nathan Knuth6b7b6ff2017-02-12 03:30:48 -0800721 ofp.ofp_bucket(actions=[pop_vlan(), output(unis[0][0])])
Stephane Barbarie4db8ca22017-04-24 10:30:20 -0400722 # ofp.ofp_bucket(actions=[pop_vlan(), output(unis[1][0])])
Zsolt Haraszti85f12852016-12-24 08:30:58 -0800723 ]
724 )
725 ))
726 stub.UpdateLogicalDeviceFlowTable(FlowTableUpdate(
727 id=logical_device_id,
728 flow_mod=mk_simple_flow_mod(
729 priority=1000,
730 match_fields=[
731 in_port(nni_port_no),
732 eth_type(0x800),
733 vlan_vid(4096 + 140),
734 ipv4_dst(0xe4020202)
735 ],
736 actions=[group(2)]
737 )
738 ))
Zsolt Harasztib9a5f752017-02-11 06:07:08 -0800739
Zsolt Haraszti85f12852016-12-24 08:30:58 -0800740 # 3rd with empty bucket
741 stub.UpdateLogicalDeviceFlowGroupTable(FlowGroupTableUpdate(
742 id=logical_device_id,
743 group_mod=mk_multicast_group_mod(
744 group_id=3,
745 buckets=[]
746 )
747 ))
748 stub.UpdateLogicalDeviceFlowTable(FlowTableUpdate(
749 id=logical_device_id,
750 flow_mod=mk_simple_flow_mod(
751 priority=1000,
752 match_fields=[
753 in_port(nni_port_no),
754 eth_type(0x800),
755 vlan_vid(4096 + 140),
756 ipv4_dst(0xe4030303)
757 ],
758 actions=[group(3)]
759 )
760 ))
761
762 self.poutput('success')
763
764 complete_install_all_sample_flows = VolthaCli.complete_logical_device
765
Nathan Knuth5f4163e2017-01-11 18:21:10 -0600766 def do_install_dhcp_flows(self, line):
767 """
768 Install all dhcp flows that are representative of the virtualized access
769 scenario in a PON network.
770 """
771 logical_device_id = line or self.default_logical_device_id
772
773 # gather NNI and UNI port IDs
Zsolt Harasztib9a5f752017-02-11 06:07:08 -0800774 nni_port_no, unis = self.get_logical_ports(logical_device_id)
Nathan Knuth5f4163e2017-01-11 18:21:10 -0600775
776 # construct and push flow rules
khenaidoo108f05c2017-07-06 11:15:29 -0400777 stub = self.get_stub()
Nathan Knuth5f4163e2017-01-11 18:21:10 -0600778
779 # Controller-bound flows
Zsolt Harasztib9a5f752017-02-11 06:07:08 -0800780 for uni_port_no, _ in unis:
781 stub.UpdateLogicalDeviceFlowTable(FlowTableUpdate(
782 id=logical_device_id,
783 flow_mod=mk_simple_flow_mod(
784 priority=1000,
785 match_fields=[
786 in_port(uni_port_no),
787 eth_type(0x800),
788 ip_proto(17),
789 udp_dst(67)
790 ],
791 actions=[output(ofp.OFPP_CONTROLLER)]
792 )
793 ))
Nathan Knuth5f4163e2017-01-11 18:21:10 -0600794
795 self.poutput('success')
796
797 complete_install_dhcp_flows = VolthaCli.complete_logical_device
798
Zsolt Haraszti85f12852016-12-24 08:30:58 -0800799 def do_delete_all_flows(self, line):
800 """
801 Remove all flows and flow groups from given logical device
802 """
803 logical_device_id = line or self.default_logical_device_id
khenaidoo108f05c2017-07-06 11:15:29 -0400804 stub = self.get_stub()
Zsolt Haraszti85f12852016-12-24 08:30:58 -0800805 stub.UpdateLogicalDeviceFlowTable(FlowTableUpdate(
806 id=logical_device_id,
807 flow_mod=ofp.ofp_flow_mod(
808 command=ofp.OFPFC_DELETE,
809 table_id=ofp.OFPTT_ALL,
810 cookie_mask=0,
811 out_port=ofp.OFPP_ANY,
812 out_group=ofp.OFPG_ANY
813 )
814 ))
815 stub.UpdateLogicalDeviceFlowGroupTable(FlowGroupTableUpdate(
816 id=logical_device_id,
817 group_mod=ofp.ofp_group_mod(
818 command=ofp.OFPGC_DELETE,
819 group_id=ofp.OFPG_ALL
820 )
821 ))
822 self.poutput('success')
823
824 complete_delete_all_flows = VolthaCli.complete_logical_device
825
Zsolt Haraszti80175202016-12-24 00:17:51 -0800826 def do_send_simulated_upstream_eapol(self, line):
Zsolt Harasztid036b7e2016-12-23 15:36:01 -0800827 """
828 Send an EAPOL upstream from a simulated OLT
829 """
Zsolt Haraszti80175202016-12-24 00:17:51 -0800830 device_id = line or self.default_device_id
Zsolt Harasztid036b7e2016-12-23 15:36:01 -0800831 requests.get('http://{}/devices/{}/test_eapol_in'.format(
832 self.voltha_sim_rest, device_id
833 ))
834
Zsolt Haraszti80175202016-12-24 00:17:51 -0800835 complete_send_simulated_upstream_eapol = VolthaCli.complete_device
836
837 def do_inject_eapol_start(self, line):
Zsolt Harasztid036b7e2016-12-23 15:36:01 -0800838 """
839 Send out an an EAPOL start message into the given Unix interface
840 """
841 pass
Zsolt Harasztia133a452016-12-22 01:26:57 -0800842
843
844if __name__ == '__main__':
Zsolt Haraszti9b485fb2016-12-26 23:11:15 -0800845
846 parser = argparse.ArgumentParser()
847
848 _help = '<hostname>:<port> to consul agent (default: %s)' % defs['consul']
849 parser.add_argument(
850 '-C', '--consul', action='store', default=defs['consul'], help=_help)
851
852 _help = 'Lookup Voltha endpoints based on service entries in Consul'
853 parser.add_argument(
854 '-L', '--lookup', action='store_true', help=_help)
855
khenaidoo108f05c2017-07-06 11:15:29 -0400856 _help = 'All requests to the Voltha gRPC service are global'
857 parser.add_argument(
858 '-G', '--global_request', action='store_true', help=_help)
859
Zsolt Haraszti9b485fb2016-12-26 23:11:15 -0800860 _help = '<hostname>:<port> of Voltha gRPC service (default={})'.format(
861 defs['voltha_grpc_endpoint'])
862 parser.add_argument('-g', '--grpc-endpoint', action='store',
863 default=defs['voltha_grpc_endpoint'], help=_help)
864
865 _help = '<hostname>:<port> of Voltha simulated adapter backend for ' \
866 'testing (default={})'.format(
867 defs['voltha_sim_rest_endpoint'])
868 parser.add_argument('-s', '--sim-rest-endpoint', action='store',
869 default=defs['voltha_sim_rest_endpoint'], help=_help)
870
871 args = parser.parse_args()
872
873 if args.lookup:
874 host = args.consul.split(':')[0].strip()
875 port = int(args.consul.split(':')[1].strip())
876 consul = Consul(host=host, port=port)
877
878 _, services = consul.catalog.service('voltha-grpc')
879 if not services:
880 print('No voltha-grpc service registered in consul; exiting')
881 sys.exit(1)
882 args.grpc_endpoint = '{}:{}'.format(services[0]['ServiceAddress'],
883 services[0]['ServicePort'])
884
885 _, services = consul.catalog.service('voltha-sim-rest')
886 if not services:
887 print('No voltha-sim-rest service registered in consul; exiting')
888 sys.exit(1)
889 args.sim_rest_endpoint = '{}:{}'.format(services[0]['ServiceAddress'],
890 services[0]['ServicePort'])
891
khenaidoo108f05c2017-07-06 11:15:29 -0400892 c = VolthaCli(args.grpc_endpoint, args.sim_rest_endpoint,
893 args.global_request)
Zsolt Haraszti80175202016-12-24 00:17:51 -0800894 c.poutput(banner)
Zsolt Harasztia133a452016-12-22 01:26:57 -0800895 c.load_history()
896 c.cmdloop()
897 c.save_history()