kenmirrors/asterisk
1
0
Fork 0
mirror of https://github.com/asterisk/asterisk.git synced 2025-09-05 20:20:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update the conversion script from sip.conf to pjsip.conf

Browse Source 
(closes issue ASTERISK-22374)
Reported by Matt Jordan

Review: https://reviewboard.asterisk.org/r/2846
........

Merged revisions 402327 from http://svn.asterisk.org/svn/asterisk/branches/12


git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@402328 65c4cc65-6c06-0410-ace0-fbb531ad65f3
This commit is contained in:
Mark Michelson
2013-10-31 22:09:47 +00:00
parent e9fc321053
commit dd221c74c5
4 changed files with 1322 additions and 490 deletions
Download Patch File Download Diff File Expand all files Collapse all files

237
contrib/scripts/sip_to_res_sip/astconfigparser.py → contrib/scripts/sip_to_pjsip/astconfigparser.py
View File

@@ -3,6 +3,7 @@ import re
from astdicts import OrderedDict
from astdicts import MultiOrderedDict
def merge_values(left, right, key):
"""Merges values from right into left."""
if isinstance(left, list):
@@ -15,8 +16,10 @@ def merge_values(left, right, key):
###############################################################################
class Section(MultiOrderedDict):
"""A Section is a MultiOrderedDict itself that maintains a list of
"""
A Section is a MultiOrderedDict itself that maintains a list of
key/value options. However, in the case of an Asterisk config
file a section may have other defaults sections that is can pull
data from (i.e. templates). So when an option is looked up by key
@@ -35,9 +38,24 @@ class Section(MultiOrderedDict):
self._templates = [] if templates is None else templates
def __cmp__(self, other):
"""
Use self.id as means of determining equality
"""
return cmp(self.id, other.id)
def get(self, key, from_self=True, from_templates=True, from_defaults=True):
def get(self, key, from_self=True, from_templates=True,
from_defaults=True):
"""
Get the values corresponding to a given key. The parameters to this
function form a hierarchy that determines priority of the search.
from_self takes priority over from_templates, and from_templates takes
priority over from_defaults.
Parameters:
from_self - If True, search within the given section.
from_templates - If True, search in this section's templates.
from_defaults - If True, search within this section's defaults.
"""
if from_self and key in self:
return MultiOrderedDict.__getitem__(self, key)
@@ -62,13 +80,19 @@ class Section(MultiOrderedDict):
raise KeyError(key)
def __getitem__(self, key):
"""Get the value for the given key. If it is not found in the 'self'
"""
Get the value for the given key. If it is not found in the 'self'
then check inside templates and defaults before declaring raising
a KeyError exception.
"""
return self.get(key)
def keys(self, self_only=False):
"""
Get the keys from this section. If self_only is True, then
keys from this section's defaults and templates are not
included in the returned value
"""
res = MultiOrderedDict.keys(self)
if self_only:
return res
@@ -85,13 +109,21 @@ class Section(MultiOrderedDict):
return res
def add_defaults(self, defaults):
"""
Add a list of defaults to the section. Defaults are
sections such as 'general'
"""
defaults.sort()
for i in defaults:
self._defaults.insert(0, i)
def add_templates(self, templates):
templates.sort(reverse=True);
self._templates.extend(templates)
"""
Add a list of templates to the section.
"""
templates.sort()
for i in templates:
self._templates.insert(0, i)
def get_merged(self, key):
"""Return a list of values for a given key merged from default(s)"""
@@ -120,9 +152,11 @@ COMMENT_END = '--;'
DEFAULTSECT = 'general'
def remove_comment(line, is_comment):
"""Remove any commented elements from the line."""
if not line: return line, is_comment
if not line:
return line, is_comment
if is_comment:
part = line.partition(COMMENT_END)
@@ -152,22 +186,20 @@ def remove_comment(line, is_comment):
# check for eol comment
return line.partition(COMMENT)[0].strip(), False
def try_include(line):
"""Checks to see if the given line is an include. If so return the
"""
Checks to see if the given line is an include. If so return the
included filename, otherwise None.
"""
if not line.startswith('#'):
return None
# it is an include - get file name
try:
return line[line.index('"') + 1:line.rindex('"')]
except ValueError:
print "Invalid include - could not parse filename."
return None
match = re.match('^#include\s*[<"]?(.*)[>"]?$', line)
return match.group(1) if match else None
def try_section(line):
"""Checks to see if the given line is a section. If so return the section
"""
Checks to see if the given line is a section. If so return the section
name, otherwise return 'None'.
"""
# leading spaces were stripped when checking for comments
@@ -188,6 +220,7 @@ def try_section(line):
except:
return section[1:], False, templates
def try_option(line):
"""Parses the line as an option, returning the key/value pair."""
data = re.split('=>?', line)
@@ -196,30 +229,12 @@ def try_option(line):
###############################################################################
def find_value(sections, key):
"""Given a list of sections, try to find value(s) for the given key."""
# always start looking in the last one added
sections.sort(reverse=True);
for s in sections:
try:
# try to find in section and section's templates
return s.get(key, from_defaults=False)
except KeyError:
pass
# wasn't found in sections or a section's templates so check in defaults
for s in sections:
try:
# try to find in section's defaultsects
return s.get(key, from_self=False, from_templates=False)
except KeyError:
pass
raise KeyError(key)
def find_dict(mdicts, key, val):
"""Given a list of mult-dicts, return the multi-dict that contains
the given key/value pair."""
"""
Given a list of mult-dicts, return the multi-dict that contains
the given key/value pair.
"""
def found(d):
return key in d and val in d[key]
@@ -230,44 +245,25 @@ def find_dict(mdicts, key, val):
raise LookupError("Dictionary not located for key = %s, value = %s"
% (key, val))
def get_sections(parser, key, attr='_sections', searched=None):
if searched is None:
searched = []
if parser is None or parser in searched:
return []
try:
sections = getattr(parser, attr)
res = sections[key] if key in sections else []
searched.append(parser)
return res + get_sections(parser._includes, key, attr, searched) \
+ get_sections(parser._parent, key, attr, searched)
except:
# assume ordereddict of parsers
res = []
for p in parser.itervalues():
res.extend(get_sections(p, key, attr, searched))
return res
def get_defaults(parser, key):
return get_sections(parser, key, '_defaults')
def write_dicts(file, mdicts):
def write_dicts(config_file, mdicts):
"""Write the contents of the mdicts to the specified config file"""
for section, sect_list in mdicts.iteritems():
# every section contains a list of dictionaries
for sect in sect_list:
file.write("[%s]\n" % section)
config_file.write("[%s]\n" % section)
for key, val_list in sect.iteritems():
# every value is also a list
for v in val_list:
key_val = key
if v is not None:
key_val += " = " + str(v)
file.write("%s\n" % (key_val))
file.write("\n")
config_file.write("%s\n" % (key_val))
config_file.write("\n")
###############################################################################
class MultiOrderedConfigParser:
def __init__(self, parent=None):
self._parent = parent
@@ -275,15 +271,38 @@ class MultiOrderedConfigParser:
self._sections = MultiOrderedDict()
self._includes = OrderedDict()
def find_value(self, sections, key):
"""Given a list of sections, try to find value(s) for the given key."""
# always start looking in the last one added
sections.sort(reverse=True)
for s in sections:
try:
# try to find in section and section's templates
return s.get(key, from_defaults=False)
except KeyError:
pass
# wasn't found in sections or a section's templates so check in
# defaults
for s in sections:
try:
# try to find in section's defaultsects
return s.get(key, from_self=False, from_templates=False)
except KeyError:
pass
raise KeyError(key)
def defaults(self):
return self._defaults
def default(self, key):
"""Retrieves a list of dictionaries for a default section."""
return get_defaults(self, key)
return self.get_defaults(key)
def add_default(self, key, template_keys=None):
"""Adds a default section to defaults, returning the
"""
Adds a default section to defaults, returning the
default Section object.
"""
if template_keys is None:
@@ -295,17 +314,47 @@ class MultiOrderedConfigParser:
def section(self, key):
"""Retrieves a list of dictionaries for a section."""
return get_sections(self, key)
return self.get_sections(key)
def get_sections(self, key, attr='_sections', searched=None):
"""
Retrieve a list of sections that have values for the given key.
The attr parameter can be used to control what part of the parser
to retrieve values from.
"""
if searched is None:
searched = []
if self in searched:
return []
sections = getattr(self, attr)
res = sections[key] if key in sections else []
searched.append(self)
if self._includes:
res += self._includes.get_sections(key, attr, searched)
if self._parent:
res += self._parent.get_sections(key, attr, searched)
return res
def get_defaults(self, key):
"""
Retrieve a list of defaults that have values for the given key.
"""
return self.get_sections(key, '_defaults')
def add_section(self, key, template_keys=None, mdicts=None):
"""
Create a new section in the configuration. The name of the
new section is the 'key' parameter.
"""
if template_keys is None:
template_keys = []
if mdicts is None:
mdicts = self._sections
res = Section()
for t in template_keys:
res.add_templates(get_defaults(self, t))
res.add_defaults(get_defaults(self, DEFAULTSECT))
res.add_templates(self.get_defaults(t))
res.add_defaults(self.get_defaults(DEFAULTSECT))
mdicts.insert(0, key, res)
return res
@@ -313,29 +362,50 @@ class MultiOrderedConfigParser:
return self._includes
def add_include(self, filename, parser=None):
"""
Add a new #include file to the configuration.
"""
if filename in self._includes:
return self._includes[filename]
self._includes[filename] = res = \
MultiOrderedConfigParser(self) if parser is None else parser
return res;
return res
def get(self, section, key):
"""Retrieves the list of values from a section for a key."""
try:
# search for the value in the list of sections
return find_value(self.section(section), key)
return self.find_value(self.section(section), key)
except KeyError:
pass
try:
# section may be a default section so, search
# for the value in the list of defaults
return find_value(self.default(section), key)
return self.find_value(self.default(section), key)
except KeyError:
raise LookupError("key %r not found for section %r"
% (key, section))
def multi_get(self, section, key_list):
"""
Retrieves the list of values from a section for a list of keys.
This method is intended to be used for equivalent keys. Thus, as soon
as any match is found for any key in the key_list, the match is
returned. This does not concatenate the lookups of all of the keys
together.
"""
for i in key_list:
try:
return self.get(section, i)
except LookupError:
pass
# Making it here means all lookups failed.
raise LookupError("keys %r not found for section %r" %
(key_list, section))
def set(self, section, key, val):
"""Sets an option in the given section."""
# TODO - set in multiple sections? (for now set in first)
@@ -346,15 +416,17 @@ class MultiOrderedConfigParser:
self.defaults(section)[0][key] = val
def read(self, filename):
"""Parse configuration information from a file"""
try:
with open(filename, 'rt') as file:
self._read(file, filename)
with open(filename, 'rt') as config_file:
self._read(config_file)
except IOError:
print "Could not open file ", filename, " for reading"
def _read(self, file, filename):
def _read(self, config_file):
"""Parse configuration information from the config_file"""
is_comment = False # used for multi-lined comments
for line in file:
for line in config_file:
line, is_comment = remove_comment(line, is_comment)
if not line:
# line was empty or was a comment
@@ -377,18 +449,19 @@ class MultiOrderedConfigParser:
key, val = try_option(line)
sect[key] = val
def write(self, f):
def write(self, config_file):
"""Write configuration information out to a file"""
try:
for key, val in self._includes.iteritems():
val.write(key)
f.write('#include "%s"\n' % key)
config_file.write('#include "%s"\n' % key)
f.write('\n')
write_dicts(f, self._defaults)
write_dicts(f, self._sections)
config_file.write('\n')
write_dicts(config_file, self._defaults)
write_dicts(config_file, self._sections)
except:
try:
with open(f, 'wt') as fp:
with open(config_file, 'wt') as fp:
self.write(fp)
except IOError:
print "Could not open file ", f, " for writing"
print "Could not open file ", config_file, " for writing"

