x
/
bilean
Code Issues Proposed changes

Replace float with decimal 

Floating point calculations are inaccurate, often lose precision even
when storing into database. So we replace float with decimal.

Change-Id: I3782264015e0b0e260f0c046dc7c3ea94eab0b52
This commit is contained in:
lvdongbing 2016-06-22 21:11:09 -04:00
parent 5025328bc1
commit ff26ed98e7
9 changed files with 139 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
bilean/common/utils.py
View File

@ -15,7 +15,9 @@ Utilities module.
''' '''
import datetime import datetime
import decimal
import random import random
import six
import string import string
from cryptography.fernet import Fernet from cryptography.fernet import Fernet
@ -27,6 +29,7 @@ from oslo_config import cfg
from oslo_log import log as logging from oslo_log import log as logging
from oslo_utils import encodeutils from oslo_utils import encodeutils
from oslo_utils import strutils from oslo_utils import strutils
from oslo_utils import timeutils
from bilean.common import exception from bilean.common import exception
from bilean.common.i18n import _ from bilean.common.i18n import _
@ -156,3 +159,38 @@ def format_time(value):
value = value.replace(microsecond=0) value = value.replace(microsecond=0)
value = value.isoformat() value = value.isoformat()
return value return value
def format_time_to_seconds(t):
"""Format datetime to seconds from 1970-01-01 00:00:00 UTC."""
epoch = datetime.datetime.utcfromtimestamp(0)
if isinstance(t, datetime.datetime):
return (t - epoch).total_seconds()
if isinstance(t, six.string_types):
dt = timeutils.parse_strtime(t)
return (dt - epoch).total_seconds()
return t
def make_decimal(value):
"""Format float to decimal."""
if isinstance(value, decimal.Decimal):
return value
if isinstance(value, float):
return decimal.Decimal.from_float(value)
return decimal.Decimal(str(value))
def format_decimal(value, num=8):
"""Format decimal and keep num decimals."""
if not isinstance(value, decimal.Decimal):
value = make_decimal(value)
dec = "0.%s" % ('0' * num)
return value.quantize(decimal.Decimal(dec))
def dec2str(value):
"""Decimal to str and keep 2 decimals."""
if not isinstance(value, decimal.Decimal):
value = make_decimal(value)
return str(value.quantize(decimal.Decimal('0.00')))

24
bilean/db/sqlalchemy/migrate_repo/versions/001_bilean_init.py
View File

