def _parse_version(self, value):
if isinstance(value, semver.VersionInfo):
version_info = value
else:
version_info = semver.parse_version_info(value)
version = semver.format_version(*tuple(version_info))
return version, version_info
def __str__(self):
"""
Return version as string compatible with semver
:return:str
"""
return semver.format_version(self.major, self.minor, self.patch, self.prerelease or None, self.build or None)
def __str__(self):
return semver.format_version(*self.version)
import pyspatialite.dbapi2 as db
import logging
from logging.config import dictConfig
import pandas as pd
import os
import semver
import datetime
version = semver.format_version(0, 1, 0, 'pre.6', 'build.1')
def get_or_create(session, model, **kwargs):
'''
Creates an object or returns the object if exists
credit to Kevin @ StackOverflow
from: http://stackoverflow.com/questions/2546207/does-sqlalchemy-have-an-equivalent-of-djangos-get-or-create
'''
instance = session.query(model).filter_by(**kwargs).first()
if not instance:
instance = model(**kwargs)
session.add(instance)
return instance
########################################################################################################################
# Hilfsklasse fuer Beobachtungen
class beobachtung(object):
def __init__(self, cur):
self.cur = cur
# do something
default=DEFAULT_WINDOWS_BASETAG,
help=
'Windows Server Core base image tag to use for Windows containers (default is '
+ DEFAULT_WINDOWS_BASETAG + ')')
# If no command-line arguments were supplied, display the help message and exit
if len(sys.argv) < 2:
parser.print_help()
sys.exit(0)
# Parse the supplied command-line arguments and validate the specified version string
args = parser.parse_args()
try:
ue4Version = semver.parse(args.release)
ue4VersionStr = semver.format_version(ue4Version['major'],
ue4Version['minor'],
ue4Version['patch'])
if ue4Version['major'] != 4 or ue4Version['prerelease'] != None:
raise Exception()
except:
logger.error(
'Error: invalid UE4 release number "{}", full semver format required (e.g. "4.19.0")'
.format(args.release))
sys.exit(1)
# Determine if we are building Windows or Linux containers
containerPlatform = 'windows' if platform.system(
) == 'Windows' and args.linux == False else 'linux'
platformArgs = []
if containerPlatform == 'windows':
def _sort_images_by_name(self, clist):
# We have a flag day where we start putting underscores into
# image tags. Those always go at the top.
# We begin by splitting the list of candidate images into new
# and old style images.
oldstyle = []
newstyle = []
for cimg in clist:
name = cimg["name"]
if name.find("_") == -1:
oldstyle.append(cimg)
else:
# "latest_X" is not a semantic version tag.
if name.startswith("latest_"):
oldstyle.append(cimg)
else:
newstyle.append(cimg)
# Old-style sort is simple string comparison.
oldstyle.sort(key=lambda x: x["name"], reverse=True)
# New style, we refer to semver module for comparison.
# (also works fine for date sorts)
seml = []
for cimg in newstyle:
name = cimg["name"]
components = name.split("_")
# Get this. It's not represented as r_17, no, it's r17.
# So if we find that the end of the first group is digits,
# we split those off with a regular expression, and insert
# them into the list where the major number should be.
ctype = components[0]
ctm = re.search(r'\d+$', ctype)
if ctm is not None:
mj = int(ctm.group())
components.insert(1, mj)
# First character is image type, not semantically significant
# for versioning.
if components[0] == "exp":
_ = components.pop(0)
major = 0
if len(components) > 1:
major = int(components[1])
minor = 0
if len(components) > 2:
minor = int(components[2])
patch = 0
prerelease = None
if len(components) > 3:
try:
patch = int(components[3])
except ValueError:
# Not an integer, so this is probably an experimental/
# not-for-release version, so leave it at patch level 0
# and treat the string as a prerelease version
prerelease = components[3]
if len(components) > 4:
prerelease = components[4]
build = None
if len(components) > 5:
build = '_'.join(components[5:])
cimg["semver"] = semver.format_version(major, minor, patch,
prerelease, build)
seml.append(cimg["semver"])
seml.sort(key=functools.cmp_to_key(semver.compare), reverse=True)
sorted_newstyle = []
for skey in seml:
for ni in newstyle:
if ni["semver"] == skey:
sorted_newstyle.append(ni)
break
# Return all new style names first.
return sorted_newstyle.extend(oldstyle)
from troposphere import Template, Ref, Tags, Join, Parameter, Output
from troposphere.ec2 import VPC as ec2VPC
from troposphere.ec2 import Subnet, NetworkAcl, NetworkAclEntry,\
InternetGateway, VPCGatewayAttachment, RouteTable, Route,\
SubnetRouteTableAssociation, SubnetNetworkAclAssociation
import semver
import argparse
import boto3
VERSION_MAJOR = 0
VERSION_MINOR = 0
VERSION_PATCH = 1
VERSION_PRE = None
VERSION_BUILD = "build.1"
VERSION = semver.format_version(VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH, VERSION_PRE, VERSION_BUILD)
from default import *
CF_TEMPLATE_NAME = "vpc.template"
class VPC:
t = Template()
def buildTemplate(self):
self.t.add_metadata({
"Comments": "This will build a standard VPC with public and private subnets",
"Version": VERSION,
"Author": "Derek Belrose <*****@*****.**>",
})
### Back references
path
field
format
}
internal
disable {
integrations
}
}
}
}
""" % (indent(OPENSHIFT_RESOURCE, 8 * ' '), indent(OPENSHIFT_RESOURCE,
6 * ' '))
QONTRACT_INTEGRATION = 'openshift_resources_base'
QONTRACT_INTEGRATION_VERSION = semver.format_version(1, 9, 2)
QONTRACT_BASE64_SUFFIX = '_qb64'
_log_lock = Lock()
class FetchVaultSecretError(Exception):
def __init__(self, msg):
super(FetchVaultSecretError,
self).__init__("error fetching vault secret: " + str(msg))
class FetchRouteError(Exception):
def __init__(self, msg):
super(FetchRouteError,
self).__init__("error fetching route: " + str(msg))
def test_should_correctly_format_version():
assert format_version(3, 4, 5) == '3.4.5'
assert format_version(3, 4, 5, 'rc.1') == '3.4.5-rc.1'
assert format_version(3, 4, 5, prerelease='rc.1') == '3.4.5-rc.1'
assert format_version(3, 4, 5, build='build.4') == '3.4.5+build.4'
assert format_version(3, 4, 5, 'rc.1', 'build.4') == '3.4.5-rc.1+build.4'
def write_version_py(filename="wradlib/version.py"):
cnt = """
# THIS FILE IS GENERATED FROM WRADLIB SETUP.PY
short_version = '%(short_version)s'
version = '%(version)s'
full_version = '%(full_version)s'
git_revision = '%(git_revision)s'
release = %(isrelease)s
"""
# Adding the git rev number needs to be done inside write_version_py(),
# otherwise the import of wradlib.version messes up the build under
# Python 3.
SHORT_VERSION = VERSION
FULL_VERSION = VERSION
GIT_REVISION = VERSION + "-unknown"
GIT_HASH = "unknown"
ISRELEASED = "'unknown'"
if os.path.exists(".git"):
GIT_REVISION, GIT_HASH = git_version()
elif os.path.exists("wradlib/version.py"):
# must be a source distribution, use existing version file
try:
from wradlib.version import full_version as GIT_REVISION
from wradlib.version import git_revision as GIT_HASH
except ImportError:
raise ImportError("Unable to import git_revision. Try removing "
"wradlib/version.py and the build directory "
"before building.")
else:
warnings.warn(
"wradlib source does not contain detailed version info "
"via git or version.py, exact version can't be "
"retrieved.",
UserWarning,
)
# parse version using semver
ver = semver.VersionInfo.parse(GIT_REVISION)
# get commit count, dev0 means tagged commit -> release
ISRELEASED = ver.prerelease == "dev0"
if not ISRELEASED:
SHORT_VERSION = semver.format_version(ver.major, ver.minor, ver.patch,
ver.prerelease)
FULL_VERSION = GIT_REVISION
a = open(filename, "w")
try:
a.write(
cnt % {
"short_version": SHORT_VERSION,
"version": FULL_VERSION,
"full_version": GIT_REVISION,
"git_revision": GIT_HASH,
"isrelease": str(ISRELEASED),
})
finally:
a.close()
return SHORT_VERSION
import sys
import semver
import reconcile.queries as queries
from utils.saasherder import SaasHerder
QONTRACT_INTEGRATION = 'saas-file-validator'
QONTRACT_INTEGRATION_VERSION = semver.format_version(0, 1, 0)
def run(dry_run):
saas_files = queries.get_saas_files()
settings = queries.get_app_interface_settings()
saasherder = SaasHerder(saas_files,
thread_pool_size=1,
gitlab=None,
integration=QONTRACT_INTEGRATION,
integration_version=QONTRACT_INTEGRATION_VERSION,
settings=settings)
if not saasherder.valid:
sys.exit(1)
from __future__ import absolute_import
import sys
import os
import semver
__all__ = ['APPS_DIR','TOP_DIR']
VERSION = (1, 1, 2)
__version__ = semver.format_version(*VERSION)
# assume we are ./apps/mainsite/__init__.py
APPS_DIR = os.path.dirname(os.path.abspath(os.path.dirname(__file__)))
if APPS_DIR not in sys.path:
sys.path.insert(0, APPS_DIR)
# Path to the whole project (one level up from apps)
TOP_DIR = os.path.dirname(APPS_DIR)
# import the celery app so INSTALLED_APPS gets autodiscovered
from .celery import app as celery_app
def test_should_correctly_format_version():
assert format_version(3, 4, 5) == "3.4.5"
assert format_version(3, 4, 5, "rc.1") == "3.4.5-rc.1"
assert format_version(3, 4, 5, prerelease="rc.1") == "3.4.5-rc.1"
assert format_version(3, 4, 5, build="build.4") == "3.4.5+build.4"
assert format_version(3, 4, 5, "rc.1", "build.4") == "3.4.5-rc.1+build.4"
def get_version(version=None):
if version is None:
from .version import VERSION
version = VERSION
return semver.format_version(*version)
from __future__ import absolute_import
import sys
import os
import semver
__all__ = ['APPS_DIR', 'TOP_DIR']
VERSION = (1, 1, 8)
__version__ = semver.format_version(*VERSION)
# assume we are ./apps/mainsite/__init__.py
APPS_DIR = os.path.dirname(os.path.abspath(os.path.dirname(__file__)))
if APPS_DIR not in sys.path:
sys.path.insert(0, APPS_DIR)
# Path to the whole project (one level up from apps)
TOP_DIR = os.path.dirname(APPS_DIR)
# import the celery app so INSTALLED_APPS gets autodiscovered
from .celery import app as celery_app
def create_version_tag(command_context: CommandContext,
operation: Callable[[VersionConfig, Optional[str], Optional[int]], Result]) -> Result:
result = Result()
context: Context = command_context.context
release_branches = command_context.context.get_release_branches(reverse=True)
# TODO configuration
allow_merge_base_tags = True # context.config.allow_shared_release_branch_base
selected_branch = command_context.selected_ref
selected_branch_base_version = context.release_branch_matcher.format(command_context.selected_ref.name)
if selected_branch_base_version is not None:
selected_branch_base_version_info = semver.parse_version_info(selected_branch_base_version)
else:
selected_branch_base_version_info = None
if selected_branch_base_version is None:
result.fail(os.EX_USAGE,
_("Cannot bump version."),
_("{branch} is not a release branch.")
.format(branch=repr(command_context.selected_ref.name)))
latest_version_tag = None
preceding_version_tag = None
preceding_branch_version_tag = None
version_tags_on_same_commit = list()
subsequent_version_tags = list()
enclosing_versions = set()
# abort scan, when a preceding commit for each tag type has been processed.
# enclosing_versions now holds enough information for operation validation,
# assuming the branch has not gone haywire in earlier commits
# TODO evaluate upper and lower bound version for efficiency
abort_version_scan = False
on_selected_branch = False
before_commit = False
before_selected_branch = False
for release_branch in release_branches:
# fork_point = repotools.git_merge_base(context.repo, context.config.release_branch_base,
# command_context.selected_commit)
# if fork_point is None:
# result.fail(os.EX_USAGE,
# _("Cannot bump version."),
# _("{branch} has no fork point on {base_branch}.")
# .format(branch=repr(command_context.selected_ref.name),
# base_branch=repr(context.config.release_branch_base)))
fork_point = None
branch_base_version = context.release_branch_matcher.format(release_branch.name)
if branch_base_version is not None:
branch_base_version_info = semver.parse_version_info(branch_base_version)
else:
branch_base_version_info = None
on_selected_branch = not before_selected_branch and release_branch.name == selected_branch.name
for history_commit in repotools.git_list_commits(
context=context.repo,
start=fork_point,
end=release_branch.obj_name,
options=const.BRANCH_COMMIT_SCAN_OPTIONS):
at_commit = not before_commit and on_selected_branch and history_commit.obj_name == command_context.selected_commit
version_tag_refs = None
assert not at_commit if before_commit else not before_commit
for tag_ref in repotools.git_get_tags_by_referred_object(context.repo, history_commit.obj_name):
version_info = context.version_tag_matcher.to_version_info(tag_ref.name)
if version_info is not None:
tag_matches = version_info.major == branch_base_version_info.major \
and version_info.minor == branch_base_version_info.minor
if tag_matches:
if version_tag_refs is None:
version_tag_refs = list()
version_tag_refs.append(tag_ref)
else:
if fork_point is not None:
# fail stray tags on exclusive branch commits
result.fail(os.EX_DATAERR,
_("Cannot bump version."),
_("Found stray version tag: {version}.")
.format(version=repr(version.format_version_info(version_info)))
)
else:
# when no merge base is used, abort at the first mismatching tag
break
if not abort_version_scan and version_tag_refs is not None and len(version_tag_refs):
version_tag_refs.sort(
reverse=True,
key=utils.cmp_to_key(
lambda tag_ref_a, tag_ref_b: semver.compare(
context.version_tag_matcher.format(tag_ref_a.name),
context.version_tag_matcher.format(tag_ref_b.name)
)
)
)
if latest_version_tag is None:
latest_version_tag = version_tag_refs[0]
if at_commit:
version_tags_on_same_commit.extend(version_tag_refs)
if at_commit or before_commit:
if preceding_version_tag is None:
preceding_version_tag = version_tag_refs[0]
if on_selected_branch and preceding_branch_version_tag is None:
preceding_branch_version_tag = version_tag_refs[0]
else:
subsequent_version_tags.extend(version_tag_refs)
for tag_ref in version_tag_refs:
enclosing_versions.add(context.version_tag_matcher.format(tag_ref.name))
if before_commit:
abort_version_scan = True
if at_commit:
before_commit = True
if on_selected_branch:
before_commit = True
before_selected_branch = True
if abort_version_scan:
break
if context.config.sequential_versioning and preceding_version_tag is not None:
match = context.version_tag_matcher.fullmatch(preceding_version_tag.name)
preceding_sequential_version = match.group(context.version_tag_matcher.group_unique_code)
else:
preceding_sequential_version = None
if preceding_sequential_version is not None:
preceding_sequential_version = int(preceding_sequential_version)
if context.verbose:
cli.print("Tags on selected commit:\n"
+ '\n'.join(' - ' + repr(tag_ref.name) for tag_ref in version_tags_on_same_commit))
cli.print("Tags in subsequent history:\n"
+ '\n'.join(' - ' + repr(tag_ref.name) for tag_ref in subsequent_version_tags))
if preceding_branch_version_tag is not None:
latest_branch_version = context.version_tag_matcher.format(preceding_branch_version_tag.name)
else:
latest_branch_version = None
global_sequence_number = get_global_sequence_number(context)
if latest_branch_version is not None:
version_result = operation(context.config.version_config, latest_branch_version, global_sequence_number)
result.add_subresult(version_result)
new_version = version_result.value
if result.has_errors():
return result
else:
template_version_info = semver.parse_version_info(context.config.version_config.initial_version)
new_version = semver.format_version(
major=selected_branch_base_version_info.major,
minor=selected_branch_base_version_info.minor,
patch=template_version_info.patch,
prerelease=str(global_sequence_number + 1) if context.config.tie_sequential_version_to_semantic_version and global_sequence_number is not None else template_version_info.prerelease,
build=template_version_info.build,
)
new_version_info = semver.parse_version_info(new_version)
new_sequential_version = scheme_procedures.get_sequence_number(context.config.version_config, new_version_info)
if new_version_info.major != selected_branch_base_version_info.major or new_version_info.minor != selected_branch_base_version_info.minor:
result.fail(os.EX_USAGE,
_("Tag creation failed."),
_("The major.minor part of the new version {new_version}"
" does not match the branch version {branch_version}.")
.format(new_version=repr(new_version),
branch_version=repr(
"%d.%d" % (selected_branch_base_version_info.major, selected_branch_base_version_info.minor)))
)
try:
config_in_selected_commit = read_config_in_commit(context.repo, command_context.selected_commit)
except FileNotFoundError:
config_in_selected_commit = dict()
try:
properties_in_selected_commit = read_properties_in_commit(context,
context.repo,
config_in_selected_commit,
command_context.selected_commit)
except FileNotFoundError:
properties_in_selected_commit = dict()
if context.verbose:
print("properties in selected commit:")
print(json.dumps(obj=properties_in_selected_commit, indent=2))
valid_tag = False
# validate the commit
if len(version_tags_on_same_commit):
if config_in_selected_commit is None:
result.fail(os.EX_DATAERR,
_("Tag creation failed."),
_("The selected commit does not contain a configuration file.")
)
version_property_name = config_in_selected_commit.get(const.CONFIG_VERSION_PROPERTY)
if version_property_name is not None \
and properties_in_selected_commit.get(version_property_name) is None:
result.warn(_("Missing version info."),
_("The selected commit does not contain a version in property '{property_name}'.")
.format(property_name=version_property_name)
)
if len(version_tags_on_same_commit):
if context.config.allow_qualifier_increments_within_commit:
preceding_commit_version = context.version_tag_matcher.format(
version_tags_on_same_commit[0].name)
prerelease_keywords_list = [context.config.version_config.qualifiers, 1]
preceding_commit_version_ = version.parse_version(preceding_commit_version)
new_commit_version_ = version.parse_version(new_version)
version_delta = version.determine_version_delta(preceding_commit_version_,
new_commit_version_,
prerelease_keywords_list
)
version_increment_eval_result = version.evaluate_version_increment(preceding_commit_version_,
new_commit_version_,
context.config.strict_mode,
prerelease_keywords_list)
result.add_subresult(version_increment_eval_result)
if result.has_errors():
return result
if not version_delta.prerelease_field_only(0, False):
result.fail(os.EX_USAGE,
_("Tag creation failed."),
_("The selected commit already has version tags.\n"
"Operations on such a commit are limited to pre-release type increments.")
)
valid_tag = True
else:
result.fail(os.EX_USAGE,
_("Tag creation failed."),
_("There are version tags pointing to the selected commit {commit}.\n"
"Consider reusing these versions or bumping them to stable."
"{listing}")
.format(commit=command_context.selected_commit,
listing='\n'.join(
' - ' + repr(tag_ref.name) for tag_ref in subsequent_version_tags))
)
if not valid_tag:
if len(subsequent_version_tags):
result.fail(os.EX_USAGE,
_("Tag creation failed."),
_("There are version tags in branch history following the selected commit {commit}:\n"
"{listing}")
.format(commit=command_context.selected_commit,
listing='\n'.join(
' - ' + repr(tag_ref.name) for tag_ref in subsequent_version_tags))
)
global_seq_number = global_sequence_number
if context.config.tie_sequential_version_to_semantic_version \
and global_seq_number is not None \
and new_sequential_version is not None \
and preceding_sequential_version != global_seq_number:
result.fail(os.EX_USAGE,
_("Tag creation failed."),
_(
"The preceding sequential version {seq_val} "
"does not equal the global sequential version {global_seq_val}.")
.format(seq_val=preceding_sequential_version
if preceding_sequential_version is not None
else '<none>',
global_seq_val=global_seq_number)
)
if not result.has_errors():
if new_version is None:
result.fail(os.EX_SOFTWARE,
_("Internal error."),
_("Missing result version.")
)
if latest_branch_version is not None and semver.compare(latest_branch_version, new_version) >= 0:
result.fail(os.EX_DATAERR,
_("Failed to increment version from {current} to {new}.")
.format(current=repr(latest_branch_version), new=repr(new_version)),
_("The new version is lower than or equal to the current version.")
)
if context.config.push_to_local \
and command_context.current_branch.short_name == command_context.selected_ref.short_name:
if context.verbose:
cli.print(
_('Checking out {base_branch} in order to avoid failing the push to a checked-out release branch')
.format(base_branch=repr(context.config.release_branch_base)))
git_or_fail(context.repo, result, ['checkout', context.config.release_branch_base])
original_current_branch = command_context.current_branch
else:
original_current_branch = None
branch_name = get_branch_name_for_version(context, new_version_info)
tag_name = get_tag_name_for_version(context, new_version_info)
clone_result = clone_repository(context, context.config.release_branch_base)
cloned_repo = clone_result.value
commit_info = CommitInfo()
commit_info.add_message("#version: " + cli.if_none(new_version))
# run version change hooks on release branch
checkout_command = ['checkout', '--force', '--track', '-b', branch_name,
repotools.create_ref_name(const.REMOTES_PREFIX,
context.config.remote_name,
branch_name)]
returncode, out, err = repotools.git(cloned_repo, *checkout_command)
if returncode != os.EX_OK:
result.fail(os.EX_DATAERR,
_("Failed to check out release branch."),
_("An unexpected error occurred.")
)
clone_context: Context = create_temp_context(context, result, cloned_repo.dir)
clone_context.config.remote_name = 'origin'
if (context.config.commit_version_property and new_version is not None) \
or (context.config.commit_sequential_version_property and new_sequential_version is not None):
update_result = update_project_property_file(clone_context,
properties_in_selected_commit,
new_version,
new_sequential_version,
commit_info)
result.add_subresult(update_result)
if result.has_errors():
result.fail(os.EX_DATAERR,
_("Property update failed."),
_("An unexpected error occurred.")
)
if new_version is not None:
execute_version_change_actions(clone_context, latest_branch_version, new_version)
if commit_info is not None:
if command_context.selected_commit != command_context.selected_ref.target.obj_name:
result.fail(os.EX_USAGE,
_("Failed to commit version update."),
_("The selected parent commit {commit} does not represent the tip of {branch}.")
.format(commit=command_context.selected_commit,
branch=repr(command_context.selected_ref.name))
)
# commit changes
commit_info.add_parent(command_context.selected_commit)
object_to_tag = create_commit(clone_context, result, commit_info)
new_branch_ref_object = object_to_tag
else:
object_to_tag = command_context.selected_commit
new_branch_ref_object = None
# if command_context.selected_branch not in repotools.git_list_refs(context.repo,
# '--contains', object_to_tag,
# command_context.selected_branch.ref):
# show info and prompt for confirmation
cli.print("ref : " + cli.if_none(command_context.selected_ref.name))
cli.print("ref_" + const.DEFAULT_VERSION_VAR_NAME + " : " + cli.if_none(latest_branch_version))
cli.print("new_tag : " + cli.if_none(tag_name))
cli.print("new_" + const.DEFAULT_VERSION_VAR_NAME + " : " + cli.if_none(new_version))
cli.print("selected object : " + cli.if_none(command_context.selected_commit))
cli.print("tagged object : " + cli.if_none(object_to_tag))
prompt_result = prompt_for_confirmation(
context=context,
fail_title=_("Failed to create release tag based on {branch}.")
.format(branch=repr(command_context.selected_ref.name)),
message=_("The tags are about to be pushed."),
prompt=_("Continue?"),
)
result.add_subresult(prompt_result)
if result.has_errors() or not prompt_result.value:
return result
# push atomically
push_command = ['push', '--atomic']
if context.dry_run:
push_command.append('--dry-run')
if context.verbose:
push_command.append('--verbose')
push_command.append(context.config.remote_name)
# push the release branch commit or its version increment commit
if new_branch_ref_object is not None:
push_command.append(
new_branch_ref_object + ':' + repotools.create_ref_name(const.LOCAL_BRANCH_PREFIX, branch_name))
# check, if preceding tags exist on remote
if preceding_version_tag is not None:
push_command.append('--force-with-lease='
+ preceding_version_tag.name + ':'
+ preceding_version_tag.name)
# push the new version tag or fail if it exists
push_command.extend(['--force-with-lease=' + repotools.create_ref_name(const.LOCAL_TAG_PREFIX, tag_name) + ':',
repotools.ref_target(object_to_tag) + ':' + repotools.create_ref_name(
const.LOCAL_TAG_PREFIX, tag_name)])
returncode, out, err = repotools.git(clone_context.repo, *push_command)
if returncode != os.EX_OK:
result.fail(os.EX_DATAERR,
_("Failed to push."),
_("git push exited with " + str(returncode))
)
if original_current_branch is not None:
if context.verbose:
cli.print(
_('Switching back to {original_branch} ')
.format(original_branch=repr(original_current_branch.name)))
git_or_fail(context.repo, result, ['checkout', original_current_branch.short_name])
return result
import requests
import semver
from datetime import datetime
import subprocess
from locations import Locations
CWD = os.path.abspath(os.path.split(sys.argv[0])[0])
app = QApplication(sys.argv)
if 'DEBUG' in os.environ:
DEBUG = os.environ['DEBUG'].lower() in ('true', 'yes', '1')
else:
DEBUG = False
VERSION = semver.format_version(0, 2, 0)
BASE_URL = 'http://diaboli.averr.in/'
LOCAL = os.path.isdir(os.path.join(CWD, 'data'))
if LOCAL:
BASE_URL = 'http://book.dev/'
DEBUG = True
META = requests.get(BASE_URL + '/data/meta.json').json()
class TemplateLoader(BaseLoader):
def __init__(self, base_url):
self.base_url = base_url
self.cache = {}
self.base = ''
def fw_version_string(self):
return semver.format_version(
self.major, self.minor, self.patch, prerelease=self.prerelease, build=self.build
)
def set_pyversion(version):
version_info = semver.parse_version_info(version)
version_string = semver.format_version(*version_info)
with open(os.path.join(GMAPS_DIR, 'gmaps', '_version.py'), 'w') as f:
f.write(VERSION_TEMPLATE.format(version_string=version_string))
def get_formatted_version(self) -> str:
return semver.format_version(*self.version)
import pytest
from .fixtures import Fixtures
import semver
from reconcile.utils.openshift_resource import (OpenshiftResource as OR,
ConstructResourceError)
fxt = Fixtures('openshift_resource')
TEST_INT = 'test_openshift_resources'
TEST_INT_VER = semver.format_version(1, 9, 2)
class TestOpenshiftResource(object):
def test_verify_valid_k8s_object(self):
resource = fxt.get_anymarkup('valid_resource.yml')
openshift_resource = OR(resource, TEST_INT, TEST_INT_VER)
assert openshift_resource.verify_valid_k8s_object() is None
def test_verify_valid_k8s_object_false(self):
resource = fxt.get_anymarkup('invalid_resource.yml')
with pytest.raises(ConstructResourceError):
openshift_resource = OR(resource, TEST_INT, TEST_INT_VER)
assert openshift_resource.verify_valid_k8s_object() is None
def test_invalid_name_format(self):
resource = fxt.get_anymarkup('invalid_resource_name_format.yml')
def get_version(version=None):
if version is None:
from .version import VERSION
version = VERSION
return semver.format_version(*version)
def write_version_py(filename='wradlib/version.py'):
cnt = """
# THIS FILE IS GENERATED FROM WRADLIB SETUP.PY
short_version = '%(short_version)s'
version = '%(version)s'
full_version = '%(full_version)s'
git_revision = '%(git_revision)s'
release = %(isrelease)s
"""
# Adding the git rev number needs to be done inside write_version_py(),
# otherwise the import of wradlib.version messes up the build under
# Python 3.
SHORT_VERSION = VERSION
FULL_VERSION = VERSION
GIT_REVISION = VERSION + '-unknown'
GIT_HASH = 'unknown'
ISRELEASED = "'unknown'"
if os.path.exists('.git'):
GIT_REVISION, GIT_HASH = git_version()
elif os.path.exists('wradlib/version.py'):
# must be a source distribution, use existing version file
try:
from wradlib.version import full_version as GIT_REVISION
from wradlib.version import git_revision as GIT_HASH
except ImportError:
raise ImportError('Unable to import git_revision. Try removing '
'wradlib/version.py and the build directory '
'before building.')
# parse version using semver
ver = semver.parse_version_info(GIT_REVISION)
# get commit count, dev0 means tagged commit -> release
try:
ISRELEASED = ver.prerelease == 'dev0'
if not ISRELEASED:
if not ver.patch:
patch = 0
minor = 1
else:
patch = 1
minor = 0
SHORT_VERSION = semver.format_version(ver.major,
ver.minor + minor,
ver.patch + patch,
ver.prerelease)
FULL_VERSION = GIT_REVISION
except ValueError:
warnings.warn("wradlib source does not contain detailed version info "
"via git or version.py, exact version can't be "
"retrieved.", UserWarning)
print(SHORT_VERSION, FULL_VERSION, GIT_REVISION, GIT_HASH, ISRELEASED)
a = open(filename, 'w')
try:
a.write(cnt % {'short_version': SHORT_VERSION,
'version': FULL_VERSION,
'full_version': GIT_REVISION,
'git_revision': GIT_HASH,
'isrelease': str(ISRELEASED)})
finally:
a.close()
return SHORT_VERSION
def test_should_correctly_format_version():
assert format_version(3, 4, 5) == '3.4.5'
assert format_version(3, 4, 5, 'rc.1') == '3.4.5-rc.1'
assert format_version(3, 4, 5, prerelease='rc.1') == '3.4.5-rc.1'
assert format_version(3, 4, 5, build='build.4') == '3.4.5+build.4'
assert format_version(3, 4, 5, 'rc.1', 'build.4') == '3.4.5-rc.1+build.4'
def test_should_correctly_format_version(self):
self.assertEqual(format_version(3, 4, 5), '3.4.5')
self.assertEqual(format_version(3, 4, 5, 'rc.1'), '3.4.5-rc.1')
self.assertEqual(format_version(3, 4, 5, prerelease='rc.1'), '3.4.5-rc.1')
self.assertEqual(format_version(3, 4, 5, build='build.4'), '3.4.5+build.4')
self.assertEqual(format_version(3, 4, 5, 'rc.1', 'build.4'), '3.4.5-rc.1+build.4')
class Subnet():
VERSION_MAJOR = 0
VERSION_MINOR = 0
VERSION_PATCH = 1
VERSION_PRE = None
VERSION_BUILD = "build.1"
VERSION = semver.format_version(VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH, VERSION_PRE, VERSION_BUILD)
conditions = {
}
def __init__(self):
self.t = Template()
def buildParams(self):
self.paramVPCID=self.t.add_parameter(Parameter(
"VPCID",
Description="The VPCID that this subnet will be attached to",
Type="String"
))
self.paramDepartment=self.t.add_parameter(Parameter(
"Department",
Description="The department that is managing this resource",
Type="String",
Default="OPS",
))
self.paramCIDRBLock=self.t.add_parameter(Parameter(
"CidrBlock",
Description="The CIDR Block that will make up this subnet",
Type="String",
))
self.paramMapPublicIP=self.t.add_parameter(Parameter(
"MapPublicIP",
Description="Boolean switch for Mapping a public IP on Launch",
Type="String",
Default="False",
AllowedValues=[
"True", "False" ],
))
self.paramRouteTable=self.t.add_parameter(Parameter(
"RouteTableId",
Description="Route Table to attach subnets",
Type="String",
))
def buildTemplate(self):
self.buildParams()
for c in self.conditions:
self.t.add_condition(c, self.conditions[c])
mysubnet=self.t.add_resource(ec2Subnet(
"Subnet",
CidrBlock=Ref(self.paramCIDRBLock),
MapPublicIpOnLaunch=Ref(self.paramMapPublicIP),
VpcId=Ref(self.paramVPCID),
))
self.t.add_resource(SubnetRouteTableAssociation(
"SubnetAssociation",
RouteTableId=Ref(self.paramRouteTable),
SubnetId=Ref(mysubnet),
))
self.t.add_output([
Output(
"SubnetId",
Description="SubnetId of the created Subnet",
Value=Ref(mysubnet)
)
])
def uploadTemplate(self):
botosession = boto3.Session(profile_name=AWS_PROFILE)
s3_client = botosession.client('s3')
res = s3_client.put_object(
Body=self.t.to_json(),
Bucket=AWS_BUCKET,
Key=CF_TEMPLATE_NAME
)
def __str__(self):
return self.t.to_json()