mirror of
https://github.com/opennetworkinglab/onos.git
synced 2025-10-14 17:01:02 +02:00
242 lines
8.4 KiB
Python
Executable File
242 lines
8.4 KiB
Python
Executable File
#!/usr/bin/env python
|
|
"""
|
|
Copyright 2018-present Open Networking Foundation
|
|
|
|
Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
|
|
|
|
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.
|
|
"""
|
|
|
|
##### Templates for features.xml
|
|
FEATURES_HEADER = '''\
|
|
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
|
|
<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0"
|
|
name="%(feature_repo_name)s">
|
|
'''
|
|
FEATURE_HEADER= '''\
|
|
<feature name="%(feature_name)s" version="%(version)s"
|
|
description="%(title)s">
|
|
'''
|
|
EXISTING_FEATURE = ' <feature>%s</feature>\n'
|
|
BUNDLE = ' <bundle>%s</bundle>\n'
|
|
FEATURE_FOOTER = ' </feature>\n'
|
|
FEATURES_FOOTER = '</features>\n'
|
|
|
|
##### Templates for app.xml
|
|
APP_HEADER = '''\
|
|
<?xml version="1.0" encoding="UTF-8"?>
|
|
<app name="%(app_name)s" origin="%(origin)s" version="%(version)s"
|
|
title="%(title)s" category="%(category)s" url="%(url)s"
|
|
featuresRepo="%(feature_repo_name)s"
|
|
features="%(feature_name)s" apps="%(apps)s">
|
|
<description>%(description)s</description>
|
|
'''
|
|
ARTIFACT = ' <artifact>%s</artifact>\n'
|
|
SECURITY = '''\
|
|
<security>
|
|
%s
|
|
</security>\n'''
|
|
APP_FOOTER = '</app>\n'
|
|
|
|
NON_OSGI_TAG = 'NON-OSGI'
|
|
|
|
def mvnUrl(bundle):
|
|
#mvn-uri := 'mvn:' [ repository-url '!' ] group-id '/' artifact-id [ '/' [version] [ '/' [type] [ '/' classifier ] ] ] ]
|
|
parts = bundle.split(':')[1:]
|
|
prefix = 'mvn:'
|
|
suffix = ''
|
|
if len(parts) > 3:
|
|
parts.insert(2, parts.pop()) # move version to the 3rd position
|
|
if len(parts) >= 5:
|
|
# check classifier for special non-OSGi tag
|
|
i = parts[4].find(NON_OSGI_TAG)
|
|
if i == 0:
|
|
prefix = 'wrap:' + prefix
|
|
suffix = '$Bundle-SymbolicName=%s.%s&Bundle-Version=%s' % tuple(parts[0:3])
|
|
if len(parts[4]) == len(NON_OSGI_TAG):
|
|
parts.pop() # pop off empty classifier
|
|
if parts[3].lower() == 'jar':
|
|
parts.pop() # pop off default extension: jar
|
|
else:
|
|
parts[4] = parts[4][len(NON_OSGI_TAG):]
|
|
return prefix + '/'.join(parts) + suffix
|
|
|
|
def generateFeatureFile(feature_repo_name,
|
|
features = [],
|
|
**kwargs):
|
|
values = {
|
|
'feature_repo_name' : '-'.join(feature_repo_name.split(':')[1:3]),
|
|
}
|
|
|
|
output = FEATURES_HEADER % values
|
|
|
|
for feature in features:
|
|
output += feature
|
|
|
|
output += FEATURES_FOOTER
|
|
return output
|
|
|
|
def generateFeature(feature_name,
|
|
version,
|
|
title,
|
|
features = [],
|
|
bundles = [],
|
|
**kwargs):
|
|
values = {
|
|
'feature_name' : feature_name,
|
|
'version' : version,
|
|
'title' : title,
|
|
}
|
|
|
|
output = FEATURE_HEADER % values
|
|
|
|
if features:
|
|
for feature in features:
|
|
output += EXISTING_FEATURE % feature
|
|
|
|
if bundles:
|
|
for bundle in bundles:
|
|
output += BUNDLE % mvnUrl(bundle)
|
|
|
|
output += FEATURE_FOOTER
|
|
return output
|
|
|
|
|
|
def generateAppFile(app_name,
|
|
origin,
|
|
version,
|
|
title,
|
|
category,
|
|
url,
|
|
feature_repo_name,
|
|
feature_name,
|
|
description = None,
|
|
apps = [],
|
|
artifacts = [],
|
|
security= None,
|
|
**kwargs):
|
|
values = {
|
|
'app_name' : app_name,
|
|
'origin' : origin,
|
|
'version' : version,
|
|
'title' : title,
|
|
'category' : category,
|
|
'url' : url,
|
|
'feature_repo_name' : mvnUrl(feature_repo_name) + '/xml/features',
|
|
'feature_name' : feature_name,
|
|
}
|
|
|
|
values['description'] = description if description else title
|
|
values['apps'] = ','.join(apps) if apps else ''
|
|
|
|
output = APP_HEADER % values
|
|
|
|
for artifact in artifacts:
|
|
output += ARTIFACT % mvnUrl(artifact)
|
|
|
|
if security is not None:
|
|
output += SECURITY % security
|
|
|
|
output += APP_FOOTER
|
|
return output
|
|
|
|
def write(name, msg):
|
|
if name is not None:
|
|
with open(name, "w") as file:
|
|
file.write(msg)
|
|
else:
|
|
print(msg)
|
|
|
|
if __name__ == '__main__':
|
|
import sys, optparse
|
|
|
|
parser = optparse.OptionParser()
|
|
parser.add_option("-O", "--output", dest="output", help="Output file")
|
|
parser.add_option("-n", "--name", dest="feature_coords", help="Feature MVN Coords")
|
|
parser.add_option("-a", "--app", dest="app_name", help="App Name")
|
|
parser.add_option("-o", "--origin", dest="origin", help="Origin")
|
|
parser.add_option("-c", "--category", dest="category", help="Category")
|
|
parser.add_option("-u", "--url", dest="url", help="URL")
|
|
parser.add_option("-v", "--version", dest="version", help="Version")
|
|
parser.add_option("-t", "--title", dest="title", help="Title")
|
|
parser.add_option("-r", "--repo", dest="repo_name", help="Repo Name")
|
|
parser.add_option('-D', '--desc', dest='desc', help='Application description')
|
|
parser.add_option('-s', '--security', dest='security', help='Application security')
|
|
|
|
parser.add_option('-b', '--bundle',
|
|
action="append", dest='included_bundles',
|
|
metavar="BUNDLE", help='Included Bundle (multiple allowed)')
|
|
parser.add_option('-e', '--excluded-bundle',
|
|
action="append", dest='excluded_bundles',
|
|
metavar="BUNDLE", help='Excluded Bundle (multiple allowed)')
|
|
parser.add_option('-f', '--feature',
|
|
action="append", dest='features',
|
|
metavar="FEATURE", help='Existing Feature (multiple allowed)')
|
|
parser.add_option('-d', '--apps',
|
|
action="append", dest='apps',
|
|
metavar="FEATURE", help='Required App (multiple allowed)')
|
|
|
|
parser.add_option("-A", "--write-app", dest="write_app", action="store_true")
|
|
parser.add_option("-F", "--write-features", dest="write_features", action="store_true")
|
|
parser.add_option("-E", "--write-feature", dest="write_feature", action="store_true")
|
|
|
|
(options, args) = parser.parse_args()
|
|
|
|
values = {}
|
|
if options.feature_coords and options.version and options.title:
|
|
parts = options.feature_coords.split(':')
|
|
values['feature_name'] = parts[2] if len(parts) > 2 else parts[0]
|
|
values['version'] = options.version
|
|
values['title'] = options.title
|
|
else:
|
|
sys.stderr.write('ERROR: Feature Name, Version, and Title are required\n')
|
|
sys.stderr.flush()
|
|
sys.exit(1)
|
|
|
|
if options.app_name and options.origin and options.category and options.url:
|
|
values['app_name'] = options.app_name
|
|
values['origin'] = options.origin
|
|
values['category'] = options.category
|
|
values['url'] = options.url
|
|
elif options.write_app:
|
|
sys.stderr.write('ERROR: Feature Name, Version, and Title are required\n')
|
|
sys.stderr.flush()
|
|
sys.exit(1)
|
|
|
|
values['feature_repo_name'] = options.repo_name if options.repo_name \
|
|
else options.feature_coords
|
|
|
|
bundles = []
|
|
if options.included_bundles:
|
|
bundles += options.included_bundles
|
|
if options.excluded_bundles:
|
|
bundles += options.excluded_bundles
|
|
if options.desc:
|
|
values['description'] = options.desc
|
|
|
|
feature = generateFeature(bundles=bundles,
|
|
features=options.features,
|
|
**values)
|
|
|
|
if options.write_feature:
|
|
write(options.output, feature)
|
|
|
|
if options.write_features:
|
|
write(options.output,
|
|
generateFeatureFile(features=[ feature ], **values))
|
|
|
|
if options.write_app:
|
|
write(options.output,
|
|
generateAppFile(artifacts=options.included_bundles,
|
|
apps=options.apps,
|
|
security=options.security,
|
|
**values))
|