@ -29,10 +29,10 @@ def upgrade(migrate_engine):
sqlalchemy.String(36), sqlalchemy.String(36),
sqlalchemy.ForeignKey('policy.id'), sqlalchemy.ForeignKey('policy.id'),
nullable=True), nullable=True),
sqlalchemy.Column('balance', sqlalchemy.Float), sqlalchemy.Column('balance', sqlalchemy.Numeric(20, 8)),
sqlalchemy.Column('rate', sqlalchemy.Float), sqlalchemy.Column('rate', sqlalchemy.Numeric(20, 8)),
sqlalchemy.Column('credit', sqlalchemy.Integer), sqlalchemy.Column('credit', sqlalchemy.Integer),
sqlalchemy.Column('last_bill', sqlalchemy.DateTime), sqlalchemy.Column('last_bill', sqlalchemy.Numeric(24, 8)),
sqlalchemy.Column('status', sqlalchemy.String(255)), sqlalchemy.Column('status', sqlalchemy.String(255)),
sqlalchemy.Column('status_reason', sqlalchemy.Text), sqlalchemy.Column('status_reason', sqlalchemy.Text),
sqlalchemy.Column('created_at', sqlalchemy.DateTime), sqlalchemy.Column('created_at', sqlalchemy.DateTime),
@ -83,9 +83,9 @@ def upgrade(migrate_engine):
sqlalchemy.Column('rule_id', sqlalchemy.String(36), nullable=False), sqlalchemy.Column('rule_id', sqlalchemy.String(36), nullable=False),
sqlalchemy.Column('resource_type', sqlalchemy.String(36), sqlalchemy.Column('resource_type', sqlalchemy.String(36),
nullable=False), nullable=False),
sqlalchemy.Column('last_bill', sqlalchemy.DateTime), sqlalchemy.Column('last_bill', sqlalchemy.Numeric(24, 8)),
sqlalchemy.Column('properties', types.Dict), sqlalchemy.Column('properties', types.Dict),
sqlalchemy.Column('rate', sqlalchemy.Float, nullable=False), sqlalchemy.Column('rate', sqlalchemy.Numeric(20, 8), nullable=False),
sqlalchemy.Column('created_at', sqlalchemy.DateTime), sqlalchemy.Column('created_at', sqlalchemy.DateTime),
sqlalchemy.Column('updated_at', sqlalchemy.DateTime), sqlalchemy.Column('updated_at', sqlalchemy.DateTime),
sqlalchemy.Column('deleted_at', sqlalchemy.DateTime), sqlalchemy.Column('deleted_at', sqlalchemy.DateTime),
@ -118,10 +118,10 @@ def upgrade(migrate_engine):
sqlalchemy.Column('user_id', sqlalchemy.String(36)), sqlalchemy.Column('user_id', sqlalchemy.String(36)),
sqlalchemy.Column('resource_id', sqlalchemy.String(36)), sqlalchemy.Column('resource_id', sqlalchemy.String(36)),
sqlalchemy.Column('resource_type', sqlalchemy.String(255)), sqlalchemy.Column('resource_type', sqlalchemy.String(255)),
sqlalchemy.Column('start_time', sqlalchemy.DateTime), sqlalchemy.Column('start_time', sqlalchemy.Numeric(24, 8)),
sqlalchemy.Column('end_time', sqlalchemy.DateTime), sqlalchemy.Column('end_time', sqlalchemy.Numeric(24, 8)),
sqlalchemy.Column('rate', sqlalchemy.Float), sqlalchemy.Column('rate', sqlalchemy.Numeric(20, 8)),
sqlalchemy.Column('cost', sqlalchemy.Float), sqlalchemy.Column('cost', sqlalchemy.Numeric(20, 8)),
sqlalchemy.Column('meta_data', types.Dict), sqlalchemy.Column('meta_data', types.Dict),
mysql_engine='InnoDB', mysql_engine='InnoDB',
mysql_charset='utf8' mysql_charset='utf8'
@ -134,7 +134,7 @@ def upgrade(migrate_engine):
sqlalchemy.Column('user_id', sqlalchemy.String(36)), sqlalchemy.Column('user_id', sqlalchemy.String(36)),
sqlalchemy.Column('type', sqlalchemy.String(255)), sqlalchemy.Column('type', sqlalchemy.String(255)),
sqlalchemy.Column('timestamp', sqlalchemy.DateTime), sqlalchemy.Column('timestamp', sqlalchemy.DateTime),
sqlalchemy.Column('value', sqlalchemy.Float), sqlalchemy.Column('value', sqlalchemy.Numeric(20, 8)),
sqlalchemy.Column('meta_data', types.Dict), sqlalchemy.Column('meta_data', types.Dict),
mysql_engine='InnoDB', mysql_engine='InnoDB',
mysql_charset='utf8' mysql_charset='utf8'
@ -150,8 +150,8 @@ def upgrade(migrate_engine):
sqlalchemy.Column('action', sqlalchemy.String(255)), sqlalchemy.Column('action', sqlalchemy.String(255)),
sqlalchemy.Column('cause', sqlalchemy.String(255)), sqlalchemy.Column('cause', sqlalchemy.String(255)),
sqlalchemy.Column('owner', sqlalchemy.String(36)), sqlalchemy.Column('owner', sqlalchemy.String(36)),
sqlalchemy.Column('start_time', sqlalchemy.Float(precision='24,8')), sqlalchemy.Column('start_time', sqlalchemy.Numeric(24, 8)),
sqlalchemy.Column('end_time', sqlalchemy.Float(precision='24,8')), sqlalchemy.Column('end_time', sqlalchemy.Numeric(24, 8)),
sqlalchemy.Column('timeout', sqlalchemy.Integer), sqlalchemy.Column('timeout', sqlalchemy.Integer),
sqlalchemy.Column('inputs', types.Dict), sqlalchemy.Column('inputs', types.Dict),
sqlalchemy.Column('outputs', types.Dict), sqlalchemy.Column('outputs', types.Dict),

25
bilean/db/sqlalchemy/models.py
View File