0
contrib/scripts/sip_to_res_sip/astdicts.py → contrib/scripts/sip_to_pjsip/astdicts.py
View File

1151
contrib/scripts/sip_to_pjsip/sip_to_pjsip.py Executable file
View File

File diff suppressed because it is too large Load Diff

392
contrib/scripts/sip_to_res_sip/sip_to_res_sip.py
View File

@@ -1,392 +0,0 @@
#!/usr/bin/python
###############################################################################
# TODO:
# (1) There is more work to do here, at least for the sip.conf items that
# aren't currently parsed. An issue will be created for that.
# (2) All of the scripts should probably be passed through pylint and have
# as many PEP8 issues fixed as possible
# (3) A public review is probably warranted at that point of the entire script
###############################################################################
import optparse
import astdicts
import astconfigparser
PREFIX = 'res_sip_'
###############################################################################
### some utility functions
###############################################################################
def section_by_type(section, res_sip, type):
"""Finds a section based upon the given type, adding it if not found."""
try:
return astconfigparser.find_dict(
res_sip.section(section), 'type', type)
except LookupError:
# section for type doesn't exist, so add
sect = res_sip.add_section(section)
sect['type'] = type
return sect
def set_value(key=None, val=None, section=None, res_sip=None,
nmapped=None, type='endpoint'):
"""Sets the key to the value within the section in res_sip.conf"""
def _set_value(k, v, s, r, n):
set_value(key if key else k, v, s, r, n, type)
# if no value or section return the set_value
# function with the enclosed key and type
if not val and not section:
return _set_value
# otherwise try to set the value
section_by_type(section, res_sip, type)[key] = \
val[0] if isinstance(val, list) else val
def merge_value(key=None, val=None, section=None, res_sip=None,
nmapped=None, type='endpoint', section_to=None):
"""Merge values from the given section with those from the default."""
def _merge_value(k, v, s, r, n):
merge_value(key if key else k, v, s, r, n, type, section_to)
# if no value or section return the merge_value
# function with the enclosed key and type
if not val and not section:
return _merge_value
# should return a single value section list
sect = sip.section(section)[0]
# for each merged value add it to res_sip.conf
for i in sect.get_merged(key):
set_value(key, i, section_to if section_to else section,
res_sip, nmapped, type)
def is_in(s, sub):
"""Returns true if 'sub' is in 's'"""
return s.find(sub) != -1
def non_mapped(nmapped):
def _non_mapped(section, key, val):
"""Writes a non-mapped value from sip.conf to the non-mapped object."""
if section not in nmapped:
nmapped[section] = astconfigparser.Section()
if isinstance(val, list):
for v in val:
# since coming from sip.conf we can assume
# single section lists
nmapped[section][0][key] = v
else:
nmapped[section][0][key] = val
return _non_mapped
###############################################################################
### mapping functions -
### define f(key, val, section) where key/val are the key/value pair to
### write to given section in res_sip.conf
###############################################################################
def set_dtmfmode(key, val, section, res_sip, nmapped):
"""Sets the dtmfmode value. If value matches allowable option in res_sip
then map it, otherwise set it to none.
"""
# available res_sip.conf values: frc4733, inband, info, none
if val != 'inband' or val != 'info':
nmapped(section, key, val + " ; did not fully map - set to none")
val = 'none'
set_value(key, val, section, res_sip, nmapped)
def from_nat(key, val, section, res_sip, nmapped):
"""Sets values from nat into the appropriate res_sip.conf options."""
# nat from sip.conf can be comma separated list of values:
# yes/no, [auto_]force_rport, [auto_]comedia
if is_in(val, 'yes'):
set_value('rtp_symmetric', 'yes', section, res_sip, nmapped)
set_value('rewrite_contact', 'yes', section, res_sip, nmapped)
if is_in(val, 'comedia'):
set_value('rtp_symmetric', 'yes', section, res_sip, nmapped)
if is_in(val, 'force_rport'):
set_value('force_rport', 'yes', section, res_sip, nmapped)
set_value('rewrite_contact', 'yes', section, res_sip, nmapped)
def set_timers(key, val, section, res_sip, nmapped):
"""Sets the timers in res_sip.conf from the session-timers option
found in sip.conf.
"""
# res_sip.conf values can be yes/no, required, always
if val == 'originate':
set_value('timers', 'always', section, res_sip, nmapped)
elif val == 'accept':
set_value('timers', 'required', section, res_sip, nmapped)
elif val == 'never':
set_value('timers', 'no', section, res_sip, nmapped)
else:
set_value('timers', 'yes', section, res_sip, nmapped)
def set_direct_media(key, val, section, res_sip, nmapped):
"""Maps values from the sip.conf comma separated direct_media option
into res_sip.conf direct_media options.
"""
if is_in(val, 'yes'):
set_value('direct_media', 'yes', section, res_sip, nmapped)
if is_in(val, 'update'):
set_value('direct_media_method', 'update', section, res_sip, nmapped)
if is_in(val, 'outgoing'):
set_value('directed_media_glare_mitigation', 'outgoing', section, res_sip, nmapped)
if is_in(val, 'nonat'):
set_value('disable_directed_media_on_nat','yes', section, res_sip, nmapped)
if (val == 'no'):
set_value('direct_media', 'no', section, res_sip, nmapped)
def from_sendrpid(key, val, section, res_sip, nmapped):
"""Sets the send_rpid/pai values in res_sip.conf."""
if val == 'yes' or val == 'rpid':
set_value('send_rpid', 'yes', section, res_sip, nmapped)
elif val == 'pai':
set_value('send_pai', 'yes', section, res_sip, nmapped)
def set_media_encryption(key, val, section, res_sip, nmapped):
"""Sets the media_encryption value in res_sip.conf"""
if val == 'yes':
set_value('media_encryption', 'sdes', section, res_sip, nmapped)
def from_recordfeature(key, val, section, res_sip, nmapped):
"""If record on/off feature is set to automixmon then set
one_touch_recording, otherwise it can't be mapped.
"""
if val == 'automixmon':
set_value('one_touch_recording', 'yes', section, res_sip, nmapped)
else:
nmapped(section, key, val + " ; could not be fully mapped")
def from_progressinband(key, val, section, res_sip, nmapped):
"""Sets the inband_progress value in res_sip.conf"""
# progressinband can = yes/no/never
if val == 'never':
val = 'no'
set_value('inband_progress', val, section, res_sip, nmapped)
def from_host(key, val, section, res_sip, nmapped):
"""Sets contact info in an AOR section in in res_sip.conf using 'host'
data from sip.conf
"""
# all aors have the same name as the endpoint so makes
# it easy to endpoint's 'aors' value
set_value('aors', section, section, res_sip, nmapped)
if val != 'dynamic':
set_value('contact', val, section, res_sip, nmapped, 'aor')
else:
set_value('max_contacts', 1, section, res_sip, nmapped, 'aor')
def from_subscribemwi(key, val, section, res_sip, nmapped):
"""Checks the subscribemwi value in sip.conf. If yes places the
mailbox value in mailboxes within the endpoint, otherwise puts
it in the aor.
"""
mailboxes = sip.get('mailbox', section, res_sip)
type = 'endpoint' if val == 'yes' else 'aor'
set_value('mailboxes', mailboxes, section, res_sip, nmapped, type)
###############################################################################
# options in res_sip.conf on an endpoint that have no sip.conf equivalent:
# type, rtp_ipv6, 100rel, trust_id_outbound, aggregate_mwi,
# connected_line_method
# known sip.conf peer keys that can be mapped to a res_sip.conf section/key
peer_map = [
# sip.conf option mapping function res_sip.conf option(s)
###########################################################################
['context', set_value],
['dtmfmode', set_dtmfmode],
['disallow', merge_value],
['allow', merge_value],
['nat', from_nat], # rtp_symmetric, force_rport,
# rewrite_contact
['icesupport', set_value('ice_support')],
['autoframing', set_value('use_ptime')],
['outboundproxy', set_value('outbound_proxy')],
['mohsuggest', set_value],
['session-timers', set_timers], # timers
['session-minse', set_value('timers_min_se')],
['session-expires', set_value('timers_sess_expires')],
['externip', set_value('external_media_address')],
['externhost', set_value('external_media_address')],
# identify_by ?
['directmedia', set_direct_media], # direct_media
# direct_media_method
# directed_media_glare_mitigation
# disable_directed_media_on_nat
['callerid', set_value], # callerid
['callingpres', set_value('callerid_privacy')],
['cid_tag', set_value('callerid_tag')],
['trustpid', set_value('trust_id_inbound')],
['sendrpid', from_sendrpid], # send_pai, send_rpid
['send_diversion', set_value],
['encrpytion', set_media_encryption],
['use_avpf', set_value],
['recordonfeature', from_recordfeature], # automixon
['recordofffeature', from_recordfeature], # automixon
['progressinband', from_progressinband], # in_band_progress
['callgroup', set_value],
['pickupgroup', set_value],
['namedcallgroup', set_value],
['namedpickupgroup', set_value],
['busylevel', set_value('devicestate_busy_at')],
############################ maps to an aor ###################################
['host', from_host], # contact, max_contacts
['subscribemwi', from_subscribemwi], # mailboxes
['qualifyfreq', set_value('qualify_frequency', type='aor')],
############################# maps to auth#####################################
# type = auth
# username
# password
# md5_cred
# realm
# nonce_lifetime
# auth_type
######################### maps to acl/security ################################
['permit', merge_value(type='security', section_to='acl')],
['deny', merge_value(type='security', section_to='acl')],
['acl', merge_value(type='security', section_to='acl')],
['contactpermit', merge_value(type='security', section_to='acl')],
['contactdeny', merge_value(type='security', section_to='acl')],
['contactacl', merge_value(type='security', section_to='acl')],
########################### maps to transport #################################
# type = transport
# protocol
# bind
# async_operations
# ca_list_file
# cert_file
# privkey_file
# password
# external_signaling_address - externip & externhost
# external_signaling_port
# external_media_address
# domain
# verify_server
# verify_client
# require_client_cert
# method
# cipher
# localnet
######################### maps to domain_alias ################################
# type = domain_alias
# domain
######################### maps to registration ################################
# type = registration
# server_uri
# client_uri
# contact_user
# transport
# outbound_proxy
# expiration
# retry_interval
# max_retries
# auth_rejection_permanent
# outbound_auth
########################### maps to identify ##################################
# type = identify
# endpoint
# match
]
def map_peer(sip, section, res_sip, nmapped):
for i in peer_map:
try:
# coming from sip.conf the values should mostly be a list with a
# single value. In the few cases that they are not a specialized
# function (see merge_value) is used to retrieve the values.
i[1](i[0], sip.get(section, i[0])[0], section, res_sip, nmapped)
except LookupError:
pass # key not found in sip.conf
def find_non_mapped(sections, nmapped):
for section, sect in sections.iteritems():
try:
# since we are pulling from sip.conf this should always
# be a single value list
sect = sect[0]
# loop through the section and store any values that were not mapped
for key in sect.keys(True):
for i in peer_map:
if i[0] == key:
break;
else:
nmapped(section, key, sect[key])
except LookupError:
pass
def convert(sip, filename, non_mappings):
res_sip = astconfigparser.MultiOrderedConfigParser()
non_mappings[filename] = astdicts.MultiOrderedDict()
nmapped = non_mapped(non_mappings[filename])
for section in sip.sections():
if section == 'authentication':
pass
else:
map_peer(sip, section, res_sip, nmapped)
find_non_mapped(sip.defaults(), nmapped)
find_non_mapped(sip.sections(), nmapped)
for key, val in sip.includes().iteritems():
res_sip.add_include(PREFIX + key, convert(val, PREFIX + key, non_mappings)[0])
return res_sip, non_mappings
def write_res_sip(filename, res_sip, non_mappings):
try:
with open(filename, 'wt') as fp:
fp.write(';--\n')
fp.write(';;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\n')
fp.write('Non mapped elements start\n')
fp.write(';;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\n\n')
astconfigparser.write_dicts(fp, non_mappings[filename])
fp.write(';;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\n')
fp.write('Non mapped elements end\n')
fp.write(';;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\n')
fp.write('--;\n\n')
# write out include file(s)
for key, val in res_sip.includes().iteritems():
write_res_sip(key, val, non_mappings)
fp.write('#include "%s"\n' % key)
fp.write('\n')
# write out mapped data elements
astconfigparser.write_dicts(fp, res_sip.defaults())
astconfigparser.write_dicts(fp, res_sip.sections())
except IOError:
print "Could not open file ", filename, " for writing"
###############################################################################
def cli_options():
global PREFIX
usage = "usage: %prog [options] [input-file [output-file]]\n\n" \
"input-file defaults to 'sip.conf'\n" \
"output-file defaults to 'res_sip.conf'"
parser = optparse.OptionParser(usage=usage)
parser.add_option('-p', '--prefix', dest='prefix', default=PREFIX,
help='output prefix for include files')
options, args = parser.parse_args()
PREFIX = options.prefix
sip_filename = args[0] if len(args) else 'sip.conf'
res_sip_filename = args[1] if len(args) == 2 else 'res_sip.conf'
return sip_filename, res_sip_filename
if __name__ == "__main__":
sip_filename, res_sip_filename = cli_options()
# configuration parser for sip.conf
sip = astconfigparser.MultiOrderedConfigParser()
sip.read(sip_filename)
res_sip, non_mappings = convert(sip, res_sip_filename, dict())
write_res_sip(res_sip_filename, res_sip, non_mappings)