def switch_app_package(billing_driver, pod_id, plan_id):
owner = KubeUtils.get_current_user()
transaction = db.session.begin_nested()
with atomic():
old_pod = PodCollection(owner).get(pod_id, as_json=True)
AppInstance(pod_id).update_plan(plan_id, async=False, dry_run=True)
pod = PodCollection(owner).get(pod_id, as_json=True)
transaction.rollback()
data = KubeUtils._get_params()
data['pod'] = pod
data['oldPod'] = old_pod
data['referer'] = data.get('referer') or ''
return billing_driver.orderswitchapppackage(**data)
def on_app_error(e):
try:
current_user = KubeUtils.get_current_user()
except AttributeError:
current_user = None
if isinstance(e, InternalAPIError):
current_app.logger.error(e.message, exc_info=e.exc_info)
if current_user and current_user.is_administrator():
return _jsonify_api_error(e)
else:
send_event_to_role('notify:error', {'message': e.message}, 'Admin')
return _jsonify_api_error(
APIError(e.response_message or 'Unknown error', 500))
elif isinstance(e, APIError):
return _jsonify_api_error(e)
else: # unexpected error
current_app.logger.exception(e.message)
if current_user and current_user.is_administrator():
return _jsonify_api_error(APIError(repr(e), 500))
else:
send_event_to_role('notify:error',
{'message': 'Unexpected error: ' + repr(e)},
'Admin')
_jsonify_api_error(
APIError('Internal error, please contact administrator', 500))
def create_host():
user = KubeUtils.get_current_user()
if not user.is_administrator():
raise APIError('Insufficient permissions level', 403,
type='PermissionDenied')
ip = request.environ.get('REMOTE_ADDR')
return register_host(ip)
def _check_if_pod_exists(pod_id):
user = KubeUtils.get_current_user()
try:
pod = Pod.filter(Pod.owner_id == user.id, Pod.id == pod_id).first()
if pod is None:
raise PodNotFound
except DataError:
# pod_id is not uuid
raise PodNotFound
def order_edit(billing_driver):
data = KubeUtils._get_params()
data['pod'] = json.dumps(data['pod'])
data['referer'] = data['referer'] if 'referer' in data else ''
response = billing_driver.orderpodedit(**data)
if isinstance(response, basestring):
raise BillingExc.InternalBillingError(details={'message': response})
if response.get('result') == 'error':
raise APIError(response.get('message'))
return response
def check_owner(owner=None):
current_user = KubeUtils.get_current_user()
owner = owner or current_user
check_permission('own', 'pods', user=owner).check()
if owner == current_user:
check_permission('create', 'yaml_pods').check()
else:
check_permission('create_non_owned', 'yaml_pods').check()
return owner
def switch_pod_plan(pod_id, plan_id, **params):
async = params.get('async', True)
dry_run = params.get('dry-run', False)
current_user = KubeUtils.get_current_user()
app = AppInstance(pod_id, current_user)
if plan_id.isdigit(): # plan_id specified with index (e.g. 0)
plan_id = int(plan_id)
func = app.update_plan
else: # plan_id specified with name ('M', 'XXL')
func = app.update_plan_by_name
return func(plan_id, async=async, dry_run=dry_run)
def order_app(billing_driver, template_id, plan_id):
data = KubeUtils._get_params()
app = PredefinedApp.get(template_id)
start_pod_from_yaml(app.get_filled_template_for_plan(plan_id, data),
dry_run=True)
filled = app.get_filled_template_for_plan(plan_id, data, as_yaml=True)
pkgid = app._get_package().id
return billing_driver.orderapp(pkgid=pkgid,
yaml=filled,
referer=request.referrer)
def order_product(billing_driver):
data = KubeUtils._get_params()
if data.get('pod'):
data['referer'] = data['referer'] if 'referer' in data else ''
return billing_driver.orderpod(**data)
return billing_driver.orderproduct(**data)
def get_billing_info(billing_driver):
data = KubeUtils._get_params()
if billing_driver is None:
return no_billing_data()
return billing_driver.getkuberdockinfo(**data)
def order_kubes(billing_driver):
data = KubeUtils._get_params()
data['referer'] = data['referer'] if 'referer' in data else ''
return billing_driver.orderkubes(**data)