@ -102,11 +102,10 @@ class User(BASE, BileanBase, SoftDelete, StateAware, models.TimestampMixin):
sqlalchemy.String(36), sqlalchemy.String(36),
sqlalchemy.ForeignKey('policy.id'), sqlalchemy.ForeignKey('policy.id'),
nullable=True) nullable=True)
balance = sqlalchemy.Column(sqlalchemy.Float, default=0.0) balance = sqlalchemy.Column(sqlalchemy.Numeric(20, 8), default=0.0)
rate = sqlalchemy.Column(sqlalchemy.Float, default=0.0) rate = sqlalchemy.Column(sqlalchemy.Numeric(20, 8), default=0.0)
credit = sqlalchemy.Column(sqlalchemy.Integer, default=0) credit = sqlalchemy.Column(sqlalchemy.Integer, default=0)
last_bill = sqlalchemy.Column( last_bill = sqlalchemy.Column(sqlalchemy.Numeric(24, 8))
sqlalchemy.DateTime, default=timeutils.utcnow())
class Policy(BASE, BileanBase, SoftDelete, models.TimestampMixin): class Policy(BASE, BileanBase, SoftDelete, models.TimestampMixin):
@ -146,8 +145,8 @@ class Resource(BASE, BileanBase, SoftDelete, models.TimestampMixin):
rule_id = sqlalchemy.Column(sqlalchemy.String(36), nullable=True) rule_id = sqlalchemy.Column(sqlalchemy.String(36), nullable=True)
user = relationship(User, backref=backref('resources')) user = relationship(User, backref=backref('resources'))
resource_type = sqlalchemy.Column(sqlalchemy.String(36), nullable=False) resource_type = sqlalchemy.Column(sqlalchemy.String(36), nullable=False)
rate = sqlalchemy.Column(sqlalchemy.Float, nullable=False) rate = sqlalchemy.Column(sqlalchemy.Numeric(20, 8), nullable=False)
last_bill = sqlalchemy.Column(sqlalchemy.DateTime) last_bill = sqlalchemy.Column(sqlalchemy.Numeric(24, 8))
properties = sqlalchemy.Column(types.Dict) properties = sqlalchemy.Column(types.Dict)
@ -163,8 +162,8 @@ class Action(BASE, BileanBase, StateAware, models.TimestampMixin):
action = sqlalchemy.Column(sqlalchemy.String(255)) action = sqlalchemy.Column(sqlalchemy.String(255))
cause = sqlalchemy.Column(sqlalchemy.String(255)) cause = sqlalchemy.Column(sqlalchemy.String(255))
owner = sqlalchemy.Column(sqlalchemy.String(36)) owner = sqlalchemy.Column(sqlalchemy.String(36))
start_time = sqlalchemy.Column(sqlalchemy.Float(precision='24,8')) start_time = sqlalchemy.Column(sqlalchemy.Numeric(24, 8))
end_time = sqlalchemy.Column(sqlalchemy.Float(precision='24,8')) end_time = sqlalchemy.Column(sqlalchemy.Numeric(24, 8))
timeout = sqlalchemy.Column(sqlalchemy.Integer) timeout = sqlalchemy.Column(sqlalchemy.Integer)
inputs = sqlalchemy.Column(types.Dict) inputs = sqlalchemy.Column(types.Dict)
outputs = sqlalchemy.Column(types.Dict) outputs = sqlalchemy.Column(types.Dict)
@ -212,10 +211,10 @@ class Consumption(BASE, BileanBase):
user_id = sqlalchemy.Column(sqlalchemy.String(36)) user_id = sqlalchemy.Column(sqlalchemy.String(36))
resource_id = sqlalchemy.Column(sqlalchemy.String(36)) resource_id = sqlalchemy.Column(sqlalchemy.String(36))
resource_type = sqlalchemy.Column(sqlalchemy.String(255)) resource_type = sqlalchemy.Column(sqlalchemy.String(255))
start_time = sqlalchemy.Column(sqlalchemy.DateTime) start_time = sqlalchemy.Column(sqlalchemy.Numeric(24, 8))
end_time = sqlalchemy.Column(sqlalchemy.DateTime) end_time = sqlalchemy.Column(sqlalchemy.Numeric(24, 8))
rate = sqlalchemy.Column(sqlalchemy.Float) rate = sqlalchemy.Column(sqlalchemy.Numeric(20, 8))
cost = sqlalchemy.Column(sqlalchemy.Float) cost = sqlalchemy.Column(sqlalchemy.Numeric(20, 8))
meta_data = sqlalchemy.Column(types.Dict) meta_data = sqlalchemy.Column(types.Dict)
@ -229,7 +228,7 @@ class Recharge(BASE, BileanBase):
user_id = sqlalchemy.Column(sqlalchemy.String(36)) user_id = sqlalchemy.Column(sqlalchemy.String(36))
type = sqlalchemy.Column(sqlalchemy.String(255)) type = sqlalchemy.Column(sqlalchemy.String(255))
timestamp = sqlalchemy.Column(sqlalchemy.DateTime) timestamp = sqlalchemy.Column(sqlalchemy.DateTime)
value = sqlalchemy.Column(sqlalchemy.Float) value = sqlalchemy.Column(sqlalchemy.Numeric(20, 8))
meta_data = sqlalchemy.Column(types.Dict) meta_data = sqlalchemy.Column(types.Dict)

