def _get_switch_descriptor_from_request_headers(self, hostname):
headers_present = [
h in request.headers
for h in ['Netman-Model', 'Netman-Username', 'Netman-Password']
]
if not any(headers_present):
return None
if not all(headers_present):
raise BadRequest(
'For anonymous switch usage, please specify headers: Netman-Model, Netman-Username and Netman-Password.'
)
port = None
if "Netman-Port" in request.headers:
try:
port = int(request.headers["Netman-Port"])
except ValueError:
raise BadRequest(
'Netman-Port optional header should be an integer')
netman_server = request.headers.get("Netman-Proxy-Server", None)
if netman_server is not None and "," in netman_server:
netman_server = [e.strip() for e in netman_server.split(",")]
self.logger.info("Anonymous Switch Access ({}) {}@{}".format(
request.headers['Netman-Model'],
request.headers['Netman-Username'], hostname))
return SwitchDescriptor(hostname=hostname,
model=request.headers['Netman-Model'],
username=request.headers['Netman-Username'],
password=request.headers['Netman-Password'],
port=port,
netman_server=netman_server)
def m(data, **_):
try:
result = json.loads(data)
except ValueError:
raise BadRequest("Malformed JSON request")
for field, validator in fields.iteritems():
validator(result, field)
for field, validator in result.iteritems():
if field not in fields:
raise BadRequest("Unknown key: {}".format(field))
return result
def is_vrrp_group(data, **_):
try:
data = json.loads(data)
except ValueError:
raise BadRequest("Malformed content, should be a JSON object")
if data.get('id') is None:
raise BadRequest("VRRP group id is mandatory")
return dict(group_id=data.pop('id'),
ips=[validate_ip_address(i) for i in data.pop('ips', [])],
**data)
def is_int(number, **_):
try:
value = int(number)
except ValueError:
raise BadRequest('Expected integer content, got "{}"'.format(number))
return {'value': value}
def is_boolean(option, **_):
option = option.lower()
if option not in ['true', 'false']:
raise BadRequest(
'Unreadable content "{}". Should be either "true" or "false"'.
format(option))
return {'state': option == 'true'}
def is_session(data, **_):
try:
json_data = json.loads(data)
except ValueError:
raise BadRequest("Malformed content, should be a JSON object")
if "hostname" not in json_data:
raise MalformedSwitchSessionRequest()
return {'hostname': json_data["hostname"]}
def is_ip_network(data, **_):
try:
try:
json_addr = json.loads(data)
ip = IPNetwork("{}/{}".format(json_addr["address"], json_addr["mask"]))
except ValueError:
ip = IPNetwork(data)
except (KeyError, AddrFormatError):
raise BadRequest('Malformed content, should be : x.x.x.x/xx or {"address": "x.x.x.x", "mask": "xx"}')
return {'validated_ip_network': ip}
def is_bond(data, **_):
try:
json_data = json.loads(data)
except ValueError:
raise BadRequest("Malformed content, should be a JSON object")
if "number" not in json_data:
raise BadBondNumber()
return {
'bond_number': is_bond_number(json_data["number"])['bond_number'],
}
def is_vlan(data, **_):
try:
json_data = json.loads(data)
except ValueError:
raise BadRequest("Malformed content, should be a JSON object")
if "number" not in json_data:
raise BadVlanNumber()
name = json_data["name"] if "name" in json_data and len(json_data["name"]) > 0 else None
if name and " " in name:
raise BadVlanName()
return {
'number': is_vlan_number(json_data["number"])['vlan_number'],
'name': name
}
def set_port_mode(self, switch, interface_id):
"""
Sets the port mode of an interface
:arg str hostname: Hostname or IP of the switch
:arg str interface_id: Interface name (ex. ``FastEthernet0/1``, ``ethernet1/11``)
:body:
``trunk`` or ``access``
"""
mode = request.get_data().lower()
if mode == 'trunk':
switch.set_trunk_mode(interface_id)
elif mode == 'access':
switch.set_access_mode(interface_id)
else:
raise BadRequest('Unknown port mode detected {}'.format(mode))
return 204, None
def set_bond_port_mode(self, switch, bond_number):
"""
Sets the port mode of a bond
:arg str hostname: Hostname or IP of the switch
:arg int bond_number: Bond number
:body:
``trunk`` or ``access``
"""
mode = request.get_data().lower()
if mode == 'trunk':
switch.set_bond_trunk_mode(bond_number)
elif mode == 'access':
switch.set_bond_access_mode(bond_number)
else:
raise BadRequest('Unknown port mode detected {}'.format(mode))
return 204, None
def act_on_session(self, session_id):
"""
Commit or rollback a session on a switch
:arg str session: ID of the session
:body:
``commit`` or ``rollback``
"""
action = request.data.lower()
if action == 'start_transaction':
self.sessions_manager.start_transaction(session_id)
elif action == 'end_transaction':
self.sessions_manager.end_transaction(session_id)
elif action == 'commit':
self.sessions_manager.commit_session(session_id)
elif action == 'rollback':
self.sessions_manager.rollback_session(session_id)
else:
raise BadRequest('Unknown action {}'.format(action))
return 204, None
def is_access_group_name(data, **_):
if data == "" or " " in data:
raise BadRequest('Malformed access group name')
return {'access_group_name': data}
def is_unincast_rpf_mode(data, **_):
if data not in [STRICT]:
raise BadRequest('Invalid unicast rpf mode')
return {'mode': data}
def process(self, parameters):
try:
self.ip_network = is_ip_network(
parameters.pop('ip_network'))['validated_ip_network']
except BadRequest:
raise BadRequest('Malformed IP, should be : x.x.x.x/xx')
def m(params, key):
if not isinstance(params[key], obj_type):
raise BadRequest('Expected "{}" type for key {}, got "{}"'.format(
obj_type.__name__, key,
type(params[key]).__name__))
def validate_ip_address(data):
try:
return IPAddress(data)
except:
raise BadRequest(
"Incorrect IP Address: \"{}\", should be x.x.x.x".format(data))
def is_vrf_name(data, **_):
if data == "" or " " in data:
raise BadRequest('Malformed VRF name')
return {'vrf_name': data}
