| # |
| # Copyright (c) 2011,2012,2013 Big Switch Networks, Inc. |
| # |
| # Licensed under the Eclipse Public License, Version 1.0 (the |
| # "License"); you may not use this file except in compliance with the |
| # License. You may obtain a copy of the License at |
| # |
| # http://www.eclipse.org/legal/epl-v10.html |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or |
| # implied. See the License for the specific language governing |
| # permissions and limitations under the License. |
| # |
| |
| # |
| # UTIlity Functions |
| # |
| |
| import re |
| |
| |
| # |
| # -------------------------------------------------------------------------------- |
| |
| def is_power_of_two(n): |
| """ |
| Return true if the integer parameter is a power of two |
| """ |
| if (n & (n - 1)) == 0: |
| return True |
| return False |
| |
| # |
| # -------------------------------------------------------------------------------- |
| |
| def unique_list_from_list(dup_list): |
| """ |
| Return a new list from the old, where the the new has no repeated items. |
| (the items are intended to be strings) |
| """ |
| return dict([[x, None] for x in dup_list]).keys() |
| |
| # |
| # -------------------------------------------------------------------------------- |
| |
| def full_word_from_choices(word, all_choices): |
| """ |
| given a single word, which could be a prefix of a word in |
| a list (which is the second parameter), return a single |
| word which matches or None, when non or more than one match. |
| """ |
| choices = [x for x in all_choices if x.startswith(word)] |
| if len(choices) == 1: |
| return choices[0] |
| if word in all_choices: # also allow an exact match |
| return word |
| return None |
| |
| |
| # |
| # -------------------------------------------------------------------------------- |
| |
| def try_int(string): |
| """ |
| Return an interger if possible, otherwise a string |
| """ |
| try: |
| str_int = int(string) |
| return str_int |
| except: |
| pass |
| return string |
| |
| # |
| # -------------------------------------------------------------------------------- |
| |
| def mask_to_cidr(mask): |
| """ |
| Given a mask used in AC's, for eample 0.0.0.255, return the cidr /<n> |
| value associated with that mask. The mask must be a power of two for |
| the cidr value to be displayed |
| """ |
| if not is_power_of_two(mask + 1): |
| return 0 |
| mask += 1 |
| cidr = 33 |
| while mask: |
| cidr -= 1 |
| mask >>= 1 |
| return cidr |
| |
| |
| |
| # |
| # -------------------------------------------------------------------------------- |
| |
| def inet_ntoa(n): |
| """ |
| Defina a local variant which exactly meets local needs |
| """ |
| return "%s.%s.%s.%s" % ( \ |
| (n & 0xff000000) >> 24, \ |
| (n & 0x00ff0000) >> 16, \ |
| (n & 0x0000ff00) >> 8, \ |
| (n & 0x000000ff) ) |
| |
| # |
| # -------------------------------------------------------------------------------- |
| |
| def inet_aton(ip): |
| """ |
| Return an integer containing the ip address passed in. |
| Assumes the field is a quad-int |
| """ |
| fields = ip.split('.') |
| return (int(fields[0]) << 24) | \ |
| (int(fields[1]) << 16) | \ |
| (int(fields[2]) << 8) | \ |
| (int(fields[3])) |
| |
| # |
| # -------------------------------------------------------------------------------- |
| |
| def ip_and_mask_ntoa(ip, mask): |
| """ |
| The two values are displayed either as 'any' or as in cidr format |
| or as a ip/mask depending on the value of the mask. |
| (note the leading space) |
| """ |
| if ip == '0.0.0.0' and mask == '255.255.255.255': |
| return 'any ' |
| n_mask = inet_aton(mask) |
| if is_power_of_two(n_mask + 1): |
| return "%s/%d " % (ip, mask_to_cidr(n_mask)) |
| return "%s %s " % (ip, mask) |
| |
| |
| # |
| # -------------------------------------------------------------------------------- |
| |
| def ip_invert_netmask(value): |
| split_bytes = value.split('.') |
| return "%s.%s.%s.%s" % (255-int(split_bytes[0]), |
| 255-int(split_bytes[1]), |
| 255-int(split_bytes[2]), |
| 255-int(split_bytes[3])) |
| |
| # |
| # -------------------------------------------------------------------------------- |
| |
| def ip_and_neg_mask(ip, mask): |
| """ |
| The two values are displayed either as 'any' or as in cidr format |
| or as a ip/mask depending on the value of the mask. |
| (note the leading space). This is different from ip_and_mask_ntoa |
| since the mask need to be printed an an inverted mask when the |
| mask is displayed |
| """ |
| if ip == '0.0.0.0' and mask == '255.255.255.255': |
| return 'any ' |
| n_mask = inet_aton(mask) |
| if is_power_of_two(n_mask + 1): |
| cidr = mask_to_cidr(n_mask) |
| if cidr: |
| return "%s/%d " % (ip, mask_to_cidr(n_mask)) |
| return "%s " % ip |
| return "%s %s " % (ip, ip_invert_netmask(mask)) |
| |
| |
| # |
| # -------------------------------------------------------------------------------- |
| |
| SINGLEQUOTE_RE = re.compile(r"'") |
| DOUBLEQUOTE_RE = re.compile(r'"') |
| WHITESPACE_RE = re.compile(r"\s") |
| |
| COMMAND_DPID_RE = re.compile(r'^(([A-Fa-f\d]){2}:?){7}[A-Fa-f\d]{2}$') |
| COMMAND_SEPARATORS_RE = re.compile(r'[>;|]') # XXX belongs in some global |
| |
| |
| def quote_string(value): |
| """ |
| Return a quoted version of the string when there's imbedded |
| spaces. Worst case is when the string has both single and |
| double quotes. |
| """ |
| |
| if SINGLEQUOTE_RE.search(value): |
| if DOUBLEQUOTE_RE.search(value): |
| new_value = [] |
| for c in value: |
| if c == '"': |
| new_value.append("\\") |
| new_value.append(c) |
| return ''.join(new_value) |
| else: |
| return '"%s"' % value |
| elif (DOUBLEQUOTE_RE.search(value) or |
| WHITESPACE_RE.search(value) or |
| COMMAND_SEPARATORS_RE.search(value)): |
| return "'%s'" % value |
| else: |
| return value |
| |
| |
| # |
| # -------------------------------------------------------------------------------- |
| |
| def add_delim(strings_list, delim): |
| """ |
| Add 'delim' to each string entry in the list, typically used to add a space |
| to completion choices for entries which aren't prefixes. |
| word mean a |
| |
| """ |
| return [str(x) + delim for x in strings_list] |
| |
| |
| # |
| # -------------------------------------------------------------------------------- |
| |
| def convert_case(case, value): |
| """ |
| Convert value to the requested case |
| """ |
| if case == None: |
| return value |
| elif case == 'lower': |
| return value.lower() |
| elif case == 'upper': |
| return value.upper() |
| return value |
| |
| |
| TAIL_INT_RE = re.compile(r'^(.*[^0-9])(\d+)$') |
| |
| |
| # |
| # -------------------------------------------------------------------------------- |
| |
| def trailing_integer_cmp(x,y): |
| """ |
| sorted() comparison function. |
| |
| Used when the two keys may possibly have trailing numbers, |
| if these are compared using a typical sort, then the trailing |
| numbers will be sorted alphabetically, not numerically. This |
| is most obvious when interfaces, for example Eth1, Eth10, Eth2 |
| are sorted. Alphabetically the order is as already shown, but |
| the desired sort order is Eth1, Eth2, Eth10 |
| """ |
| |
| def last_digit(value): |
| # only interested in sequences tailing a digit, where |
| # the first charcter isn't a digit, used to sidestep tail_int re |
| if len(value) >= 2: |
| last_char = ord(value[-1]) |
| if last_char >= ord('0') and last_char <= ord('9'): |
| first_char = ord(value[0]) |
| if first_char < ord('0') or first_char > ord('9'): |
| return True |
| return False |
| |
| if type(x) == int and type(y) == int: |
| return cmp(x,y) |
| if last_digit(x) and last_digit(y): |
| x_m = TAIL_INT_RE.match(x) |
| y_m = TAIL_INT_RE.match(y) |
| c = cmp(x_m.group(1), y_m.group(1)) |
| if c: |
| return c |
| c = cmp(int(x_m.group(2)), int(y_m.group(2))) |
| if c: |
| return c |
| else: |
| c = cmp(try_int(x), try_int(y)) |
| if c != 0: |
| return c; |
| |
| return 0 |
| |
| COMPLETION_TAIL_INT_RE = re.compile(r'^([A-Za-z0-9-]*[^0-9])(\d+) $') |
| |
| # |
| # -------------------------------------------------------------------------------- |
| |
| def completion_trailing_integer_cmp(x,y): |
| """ |
| sorted() comparison function. |
| |
| This is used for completion values sorting. |
| |
| This function differs from trailing_integer_cmp, since for completions, |
| the last character may be a space to indicate that the selection is |
| complete. If the last character is a space, the character ahead |
| of it is used instead. |
| """ |
| |
| x_v = x |
| if isinstance(x_v, tuple): |
| x_v = x_v[0] |
| if x[-1] == ' ': |
| x_v = x[:-1] |
| |
| y_v = y |
| if isinstance(y_v, tuple): |
| y_v = y_v[0] |
| if y[-1] == ' ': |
| y_v = y[:-1] |
| return trailing_integer_cmp(x_v, y_v) |
| |
| |
| # |
| # -------------------------------------------------------------------------------- |
| |
| ABERRANT_PLURAL_MAP = { |
| 'appendix': 'appendices', |
| 'barracks': 'barracks', |
| 'cactus': 'cacti', |
| 'child': 'children', |
| 'criterion': 'criteria', |
| 'deer': 'deer', |
| 'echo': 'echoes', |
| 'elf': 'elves', |
| 'embargo': 'embargoes', |
| 'focus': 'foci', |
| 'fungus': 'fungi', |
| 'goose': 'geese', |
| 'hero': 'heroes', |
| 'hoof': 'hooves', |
| 'index': 'indices', |
| 'knife': 'knives', |
| 'leaf': 'leaves', |
| 'life': 'lives', |
| 'man': 'men', |
| 'mouse': 'mice', |
| 'nucleus': 'nuclei', |
| 'person': 'people', |
| 'phenomenon': 'phenomena', |
| 'potato': 'potatoes', |
| 'self': 'selves', |
| 'syllabus': 'syllabi', |
| 'tomato': 'tomatoes', |
| 'torpedo': 'torpedoes', |
| 'veto': 'vetoes', |
| 'woman': 'women', |
| } |
| |
| VOWELS = set('aeiou') |
| |
| def pluralize(singular): |
| """Return plural form of given lowercase singular word (English only). Based on |
| ActiveState recipe http://code.activestate.com/recipes/413172/ |
| |
| >>> pluralize('') |
| '' |
| >>> pluralize('goose') |
| 'geese' |
| >>> pluralize('dolly') |
| 'dollies' |
| >>> pluralize('genius') |
| 'genii' |
| >>> pluralize('jones') |
| 'joneses' |
| >>> pluralize('pass') |
| 'passes' |
| >>> pluralize('zero') |
| 'zeros' |
| >>> pluralize('casino') |
| 'casinos' |
| >>> pluralize('hero') |
| 'heroes' |
| >>> pluralize('church') |
| 'churches' |
| >>> pluralize('x') |
| 'xs' |
| >>> pluralize('car') |
| 'cars' |
| |
| """ |
| if not singular: |
| return '' |
| plural = ABERRANT_PLURAL_MAP.get(singular) |
| if plural: |
| return plural |
| root = singular |
| try: |
| if singular[-1] == 'y' and singular[-2] not in VOWELS: |
| root = singular[:-1] |
| suffix = 'ies' |
| elif singular[-1] == 's': |
| if singular[-2] in VOWELS: |
| if singular[-3:] == 'ius': |
| root = singular[:-2] |
| suffix = 'i' |
| else: |
| root = singular[:-1] |
| suffix = 'ses' |
| else: |
| suffix = 'es' |
| elif singular[-2:] in ('ch', 'sh'): |
| suffix = 'es' |
| else: |
| suffix = 's' |
| except IndexError: |
| suffix = 's' |
| plural = root + suffix |
| return plural |