13
bilean/engine/actions/base.py
View File

@ -21,6 +21,7 @@ from bilean.common import context as req_context
from bilean.common import exception from bilean.common import exception
from bilean.common.i18n import _ from bilean.common.i18n import _
from bilean.common.i18n import _LE from bilean.common.i18n import _LE
from bilean.common import utils
from bilean.db import api as db_api from bilean.db import api as db_api
from bilean.engine import event as EVENT from bilean.engine import event as EVENT
@ -104,8 +105,8 @@ class Action(object):
# working on the action. It also serves as a lock. # working on the action. It also serves as a lock.
self.owner = kwargs.get('owner', None) self.owner = kwargs.get('owner', None)
self.start_time = kwargs.get('start_time', None) self.start_time = utils.make_decimal(kwargs.get('start_time', 0))
self.end_time = kwargs.get('end_time', None) self.end_time = utils.make_decimal(kwargs.get('end_time', 0))
# Timeout is a placeholder in case some actions may linger too long # Timeout is a placeholder in case some actions may linger too long
self.timeout = kwargs.get('timeout', cfg.CONF.default_action_timeout) self.timeout = kwargs.get('timeout', cfg.CONF.default_action_timeout)
@ -141,8 +142,8 @@ class Action(object):
'action': self.action, 'action': self.action,
'cause': self.cause, 'cause': self.cause,
'owner': self.owner, 'owner': self.owner,
'start_time': self.start_time, 'start_time': utils.format_decimal(self.start_time),
'end_time': self.end_time, 'end_time': utils.format_decimal(self.end_time),
'timeout': self.timeout, 'timeout': self.timeout,
'status': self.status, 'status': self.status,
'status_reason': self.status_reason, 'status_reason': self.status_reason,
@ -364,8 +365,8 @@ class Action(object):
'target': self.target, 'target': self.target,
'cause': self.cause, 'cause': self.cause,
'owner': self.owner, 'owner': self.owner,
'start_time': self.start_time, 'start_time': utils.dec2str(self.start_time),
'end_time': self.end_time, 'end_time': utils.dec2str(self.end_time),
'timeout': self.timeout, 'timeout': self.timeout,
'status': self.status, 'status': self.status,
'status_reason': self.status_reason, 'status_reason': self.status_reason,

24
bilean/engine/consumption.py
View File

@ -30,10 +30,10 @@ class Consumption(object):
self.resource_id = kwargs.get('resource_id') self.resource_id = kwargs.get('resource_id')
self.resource_type = kwargs.get('resource_type') self.resource_type = kwargs.get('resource_type')
self.start_time = kwargs.get('start_time') self.start_time = utils.make_decimal(kwargs.get('start_time', 0))
self.end_time = kwargs.get('end_time') self.end_time = utils.make_decimal(kwargs.get('end_time', 0))
self.rate = kwargs.get('rate') self.rate = utils.make_decimal(kwargs.get('rate', 0))
self.cost = kwargs.get('cost') self.cost = utils.make_decimal(kwargs.get('cost', 0))
self.metadata = kwargs.get('metadata') self.metadata = kwargs.get('metadata')
@classmethod @classmethod
@ -87,10 +87,10 @@ class Consumption(object):
'user_id': self.user_id, 'user_id': self.user_id,
'resource_id': self.resource_id, 'resource_id': self.resource_id,
'resource_type': self.resource_type, 'resource_type': self.resource_type,
'start_time': self.start_time, 'start_time': utils.format_decimal(self.start_time),
'end_time': self.end_time, 'end_time': utils.format_decimal(self.end_time),
'rate': self.rate, 'rate': utils.format_decimal(self.rate),
'cost': self.cost, 'cost': utils.format_decimal(self.cost),
'meta_data': self.metadata, 'meta_data': self.metadata,
} }
@ -109,10 +109,10 @@ class Consumption(object):
'user_id': self.user_id, 'user_id': self.user_id,
'resource_id': self.resource_id, 'resource_id': self.resource_id,
'resource_type': self.resource_type, 'resource_type': self.resource_type,
'start_time': utils.format_time(self.start_time), 'start_time': utils.dec2str(self.start_time),
'end_time': utils.format_time(self.end_time), 'end_time': utils.dec2str(self.end_time),
'rate': self.rate, 'rate': utils.dec2str(self.rate),
'cost': self.cost, 'cost': utils.dec2str(self.cost),
'metadata': self.metadata, 'metadata': self.metadata,
} }
return consumption return consumption

8
bilean/engine/flows/flow.py
View File

@ -22,6 +22,7 @@ from taskflow.types import failure as ft
from bilean.common import exception from bilean.common import exception
from bilean.common.i18n import _LE from bilean.common.i18n import _LE
from bilean.common import utils
from bilean.engine import policy as policy_mod from bilean.engine import policy as policy_mod
from bilean.engine import user as user_mod from bilean.engine import user as user_mod
from bilean.plugins import base as plugin_base from bilean.plugins import base as plugin_base
@ -77,7 +78,7 @@ class CreateResourceTask(task.Task):
# Update resource with rule_id and rate # Update resource with rule_id and rate
resource.rule_id = rule.id resource.rule_id = rule.id
resource.rate = rule.get_price(resource) resource.rate = utils.make_decimal(rule.get_price(resource))
resource.store(context) resource.store(context)
def revert(self, context, resource, result, **kwargs): def revert(self, context, resource, result, **kwargs):
@ -96,7 +97,7 @@ class UpdateResourceTask(task.Task):
old_rate = resource.rate old_rate = resource.rate
resource.properties = values.get('properties') resource.properties = values.get('properties')
rule = plugin_base.Rule.load(context, rule_id=resource.rule_id) rule = plugin_base.Rule.load(context, rule_id=resource.rule_id)
resource.rate = rule.get_price(resource) resource.rate = utils.make_decimal(rule.get_price(resource))
resource.delta_rate = resource.rate - old_rate resource.delta_rate = resource.rate - old_rate
resource.store(context) resource.store(context)
@ -177,8 +178,7 @@ class UpdateUserRateTask(task.Task):
def execute(self, context, user_obj, user_bak, resource, *args, **kwargs): def execute(self, context, user_obj, user_bak, resource, *args, **kwargs):
user_obj.update_rate(context, resource.delta_rate, user_obj.update_rate(context, resource.delta_rate,
timestamp=resource.last_bill, timestamp=resource.last_bill)
delayed_cost=resource.delayed_cost)
def revert(self, context, user_obj, user_bak, resource, result, def revert(self, context, user_obj, user_bak, resource, result,
*args, **kwargs): *args, **kwargs):

64
bilean/engine/user.py
View File

@ -12,6 +12,7 @@
# under the License. # under the License.
import six import six
import time
from bilean.common import exception from bilean.common import exception
from bilean.common.i18n import _ from bilean.common.i18n import _
@ -24,8 +25,8 @@ from bilean.plugins import base as plugin_base
from oslo_config import cfg from oslo_config import cfg
from oslo_log import log as logging from oslo_log import log as logging
from oslo_utils import timeutils
wallclock = time.time
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)
@ -38,16 +39,14 @@ class User(object):
'INIT', 'FREE', 'ACTIVE', 'WARNING', 'FREEZE', 'INIT', 'FREE', 'ACTIVE', 'WARNING', 'FREEZE',
) )
ALLOW_DELAY_TIME = 10
def __init__(self, user_id, **kwargs): def __init__(self, user_id, **kwargs):
self.id = user_id self.id = user_id
self.name = kwargs.get('name') self.name = kwargs.get('name')
self.policy_id = kwargs.get('policy_id') self.policy_id = kwargs.get('policy_id')
self.balance = kwargs.get('balance', 0) self.balance = utils.make_decimal(kwargs.get('balance', 0))
self.rate = kwargs.get('rate', 0.0) self.rate = utils.make_decimal(kwargs.get('rate', 0))
self.credit = kwargs.get('credit', 0) self.credit = kwargs.get('credit', 0)
self.last_bill = kwargs.get('last_bill') self.last_bill = utils.make_decimal(kwargs.get('last_bill', 0))
self.status = kwargs.get('status', self.INIT) self.status = kwargs.get('status', self.INIT)
self.status_reason = kwargs.get('status_reason', 'Init user') self.status_reason = kwargs.get('status_reason', 'Init user')
@ -65,10 +64,10 @@ class User(object):
values = { values = {
'name': self.name, 'name': self.name,
'policy_id': self.policy_id, 'policy_id': self.policy_id,
'balance': self.balance, 'balance': utils.format_decimal(self.balance),
'rate': self.rate, 'rate': utils.format_decimal(self.rate),
'credit': self.credit, 'credit': self.credit,
'last_bill': self.last_bill, 'last_bill': utils.format_decimal(self.last_bill),
'status': self.status, 'status': self.status,
'status_reason': self.status_reason, 'status_reason': self.status_reason,
'created_at': self.created_at, 'created_at': self.created_at,
@ -156,7 +155,7 @@ class User(object):
if not realtime: if not realtime:
return u return u
if u.rate > 0 and u.status != u.FREEZE: if u.rate > 0 and u.status != u.FREEZE:
seconds = (timeutils.utcnow() - u.last_bill).total_seconds() seconds = utils.make_decimal(wallclock()) - u.last_bill
u.balance -= u.rate * seconds u.balance -= u.rate * seconds
return u return u
@ -194,10 +193,10 @@ class User(object):
'id': self.id, 'id': self.id,
'name': self.name, 'name': self.name,
'policy_id': self.policy_id, 'policy_id': self.policy_id,
'balance': self.balance, 'balance': utils.dec2str(self.balance),
'rate': self.rate, 'rate': utils.dec2str(self.rate),
'credit': self.credit, 'credit': self.credit,
'last_bill': utils.format_time(self.last_bill), 'last_bill': utils.dec2str(self.last_bill),
'status': self.status, 'status': self.status,
'status_reason': self.status_reason, 'status_reason': self.status_reason,
'created_at': utils.format_time(self.created_at), 'created_at': utils.format_time(self.created_at),
@ -213,7 +212,7 @@ class User(object):
self.status_reason = reason self.status_reason = reason
self.store(context) self.store(context)
def update_rate(self, context, delta_rate, timestamp=None, delayed_cost=0): def update_rate(self, context, delta_rate, timestamp=None):
"""Update user's rate and update user status. """Update user's rate and update user status.
:param context: The request context. :param context: The request context.
@ -223,18 +222,15 @@ class User(object):
adjust balance by delayed_cost. adjust balance by delayed_cost.
""" """
if delta_rate == 0 and delayed_cost == 0:
return
# Settle account before update rate # Settle account before update rate
self._settle_account(context, timestamp=timestamp, self._settle_account(context, delta_rate=delta_rate,
delayed_cost=delayed_cost) timestamp=timestamp)
old_rate = self.rate old_rate = self.rate
new_rate = old_rate + delta_rate new_rate = old_rate + delta_rate
if old_rate == 0 and new_rate > 0: if old_rate == 0 and new_rate > 0:
# Set last_bill when status change to 'ACTIVE' from 'FREE' # Set last_bill when status change to 'ACTIVE' from 'FREE'
self.last_bill = timeutils.utcnow() self.last_bill = timestamp or wallclock()
reason = _("Status change to 'ACTIVE' cause resource creation.") reason = _("Status change to 'ACTIVE' cause resource creation.")
self.status = self.ACTIVE self.status = self.ACTIVE
self.status_reason = reason self.status_reason = reason
@ -262,7 +258,7 @@ class User(object):
param timestamp: Record when recharge action occurs. param timestamp: Record when recharge action occurs.
param metadata: Some other keyword. param metadata: Some other keyword.
""" """
self.balance += value self.balance += utils.make_decimal(value)
if self.status == self.INIT and self.balance > 0: if self.status == self.INIT and self.balance > 0:
self.status = self.FREE self.status = self.FREE
self.status_reason = "Recharged" self.status_reason = "Recharged"
@ -293,31 +289,31 @@ class User(object):
'bilean.scheduler.cron_scheduler', 'bilean.scheduler.cron_scheduler',
group='scheduler') group='scheduler')
prior_notify_time = cfg.CONF.scheduler.prior_notify_time * 3600 prior_notify_time = cfg.CONF.scheduler.prior_notify_time * 3600
rest_usage = prior_notify_time * self.rate rest_usage = utils.make_decimal(prior_notify_time) * self.rate
if self.balance > rest_usage: return self.balance < rest_usage
return False
return True
def do_delete(self, context): def do_delete(self, context):
db_api.user_delete(context, self.id) db_api.user_delete(context, self.id)
return True return True
def _settle_account(self, context, timestamp=None, delayed_cost=0): def _settle_account(self, context, delta_rate=0, timestamp=None):
if self.rate == 0 and delayed_cost == 0: if self.rate == 0:
LOG.info(_LI("Ignore settlement action because user is in '%s' " LOG.info(_LI("Ignore settlement action because user is in '%s' "
"status."), self.status) "status."), self.status)
return return
# Calculate user's cost before last_bill and now # Calculate user's cost between last_bill and now
cost = 0 now = utils.make_decimal(wallclock())
if self.rate > 0 and self.last_bill: delayed_cost = 0
timestamp = timestamp or timeutils.utcnow() if delta_rate != 0:
total_seconds = (timestamp - self.last_bill).total_seconds() delayed_seconds = now - timestamp
cost = self.rate * total_seconds delayed_cost = delayed_seconds * utils.make_decimal(delta_rate)
usage_seconds = now - self.last_bill
cost = self.rate * usage_seconds
total_cost = cost + delayed_cost total_cost = cost + delayed_cost
self.balance -= total_cost self.balance -= total_cost
self.last_bill = timestamp self.last_bill = now
def settle_account(self, context, task=None): def settle_account(self, context, task=None):
'''Settle account for user.''' '''Settle account for user.'''

60
bilean/plugins/base.py
View File

@ -10,6 +10,8 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import time
from oslo_config import cfg from oslo_config import cfg
from oslo_log import log as logging from oslo_log import log as logging
from oslo_utils import timeutils from oslo_utils import timeutils
@ -22,6 +24,7 @@ from bilean.db import api as db_api
from bilean.engine import consumption as consumption_mod from bilean.engine import consumption as consumption_mod
from bilean.engine import environment from bilean.engine import environment
wallclock = time.time
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)
@ -233,8 +236,6 @@ class Resource(object):
something else. something else.
""" """
ALLOW_DELAY_TIME = 10
def __new__(cls, id, user_id, res_type, properties, **kwargs): def __new__(cls, id, user_id, res_type, properties, **kwargs):
"""Create a new resource of the appropriate class. """Create a new resource of the appropriate class.
@ -258,8 +259,8 @@ class Resource(object):
self.properties = properties self.properties = properties
self.rule_id = kwargs.get('rule_id') self.rule_id = kwargs.get('rule_id')
self.rate = kwargs.get('rate', 0) self.rate = utils.make_decimal(kwargs.get('rate', 0))
self.last_bill = kwargs.get('last_bill') self.last_bill = utils.make_decimal(kwargs.get('last_bill', 0))
self.created_at = kwargs.get('created_at') self.created_at = kwargs.get('created_at')
self.updated_at = kwargs.get('updated_at') self.updated_at = kwargs.get('updated_at')
@ -267,7 +268,6 @@ class Resource(object):
# Properties pass to user to help settle account, not store to db # Properties pass to user to help settle account, not store to db
self.delta_rate = 0 self.delta_rate = 0
self.delayed_cost = 0
self.consumption = None self.consumption = None
def store(self, context): def store(self, context):
@ -278,8 +278,8 @@ class Resource(object):
'resource_type': self.resource_type, 'resource_type': self.resource_type,
'properties': self.properties, 'properties': self.properties,
'rule_id': self.rule_id, 'rule_id': self.rule_id,
'rate': self.rate, 'rate': utils.format_decimal(self.rate),
'last_bill': self.last_bill, 'last_bill': utils.format_decimal(self.last_bill),
'created_at': self.created_at, 'created_at': self.created_at,
'updated_at': self.updated_at, 'updated_at': self.updated_at,
'deleted_at': self.deleted_at, 'deleted_at': self.deleted_at,
@ -304,19 +304,13 @@ class Resource(object):
self.created_at = resource.created_at self.created_at = resource.created_at
return return
now = timeutils.utcnow() self.last_bill = utils.make_decimal(wallclock())
self.last_bill = now
create_time = self.properties.get('created_at') create_time = self.properties.get('created_at')
if create_time is not None: if create_time is not None:
created_at = timeutils.parse_strtime(create_time) sec = utils.format_time_to_seconds(create_time)
delayed_seconds = (now - created_at).total_seconds() self.last_bill = utils.make_decimal(sec)
# Engine handle resource creation is delayed because of something,
# we suppose less than ALLOW_DELAY_TIME is acceptable.
if delayed_seconds > self.ALLOW_DELAY_TIME:
self.delayed_cost = self.delta_rate * delayed_seconds
self.last_bill = created_at
values.update(last_bill=self.last_bill) values.update(last_bill=utils.format_decimal(self.last_bill))
resource = db_api.resource_create(context, values) resource = db_api.resource_create(context, values)
self.created_at = resource.created_at self.created_at = resource.created_at
@ -326,19 +320,14 @@ class Resource(object):
return return
update_time = self.properties.get('updated_at') update_time = self.properties.get('updated_at')
now = timeutils.utcnow() updated_at = utils.make_decimal(wallclock())
updated_at = now
if update_time is not None: if update_time is not None:
updated_at = timeutils.parse_strtime(update_time) sec = utils.format_time_to_seconds(update_time)
delayed_seconds = (now - updated_at).total_seconds() updated_at = utils.make_decimal(sec)
# Engine handle resource update is delayed because of something,
# we suppose less than ALLOW_DELAY_TIME is acceptable.
if delayed_seconds > self.ALLOW_DELAY_TIME:
self.delayed_cost = self.delta_rate * delayed_seconds
# Generate consumption between lass bill and update time # Generate consumption between lass bill and update time
old_rate = self.rate - self.delta_rate old_rate = self.rate - self.delta_rate
cost = (updated_at - self.last_bill).total_seconds() * old_rate cost = (updated_at - self.last_bill) * old_rate
params = {'resource_id': self.id, params = {'resource_id': self.id,
'resource_type': self.resource_type, 'resource_type': self.resource_type,
'start_time': self.last_bill, 'start_time': self.last_bill,
@ -349,7 +338,7 @@ class Resource(object):
self.consumption = consumption_mod.Consumption(self.user_id, **params) self.consumption = consumption_mod.Consumption(self.user_id, **params)
self.last_bill = updated_at self.last_bill = updated_at
values.update(last_bill=updated_at) values.update(last_bill=utils.format_decimal(updated_at))
db_api.resource_update(context, self.id, values) db_api.resource_update(context, self.id, values)
def _delete(self, context, soft_delete=True): def _delete(self, context, soft_delete=True):
@ -359,18 +348,13 @@ class Resource(object):
return return
delete_time = self.properties.get('deleted_at') delete_time = self.properties.get('deleted_at')
now = timeutils.utcnow() deleted_at = utils.make_decimal(wallclock())
deleted_at = now
if delete_time is not None: if delete_time is not None:
deleted_at = timeutils.parse_strtime(delete_time) sec = utils.format_time_to_seconds(delete_time)
delayed_seconds = (now - deleted_at).total_seconds() deleted_at = utils.make_decimal(sec)
# Engine handle resource deletion is delayed because of something,
# we suppose less than ALLOW_DELAY_TIME is acceptable.
if delayed_seconds > self.ALLOW_DELAY_TIME:
self.delayed_cost = self.delta_rate * delayed_seconds
# Generate consumption between lass bill and delete time # Generate consumption between lass bill and delete time
cost = (deleted_at - self.last_bill).total_seconds() * self.rate cost = (deleted_at - self.last_bill) * self.rate
params = {'resource_id': self.id, params = {'resource_id': self.id,
'resource_type': self.resource_type, 'resource_type': self.resource_type,
'start_time': self.last_bill, 'start_time': self.last_bill,
@ -447,8 +431,8 @@ class Resource(object):
'resource_type': self.resource_type, 'resource_type': self.resource_type,
'properties': self.properties, 'properties': self.properties,
'rule_id': self.rule_id, 'rule_id': self.rule_id,
'rate': self.rate, 'rate': utils.dec2str(self.rate),
'last_bill': utils.format_time(self.last_bill), 'last_bill': utils.dec2str(self.last_bill),
'created_at': utils.format_time(self.created_at), 'created_at': utils.format_time(self.created_at),
'updated_at': utils.format_time(self.updated_at), 'updated_at': utils.format_time(self.updated_at),
'deleted_at': utils.format_time(self.deleted_at), 'deleted_at': utils.format_time(self.deleted_at),

4
bilean/scheduler/cron_scheduler.py
View File

@ -179,7 +179,7 @@ class CronScheduler(object):
def _add_notify_job(self, user): def _add_notify_job(self, user):
if user.rate == 0: if user.rate == 0:
return False return False
total_seconds = user.balance / user.rate total_seconds = float(user.balance / user.rate)
prior_notify_time = cfg.CONF.scheduler.prior_notify_time * 3600 prior_notify_time = cfg.CONF.scheduler.prior_notify_time * 3600
notify_seconds = total_seconds - prior_notify_time notify_seconds = total_seconds - prior_notify_time
notify_seconds = notify_seconds if notify_seconds > 0 else 0 notify_seconds = notify_seconds if notify_seconds > 0 else 0
@ -198,7 +198,7 @@ class CronScheduler(object):
def _add_freeze_job(self, user): def _add_freeze_job(self, user):
if user.rate == 0: if user.rate == 0:
return False return False
total_seconds = user.balance / user.rate total_seconds = float(user.balance / user.rate)
run_date = timeutils.utcnow() + timedelta(seconds=total_seconds) run_date = timeutils.utcnow() + timedelta(seconds=total_seconds)
job_params = {'run_date': run_date} job_params = {'run_date': run_date}
job_id = self._generate_job_id(user.id, self.FREEZE) job_id = self._generate_job_id(user.id, self.FREEZE)